/mandos/trunk : revision 237.4.98

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

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:

423

496

class AvahiServiceToSyslog(AvahiService):

424

497

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

425

498

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

426

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

499

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

427

500

syslogger.setFormatter(logging.Formatter(

428

501

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

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

453

530

E_INTERRUPTED = -52

458

535

CRD_CERTIFICATE = 1

459

536

E_NO_CERTIFICATE_FOUND = -49

460

537

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

461

538

462

539

# Types

463

540

class session_int(ctypes.Structure):

464

541

_fields_ = []

465

542

session_t = ctypes.POINTER(session_int)

543

466

544

class certificate_credentials_st(ctypes.Structure):

467

545

_fields_ = []

468

546

certificate_credentials_t = ctypes.POINTER(

469

547

certificate_credentials_st)

470

548

certificate_type_t = ctypes.c_int

549

471

550

class datum_t(ctypes.Structure):

472

551

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

473

552

('size', ctypes.c_uint)]

553

474

554

class openpgp_crt_int(ctypes.Structure):

475

555

_fields_ = []

476

556

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

477

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

557

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

478

558

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

479

credentials_type_t = ctypes.c_int #

559

credentials_type_t = ctypes.c_int

480

560

transport_ptr_t = ctypes.c_void_p

481

561

close_request_t = ctypes.c_int

482

562

483

563

# Exceptions

484

564

class Error(Exception):

485

565

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

486

566

# exception might be raised from within GnuTLS.__init__,

487

567

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

488

568

# global variable has happened.

489

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

569

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

490

570

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

491

571

# code is passed, convert it to a string with

492

572

# gnutls.strerror()

495

575

message = GnuTLS.strerror(code)

496

576

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

497

577

message, *args)

498

578

499

579

class CertificateSecurityError(Error):

500

580

pass

501

581

502

582

# Classes

503

583

class Credentials(object):

504

584

def __init__(self):

506

586

gnutls.certificate_allocate_credentials(

507

587

ctypes.byref(self._c_object))

508

588

self.type = gnutls.CRD_CERTIFICATE

509

589

510

590

def __del__(self):

511

591

gnutls.certificate_free_credentials(self._c_object)

512

592

513

593

class ClientSession(object):

514

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

594

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

515

595

self._c_object = gnutls.session_t()

516

596

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

517

597

gnutls.set_default_priority(self._c_object)

525

605

ctypes.cast(credentials._c_object,

526

606

ctypes.c_void_p))

527

607

self.credentials = credentials

528

608

529

609

def __del__(self):

530

610

gnutls.deinit(self._c_object)

531

611

532

612

def handshake(self):

533

613

return gnutls.handshake(self._c_object)

534

614

535

615

def send(self, data):

536

616

data = bytes(data)

537

617

data_len = len(data)

539

619

data_len -= gnutls.record_send(self._c_object,

540

620

data[-data_len:],

541

621

data_len)

542

622

543

623

def bye(self):

544

624

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

545

625

546

626

# Error handling functions

547

627

def _error_code(result):

548

628

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

550

630

if result >= 0:

551

631

return result

552

632

if result == gnutls.E_NO_CERTIFICATE_FOUND:

553

raise gnutls.CertificateSecurityError(code = result)

554

raise gnutls.Error(code = result)

555

633

raise gnutls.CertificateSecurityError(code=result)

634

raise gnutls.Error(code=result)

635

556

636

def _retry_on_error(result, func, arguments):

557

637

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

558

638

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

561

641

return _error_code(result)

562

642

result = func(*arguments)

563

643

return result

564

644

565

645

# Unless otherwise indicated, the function declarations below are

566

646

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

567

647

568

648

# Functions

569

649

priority_set_direct = _library.gnutls_priority_set_direct

570

650

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

571

651

ctypes.POINTER(ctypes.c_char_p)]

572

652

priority_set_direct.restype = _error_code

573

653

574

654

init = _library.gnutls_init

575

655

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

576

656

init.restype = _error_code

577

657

578

658

set_default_priority = _library.gnutls_set_default_priority

579

659

set_default_priority.argtypes = [session_t]

580

660

set_default_priority.restype = _error_code

581

661

582

662

record_send = _library.gnutls_record_send

583

663

record_send.argtypes = [session_t, ctypes.c_void_p,

584

664

ctypes.c_size_t]

585

665

record_send.restype = ctypes.c_ssize_t

586

666

record_send.errcheck = _retry_on_error

587

667

588

668

certificate_allocate_credentials = (

589

669

_library.gnutls_certificate_allocate_credentials)

590

670

certificate_allocate_credentials.argtypes = [

591

671

ctypes.POINTER(certificate_credentials_t)]

592

672

certificate_allocate_credentials.restype = _error_code

593

673

594

674

certificate_free_credentials = (

595

675

_library.gnutls_certificate_free_credentials)

596

certificate_free_credentials.argtypes = [certificate_credentials_t]

676

certificate_free_credentials.argtypes = [

677

certificate_credentials_t]

597

678

certificate_free_credentials.restype = None

598

679

599

680

handshake_set_private_extensions = (

600

681

_library.gnutls_handshake_set_private_extensions)

601

682

handshake_set_private_extensions.argtypes = [session_t,

602

683

ctypes.c_int]

603

684

handshake_set_private_extensions.restype = None

604

685

605

686

credentials_set = _library.gnutls_credentials_set

606

687

credentials_set.argtypes = [session_t, credentials_type_t,

607

688

ctypes.c_void_p]

608

689

credentials_set.restype = _error_code

609

690

610

691

strerror = _library.gnutls_strerror

611

692

strerror.argtypes = [ctypes.c_int]

612

693

strerror.restype = ctypes.c_char_p

613

694

614

695

certificate_type_get = _library.gnutls_certificate_type_get

615

696

certificate_type_get.argtypes = [session_t]

616

697

certificate_type_get.restype = _error_code

617

698

618

699

certificate_get_peers = _library.gnutls_certificate_get_peers

619

700

certificate_get_peers.argtypes = [session_t,

620

701

ctypes.POINTER(ctypes.c_uint)]

621

702

certificate_get_peers.restype = ctypes.POINTER(datum_t)

622

703

623

704

global_set_log_level = _library.gnutls_global_set_log_level

624

705

global_set_log_level.argtypes = [ctypes.c_int]

625

706

global_set_log_level.restype = None

626

707

627

708

global_set_log_function = _library.gnutls_global_set_log_function

628

709

global_set_log_function.argtypes = [log_func]

629

710

global_set_log_function.restype = None

630

711

631

712

deinit = _library.gnutls_deinit

632

713

deinit.argtypes = [session_t]

633

714

deinit.restype = None

634

715

635

716

handshake = _library.gnutls_handshake

636

717

handshake.argtypes = [session_t]

637

718

handshake.restype = _error_code

638

719

handshake.errcheck = _retry_on_error

639

720

640

721

transport_set_ptr = _library.gnutls_transport_set_ptr

641

722

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

642

723

transport_set_ptr.restype = None

643

724

644

725

bye = _library.gnutls_bye

645

726

bye.argtypes = [session_t, close_request_t]

646

727

bye.restype = _error_code

647

728

bye.errcheck = _retry_on_error

648

729

649

730

check_version = _library.gnutls_check_version

650

731

check_version.argtypes = [ctypes.c_char_p]

651

732

check_version.restype = ctypes.c_char_p

652

733

653

734

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

654

735

655

736

openpgp_crt_init = _library.gnutls_openpgp_crt_init

656

737

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

657

738

openpgp_crt_init.restype = _error_code

658

739

659

740

openpgp_crt_import = _library.gnutls_openpgp_crt_import

660

741

openpgp_crt_import.argtypes = [openpgp_crt_t,

661

742

ctypes.POINTER(datum_t),

662

743

openpgp_crt_fmt_t]

663

744

openpgp_crt_import.restype = _error_code

664

745

665

746

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

666

747

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

667

748

ctypes.POINTER(ctypes.c_uint)]

668

749

openpgp_crt_verify_self.restype = _error_code

669

750

670

751

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

671

752

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

672

753

openpgp_crt_deinit.restype = None

673

754

674

755

openpgp_crt_get_fingerprint = (

675

756

_library.gnutls_openpgp_crt_get_fingerprint)

676

757

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

678

759

ctypes.POINTER(

679

760

ctypes.c_size_t)]

680

761

openpgp_crt_get_fingerprint.restype = _error_code

681

762

682

763

# Remove non-public functions

683

764

del _error_code, _retry_on_error

684

765

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

685

766

gnutls = GnuTLS()

686

767

768

687

769

def call_pipe(connection, # : multiprocessing.Connection

688

770

func, *args, **kwargs):

689

771

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

690

772

691

773

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

692

774

return value on the provided multiprocessing.Connection.

693

775

"""

694

776

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

695

777

connection.close()

696

778

779

697

780

class Client(object):

698

781

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

699

782

700

783

Attributes:

701

784

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

702

785

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

704

787

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

705

788

to see if the client lives.

706

789

'None' if no process is running.

707

checker_callback_tag: a gobject event source tag, or None

790

checker_callback_tag: a GLib event source tag, or None

708

791

checker_command: string; External command which is run to check

709

792

if client lives. %() expansions are done at

710

793

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

711

794

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

712

checker_initiator_tag: a gobject event source tag, or None

795

checker_initiator_tag: a GLib event source tag, or None

713

796

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

714

797

client_structure: Object describing what attributes a client has

715

798

and is used for storing the client at exit

716

799

current_checker_command: string; current running checker_command

717

disable_initiator_tag: a gobject event source tag, or None

800

disable_initiator_tag: a GLib event source tag, or None

718

801

enabled: bool()

719

802

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

720

803

uniquely identify the client

739

822

disabled, or None

740

823

server_settings: The server_settings dict from main()

741

824

"""

742

825

743

826

runtime_expansions = ("approval_delay", "approval_duration",

744

827

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

745

828

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

756

839

"approved_by_default": "True",

757

840

"enabled": "True",

758

841

}

759

842

760

843

@staticmethod

761

844

def config_parser(config):

762

845

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

769

852

for client_name in config.sections():

770

853

section = dict(config.items(client_name))

771

854

client = settings[client_name] = {}

772

855

773

856

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

774

857

# Reformat values from string types to Python types

775

858

client["approved_by_default"] = config.getboolean(

776

859

client_name, "approved_by_default")

777

860

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

778

861

"enabled")

779

862

780

863

# Uppercase and remove spaces from fingerprint for later

781

864

# comparison purposes with return value from the

782

865

# fingerprint() function

783

866

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

784

867

.replace(" ", ""))

785

868

if "secret" in section:

786

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

869

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

870

.encode("utf-8"),

871

"base64")

787

872

elif "secfile" in section:

788

873

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

789

874

(section["secfile"])),

804

889

client["last_approval_request"] = None

805

890

client["last_checked_ok"] = None

806

891

client["last_checker_status"] = -2

807

892

808

893

return settings

809

810

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

894

895

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

811

896

self.name = name

812

897

if server_settings is None:

813

898

server_settings = {}

815

900

# adding all client settings

816

901

for setting, value in settings.items():

817

902

setattr(self, setting, value)

818

903

819

904

if self.enabled:

820

905

if not hasattr(self, "last_enabled"):

821

906

self.last_enabled = datetime.datetime.utcnow()

825

910

else:

826

911

self.last_enabled = None

827

912

self.expires = None

828

913

829

914

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

830

915

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

831

916

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

832

917

datetime.datetime.utcnow())

833

918

834

919

# attributes specific for this server instance

835

920

self.checker = None

836

921

self.checker_initiator_tag = None

842

927

self.changedstate = multiprocessing_manager.Condition(

843

928

multiprocessing_manager.Lock())

844

929

self.client_structure = [attr

845

for attr in self.__dict__.iterkeys()

930

for attr in self.__dict__.keys()

846

931

if not attr.startswith("_")]

847

932

self.client_structure.append("client_structure")

848

933

849

934

for name, t in inspect.getmembers(

850

935

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

851

936

if not name.startswith("_"):

852

937

self.client_structure.append(name)

853

938

854

939

# Send notice to process children that client state has changed

855

940

def send_changedstate(self):

856

941

with self.changedstate:

857

942

self.changedstate.notify_all()

858

943

859

944

def enable(self):

860

945

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

861

946

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

866

951

self.last_enabled = datetime.datetime.utcnow()

867

952

self.init_checker()

868

953

self.send_changedstate()

869

954

870

955

def disable(self, quiet=True):

871

956

"""Disable this client."""

872

957

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

874

959

if not quiet:

875

960

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

876

961

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

877

gobject.source_remove(self.disable_initiator_tag)

962

GLib.source_remove(self.disable_initiator_tag)

878

963

self.disable_initiator_tag = None

879

964

self.expires = None

880

965

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

881

gobject.source_remove(self.checker_initiator_tag)

966

GLib.source_remove(self.checker_initiator_tag)

882

967

self.checker_initiator_tag = None

883

968

self.stop_checker()

884

969

self.enabled = False

885

970

if not quiet:

886

971

self.send_changedstate()

887

# 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

888

973

return False

889

974

890

975

def __del__(self):

891

976

self.disable()

892

977

893

978

def init_checker(self):

894

979

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

895

980

# and every interval from then on.

896

981

if self.checker_initiator_tag is not None:

897

gobject.source_remove(self.checker_initiator_tag)

898

self.checker_initiator_tag = gobject.timeout_add(

982

GLib.source_remove(self.checker_initiator_tag)

983

self.checker_initiator_tag = GLib.timeout_add(

899

984

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

900

985

self.start_checker)

901

986

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

902

987

if self.disable_initiator_tag is not None:

903

gobject.source_remove(self.disable_initiator_tag)

904

self.disable_initiator_tag = gobject.timeout_add(

988

GLib.source_remove(self.disable_initiator_tag)

989

self.disable_initiator_tag = GLib.timeout_add(

905

990

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

906

991

# Also start a new checker *right now*.

907

992

self.start_checker()

908

993

909

994

def checker_callback(self, source, condition, connection,

910

995

command):

911

996

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

914

999

# Read return code from connection (see call_pipe)

915

1000

returncode = connection.recv()

916

1001

connection.close()

917

1002

918

1003

if returncode >= 0:

919

1004

self.last_checker_status = returncode

920

1005

self.last_checker_signal = None

930

1015

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

931

1016

vars(self))

932

1017

return False

933

1018

934

1019

def checked_ok(self):

935

1020

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

936

1021

self.last_checked_ok = datetime.datetime.utcnow()

937

1022

self.last_checker_status = 0

938

1023

self.last_checker_signal = None

939

1024

self.bump_timeout()

940

1025

941

1026

def bump_timeout(self, timeout=None):

942

1027

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

943

1028

if timeout is None:

944

1029

timeout = self.timeout

945

1030

if self.disable_initiator_tag is not None:

946

gobject.source_remove(self.disable_initiator_tag)

1031

GLib.source_remove(self.disable_initiator_tag)

947

1032

self.disable_initiator_tag = None

948

1033

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

949

self.disable_initiator_tag = gobject.timeout_add(

1034

self.disable_initiator_tag = GLib.timeout_add(

950

1035

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

951

1036

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

952

1037

953

1038

def need_approval(self):

954

1039

self.last_approval_request = datetime.datetime.utcnow()

955

1040

956

1041

def start_checker(self):

957

1042

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

958

1043

959

1044

If a checker already exists, leave it running and do

960

1045

nothing."""

961

1046

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

966

1051

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

967

1052

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

968

1053

# should be.

969

1054

970

1055

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

971

1056

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

972

1057

self.checker.join()

976

1061

# Escape attributes for the shell

977

1062

escaped_attrs = {

978

1063

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

979

for attr in self.runtime_expansions }

1064

for attr in self.runtime_expansions}

980

1065

try:

981

1066

command = self.checker_command % escaped_attrs

982

1067

except TypeError as error:

994

1079

# The exception is when not debugging but nevertheless

995

1080

# running in the foreground; use the previously

996

1081

# created wnull.

997

popen_args = { "close_fds": True,

998

"shell": True,

999

"cwd": "/" }

1082

popen_args = {"close_fds": True,

1083

"shell": True,

1084

"cwd": "/"}

1000

1085

if (not self.server_settings["debug"]

1001

1086

and self.server_settings["foreground"]):

1002

1087

popen_args.update({"stdout": wnull,

1003

"stderr": wnull })

1004

pipe = multiprocessing.Pipe(duplex = False)

1088

"stderr": wnull})

1089

pipe = multiprocessing.Pipe(duplex=False)

1005

1090

self.checker = multiprocessing.Process(

1006

target = call_pipe,

1007

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

1008

kwargs = popen_args)

1091

target=call_pipe,

1092

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

1093

kwargs=popen_args)

1009

1094

self.checker.start()

1010

self.checker_callback_tag = gobject.io_add_watch(

1011

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

1095

self.checker_callback_tag = GLib.io_add_watch(

1096

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

1012

1097

self.checker_callback, pipe[0], command)

1013

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

1098

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

1014

1099

return True

1015

1100

1016

1101

def stop_checker(self):

1017

1102

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

1018

1103

if self.checker_callback_tag:

1019

gobject.source_remove(self.checker_callback_tag)

1104

GLib.source_remove(self.checker_callback_tag)

1020

1105

self.checker_callback_tag = None

1021

1106

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

1022

1107

return

1031

1116

byte_arrays=False):

1032

1117

"""Decorators for marking methods of a DBusObjectWithProperties to

1033

1118

become properties on the D-Bus.

1034

1119

1035

1120

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

1036

1121

and with one argument by "Set".

1037

1122

1038

1123

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

1039

1124

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

1040

1125

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

1044

1129

if byte_arrays and signature != "ay":

1045

1130

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

1046

1131

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

1047

1132

1048

1133

def decorator(func):

1049

1134

func._dbus_is_property = True

1050

1135

func._dbus_interface = dbus_interface

1053

1138

func._dbus_name = func.__name__

1054

1139

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

1055

1140

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

1056

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

1141

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

1057

1142

return func

1058

1143

1059

1144

return decorator

1060

1145

1061

1146

1062

1147

def dbus_interface_annotations(dbus_interface):

1063

1148

"""Decorator for marking functions returning interface annotations

1064

1149

1065

1150

Usage:

1066

1151

1067

1152

@dbus_interface_annotations("org.example.Interface")

1068

1153

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

1069

1154

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

1070

1155

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

1071

1156

"false"}

1072

1157

"""

1073

1158

1074

1159

def decorator(func):

1075

1160

func._dbus_is_interface = True

1076

1161

func._dbus_interface = dbus_interface

1077

1162

func._dbus_name = dbus_interface

1078

1163

return func

1079

1164

1080

1165

return decorator

1081

1166

1082

1167

1083

1168

def dbus_annotations(annotations):

1084

1169

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

1085

1170

Usage:

1086

1171

1087

1172

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

1088

1173

"org.freedesktop.DBus.Property."

1089

1174

"EmitsChangedSignal": "false"})

1091

1176

access="r")

1092

1177

def Property_dbus_property(self):

1093

1178

return dbus.Boolean(False)

1094

1179

1095

1180

See also the DBusObjectWithAnnotations class.

1096

1181

"""

1097

1182

1098

1183

def decorator(func):

1099

1184

func._dbus_annotations = annotations

1100

1185

return func

1101

1186

1102

1187

return decorator

1103

1188

1104

1189

1122

1207

1123

1208

class DBusObjectWithAnnotations(dbus.service.Object):

1124

1209

"""A D-Bus object with annotations.

1125

1210

1126

1211

Classes inheriting from this can use the dbus_annotations

1127

1212

decorator to add annotations to methods or signals.

1128

1213

"""

1129

1214

1130

1215

@staticmethod

1131

1216

def _is_dbus_thing(thing):

1132

1217

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

1133

1218

1134

1219

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

1135

1220

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

1136

1221

"""

1137

1222

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

1138

1223

False)

1139

1224

1140

1225

def _get_all_dbus_things(self, thing):

1141

1226

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

1142

1227

"""

1145

1230

for cls in self.__class__.__mro__

1146

1231

for name, athing in

1147

1232

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

1148

1233

1149

1234

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1150

out_signature = "s",

1151

path_keyword = 'object_path',

1152

connection_keyword = 'connection')

1235

out_signature="s",

1236

path_keyword='object_path',

1237

connection_keyword='connection')

1153

1238

def Introspect(self, object_path, connection):

1154

1239

"""Overloading of standard D-Bus method.

1155

1240

1156

1241

Inserts annotation tags on methods and signals.

1157

1242

"""

1158

1243

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

1159

1244

connection)

1160

1245

try:

1161

1246

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

1162

1247

1163

1248

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

1164

1249

# Add annotation tags

1165

1250

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

1192

1277

if_tag.appendChild(ann_tag)

1193

1278

# Fix argument name for the Introspect method itself

1194

1279

if (if_tag.getAttribute("name")

1195

== dbus.INTROSPECTABLE_IFACE):

1280

== dbus.INTROSPECTABLE_IFACE):

1196

1281

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

1197

1282

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

1198

1283

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

1211

1296

1212

1297

class DBusObjectWithProperties(DBusObjectWithAnnotations):

1213

1298

"""A D-Bus object with properties.

1214

1299

1215

1300

Classes inheriting from this can use the dbus_service_property

1216

1301

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

1217

1302

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

1218

1303

"""

1219

1304

1220

1305

def _get_dbus_property(self, interface_name, property_name):

1221

1306

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

1222

1307

property with the specified name and interface.

1227

1312

if (value._dbus_name == property_name

1228

1313

and value._dbus_interface == interface_name):

1229

1314

return value.__get__(self)

1230

1315

1231

1316

# No such property

1232

1317

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

1233

1318

self.dbus_object_path, interface_name, property_name))

1234

1319

1235

1320

@classmethod

1236

1321

def _get_all_interface_names(cls):

1237

1322

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

1240

1325

for x in (inspect.getmro(cls))

1241

1326

for attr in dir(x))

1242

1327

if name is not None)

1243

1328

1244

1329

@dbus.service.method(dbus.PROPERTIES_IFACE,

1245

1330

in_signature="ss",

1246

1331

out_signature="v")

1254

1339

if not hasattr(value, "variant_level"):

1255

1340

return value

1256

1341

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

1257

1342

1258

1343

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

1259

1344

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

1260

1345

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

1272

1357

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

1273

1358

for byte in value))

1274

1359

prop(value)

1275

1360

1276

1361

@dbus.service.method(dbus.PROPERTIES_IFACE,

1277

1362

in_signature="s",

1278

1363

out_signature="a{sv}")

1279

1364

def GetAll(self, interface_name):

1280

1365

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

1281

1366

standard.

1282

1367

1283

1368

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

1284

1369

"""

1285

1370

properties = {}

1296

1381

properties[name] = value

1297

1382

continue

1298

1383

properties[name] = type(value)(

1299

value, variant_level = value.variant_level + 1)

1384

value, variant_level=value.variant_level + 1)

1300

1385

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

1301

1386

1302

1387

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

1303

1388

def PropertiesChanged(self, interface_name, changed_properties,

1304

1389

invalidated_properties):

1306

1391

standard.

1307

1392

"""

1308

1393

pass

1309

1394

1310

1395

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1311

1396

out_signature="s",

1312

1397

path_keyword='object_path',

1313

1398

connection_keyword='connection')

1314

1399

def Introspect(self, object_path, connection):

1315

1400

"""Overloading of standard D-Bus method.

1316

1401

1317

1402

Inserts property tags and interface annotation tags.

1318

1403

"""

1319

1404

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1321

1406

connection)

1322

1407

try:

1323

1408

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

1324

1409

1325

1410

def make_tag(document, name, prop):

1326

1411

e = document.createElement("property")

1327

1412

e.setAttribute("name", name)

1328

1413

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

1329

1414

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

1330

1415

return e

1331

1416

1332

1417

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

1333

1418

# Add property tags

1334

1419

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

1376

1461

exc_info=error)

1377

1462

return xmlstring

1378

1463

1464

1379

1465

try:

1380

1466

dbus.OBJECT_MANAGER_IFACE

1381

1467

except AttributeError:

1382

1468

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

1383

1469

1470

1384

1471

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1385

1472

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

1386

1473

1387

1474

Classes inheriting from this exposes the standard

1388

1475

GetManagedObjects call and the InterfacesAdded and

1389

1476

InterfacesRemoved signals on the standard

1390

1477

"org.freedesktop.DBus.ObjectManager" interface.

1391

1478

1392

1479

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

1393

1480

manually.

1394

1481

"""

1395

1482

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1396

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

1483

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

1397

1484

def GetManagedObjects(self):

1398

1485

"""This function must be overridden"""

1399

1486

raise NotImplementedError()

1400

1487

1401

1488

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1402

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

1489

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

1403

1490

def InterfacesAdded(self, object_path, interfaces_and_properties):

1404

1491

pass

1405

1406

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

1492

1493

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

1407

1494

def InterfacesRemoved(self, object_path, interfaces):

1408

1495

pass

1409

1496

1410

1497

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1411

out_signature = "s",

1412

path_keyword = 'object_path',

1413

connection_keyword = 'connection')

1498

out_signature="s",

1499

path_keyword='object_path',

1500

connection_keyword='connection')

1414

1501

def Introspect(self, object_path, connection):

1415

1502

"""Overloading of standard D-Bus method.

1416

1503

1417

1504

Override return argument name of GetManagedObjects to be

1418

1505

"objpath_interfaces_and_properties"

1419

1506

"""

1422

1509

connection)

1423

1510

try:

1424

1511

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

1425

1512

1426

1513

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

1427

1514

# Fix argument name for the GetManagedObjects method

1428

1515

if (if_tag.getAttribute("name")

1429

== dbus.OBJECT_MANAGER_IFACE):

1516

== dbus.OBJECT_MANAGER_IFACE):

1430

1517

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

1431

1518

if (cn.getAttribute("name")

1432

1519

== "GetManagedObjects"):

1442

1529

except (AttributeError, xml.dom.DOMException,

1443

1530

xml.parsers.expat.ExpatError) as error:

1444

1531

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

1445

exc_info = error)

1532

exc_info=error)

1446

1533

return xmlstring

1447

1534

1535

1448

1536

def datetime_to_dbus(dt, variant_level=0):

1449

1537

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

1450

1538

if dt is None:

1451

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

1539

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

1452

1540

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

1453

1541

1454

1542

1457

1545

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

1458

1546

interface names according to the "alt_interface_names" mapping.

1459

1547

Usage:

1460

1548

1461

1549

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

1462

1550

"net.example.AlternateInterface"})

1463

1551

class SampleDBusObject(dbus.service.Object):

1464

1552

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

1465

1553

def SampleDBusMethod():

1466

1554

pass

1467

1555

1468

1556

The above "SampleDBusMethod" on "SampleDBusObject" will be

1469

1557

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

1470

1558

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

1471

1559

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

1472

1560

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

1473

1561

1474

1562

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

1475

1563

(from DBusObjectWithProperties) and interfaces (from the

1476

1564

dbus_interface_annotations decorator).

1477

1565

"""

1478

1566

1479

1567

def wrapper(cls):

1480

1568

for orig_interface_name, alt_interface_name in (

1481

1569

alt_interface_names.items()):

1496

1584

interface_names.add(alt_interface)

1497

1585

# Is this a D-Bus signal?

1498

1586

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

1587

# Extract the original non-method undecorated

1588

# function by black magic

1499

1589

if sys.version_info.major == 2:

1500

# Extract the original non-method undecorated

1501

# function by black magic

1502

1590

nonmethod_func = (dict(

1503

1591

zip(attribute.func_code.co_freevars,

1504

1592

attribute.__closure__))

1505

1593

["func"].cell_contents)

1506

1594

else:

1507

nonmethod_func = attribute

1595

nonmethod_func = (dict(

1596

zip(attribute.__code__.co_freevars,

1597

attribute.__closure__))

1598

["func"].cell_contents)

1508

1599

# Create a new, but exactly alike, function

1509

1600

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

1510

1601

# with the alternate D-Bus interface name

1511

if sys.version_info.major == 2:

1512

new_function = types.FunctionType(

1513

nonmethod_func.func_code,

1514

nonmethod_func.func_globals,

1515

nonmethod_func.func_name,

1516

nonmethod_func.func_defaults,

1517

nonmethod_func.func_closure)

1518

else:

1519

new_function = types.FunctionType(

1520

nonmethod_func.__code__,

1521

nonmethod_func.__globals__,

1522

nonmethod_func.__name__,

1523

nonmethod_func.__defaults__,

1524

nonmethod_func.__closure__)

1602

new_function = copy_function(nonmethod_func)

1525

1603

new_function = (dbus.service.signal(

1526

1604

alt_interface,

1527

1605

attribute._dbus_signature)(new_function))

1531

1609

attribute._dbus_annotations)

1532

1610

except AttributeError:

1533

1611

pass

1612

1534

1613

# Define a creator of a function to call both the

1535

1614

# original and alternate functions, so both the

1536

1615

# original and alternate signals gets sent when

1539

1618

"""This function is a scope container to pass

1540

1619

func1 and func2 to the "call_both" function

1541

1620

outside of its arguments"""

1542

1621

1543

1622

@functools.wraps(func2)

1544

1623

def call_both(*args, **kwargs):

1545

1624

"""This function will emit two D-Bus

1546

1625

signals by calling func1 and func2"""

1547

1626

func1(*args, **kwargs)

1548

1627

func2(*args, **kwargs)

1549

# Make wrapper function look like a D-Bus signal

1628

# Make wrapper function look like a D-Bus

1629

# signal

1550

1630

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

1551

1631

if name.startswith("_dbus_"):

1552

1632

setattr(call_both, name, attr)

1553

1633

1554

1634

return call_both

1555

1635

# Create the "call_both" function and add it to

1556

1636

# the class

1566

1646

alt_interface,

1567

1647

attribute._dbus_in_signature,

1568

1648

attribute._dbus_out_signature)

1569

(types.FunctionType(attribute.func_code,

1570

attribute.func_globals,

1571

attribute.func_name,

1572

attribute.func_defaults,

1573

attribute.func_closure)))

1649

(copy_function(attribute)))

1574

1650

# Copy annotations, if any

1575

1651

try:

1576

1652

attr[attrname]._dbus_annotations = dict(

1588

1664

attribute._dbus_access,

1589

1665

attribute._dbus_get_args_options

1590

1666

["byte_arrays"])

1591

(types.FunctionType(

1592

attribute.func_code,

1593

attribute.func_globals,

1594

attribute.func_name,

1595

attribute.func_defaults,

1596

attribute.func_closure)))

1667

(copy_function(attribute)))

1597

1668

# Copy annotations, if any

1598

1669

try:

1599

1670

attr[attrname]._dbus_annotations = dict(

1608

1679

# to the class.

1609

1680

attr[attrname] = (

1610

1681

dbus_interface_annotations(alt_interface)

1611

(types.FunctionType(attribute.func_code,

1612

attribute.func_globals,

1613

attribute.func_name,

1614

attribute.func_defaults,

1615

attribute.func_closure)))

1682

(copy_function(attribute)))

1616

1683

if deprecate:

1617

1684

# Deprecate all alternate interfaces

1618

iname="_AlternateDBusNames_interface_annotation{}"

1685

iname = "_AlternateDBusNames_interface_annotation{}"

1619

1686

for interface_name in interface_names:

1620

1687

1621

1688

@dbus_interface_annotations(interface_name)

1622

1689

def func(self):

1623

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

1624

"true" }

1690

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

1691

"true"}

1625

1692

# Find an unused name

1626

1693

for aname in (iname.format(i)

1627

1694

for i in itertools.count()):

1631

1698

if interface_names:

1632

1699

# Replace the class with a new subclass of it with

1633

1700

# methods, signals, etc. as created above.

1634

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

1635

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

1636

1707

return cls

1637

1708

1638

1709

return wrapper

1639

1710

1640

1711

1642

1713

"se.bsnet.fukt.Mandos"})

1643

1714

class ClientDBus(Client, DBusObjectWithProperties):

1644

1715

"""A Client class using D-Bus

1645

1716

1646

1717

Attributes:

1647

1718

dbus_object_path: dbus.ObjectPath

1648

1719

bus: dbus.SystemBus()

1649

1720

"""

1650

1721

1651

1722

runtime_expansions = (Client.runtime_expansions

1652

1723

+ ("dbus_object_path", ))

1653

1724

1654

1725

_interface = "se.recompile.Mandos.Client"

1655

1726

1656

1727

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

1657

1658

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

1728

1729

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

1659

1730

self.bus = bus

1660

1731

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

1661

1732

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

1667

1738

"/clients/" + client_object_name)

1668

1739

DBusObjectWithProperties.__init__(self, self.bus,

1669

1740

self.dbus_object_path)

1670

1741

1671

1742

def notifychangeproperty(transform_func, dbus_name,

1672

1743

type_func=lambda x: x,

1673

1744

variant_level=1,

1675

1746

_interface=_interface):

1676

1747

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

1677

1748

its changes to DBus.

1678

1749

1679

1750

transform_fun: Function that takes a value and a variant_level

1680

1751

and transforms it to a D-Bus type.

1681

1752

dbus_name: D-Bus name of the variable

1684

1755

variant_level: D-Bus variant level. Default: 1

1685

1756

"""

1686

1757

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

1687

1758

1688

1759

def setter(self, value):

1689

1760

if hasattr(self, "dbus_object_path"):

1690

1761

if (not hasattr(self, attrname) or

1697

1768

else:

1698

1769

dbus_value = transform_func(

1699

1770

type_func(value),

1700

variant_level = variant_level)

1771

variant_level=variant_level)

1701

1772

self.PropertyChanged(dbus.String(dbus_name),

1702

1773

dbus_value)

1703

1774

self.PropertiesChanged(

1704

1775

_interface,

1705

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

1706

dbus_value }),

1776

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

1777

dbus_value}),

1707

1778

dbus.Array())

1708

1779

setattr(self, attrname, value)

1709

1780

1710

1781

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

1711

1782

1712

1783

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1713

1784

approvals_pending = notifychangeproperty(dbus.Boolean,

1714

1785

"ApprovalPending",

1715

type_func = bool)

1786

type_func=bool)

1716

1787

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

1717

1788

last_enabled = notifychangeproperty(datetime_to_dbus,

1718

1789

"LastEnabled")

1719

1790

checker = notifychangeproperty(

1720

1791

dbus.Boolean, "CheckerRunning",

1721

type_func = lambda checker: checker is not None)

1792

type_func=lambda checker: checker is not None)

1722

1793

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1723

1794

"LastCheckedOK")

1724

1795

last_checker_status = notifychangeproperty(dbus.Int16,

1729

1800

"ApprovedByDefault")

1730

1801

approval_delay = notifychangeproperty(

1731

1802

dbus.UInt64, "ApprovalDelay",

1732

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

1803

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

1733

1804

approval_duration = notifychangeproperty(

1734

1805

dbus.UInt64, "ApprovalDuration",

1735

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

1806

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

1736

1807

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

1737

1808

timeout = notifychangeproperty(

1738

1809

dbus.UInt64, "Timeout",

1739

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

1810

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

1740

1811

extended_timeout = notifychangeproperty(

1741

1812

dbus.UInt64, "ExtendedTimeout",

1742

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

1813

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

1743

1814

interval = notifychangeproperty(

1744

1815

dbus.UInt64, "Interval",

1745

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

1816

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

1746

1817

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

1747

1818

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

1748

1819

invalidate_only=True)

1749

1820

1750

1821

del notifychangeproperty

1751

1822

1752

1823

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

1753

1824

try:

1754

1825

self.remove_from_connection()

1757

1828

if hasattr(DBusObjectWithProperties, "__del__"):

1758

1829

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

1759

1830

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

1760

1831

1761

1832

def checker_callback(self, source, condition,

1762

1833

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

1763

1834

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

1779

1850

| self.last_checker_signal),

1780

1851

dbus.String(command))

1781

1852

return ret

1782

1853

1783

1854

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

1784

1855

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

1785

1856

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

1789

1860

# Emit D-Bus signal

1790

1861

self.CheckerStarted(self.current_checker_command)

1791

1862

return r

1792

1863

1793

1864

def _reset_approved(self):

1794

1865

self.approved = None

1795

1866

return False

1796

1867

1797

1868

def approve(self, value=True):

1798

1869

self.approved = value

1799

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

1800

* 1000), self._reset_approved)

1870

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

1871

* 1000), self._reset_approved)

1801

1872

self.send_changedstate()

1802

1803

## D-Bus methods, signals & properties

1804

1805

## Interfaces

1806

1807

## Signals

1808

1873

1874

# D-Bus methods, signals & properties

1875

1876

# Interfaces

1877

1878

# Signals

1879

1809

1880

# CheckerCompleted - signal

1810

1881

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

1811

1882

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

1812

1883

"D-Bus signal"

1813

1884

pass

1814

1885

1815

1886

# CheckerStarted - signal

1816

1887

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

1817

1888

def CheckerStarted(self, command):

1818

1889

"D-Bus signal"

1819

1890

pass

1820

1891

1821

1892

# PropertyChanged - signal

1822

1893

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

1823

1894

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

1824

1895

def PropertyChanged(self, property, value):

1825

1896

"D-Bus signal"

1826

1897

pass

1827

1898

1828

1899

# GotSecret - signal

1829

1900

@dbus.service.signal(_interface)

1830

1901

def GotSecret(self):

1833

1904

server to mandos-client

1834

1905

"""

1835

1906

pass

1836

1907

1837

1908

# Rejected - signal

1838

1909

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

1839

1910

def Rejected(self, reason):

1840

1911

"D-Bus signal"

1841

1912

pass

1842

1913

1843

1914

# NeedApproval - signal

1844

1915

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

1845

1916

def NeedApproval(self, timeout, default):

1846

1917

"D-Bus signal"

1847

1918

return self.need_approval()

1848

1849

## Methods

1850

1919

1920

# Methods

1921

1851

1922

# Approve - method

1852

1923

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

1853

1924

def Approve(self, value):

1854

1925

self.approve(value)

1855

1926

1856

1927

# CheckedOK - method

1857

1928

@dbus.service.method(_interface)

1858

1929

def CheckedOK(self):

1859

1930

self.checked_ok()

1860

1931

1861

1932

# Enable - method

1862

1933

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

1863

1934

@dbus.service.method(_interface)

1864

1935

def Enable(self):

1865

1936

"D-Bus method"

1866

1937

self.enable()

1867

1938

1868

1939

# StartChecker - method

1869

1940

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

1870

1941

@dbus.service.method(_interface)

1871

1942

def StartChecker(self):

1872

1943

"D-Bus method"

1873

1944

self.start_checker()

1874

1945

1875

1946

# Disable - method

1876

1947

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

1877

1948

@dbus.service.method(_interface)

1878

1949

def Disable(self):

1879

1950

"D-Bus method"

1880

1951

self.disable()

1881

1952

1882

1953

# StopChecker - method

1883

1954

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

1884

1955

@dbus.service.method(_interface)

1885

1956

def StopChecker(self):

1886

1957

self.stop_checker()

1887

1888

## Properties

1889

1958

1959

# Properties

1960

1890

1961

# ApprovalPending - property

1891

1962

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

1892

1963

def ApprovalPending_dbus_property(self):

1893

1964

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

1894

1965

1895

1966

# ApprovedByDefault - property

1896

1967

@dbus_service_property(_interface,

1897

1968

signature="b",

1900

1971

if value is None: # get

1901

1972

return dbus.Boolean(self.approved_by_default)

1902

1973

self.approved_by_default = bool(value)

1903

1974

1904

1975

# ApprovalDelay - property

1905

1976

@dbus_service_property(_interface,

1906

1977

signature="t",

1910

1981

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

1911

1982

* 1000)

1912

1983

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

1913

1984

1914

1985

# ApprovalDuration - property

1915

1986

@dbus_service_property(_interface,

1916

1987

signature="t",

1920

1991

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

1921

1992

* 1000)

1922

1993

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

1923

1994

1924

1995

# Name - property

1925

1996

@dbus_annotations(

1926

1997

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

1927

1998

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

1928

1999

def Name_dbus_property(self):

1929

2000

return dbus.String(self.name)

1930

2001

1931

2002

# Fingerprint - property

1932

2003

@dbus_annotations(

1933

2004

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

1934

2005

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

1935

2006

def Fingerprint_dbus_property(self):

1936

2007

return dbus.String(self.fingerprint)

1937

2008

1938

2009

# Host - property

1939

2010

@dbus_service_property(_interface,

1940

2011

signature="s",

1943

2014

if value is None: # get

1944

2015

return dbus.String(self.host)

1945

2016

self.host = str(value)

1946

2017

1947

2018

# Created - property

1948

2019

@dbus_annotations(

1949

2020

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

1950

2021

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

1951

2022

def Created_dbus_property(self):

1952

2023

return datetime_to_dbus(self.created)

1953

2024

1954

2025

# LastEnabled - property

1955

2026

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

1956

2027

def LastEnabled_dbus_property(self):

1957

2028

return datetime_to_dbus(self.last_enabled)

1958

2029

1959

2030

# Enabled - property

1960

2031

@dbus_service_property(_interface,

1961

2032

signature="b",

1967

2038

self.enable()

1968

2039

else:

1969

2040

self.disable()

1970

2041

1971

2042

# LastCheckedOK - property

1972

2043

@dbus_service_property(_interface,

1973

2044

signature="s",

1977

2048

self.checked_ok()

1978

2049

return

1979

2050

return datetime_to_dbus(self.last_checked_ok)

1980

2051

1981

2052

# LastCheckerStatus - property

1982

2053

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

1983

2054

def LastCheckerStatus_dbus_property(self):

1984

2055

return dbus.Int16(self.last_checker_status)

1985

2056

1986

2057

# Expires - property

1987

2058

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

1988

2059

def Expires_dbus_property(self):

1989

2060

return datetime_to_dbus(self.expires)

1990

2061

1991

2062

# LastApprovalRequest - property

1992

2063

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

1993

2064

def LastApprovalRequest_dbus_property(self):

1994

2065

return datetime_to_dbus(self.last_approval_request)

1995

2066

1996

2067

# Timeout - property

1997

2068

@dbus_service_property(_interface,

1998

2069

signature="t",

2013

2084

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

2014

2085

is None):

2015

2086

return

2016

gobject.source_remove(self.disable_initiator_tag)

2017

self.disable_initiator_tag = gobject.timeout_add(

2087

GLib.source_remove(self.disable_initiator_tag)

2088

self.disable_initiator_tag = GLib.timeout_add(

2018

2089

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

2019

2090

self.disable)

2020

2091

2021

2092

# ExtendedTimeout - property

2022

2093

@dbus_service_property(_interface,

2023

2094

signature="t",

2027

2098

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

2028

2099

* 1000)

2029

2100

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

2030

2101

2031

2102

# Interval - property

2032

2103

@dbus_service_property(_interface,

2033

2104

signature="t",

2040

2111

return

2041

2112

if self.enabled:

2042

2113

# Reschedule checker run

2043

gobject.source_remove(self.checker_initiator_tag)

2044

self.checker_initiator_tag = gobject.timeout_add(

2114

GLib.source_remove(self.checker_initiator_tag)

2115

self.checker_initiator_tag = GLib.timeout_add(

2045

2116

value, self.start_checker)

2046

self.start_checker() # Start one now, too

2047

2117

self.start_checker() # Start one now, too

2118

2048

2119

# Checker - property

2049

2120

@dbus_service_property(_interface,

2050

2121

signature="s",

2053

2124

if value is None: # get

2054

2125

return dbus.String(self.checker_command)

2055

2126

self.checker_command = str(value)

2056

2127

2057

2128

# CheckerRunning - property

2058

2129

@dbus_service_property(_interface,

2059

2130

signature="b",

2065

2136

self.start_checker()

2066

2137

else:

2067

2138

self.stop_checker()

2068

2139

2069

2140

# ObjectPath - property

2070

2141

@dbus_annotations(

2071

2142

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

2072

2143

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

2073

2144

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

2074

2145

def ObjectPath_dbus_property(self):

2075

return self.dbus_object_path # is already a dbus.ObjectPath

2076

2146

return self.dbus_object_path # is already a dbus.ObjectPath

2147

2077

2148

# Secret = property

2078

2149

@dbus_annotations(

2079

2150

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

2084

2155

byte_arrays=True)

2085

2156

def Secret_dbus_property(self, value):

2086

2157

self.secret = bytes(value)

2087

2158

2088

2159

del _interface

2089

2160

2090

2161

2094

2165

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

2095

2166

if not self._pipe.recv():

2096

2167

raise KeyError(fpr)

2097

2168

2098

2169

def __getattribute__(self, name):

2099

2170

if name == '_pipe':

2100

2171

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

2103

2174

if data[0] == 'data':

2104

2175

return data[1]

2105

2176

if data[0] == 'function':

2106

2177

2107

2178

def func(*args, **kwargs):

2108

2179

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

2109

2180

return self._pipe.recv()[1]

2110

2181

2111

2182

return func

2112

2183

2113

2184

def __setattr__(self, name, value):

2114

2185

if name == '_pipe':

2115

2186

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

2118

2189

2119

2190

class ClientHandler(socketserver.BaseRequestHandler, object):

2120

2191

"""A class to handle client connections.

2121

2192

2122

2193

Instantiated once for each connection to handle it.

2123

2194

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

2124

2195

2125

2196

def handle(self):

2126

2197

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

2127

2198

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

2128

2199

str(self.client_address))

2129

2200

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

2130

2201

self.server.child_pipe.fileno())

2131

2202

2132

2203

session = gnutls.ClientSession(self.request)

2133

2134

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

2135

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

2136

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

2137

# "+DHE-DSS"))

2204

2205

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

2206

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

2207

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

2208

# "+DHE-DSS"))

2138

2209

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

2139

2210

priority = self.server.gnutls_priority

2140

2211

if priority is None:

2141

2212

priority = "NORMAL"

2142

gnutls.priority_set_direct(session._c_object, priority,

2213

gnutls.priority_set_direct(session._c_object,

2214

priority.encode("utf-8"),

2143

2215

None)

2144

2216

2145

2217

# Start communication using the Mandos protocol

2146

2218

# Get protocol number

2147

2219

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

2152

2224

except (ValueError, IndexError, RuntimeError) as error:

2153

2225

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

2154

2226

return

2155

2227

2156

2228

# Start GnuTLS connection

2157

2229

try:

2158

2230

session.handshake()

2162

2234

# established. Just abandon the request.

2163

2235

return

2164

2236

logger.debug("Handshake succeeded")

2165

2237

2166

2238

approval_required = False

2167

2239

try:

2168

2240

try:

2172

2244

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

2173

2245

return

2174

2246

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

2175

2247

2176

2248

try:

2177

2249

client = ProxyClient(child_pipe, fpr,

2178

2250

self.client_address)

2179

2251

except KeyError:

2180

2252

return

2181

2253

2182

2254

if client.approval_delay:

2183

2255

delay = client.approval_delay

2184

2256

client.approvals_pending += 1

2185

2257

approval_required = True

2186

2258

2187

2259

while True:

2188

2260

if not client.enabled:

2189

2261

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

2192

2264

# Emit D-Bus signal

2193

2265

client.Rejected("Disabled")

2194

2266

return

2195

2267

2196

2268

if client.approved or not client.approval_delay:

2197

#We are approved or approval is disabled

2269

# We are approved or approval is disabled

2198

2270

break

2199

2271

elif client.approved is None:

2200

2272

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

2211

2283

# Emit D-Bus signal

2212

2284

client.Rejected("Denied")

2213

2285

return

2214

2215

#wait until timeout or approved

2286

2287

# wait until timeout or approved

2216

2288

time = datetime.datetime.now()

2217

2289

client.changedstate.acquire()

2218

2290

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

2231

2303

break

2232

2304

else:

2233

2305

delay -= time2 - time

2234

2306

2235

2307

try:

2236

2308

session.send(client.secret)

2237

2309

except gnutls.Error as error:

2238

2310

logger.warning("gnutls send failed",

2239

exc_info = error)

2311

exc_info=error)

2240

2312

return

2241

2313

2242

2314

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

2243

2315

# bump the timeout using extended_timeout

2244

2316

client.bump_timeout(client.extended_timeout)

2245

2317

if self.server.use_dbus:

2246

2318

# Emit D-Bus signal

2247

2319

client.GotSecret()

2248

2320

2249

2321

finally:

2250

2322

if approval_required:

2251

2323

client.approvals_pending -= 1

2254

2326

except gnutls.Error as error:

2255

2327

logger.warning("GnuTLS bye failed",

2256

2328

exc_info=error)

2257

2329

2258

2330

@staticmethod

2259

2331

def peer_certificate(session):

2260

2332

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

2272

2344

return None

2273

2345

cert = cert_list[0]

2274

2346

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

2275

2347

2276

2348

@staticmethod

2277

2349

def fingerprint(openpgp):

2278

2350

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2311

2383

2312

2384

class MultiprocessingMixIn(object):

2313

2385

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

2314

2386

2315

2387

def sub_process_main(self, request, address):

2316

2388

try:

2317

2389

self.finish_request(request, address)

2318

2390

except Exception:

2319

2391

self.handle_error(request, address)

2320

2392

self.close_request(request)

2321

2393

2322

2394

def process_request(self, request, address):

2323

2395

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

2324

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

2325

args = (request, address))

2396

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

2397

args=(request, address))

2326

2398

proc.start()

2327

2399

return proc

2328

2400

2329

2401

2330

2402

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2331

2403

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

2332

2404

2333

2405

def process_request(self, request, client_address):

2334

2406

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

2335

2407

2336

2408

This function creates a new pipe in self.pipe

2337

2409

"""

2338

2410

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2339

2411

2340

2412

proc = MultiprocessingMixIn.process_request(self, request,

2341

2413

client_address)

2342

2414

self.child_pipe.close()

2343

2415

self.add_pipe(parent_pipe, proc)

2344

2416

2345

2417

def add_pipe(self, parent_pipe, proc):

2346

2418

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

2347

2419

raise NotImplementedError()

2350

2422

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2351

2423

socketserver.TCPServer, object):

2352

2424

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

2353

2425

2354

2426

Attributes:

2355

2427

enabled: Boolean; whether this server is activated yet

2356

2428

interface: None or a network interface name (string)

2357

2429

use_ipv6: Boolean; to use IPv6 or not

2358

2430

"""

2359

2431

2360

2432

def __init__(self, server_address, RequestHandlerClass,

2361

2433

interface=None,

2362

2434

use_ipv6=True,

2372

2444

self.socketfd = socketfd

2373

2445

# Save the original socket.socket() function

2374

2446

self.socket_socket = socket.socket

2447

2375

2448

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

2376

#

2449

#

2377

2450

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

2378

2451

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

2379

2452

# patching socket.socket.)

2380

#

2453

#

2381

2454

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

2382

2455

@functools.wraps(socket.socket)

2383

2456

def socket_wrapper(*args, **kwargs):

2395

2468

# socket_wrapper(), if socketfd was set.

2396

2469

socketserver.TCPServer.__init__(self, server_address,

2397

2470

RequestHandlerClass)

2398

2471

2399

2472

def server_bind(self):

2400

2473

"""This overrides the normal server_bind() function

2401

2474

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

2402

2475

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

2476

global SO_BINDTODEVICE

2403

2477

if self.interface is not None:

2404

2478

if SO_BINDTODEVICE is None:

2405

logger.error("SO_BINDTODEVICE does not exist;"

2406

" cannot bind to interface %s",

2407

self.interface)

2408

else:

2409

try:

2410

self.socket.setsockopt(

2411

socket.SOL_SOCKET, SO_BINDTODEVICE,

2412

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

2413

except socket.error as error:

2414

if error.errno == errno.EPERM:

2415

logger.error("No permission to bind to"

2416

" interface %s", self.interface)

2417

elif error.errno == errno.ENOPROTOOPT:

2418

logger.error("SO_BINDTODEVICE not available;"

2419

" cannot bind to interface %s",

2420

self.interface)

2421

elif error.errno == errno.ENODEV:

2422

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

2423

" cannot bind", self.interface)

2424

else:

2425

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

2426

2500

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

2427

2501

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

2428

2502

if not self.server_address[0]:

2429

2503

if self.address_family == socket.AF_INET6:

2430

any_address = "::" # in6addr_any

2504

any_address = "::" # in6addr_any

2431

2505

else:

2432

any_address = "0.0.0.0" # INADDR_ANY

2506

any_address = "0.0.0.0" # INADDR_ANY

2433

2507

self.server_address = (any_address,

2434

2508

self.server_address[1])

2435

2509

elif not self.server_address[1]:

2445

2519

2446

2520

class MandosServer(IPv6_TCPServer):

2447

2521

"""Mandos server.

2448

2522

2449

2523

Attributes:

2450

2524

clients: set of Client objects

2451

2525

gnutls_priority GnuTLS priority string

2452

2526

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

2453

2454

Assumes a gobject.MainLoop event loop.

2527

2528

Assumes a GLib.MainLoop event loop.

2455

2529

"""

2456

2530

2457

2531

def __init__(self, server_address, RequestHandlerClass,

2458

2532

interface=None,

2459

2533

use_ipv6=True,

2469

2543

self.gnutls_priority = gnutls_priority

2470

2544

IPv6_TCPServer.__init__(self, server_address,

2471

2545

RequestHandlerClass,

2472

interface = interface,

2473

use_ipv6 = use_ipv6,

2474

socketfd = socketfd)

2475

2546

interface=interface,

2547

use_ipv6=use_ipv6,

2548

socketfd=socketfd)

2549

2476

2550

def server_activate(self):

2477

2551

if self.enabled:

2478

2552

return socketserver.TCPServer.server_activate(self)

2479

2553

2480

2554

def enable(self):

2481

2555

self.enabled = True

2482

2556

2483

2557

def add_pipe(self, parent_pipe, proc):

2484

2558

# Call "handle_ipc" for both data and EOF events

2485

gobject.io_add_watch(

2559

GLib.io_add_watch(

2486

2560

parent_pipe.fileno(),

2487

gobject.IO_IN | gobject.IO_HUP,

2561

GLib.IO_IN | GLib.IO_HUP,

2488

2562

functools.partial(self.handle_ipc,

2489

parent_pipe = parent_pipe,

2490

proc = proc))

2491

2563

parent_pipe=parent_pipe,

2564

proc=proc))

2565

2492

2566

def handle_ipc(self, source, condition,

2493

2567

parent_pipe=None,

2494

proc = None,

2568

proc=None,

2495

2569

client_object=None):

2496

2570

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

2497

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

2571

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

2498

2572

# Wait for other process to exit

2499

2573

proc.join()

2500

2574

return False

2501

2575

2502

2576

# Read a request from the child

2503

2577

request = parent_pipe.recv()

2504

2578

command = request[0]

2505

2579

2506

2580

if command == 'init':

2507

fpr = request[1]

2581

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

2508

2582

address = request[2]

2509

2510

for c in self.clients.itervalues():

2583

2584

for c in self.clients.values():

2511

2585

if c.fingerprint == fpr:

2512

2586

client = c

2513

2587

break

2520

2594

address[0])

2521

2595

parent_pipe.send(False)

2522

2596

return False

2523

2524

gobject.io_add_watch(

2597

2598

GLib.io_add_watch(

2525

2599

parent_pipe.fileno(),

2526

gobject.IO_IN | gobject.IO_HUP,

2600

GLib.IO_IN | GLib.IO_HUP,

2527

2601

functools.partial(self.handle_ipc,

2528

parent_pipe = parent_pipe,

2529

proc = proc,

2530

client_object = client))

2602

parent_pipe=parent_pipe,

2603

proc=proc,

2604

client_object=client))

2531

2605

parent_pipe.send(True)

2532

2606

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

2533

2607

# same fileno

2536

2610

funcname = request[1]

2537

2611

args = request[2]

2538

2612

kwargs = request[3]

2539

2613

2540

2614

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

2541

2615

funcname)(*args,

2542

2616

**kwargs)))

2543

2617

2544

2618

if command == 'getattr':

2545

2619

attrname = request[1]

2546

2620

if isinstance(client_object.__getattribute__(attrname),

2549

2623

else:

2550

2624

parent_pipe.send((

2551

2625

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

2552

2626

2553

2627

if command == 'setattr':

2554

2628

attrname = request[1]

2555

2629

value = request[2]

2556

2630

setattr(client_object, attrname, value)

2557

2631

2558

2632

return True

2559

2633

2560

2634

2561

2635

def rfc3339_duration_to_delta(duration):

2562

2636

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

2563

2637

2564

2638

>>> rfc3339_duration_to_delta("P7D")

2565

2639

datetime.timedelta(7)

2566

2640

>>> rfc3339_duration_to_delta("PT60S")

2576

2650

>>> rfc3339_duration_to_delta("P1DT3M20S")

2577

2651

datetime.timedelta(1, 200)

2578

2652

"""

2579

2653

2580

2654

# Parsing an RFC 3339 duration with regular expressions is not

2581

2655

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

2582

2656

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

2583

2657

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

2584

2658

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

2585

2659

# avoid excessive use of external libraries.

2586

2660

2587

2661

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

2588

2662

Token = collections.namedtuple("Token", (

2589

2663

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

2622

2696

frozenset((token_year, token_month,

2623

2697

token_day, token_time,

2624

2698

token_week)))

2625

# Define starting values

2626

value = datetime.timedelta() # Value so far

2699

# Define starting values:

2700

# Value so far

2701

value = datetime.timedelta()

2627

2702

found_token = None

2628

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

2629

s = duration # String left to parse

2703

# Following valid tokens

2704

followers = frozenset((token_duration, ))

2705

# String left to parse

2706

s = duration

2630

2707

# Loop until end token is found

2631

2708

while found_token is not token_end:

2632

2709

# Search for any currently valid tokens

2656

2733

2657

2734

def string_to_delta(interval):

2658

2735

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

2659

2736

2660

2737

>>> string_to_delta('7d')

2661

2738

datetime.timedelta(7)

2662

2739

>>> string_to_delta('60s')

2670

2747

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

2671

2748

datetime.timedelta(0, 330)

2672

2749

"""

2673

2750

2674

2751

try:

2675

2752

return rfc3339_duration_to_delta(interval)

2676

2753

except ValueError:

2677

2754

pass

2678

2755

2679

2756

timevalue = datetime.timedelta(0)

2680

2757

for s in interval.split():

2681

2758

try:

2699

2776

return timevalue

2700

2777

2701

2778

2702

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

2779

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

2703

2780

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

2704

2781

2705

2782

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

2706

2783

if os.fork():

2707

2784

sys.exit()

2725

2802

2726

2803

2727

2804

def main():

2728

2805

2729

2806

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

2730

2807

# Parsing of options, both command line and config file

2731

2808

2732

2809

parser = argparse.ArgumentParser()

2733

2810

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

2734

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

2811

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

2735

2812

help="show version number and exit")

2736

2813

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

2737

2814

help="Bind to interface IF")

2773

2850

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

2774

2851

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

2775

2852

default=None)

2776

2853

2777

2854

options = parser.parse_args()

2778

2855

2779

2856

if options.check:

2780

2857

import doctest

2781

2858

fail_count, test_count = doctest.testmod()

2782

2859

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

2783

2860

2784

2861

# Default values for config file for server-global settings

2785

server_defaults = { "interface": "",

2786

"address": "",

2787

"port": "",

2788

"debug": "False",

2789

"priority":

2790

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

2791

":+SIGN-DSA-SHA256",

2792

"servicename": "Mandos",

2793

"use_dbus": "True",

2794

"use_ipv6": "True",

2795

"debuglevel": "",

2796

"restore": "True",

2797

"socket": "",

2798

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

2799

"foreground": "False",

2800

"zeroconf": "True",

2801

}

2802

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

2803

2880

# Parse config file for server-global settings

2804

2881

server_config = configparser.SafeConfigParser(server_defaults)

2805

2882

del server_defaults

2807

2884

# Convert the SafeConfigParser object to a dict

2808

2885

server_settings = server_config.defaults()

2809

2886

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

2810

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

2887

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

2888

"foreground", "zeroconf"):

2811

2889

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

2812

2890

option)

2813

2891

if server_settings["port"]:

2823

2901

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

2824

2902

["socket"])

2825

2903

del server_config

2826

2904

2827

2905

# Override the settings from the config file with command line

2828

2906

# options, if set.

2829

2907

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

2847

2925

if server_settings["debug"]:

2848

2926

server_settings["foreground"] = True

2849

2927

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

2850

2928

2851

2929

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

2852

2930

2853

2931

if (not server_settings["zeroconf"]

2854

2932

and not (server_settings["port"]

2855

2933

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

2856

2934

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

2857

2935

2858

2936

# For convenience

2859

2937

debug = server_settings["debug"]

2860

2938

debuglevel = server_settings["debuglevel"]

2864

2942

stored_state_file)

2865

2943

foreground = server_settings["foreground"]

2866

2944

zeroconf = server_settings["zeroconf"]

2867

2945

2868

2946

if debug:

2869

2947

initlogger(debug, logging.DEBUG)

2870

2948

else:

2873

2951

else:

2874

2952

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

2875

2953

initlogger(debug, level)

2876

2954

2877

2955

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

2878

2956

syslogger.setFormatter(

2879

2957

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

2880

2958

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

2881

2959

server_settings["servicename"])))

2882

2960

2883

2961

# Parse config file with clients

2884

2962

client_config = configparser.SafeConfigParser(Client

2885

2963

.client_defaults)

2886

2964

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

2887

2965

"clients.conf"))

2888

2966

2889

2967

global mandos_dbus_service

2890

2968

mandos_dbus_service = None

2891

2969

2892

2970

socketfd = None

2893

2971

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

2894

2972

socketfd = server_settings["socket"]

2910

2988

except IOError as e:

2911

2989

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

2912

2990

exc_info=e)

2913

2914

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

2991

2992

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

2993

("mandos", "mandos"),

2994

("nobody", "nogroup")):

2915

2995

try:

2916

2996

uid = pwd.getpwnam(name).pw_uid

2917

gid = pwd.getpwnam(name).pw_gid

2997

gid = pwd.getpwnam(group).pw_gid

2918

2998

break

2919

2999

except KeyError:

2920

3000

continue

2924

3004

try:

2925

3005

os.setgid(gid)

2926

3006

os.setuid(uid)

3007

if debug:

3008

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

3009

gid))

2927

3010

except OSError as error:

3011

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

3012

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

2928

3013

if error.errno != errno.EPERM:

2929

3014

raise

2930

3015

2931

3016

if debug:

2932

3017

# Enable all possible GnuTLS debugging

2933

3018

2934

3019

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

2935

3020

# - GnuTLS manual

2936

3021

gnutls.global_set_log_level(11)

2937

3022

2938

3023

@gnutls.log_func

2939

3024

def debug_gnutls(level, string):

2940

3025

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

2941

3026

2942

3027

gnutls.global_set_log_function(debug_gnutls)

2943

3028

2944

3029

# Redirect stdin so all checkers get /dev/null

2945

3030

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

2946

3031

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

2947

3032

if null > 2:

2948

3033

os.close(null)

2949

3034

2950

3035

# Need to fork before connecting to D-Bus

2951

3036

if not foreground:

2952

3037

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

2953

3038

daemon()

2954

2955

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

2956

# need to inform gobject that threads will be used.

2957

gobject.threads_init()

2958

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

2959

3044

global main_loop

2960

3045

# From the Avahi example code

2961

3046

DBusGMainLoop(set_as_default=True)

2962

main_loop = gobject.MainLoop()

3047

main_loop = GLib.MainLoop()

2963

3048

bus = dbus.SystemBus()

2964

3049

# End of Avahi example code

2965

3050

if use_dbus:

2978

3063

if zeroconf:

2979

3064

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2980

3065

service = AvahiServiceToSyslog(

2981

name = server_settings["servicename"],

2982

servicetype = "_mandos._tcp",

2983

protocol = protocol,

2984

bus = bus)

3066

name=server_settings["servicename"],

3067

servicetype="_mandos._tcp",

3068

protocol=protocol,

3069

bus=bus)

2985

3070

if server_settings["interface"]:

2986

3071

service.interface = if_nametoindex(

2987

3072

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

2988

3073

2989

3074

global multiprocessing_manager

2990

3075

multiprocessing_manager = multiprocessing.Manager()

2991

3076

2992

3077

client_class = Client

2993

3078

if use_dbus:

2994

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

2995

3079

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

3080

2996

3081

client_settings = Client.config_parser(client_config)

2997

3082

old_client_settings = {}

2998

3083

clients_data = {}

2999

3084

3000

3085

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

3001

3086

global wnull

3002

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

3087

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

3003

3088

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

3004

3089

# mode

3005

3090

if debug or not foreground:

3006

3091

wnull.close()

3007

3092

3008

3093

# Get client data and settings from last running state.

3009

3094

if server_settings["restore"]:

3010

3095

try:

3011

3096

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

3012

clients_data, old_client_settings = pickle.load(

3013

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

3014

3142

os.remove(stored_state_path)

3015

3143

except IOError as e:

3016

3144

if e.errno == errno.ENOENT:

3024

3152

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

3025

3153

"EOFError:",

3026

3154

exc_info=e)

3027

3155

3028

3156

with PGPEngine() as pgp:

3029

3157

for client_name, client in clients_data.items():

3030

3158

# Skip removed clients

3031

3159

if client_name not in client_settings:

3032

3160

continue

3033

3161

3034

3162

# Decide which value to use after restoring saved state.

3035

3163

# We have three different values: Old config file,

3036

3164

# new config file, and saved state.

3047

3175

client[name] = value

3048

3176

except KeyError:

3049

3177

pass

3050

3178

3051

3179

# Clients who has passed its expire date can still be

3052

3180

# enabled if its last checker was successful. A Client

3053

3181

# whose checker succeeded before we stored its state is

3086

3214

client_name))

3087

3215

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

3088

3216

["secret"])

3089

3217

3090

3218

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

3091

3219

for client_name in (set(old_client_settings)

3092

3220

- set(client_settings)):

3094

3222

for client_name in (set(client_settings)

3095

3223

- set(old_client_settings)):

3096

3224

clients_data[client_name] = client_settings[client_name]

3097

3225

3098

3226

# Create all client objects

3099

3227

for client_name, client in clients_data.items():

3100

3228

tcp_server.clients[client_name] = client_class(

3101

name = client_name,

3102

settings = client,

3103

server_settings = server_settings)

3104

3229

name=client_name,

3230

settings=client,

3231

server_settings=server_settings)

3232

3105

3233

if not tcp_server.clients:

3106

3234

logger.warning("No clients defined")

3107

3235

3108

3236

if not foreground:

3109

3237

if pidfile is not None:

3110

3238

pid = os.getpid()

3116

3244

pidfilename, pid)

3117

3245

del pidfile

3118

3246

del pidfilename

3119

3120

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

3121

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

3122

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

3123

3252

if use_dbus:

3124

3253

3125

3254

@alternate_dbus_interfaces(

3126

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

3255

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

3127

3256

class MandosDBusService(DBusObjectWithObjectManager):

3128

3257

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

3129

3258

3130

3259

def __init__(self):

3131

3260

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

3132

3261

3133

3262

_interface = "se.recompile.Mandos"

3134

3263

3135

3264

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

3136

3265

def ClientAdded(self, objpath):

3137

3266

"D-Bus signal"

3138

3267

pass

3139

3268

3140

3269

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

3141

3270

def ClientNotFound(self, fingerprint, address):

3142

3271

"D-Bus signal"

3143

3272

pass

3144

3273

3145

3274

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

3146

3275

"true"})

3147

3276

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

3148

3277

def ClientRemoved(self, objpath, name):

3149

3278

"D-Bus signal"

3150

3279

pass

3151

3280

3152

3281

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

3153

3282

"true"})

3154

3283

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

3155

3284

def GetAllClients(self):

3156

3285

"D-Bus method"

3157

3286

return dbus.Array(c.dbus_object_path for c in

3158

tcp_server.clients.itervalues())

3159

3287

tcp_server.clients.values())

3288

3160

3289

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

3161

3290

"true"})

3162

3291

@dbus.service.method(_interface,

3164

3293

def GetAllClientsWithProperties(self):

3165

3294

"D-Bus method"

3166

3295

return dbus.Dictionary(

3167

{ c.dbus_object_path: c.GetAll(

3296

{c.dbus_object_path: c.GetAll(

3168

3297

"se.recompile.Mandos.Client")

3169

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

3298

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

3170

3299

signature="oa{sv}")

3171

3300

3172

3301

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

3173

3302

def RemoveClient(self, object_path):

3174

3303

"D-Bus method"

3175

for c in tcp_server.clients.itervalues():

3304

for c in tcp_server.clients.values():

3176

3305

if c.dbus_object_path == object_path:

3177

3306

del tcp_server.clients[c.name]

3178

3307

c.remove_from_connection()

3182

3311

self.client_removed_signal(c)

3183

3312

return

3184

3313

raise KeyError(object_path)

3185

3314

3186

3315

del _interface

3187

3316

3188

3317

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3189

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

3318

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

3190

3319

def GetManagedObjects(self):

3191

3320

"""D-Bus method"""

3192

3321

return dbus.Dictionary(

3193

{ client.dbus_object_path:

3194

dbus.Dictionary(

3195

{ interface: client.GetAll(interface)

3196

for interface in

3197

client._get_all_interface_names()})

3198

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

3199

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

3200

3329

def client_added_signal(self, client):

3201

3330

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

3202

3331

if use_dbus:

3204

3333

self.InterfacesAdded(

3205

3334

client.dbus_object_path,

3206

3335

dbus.Dictionary(

3207

{ interface: client.GetAll(interface)

3208

for interface in

3209

client._get_all_interface_names()}))

3336

{interface: client.GetAll(interface)

3337

for interface in

3338

client._get_all_interface_names()}))

3210

3339

# Old signal

3211

3340

self.ClientAdded(client.dbus_object_path)

3212

3341

3213

3342

def client_removed_signal(self, client):

3214

3343

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

3215

3344

if use_dbus:

3220

3349

# Old signal

3221

3350

self.ClientRemoved(client.dbus_object_path,

3222

3351

client.name)

3223

3352

3224

3353

mandos_dbus_service = MandosDBusService()

3225

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

3226

3360

def cleanup():

3227

3361

"Cleanup function; run on exit"

3228

3362

if zeroconf:

3229

3363

service.cleanup()

3230

3231

multiprocessing.active_children()

3232

wnull.close()

3364

3365

mp.active_children()

3366

wn.close()

3233

3367

if not (tcp_server.clients or client_settings):

3234

3368

return

3235

3369

3236

3370

# Store client before exiting. Secrets are encrypted with key

3237

3371

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

3238

3372

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

3239

3373

clients = {}

3240

3374

with PGPEngine() as pgp:

3241

for client in tcp_server.clients.itervalues():

3375

for client in tcp_server.clients.values():

3242

3376

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

3243

3377

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

3244

3378

key)

3245

3379

client_dict = {}

3246

3380

3247

3381

# A list of attributes that can not be pickled

3248

3382

# + secret.

3249

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

3250

"checker", "server_settings" }

3383

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

3384

"checker", "server_settings"}

3251

3385

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

3252

3386

.Object):

3253

3387

exclude.add(name)

3254

3388

3255

3389

client_dict["encrypted_secret"] = (client

3256

3390

.encrypted_secret)

3257

3391

for attr in client.client_structure:

3258

3392

if attr not in exclude:

3259

3393

client_dict[attr] = getattr(client, attr)

3260

3394

3261

3395

clients[client.name] = client_dict

3262

3396

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

3263

3397

3264

3398

try:

3265

3399

with tempfile.NamedTemporaryFile(

3266

3400

mode='wb',

3268

3402

prefix='clients-',

3269

3403

dir=os.path.dirname(stored_state_path),

3270

3404

delete=False) as stored_state:

3271

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

3405

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

3406

protocol=2)

3272

3407

tempname = stored_state.name

3273

3408

os.rename(tempname, stored_state_path)

3274

3409

except (IOError, OSError) as e:

3284

3419

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

3285

3420

exc_info=e)

3286

3421

raise

3287

3422

3288

3423

# Delete all clients, and settings from config

3289

3424

while tcp_server.clients:

3290

3425

name, client = tcp_server.clients.popitem()

3296

3431

if use_dbus:

3297

3432

mandos_dbus_service.client_removed_signal(client)

3298

3433

client_settings.clear()

3299

3434

3300

3435

atexit.register(cleanup)

3301

3302

for client in tcp_server.clients.itervalues():

3436

3437

for client in tcp_server.clients.values():

3303

3438

if use_dbus:

3304

3439

# Emit D-Bus signal for adding

3305

3440

mandos_dbus_service.client_added_signal(client)

3306

3441

# Need to initiate checking of clients

3307

3442

if client.enabled:

3308

3443

client.init_checker()

3309

3444

3310

3445

tcp_server.enable()

3311

3446

tcp_server.server_activate()

3312

3447

3313

3448

# Find out what port we got

3314

3449

if zeroconf:

3315

3450

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

3320

3455

else: # IPv4

3321

3456

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

3322

3457

*tcp_server.socket.getsockname())

3323

3324

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

3325

3458

3459

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

3460

3326

3461

try:

3327

3462

if zeroconf:

3328

3463

# From the Avahi example code

3333

3468

cleanup()

3334

3469

sys.exit(1)

3335

3470

# End of Avahi example code

3336

3337

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

3338

lambda *args, **kwargs:

3339

(tcp_server.handle_request

3340

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

3341

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

3342

3477

logger.debug("Starting main loop")

3343

3478

main_loop.run()

3344

3479

except AvahiError as error: