/mandos/trunk : revision 237.4.116

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)

79

80

81

import dbus

81

82

import dbus.service

82

try:

83

from gi.repository import GObject

84

except ImportError:

85

import gobject as GObject

83

from gi.repository import GLib

86

84

from dbus.mainloop.glib import DBusGMainLoop

87

85

import ctypes

88

86

import ctypes.util

89

87

import xml.dom.minidom

90

88

import inspect

91

89

90

# Try to find the value of SO_BINDTODEVICE:

92

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:

93

94

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

94

95

except AttributeError:

95

96

try:

97

# This is where SO_BINDTODEVICE was up to and including Python

98

# 2.6, and also 3.2:

96

99

from IN import SO_BINDTODEVICE

97

100

except ImportError:

98

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

99

114

100

115

if sys.version_info.major == 2:

101

116

str = unicode

102

117

103

version = "1.7.5"

118

version = "1.8.5"

104

119

stored_state_file = "clients.pickle"

105

120

106

121

logger = logging.getLogger()

110

125

if_nametoindex = ctypes.cdll.LoadLibrary(

111

126

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

112

127

except (OSError, AttributeError):

113

128

114

129

def if_nametoindex(interface):

115

130

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

116

131

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

139

154

140

155

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

141

156

"""init logger and add loglevel"""

142

157

143

158

global syslogger

144

159

syslogger = (logging.handlers.SysLogHandler(

145

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

146

address = "/dev/log"))

160

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

161

address="/dev/log"))

147

162

syslogger.setFormatter(logging.Formatter

148

163

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

149

164

' %(message)s'))

150

165

logger.addHandler(syslogger)

151

166

152

167

if debug:

153

168

console = logging.StreamHandler()

154

169

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

166

181

167

182

class PGPEngine(object):

168

183

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

169

184

170

185

def __init__(self):

171

186

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

172

187

self.gpg = "gpg"

183

198

self.gnupgargs = ['--batch',

184

199

'--homedir', self.tempdir,

185

200

'--force-mdc',

186

'--quiet',

187

'--no-use-agent']

188

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

189

206

def __enter__(self):

190

207

return self

191

208

192

209

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

193

210

self._cleanup()

194

211

return False

195

212

196

213

def __del__(self):

197

214

self._cleanup()

198

215

199

216

def _cleanup(self):

200

217

if self.tempdir is not None:

201

218

# Delete contents of tempdir

202

219

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

203

topdown = False):

220

topdown=False):

204

221

for filename in files:

205

222

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

206

223

for dirname in dirs:

208

225

# Remove tempdir

209

226

os.rmdir(self.tempdir)

210

227

self.tempdir = None

211

228

212

229

def password_encode(self, password):

213

230

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

214

231

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

219

236

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

220

237

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

221

238

return encoded

222

239

223

240

def encrypt(self, data, password):

224

241

passphrase = self.password_encode(password)

225

242

with tempfile.NamedTemporaryFile(

230

247

'--passphrase-file',

231

248

passfile.name]

232

249

+ self.gnupgargs,

233

stdin = subprocess.PIPE,

234

stdout = subprocess.PIPE,

235

stderr = subprocess.PIPE)

236

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)

237

254

if proc.returncode != 0:

238

255

raise PGPError(err)

239

256

return ciphertext

240

257

241

258

def decrypt(self, data, password):

242

259

passphrase = self.password_encode(password)

243

260

with tempfile.NamedTemporaryFile(

244

dir = self.tempdir) as passfile:

261

dir=self.tempdir) as passfile:

245

262

passfile.write(passphrase)

246

263

passfile.flush()

247

264

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

248

265

'--passphrase-file',

249

266

passfile.name]

250

267

+ self.gnupgargs,

251

stdin = subprocess.PIPE,

252

stdout = subprocess.PIPE,

253

stderr = subprocess.PIPE)

254

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)

255

272

if proc.returncode != 0:

256

273

raise PGPError(err)

257

274

return decrypted_plaintext

258

275

276

259

277

# Pretend that we have an Avahi module

260

class Avahi(object):

261

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

262

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

263

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

264

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

265

PROTO_INET = 0 # avahi-common/address.h

266

PROTO_INET6 = 1 # avahi-common/address.h

278

class avahi(object):

279

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

280

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

281

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

282

PROTO_INET = 0 # avahi-common/address.h

283

PROTO_INET6 = 1 # avahi-common/address.h

267

284

DBUS_NAME = "org.freedesktop.Avahi"

268

285

DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"

269

286

DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"

270

287

DBUS_PATH_SERVER = "/"

271

def string_array_to_txt_array(self, t):

288

289

@staticmethod

290

def string_array_to_txt_array(t):

272

291

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

273

292

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

274

ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h

275

ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h

276

ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h

277

SERVER_INVALID = 0 # avahi-common/defs.h

278

SERVER_REGISTERING = 1 # avahi-common/defs.h

279

SERVER_RUNNING = 2 # avahi-common/defs.h

280

SERVER_COLLISION = 3 # avahi-common/defs.h

281

SERVER_FAILURE = 4 # avahi-common/defs.h

282

avahi = Avahi()

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

283

302

284

303

class AvahiError(Exception):

285

304

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

298

317

299

318

class AvahiService(object):

300

319

"""An Avahi (Zeroconf) service.

301

320

302

321

Attributes:

303

322

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

304

323

Used to optionally bind to the specified interface.

316

335

server: D-Bus Server

317

336

bus: dbus.SystemBus()

318

337

"""

319

338

320

339

def __init__(self,

321

interface = avahi.IF_UNSPEC,

322

name = None,

323

servicetype = None,

324

port = None,

325

TXT = None,

326

domain = "",

327

host = "",

328

max_renames = 32768,

329

protocol = avahi.PROTO_UNSPEC,

330

bus = None):

340

interface=avahi.IF_UNSPEC,

341

name=None,

342

servicetype=None,

343

port=None,

344

TXT=None,

345

domain="",

346

host="",

347

max_renames=32768,

348

protocol=avahi.PROTO_UNSPEC,

349

bus=None):

331

350

self.interface = interface

332

351

self.name = name

333

352

self.type = servicetype

342

361

self.server = None

343

362

self.bus = bus

344

363

self.entry_group_state_changed_match = None

345

364

346

365

def rename(self, remove=True):

347

366

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

348

367

if self.rename_count >= self.max_renames:

368

387

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

369

388

self.cleanup()

370

389

os._exit(1)

371

390

372

391

def remove(self):

373

392

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

374

393

if self.entry_group_state_changed_match is not None:

376

395

self.entry_group_state_changed_match = None

377

396

if self.group is not None:

378

397

self.group.Reset()

379

398

380

399

def add(self):

381

400

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

382

401

self.remove()

399

418

dbus.UInt16(self.port),

400

419

avahi.string_array_to_txt_array(self.TXT))

401

420

self.group.Commit()

402

421

403

422

def entry_group_state_changed(self, state, error):

404

423

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

405

424

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

406

425

407

426

if state == avahi.ENTRY_GROUP_ESTABLISHED:

408

427

logger.debug("Zeroconf service established.")

409

428

elif state == avahi.ENTRY_GROUP_COLLISION:

413

432

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

414

433

str(error))

415

434

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

416

435

417

436

def cleanup(self):

418

437

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

419

438

if self.group is not None:

424

443

pass

425

444

self.group = None

426

445

self.remove()

427

446

428

447

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

429

448

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

430

449

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

459

478

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

460

479

else:

461

480

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

462

481

463

482

def activate(self):

464

483

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

465

484

if self.server is None:

476

495

class AvahiServiceToSyslog(AvahiService):

477

496

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

478

497

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

479

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

498

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

480

499

syslogger.setFormatter(logging.Formatter(

481

500

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

482

501

.format(self.name)))

483

502

return ret

484

503

504

485

505

# Pretend that we have a GnuTLS module

486

class GnuTLS(object):

487

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

488

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

489

490

_library = ctypes.cdll.LoadLibrary(

491

ctypes.util.find_library("gnutls"))

492

_need_version = b"3.3.0"

493

def __init__(self):

494

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

495

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

496

# happens.

497

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

498

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

499

.format(self._need_version))

500

506

class gnutls(object):

507

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

508

509

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

510

if library is None:

511

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

512

_library = ctypes.cdll.LoadLibrary(library)

513

del library

514

501

515

# Unless otherwise indicated, the constants and types below are

502

516

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

503

517

504

518

# Constants

505

519

E_SUCCESS = 0

506

520

E_INTERRUPTED = -52

507

521

E_AGAIN = -28

508

522

CRT_OPENPGP = 2

523

CRT_RAWPK = 3

509

524

CLIENT = 2

510

525

SHUT_RDWR = 0

511

526

CRD_CERTIFICATE = 1

512

527

E_NO_CERTIFICATE_FOUND = -49

528

X509_FMT_DER = 0

529

NO_TICKETS = 1<<10

530

ENABLE_RAWPK = 1<<18

531

CTYPE_PEERS = 3

532

KEYID_USE_SHA256 = 1 # gnutls/x509.h

513

533

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

514

534

515

535

# Types

516

536

class session_int(ctypes.Structure):

517

537

_fields_ = []

518

538

session_t = ctypes.POINTER(session_int)

539

519

540

class certificate_credentials_st(ctypes.Structure):

520

541

_fields_ = []

521

542

certificate_credentials_t = ctypes.POINTER(

522

543

certificate_credentials_st)

523

544

certificate_type_t = ctypes.c_int

545

524

546

class datum_t(ctypes.Structure):

525

547

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

526

548

('size', ctypes.c_uint)]

549

527

550

class openpgp_crt_int(ctypes.Structure):

528

551

_fields_ = []

529

552

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

530

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

553

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

531

554

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

532

555

credentials_type_t = ctypes.c_int

533

556

transport_ptr_t = ctypes.c_void_p

534

557

close_request_t = ctypes.c_int

535

558

536

559

# Exceptions

537

560

class Error(Exception):

538

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

539

# exception might be raised from within GnuTLS.__init__,

540

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

541

# global variable has happened.

542

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

561

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

543

562

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

544

563

# code is passed, convert it to a string with

545

564

# gnutls.strerror()

546

565

self.code = code

547

566

if message is None and code is not None:

548

message = GnuTLS.strerror(code)

549

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

567

message = gnutls.strerror(code)

568

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

550

569

message, *args)

551

570

552

571

class CertificateSecurityError(Error):

553

572

pass

554

573

555

574

# Classes

556

575

class Credentials(object):

557

576

def __init__(self):

559

578

gnutls.certificate_allocate_credentials(

560

579

ctypes.byref(self._c_object))

561

580

self.type = gnutls.CRD_CERTIFICATE

562

581

563

582

def __del__(self):

564

583

gnutls.certificate_free_credentials(self._c_object)

565

584

566

585

class ClientSession(object):

567

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

586

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

568

587

self._c_object = gnutls.session_t()

569

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

588

gnutls_flags = gnutls.CLIENT

589

if gnutls.check_version(b"3.5.6"):

590

gnutls_flags |= gnutls.NO_TICKETS

591

if gnutls.has_rawpk:

592

gnutls_flags |= gnutls.ENABLE_RAWPK

593

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

594

del gnutls_flags

570

595

gnutls.set_default_priority(self._c_object)

571

596

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

572

597

gnutls.handshake_set_private_extensions(self._c_object,

578

603

ctypes.cast(credentials._c_object,

579

604

ctypes.c_void_p))

580

605

self.credentials = credentials

581

606

582

607

def __del__(self):

583

608

gnutls.deinit(self._c_object)

584

609

585

610

def handshake(self):

586

611

return gnutls.handshake(self._c_object)

587

612

588

613

def send(self, data):

589

614

data = bytes(data)

590

615

data_len = len(data)

592

617

data_len -= gnutls.record_send(self._c_object,

593

618

data[-data_len:],

594

619

data_len)

595

620

596

621

def bye(self):

597

622

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

598

623

599

624

# Error handling functions

600

625

def _error_code(result):

601

626

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

603

628

if result >= 0:

604

629

return result

605

630

if result == gnutls.E_NO_CERTIFICATE_FOUND:

606

raise gnutls.CertificateSecurityError(code = result)

607

raise gnutls.Error(code = result)

608

631

raise gnutls.CertificateSecurityError(code=result)

632

raise gnutls.Error(code=result)

633

609

634

def _retry_on_error(result, func, arguments):

610

635

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

611

636

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

614

639

return _error_code(result)

615

640

result = func(*arguments)

616

641

return result

617

642

618

643

# Unless otherwise indicated, the function declarations below are

619

644

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

620

645

621

646

# Functions

622

647

priority_set_direct = _library.gnutls_priority_set_direct

623

648

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

624

649

ctypes.POINTER(ctypes.c_char_p)]

625

650

priority_set_direct.restype = _error_code

626

651

627

652

init = _library.gnutls_init

628

653

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

629

654

init.restype = _error_code

630

655

631

656

set_default_priority = _library.gnutls_set_default_priority

632

657

set_default_priority.argtypes = [session_t]

633

658

set_default_priority.restype = _error_code

634

659

635

660

record_send = _library.gnutls_record_send

636

661

record_send.argtypes = [session_t, ctypes.c_void_p,

637

662

ctypes.c_size_t]

638

663

record_send.restype = ctypes.c_ssize_t

639

664

record_send.errcheck = _retry_on_error

640

665

641

666

certificate_allocate_credentials = (

642

667

_library.gnutls_certificate_allocate_credentials)

643

668

certificate_allocate_credentials.argtypes = [

644

669

ctypes.POINTER(certificate_credentials_t)]

645

670

certificate_allocate_credentials.restype = _error_code

646

671

647

672

certificate_free_credentials = (

648

673

_library.gnutls_certificate_free_credentials)

649

certificate_free_credentials.argtypes = [certificate_credentials_t]

674

certificate_free_credentials.argtypes = [

675

certificate_credentials_t]

650

676

certificate_free_credentials.restype = None

651

677

652

678

handshake_set_private_extensions = (

653

679

_library.gnutls_handshake_set_private_extensions)

654

680

handshake_set_private_extensions.argtypes = [session_t,

655

681

ctypes.c_int]

656

682

handshake_set_private_extensions.restype = None

657

683

658

684

credentials_set = _library.gnutls_credentials_set

659

685

credentials_set.argtypes = [session_t, credentials_type_t,

660

686

ctypes.c_void_p]

661

687

credentials_set.restype = _error_code

662

688

663

689

strerror = _library.gnutls_strerror

664

690

strerror.argtypes = [ctypes.c_int]

665

691

strerror.restype = ctypes.c_char_p

666

692

667

693

certificate_type_get = _library.gnutls_certificate_type_get

668

694

certificate_type_get.argtypes = [session_t]

669

695

certificate_type_get.restype = _error_code

670

696

671

697

certificate_get_peers = _library.gnutls_certificate_get_peers

672

698

certificate_get_peers.argtypes = [session_t,

673

699

ctypes.POINTER(ctypes.c_uint)]

674

700

certificate_get_peers.restype = ctypes.POINTER(datum_t)

675

701

676

702

global_set_log_level = _library.gnutls_global_set_log_level

677

703

global_set_log_level.argtypes = [ctypes.c_int]

678

704

global_set_log_level.restype = None

679

705

680

706

global_set_log_function = _library.gnutls_global_set_log_function

681

707

global_set_log_function.argtypes = [log_func]

682

708

global_set_log_function.restype = None

683

709

684

710

deinit = _library.gnutls_deinit

685

711

deinit.argtypes = [session_t]

686

712

deinit.restype = None

687

713

688

714

handshake = _library.gnutls_handshake

689

715

handshake.argtypes = [session_t]

690

716

handshake.restype = _error_code

691

717

handshake.errcheck = _retry_on_error

692

718

693

719

transport_set_ptr = _library.gnutls_transport_set_ptr

694

720

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

695

721

transport_set_ptr.restype = None

696

722

697

723

bye = _library.gnutls_bye

698

724

bye.argtypes = [session_t, close_request_t]

699

725

bye.restype = _error_code

700

726

bye.errcheck = _retry_on_error

701

727

702

728

check_version = _library.gnutls_check_version

703

729

check_version.argtypes = [ctypes.c_char_p]

704

730

check_version.restype = ctypes.c_char_p

705

706

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

707

708

openpgp_crt_init = _library.gnutls_openpgp_crt_init

709

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

710

openpgp_crt_init.restype = _error_code

711

712

openpgp_crt_import = _library.gnutls_openpgp_crt_import

713

openpgp_crt_import.argtypes = [openpgp_crt_t,

714

ctypes.POINTER(datum_t),

715

openpgp_crt_fmt_t]

716

openpgp_crt_import.restype = _error_code

717

718

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

719

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

720

ctypes.POINTER(ctypes.c_uint)]

721

openpgp_crt_verify_self.restype = _error_code

722

723

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

724

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

725

openpgp_crt_deinit.restype = None

726

727

openpgp_crt_get_fingerprint = (

728

_library.gnutls_openpgp_crt_get_fingerprint)

729

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

730

ctypes.c_void_p,

731

ctypes.POINTER(

732

ctypes.c_size_t)]

733

openpgp_crt_get_fingerprint.restype = _error_code

734

731

732

_need_version = b"3.3.0"

733

if check_version(_need_version) is None:

734

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

735

.format(_need_version))

736

737

_tls_rawpk_version = b"3.6.6"

738

has_rawpk = bool(check_version(_tls_rawpk_version))

739

740

if has_rawpk:

741

# Types

742

class pubkey_st(ctypes.Structure):

743

_fields = []

744

pubkey_t = ctypes.POINTER(pubkey_st)

745

746

x509_crt_fmt_t = ctypes.c_int

747

748

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

749

pubkey_init = _library.gnutls_pubkey_init

750

pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]

751

pubkey_init.restype = _error_code

752

753

pubkey_import = _library.gnutls_pubkey_import

754

pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),

755

x509_crt_fmt_t]

756

pubkey_import.restype = _error_code

757

758

pubkey_get_key_id = _library.gnutls_pubkey_get_key_id

759

pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,

760

ctypes.POINTER(ctypes.c_ubyte),

761

ctypes.POINTER(ctypes.c_size_t)]

762

pubkey_get_key_id.restype = _error_code

763

764

pubkey_deinit = _library.gnutls_pubkey_deinit

765

pubkey_deinit.argtypes = [pubkey_t]

766

pubkey_deinit.restype = None

767

else:

768

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

769

770

openpgp_crt_init = _library.gnutls_openpgp_crt_init

771

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

772

openpgp_crt_init.restype = _error_code

773

774

openpgp_crt_import = _library.gnutls_openpgp_crt_import

775

openpgp_crt_import.argtypes = [openpgp_crt_t,

776

ctypes.POINTER(datum_t),

777

openpgp_crt_fmt_t]

778

openpgp_crt_import.restype = _error_code

779

780

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

781

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

782

ctypes.POINTER(ctypes.c_uint)]

783

openpgp_crt_verify_self.restype = _error_code

784

785

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

786

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

787

openpgp_crt_deinit.restype = None

788

789

openpgp_crt_get_fingerprint = (

790

_library.gnutls_openpgp_crt_get_fingerprint)

791

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

792

ctypes.c_void_p,

793

ctypes.POINTER(

794

ctypes.c_size_t)]

795

openpgp_crt_get_fingerprint.restype = _error_code

796

797

if check_version(b"3.6.4"):

798

certificate_type_get2 = _library.gnutls_certificate_type_get2

799

certificate_type_get2.argtypes = [session_t, ctypes.c_int]

800

certificate_type_get2.restype = _error_code

801

735

802

# Remove non-public functions

736

803

del _error_code, _retry_on_error

737

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

738

gnutls = GnuTLS()

804

739

805

740

806

def call_pipe(connection, # : multiprocessing.Connection

741

807

func, *args, **kwargs):

742

808

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

743

809

744

810

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

745

811

return value on the provided multiprocessing.Connection.

746

812

"""

747

813

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

748

814

connection.close()

749

815

816

750

817

class Client(object):

751

818

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

752

819

753

820

Attributes:

754

821

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

755

822

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

756

823

approval_duration: datetime.timedelta(); Duration of one approval

757

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

758

to see if the client lives.

759

'None' if no process is running.

760

checker_callback_tag: a GObject event source tag, or None

824

checker: multiprocessing.Process(); a running checker process used

825

to see if the client lives. 'None' if no process is

826

running.

827

checker_callback_tag: a GLib event source tag, or None

761

828

checker_command: string; External command which is run to check

762

829

if client lives. %() expansions are done at

763

830

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

764

831

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

765

checker_initiator_tag: a GObject event source tag, or None

832

checker_initiator_tag: a GLib event source tag, or None

766

833

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

767

834

client_structure: Object describing what attributes a client has

768

835

and is used for storing the client at exit

769

836

current_checker_command: string; current running checker_command

770

disable_initiator_tag: a GObject event source tag, or None

837

disable_initiator_tag: a GLib event source tag, or None

771

838

enabled: bool()

772

839

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

773

uniquely identify the client

840

uniquely identify an OpenPGP client

841

key_id: string (64 hexadecimal digits); used to uniquely identify

842

a client using raw public keys

774

843

host: string; available for use by the checker command

775

844

interval: datetime.timedelta(); How often to start a new checker

776

845

last_approval_request: datetime.datetime(); (UTC) or None

792

861

disabled, or None

793

862

server_settings: The server_settings dict from main()

794

863

"""

795

864

796

865

runtime_expansions = ("approval_delay", "approval_duration",

797

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

866

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

798

867

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

799

868

"last_approval_request", "last_checked_ok",

800

869

"last_enabled", "name", "timeout")

809

878

"approved_by_default": "True",

810

879

"enabled": "True",

811

880

}

812

881

813

882

@staticmethod

814

883

def config_parser(config):

815

884

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

822

891

for client_name in config.sections():

823

892

section = dict(config.items(client_name))

824

893

client = settings[client_name] = {}

825

894

826

895

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

827

896

# Reformat values from string types to Python types

828

897

client["approved_by_default"] = config.getboolean(

829

898

client_name, "approved_by_default")

830

899

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

831

900

"enabled")

832

833

# Uppercase and remove spaces from fingerprint for later

834

# comparison purposes with return value from the

835

# fingerprint() function

901

902

# Uppercase and remove spaces from key_id and fingerprint

903

# for later comparison purposes with return value from the

904

# key_id() and fingerprint() functions

905

client["key_id"] = (section.get("key_id", "").upper()

906

.replace(" ", ""))

836

907

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

837

908

.replace(" ", ""))

838

909

if "secret" in section:

859

930

client["last_approval_request"] = None

860

931

client["last_checked_ok"] = None

861

932

client["last_checker_status"] = -2

862

933

863

934

return settings

864

865

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

935

936

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

866

937

self.name = name

867

938

if server_settings is None:

868

939

server_settings = {}

870

941

# adding all client settings

871

942

for setting, value in settings.items():

872

943

setattr(self, setting, value)

873

944

874

945

if self.enabled:

875

946

if not hasattr(self, "last_enabled"):

876

947

self.last_enabled = datetime.datetime.utcnow()

880

951

else:

881

952

self.last_enabled = None

882

953

self.expires = None

883

954

884

955

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

956

logger.debug(" Key ID: %s", self.key_id)

885

957

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

886

958

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

887

959

datetime.datetime.utcnow())

888

960

889

961

# attributes specific for this server instance

890

962

self.checker = None

891

963

self.checker_initiator_tag = None

900

972

for attr in self.__dict__.keys()

901

973

if not attr.startswith("_")]

902

974

self.client_structure.append("client_structure")

903

975

904

976

for name, t in inspect.getmembers(

905

977

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

906

978

if not name.startswith("_"):

907

979

self.client_structure.append(name)

908

980

909

981

# Send notice to process children that client state has changed

910

982

def send_changedstate(self):

911

983

with self.changedstate:

912

984

self.changedstate.notify_all()

913

985

914

986

def enable(self):

915

987

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

916

988

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

921

993

self.last_enabled = datetime.datetime.utcnow()

922

994

self.init_checker()

923

995

self.send_changedstate()

924

996

925

997

def disable(self, quiet=True):

926

998

"""Disable this client."""

927

999

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

929

1001

if not quiet:

930

1002

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

931

1003

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

932

GObject.source_remove(self.disable_initiator_tag)

1004

GLib.source_remove(self.disable_initiator_tag)

933

1005

self.disable_initiator_tag = None

934

1006

self.expires = None

935

1007

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

936

GObject.source_remove(self.checker_initiator_tag)

1008

GLib.source_remove(self.checker_initiator_tag)

937

1009

self.checker_initiator_tag = None

938

1010

self.stop_checker()

939

1011

self.enabled = False

940

1012

if not quiet:

941

1013

self.send_changedstate()

942

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

1014

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

943

1015

return False

944

1016

945

1017

def __del__(self):

946

1018

self.disable()

947

1019

948

1020

def init_checker(self):

949

1021

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

950

1022

# and every interval from then on.

951

1023

if self.checker_initiator_tag is not None:

952

GObject.source_remove(self.checker_initiator_tag)

953

self.checker_initiator_tag = GObject.timeout_add(

1024

GLib.source_remove(self.checker_initiator_tag)

1025

self.checker_initiator_tag = GLib.timeout_add(

954

1026

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

955

1027

self.start_checker)

956

1028

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

957

1029

if self.disable_initiator_tag is not None:

958

GObject.source_remove(self.disable_initiator_tag)

959

self.disable_initiator_tag = GObject.timeout_add(

1030

GLib.source_remove(self.disable_initiator_tag)

1031

self.disable_initiator_tag = GLib.timeout_add(

960

1032

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

961

1033

# Also start a new checker *right now*.

962

1034

self.start_checker()

963

1035

964

1036

def checker_callback(self, source, condition, connection,

965

1037

command):

966

1038

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

967

self.checker_callback_tag = None

968

self.checker = None

969

1039

# Read return code from connection (see call_pipe)

970

1040

returncode = connection.recv()

971

1041

connection.close()

972

1042

self.checker.join()

1043

self.checker_callback_tag = None

1044

self.checker = None

1045

973

1046

if returncode >= 0:

974

1047

self.last_checker_status = returncode

975

1048

self.last_checker_signal = None

985

1058

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

986

1059

vars(self))

987

1060

return False

988

1061

989

1062

def checked_ok(self):

990

1063

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

991

1064

self.last_checked_ok = datetime.datetime.utcnow()

992

1065

self.last_checker_status = 0

993

1066

self.last_checker_signal = None

994

1067

self.bump_timeout()

995

1068

996

1069

def bump_timeout(self, timeout=None):

997

1070

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

998

1071

if timeout is None:

999

1072

timeout = self.timeout

1000

1073

if self.disable_initiator_tag is not None:

1001

GObject.source_remove(self.disable_initiator_tag)

1074

GLib.source_remove(self.disable_initiator_tag)

1002

1075

self.disable_initiator_tag = None

1003

1076

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

1004

self.disable_initiator_tag = GObject.timeout_add(

1077

self.disable_initiator_tag = GLib.timeout_add(

1005

1078

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

1006

1079

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

1007

1080

1008

1081

def need_approval(self):

1009

1082

self.last_approval_request = datetime.datetime.utcnow()

1010

1083

1011

1084

def start_checker(self):

1012

1085

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

1013

1086

1014

1087

If a checker already exists, leave it running and do

1015

1088

nothing."""

1016

1089

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

1021

1094

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

1022

1095

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

1023

1096

# should be.

1024

1097

1025

1098

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

1026

1099

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

1027

1100

self.checker.join()

1031

1104

# Escape attributes for the shell

1032

1105

escaped_attrs = {

1033

1106

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

1034

for attr in self.runtime_expansions }

1107

for attr in self.runtime_expansions}

1035

1108

try:

1036

1109

command = self.checker_command % escaped_attrs

1037

1110

except TypeError as error:

1049

1122

# The exception is when not debugging but nevertheless

1050

1123

# running in the foreground; use the previously

1051

1124

# created wnull.

1052

popen_args = { "close_fds": True,

1053

"shell": True,

1054

"cwd": "/" }

1125

popen_args = {"close_fds": True,

1126

"shell": True,

1127

"cwd": "/"}

1055

1128

if (not self.server_settings["debug"]

1056

1129

and self.server_settings["foreground"]):

1057

1130

popen_args.update({"stdout": wnull,

1058

"stderr": wnull })

1059

pipe = multiprocessing.Pipe(duplex = False)

1131

"stderr": wnull})

1132

pipe = multiprocessing.Pipe(duplex=False)

1060

1133

self.checker = multiprocessing.Process(

1061

target = call_pipe,

1062

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

1063

kwargs = popen_args)

1134

target=call_pipe,

1135

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

1136

kwargs=popen_args)

1064

1137

self.checker.start()

1065

self.checker_callback_tag = GObject.io_add_watch(

1066

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

1138

self.checker_callback_tag = GLib.io_add_watch(

1139

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

1067

1140

self.checker_callback, pipe[0], command)

1068

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

1141

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

1069

1142

return True

1070

1143

1071

1144

def stop_checker(self):

1072

1145

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

1073

1146

if self.checker_callback_tag:

1074

GObject.source_remove(self.checker_callback_tag)

1147

GLib.source_remove(self.checker_callback_tag)

1075

1148

self.checker_callback_tag = None

1076

1149

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

1077

1150

return

1086

1159

byte_arrays=False):

1087

1160

"""Decorators for marking methods of a DBusObjectWithProperties to

1088

1161

become properties on the D-Bus.

1089

1162

1090

1163

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

1091

1164

and with one argument by "Set".

1092

1165

1093

1166

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

1094

1167

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

1095

1168

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

1099

1172

if byte_arrays and signature != "ay":

1100

1173

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

1101

1174

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

1102

1175

1103

1176

def decorator(func):

1104

1177

func._dbus_is_property = True

1105

1178

func._dbus_interface = dbus_interface

1108

1181

func._dbus_name = func.__name__

1109

1182

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

1110

1183

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

1111

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

1184

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

1112

1185

return func

1113

1186

1114

1187

return decorator

1115

1188

1116

1189

1117

1190

def dbus_interface_annotations(dbus_interface):

1118

1191

"""Decorator for marking functions returning interface annotations

1119

1192

1120

1193

Usage:

1121

1194

1122

1195

@dbus_interface_annotations("org.example.Interface")

1123

1196

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

1124

1197

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

1125

1198

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

1126

1199

"false"}

1127

1200

"""

1128

1201

1129

1202

def decorator(func):

1130

1203

func._dbus_is_interface = True

1131

1204

func._dbus_interface = dbus_interface

1132

1205

func._dbus_name = dbus_interface

1133

1206

return func

1134

1207

1135

1208

return decorator

1136

1209

1137

1210

1138

1211

def dbus_annotations(annotations):

1139

1212

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

1140

1213

Usage:

1141

1214

1142

1215

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

1143

1216

"org.freedesktop.DBus.Property."

1144

1217

"EmitsChangedSignal": "false"})

1146

1219

access="r")

1147

1220

def Property_dbus_property(self):

1148

1221

return dbus.Boolean(False)

1149

1222

1150

1223

See also the DBusObjectWithAnnotations class.

1151

1224

"""

1152

1225

1153

1226

def decorator(func):

1154

1227

func._dbus_annotations = annotations

1155

1228

return func

1156

1229

1157

1230

return decorator

1158

1231

1159

1232

1177

1250

1178

1251

class DBusObjectWithAnnotations(dbus.service.Object):

1179

1252

"""A D-Bus object with annotations.

1180

1253

1181

1254

Classes inheriting from this can use the dbus_annotations

1182

1255

decorator to add annotations to methods or signals.

1183

1256

"""

1184

1257

1185

1258

@staticmethod

1186

1259

def _is_dbus_thing(thing):

1187

1260

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

1188

1261

1189

1262

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

1190

1263

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

1191

1264

"""

1192

1265

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

1193

1266

False)

1194

1267

1195

1268

def _get_all_dbus_things(self, thing):

1196

1269

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

1197

1270

"""

1200

1273

for cls in self.__class__.__mro__

1201

1274

for name, athing in

1202

1275

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

1203

1276

1204

1277

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1205

out_signature = "s",

1206

path_keyword = 'object_path',

1207

connection_keyword = 'connection')

1278

out_signature="s",

1279

path_keyword='object_path',

1280

connection_keyword='connection')

1208

1281

def Introspect(self, object_path, connection):

1209

1282

"""Overloading of standard D-Bus method.

1210

1283

1211

1284

Inserts annotation tags on methods and signals.

1212

1285

"""

1213

1286

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

1214

1287

connection)

1215

1288

try:

1216

1289

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

1217

1290

1218

1291

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

1219

1292

# Add annotation tags

1220

1293

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

1247

1320

if_tag.appendChild(ann_tag)

1248

1321

# Fix argument name for the Introspect method itself

1249

1322

if (if_tag.getAttribute("name")

1250

== dbus.INTROSPECTABLE_IFACE):

1323

== dbus.INTROSPECTABLE_IFACE):

1251

1324

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

1252

1325

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

1253

1326

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

1266

1339

1267

1340

class DBusObjectWithProperties(DBusObjectWithAnnotations):

1268

1341

"""A D-Bus object with properties.

1269

1342

1270

1343

Classes inheriting from this can use the dbus_service_property

1271

1344

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

1272

1345

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

1273

1346

"""

1274

1347

1275

1348

def _get_dbus_property(self, interface_name, property_name):

1276

1349

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

1277

1350

property with the specified name and interface.

1282

1355

if (value._dbus_name == property_name

1283

1356

and value._dbus_interface == interface_name):

1284

1357

return value.__get__(self)

1285

1358

1286

1359

# No such property

1287

1360

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

1288

1361

self.dbus_object_path, interface_name, property_name))

1289

1362

1290

1363

@classmethod

1291

1364

def _get_all_interface_names(cls):

1292

1365

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

1295

1368

for x in (inspect.getmro(cls))

1296

1369

for attr in dir(x))

1297

1370

if name is not None)

1298

1371

1299

1372

@dbus.service.method(dbus.PROPERTIES_IFACE,

1300

1373

in_signature="ss",

1301

1374

out_signature="v")

1309

1382

if not hasattr(value, "variant_level"):

1310

1383

return value

1311

1384

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

1312

1385

1313

1386

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

1314

1387

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

1315

1388

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

1327

1400

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

1328

1401

for byte in value))

1329

1402

prop(value)

1330

1403

1331

1404

@dbus.service.method(dbus.PROPERTIES_IFACE,

1332

1405

in_signature="s",

1333

1406

out_signature="a{sv}")

1334

1407

def GetAll(self, interface_name):

1335

1408

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

1336

1409

standard.

1337

1410

1338

1411

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

1339

1412

"""

1340

1413

properties = {}

1351

1424

properties[name] = value

1352

1425

continue

1353

1426

properties[name] = type(value)(

1354

value, variant_level = value.variant_level + 1)

1427

value, variant_level=value.variant_level + 1)

1355

1428

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

1356

1429

1357

1430

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

1358

1431

def PropertiesChanged(self, interface_name, changed_properties,

1359

1432

invalidated_properties):

1361

1434

standard.

1362

1435

"""

1363

1436

pass

1364

1437

1365

1438

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1366

1439

out_signature="s",

1367

1440

path_keyword='object_path',

1368

1441

connection_keyword='connection')

1369

1442

def Introspect(self, object_path, connection):

1370

1443

"""Overloading of standard D-Bus method.

1371

1444

1372

1445

Inserts property tags and interface annotation tags.

1373

1446

"""

1374

1447

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1376

1449

connection)

1377

1450

try:

1378

1451

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

1379

1452

1380

1453

def make_tag(document, name, prop):

1381

1454

e = document.createElement("property")

1382

1455

e.setAttribute("name", name)

1383

1456

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

1384

1457

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

1385

1458

return e

1386

1459

1387

1460

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

1388

1461

# Add property tags

1389

1462

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

1431

1504

exc_info=error)

1432

1505

return xmlstring

1433

1506

1507

1434

1508

try:

1435

1509

dbus.OBJECT_MANAGER_IFACE

1436

1510

except AttributeError:

1437

1511

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

1438

1512

1513

1439

1514

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1440

1515

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

1441

1516

1442

1517

Classes inheriting from this exposes the standard

1443

1518

GetManagedObjects call and the InterfacesAdded and

1444

1519

InterfacesRemoved signals on the standard

1445

1520

"org.freedesktop.DBus.ObjectManager" interface.

1446

1521

1447

1522

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

1448

1523

manually.

1449

1524

"""

1450

1525

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1451

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

1526

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

1452

1527

def GetManagedObjects(self):

1453

1528

"""This function must be overridden"""

1454

1529

raise NotImplementedError()

1455

1530

1456

1531

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1457

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

1532

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

1458

1533

def InterfacesAdded(self, object_path, interfaces_and_properties):

1459

1534

pass

1460

1461

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

1535

1536

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

1462

1537

def InterfacesRemoved(self, object_path, interfaces):

1463

1538

pass

1464

1539

1465

1540

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1466

out_signature = "s",

1467

path_keyword = 'object_path',

1468

connection_keyword = 'connection')

1541

out_signature="s",

1542

path_keyword='object_path',

1543

connection_keyword='connection')

1469

1544

def Introspect(self, object_path, connection):

1470

1545

"""Overloading of standard D-Bus method.

1471

1546

1472

1547

Override return argument name of GetManagedObjects to be

1473

1548

"objpath_interfaces_and_properties"

1474

1549

"""

1477

1552

connection)

1478

1553

try:

1479

1554

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

1480

1555

1481

1556

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

1482

1557

# Fix argument name for the GetManagedObjects method

1483

1558

if (if_tag.getAttribute("name")

1484

== dbus.OBJECT_MANAGER_IFACE):

1559

== dbus.OBJECT_MANAGER_IFACE):

1485

1560

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

1486

1561

if (cn.getAttribute("name")

1487

1562

== "GetManagedObjects"):

1497

1572

except (AttributeError, xml.dom.DOMException,

1498

1573

xml.parsers.expat.ExpatError) as error:

1499

1574

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

1500

exc_info = error)

1575

exc_info=error)

1501

1576

return xmlstring

1502

1577

1578

1503

1579

def datetime_to_dbus(dt, variant_level=0):

1504

1580

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

1505

1581

if dt is None:

1506

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

1582

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

1507

1583

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

1508

1584

1509

1585

1512

1588

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

1513

1589

interface names according to the "alt_interface_names" mapping.

1514

1590

Usage:

1515

1591

1516

1592

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

1517

1593

"net.example.AlternateInterface"})

1518

1594

class SampleDBusObject(dbus.service.Object):

1519

1595

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

1520

1596

def SampleDBusMethod():

1521

1597

pass

1522

1598

1523

1599

The above "SampleDBusMethod" on "SampleDBusObject" will be

1524

1600

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

1525

1601

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

1526

1602

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

1527

1603

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

1528

1604

1529

1605

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

1530

1606

(from DBusObjectWithProperties) and interfaces (from the

1531

1607

dbus_interface_annotations decorator).

1532

1608

"""

1533

1609

1534

1610

def wrapper(cls):

1535

1611

for orig_interface_name, alt_interface_name in (

1536

1612

alt_interface_names.items()):

1576

1652

attribute._dbus_annotations)

1577

1653

except AttributeError:

1578

1654

pass

1655

1579

1656

# Define a creator of a function to call both the

1580

1657

# original and alternate functions, so both the

1581

1658

# original and alternate signals gets sent when

1584

1661

"""This function is a scope container to pass

1585

1662

func1 and func2 to the "call_both" function

1586

1663

outside of its arguments"""

1587

1664

1588

1665

@functools.wraps(func2)

1589

1666

def call_both(*args, **kwargs):

1590

1667

"""This function will emit two D-Bus

1591

1668

signals by calling func1 and func2"""

1592

1669

func1(*args, **kwargs)

1593

1670

func2(*args, **kwargs)

1594

# Make wrapper function look like a D-Bus signal

1671

# Make wrapper function look like a D-Bus

1672

# signal

1595

1673

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

1596

1674

if name.startswith("_dbus_"):

1597

1675

setattr(call_both, name, attr)

1598

1676

1599

1677

return call_both

1600

1678

# Create the "call_both" function and add it to

1601

1679

# the class

1647

1725

(copy_function(attribute)))

1648

1726

if deprecate:

1649

1727

# Deprecate all alternate interfaces

1650

iname="_AlternateDBusNames_interface_annotation{}"

1728

iname = "_AlternateDBusNames_interface_annotation{}"

1651

1729

for interface_name in interface_names:

1652

1730

1653

1731

@dbus_interface_annotations(interface_name)

1654

1732

def func(self):

1655

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

1656

"true" }

1733

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

1734

"true"}

1657

1735

# Find an unused name

1658

1736

for aname in (iname.format(i)

1659

1737

for i in itertools.count()):

1670

1748

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

1671

1749

(cls, ), attr)

1672

1750

return cls

1673

1751

1674

1752

return wrapper

1675

1753

1676

1754

1678

1756

"se.bsnet.fukt.Mandos"})

1679

1757

class ClientDBus(Client, DBusObjectWithProperties):

1680

1758

"""A Client class using D-Bus

1681

1759

1682

1760

Attributes:

1683

1761

dbus_object_path: dbus.ObjectPath

1684

1762

bus: dbus.SystemBus()

1685

1763

"""

1686

1764

1687

1765

runtime_expansions = (Client.runtime_expansions

1688

1766

+ ("dbus_object_path", ))

1689

1767

1690

1768

_interface = "se.recompile.Mandos.Client"

1691

1769

1692

1770

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

1693

1694

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

1771

1772

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

1695

1773

self.bus = bus

1696

1774

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

1697

1775

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

1703

1781

"/clients/" + client_object_name)

1704

1782

DBusObjectWithProperties.__init__(self, self.bus,

1705

1783

self.dbus_object_path)

1706

1784

1707

1785

def notifychangeproperty(transform_func, dbus_name,

1708

1786

type_func=lambda x: x,

1709

1787

variant_level=1,

1711

1789

_interface=_interface):

1712

1790

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

1713

1791

its changes to DBus.

1714

1792

1715

1793

transform_fun: Function that takes a value and a variant_level

1716

1794

and transforms it to a D-Bus type.

1717

1795

dbus_name: D-Bus name of the variable

1720

1798

variant_level: D-Bus variant level. Default: 1

1721

1799

"""

1722

1800

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

1723

1801

1724

1802

def setter(self, value):

1725

1803

if hasattr(self, "dbus_object_path"):

1726

1804

if (not hasattr(self, attrname) or

1733

1811

else:

1734

1812

dbus_value = transform_func(

1735

1813

type_func(value),

1736

variant_level = variant_level)

1814

variant_level=variant_level)

1737

1815

self.PropertyChanged(dbus.String(dbus_name),

1738

1816

dbus_value)

1739

1817

self.PropertiesChanged(

1740

1818

_interface,

1741

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

1742

dbus_value }),

1819

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

1820

dbus_value}),

1743

1821

dbus.Array())

1744

1822

setattr(self, attrname, value)

1745

1823

1746

1824

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

1747

1825

1748

1826

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1749

1827

approvals_pending = notifychangeproperty(dbus.Boolean,

1750

1828

"ApprovalPending",

1751

type_func = bool)

1829

type_func=bool)

1752

1830

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

1753

1831

last_enabled = notifychangeproperty(datetime_to_dbus,

1754

1832

"LastEnabled")

1755

1833

checker = notifychangeproperty(

1756

1834

dbus.Boolean, "CheckerRunning",

1757

type_func = lambda checker: checker is not None)

1835

type_func=lambda checker: checker is not None)

1758

1836

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1759

1837

"LastCheckedOK")

1760

1838

last_checker_status = notifychangeproperty(dbus.Int16,

1765

1843

"ApprovedByDefault")

1766

1844

approval_delay = notifychangeproperty(

1767

1845

dbus.UInt64, "ApprovalDelay",

1768

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

1846

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

1769

1847

approval_duration = notifychangeproperty(

1770

1848

dbus.UInt64, "ApprovalDuration",

1771

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

1849

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

1772

1850

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

1773

1851

timeout = notifychangeproperty(

1774

1852

dbus.UInt64, "Timeout",

1775

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

1853

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

1776

1854

extended_timeout = notifychangeproperty(

1777

1855

dbus.UInt64, "ExtendedTimeout",

1778

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

1856

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

1779

1857

interval = notifychangeproperty(

1780

1858

dbus.UInt64, "Interval",

1781

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

1859

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

1782

1860

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

1783

1861

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

1784

1862

invalidate_only=True)

1785

1863

1786

1864

del notifychangeproperty

1787

1865

1788

1866

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

1789

1867

try:

1790

1868

self.remove_from_connection()

1793

1871

if hasattr(DBusObjectWithProperties, "__del__"):

1794

1872

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

1795

1873

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

1796

1874

1797

1875

def checker_callback(self, source, condition,

1798

1876

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

1799

1877

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

1815

1893

| self.last_checker_signal),

1816

1894

dbus.String(command))

1817

1895

return ret

1818

1896

1819

1897

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

1820

1898

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

1821

1899

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

1825

1903

# Emit D-Bus signal

1826

1904

self.CheckerStarted(self.current_checker_command)

1827

1905

return r

1828

1906

1829

1907

def _reset_approved(self):

1830

1908

self.approved = None

1831

1909

return False

1832

1910

1833

1911

def approve(self, value=True):

1834

1912

self.approved = value

1835

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

1836

* 1000), self._reset_approved)

1913

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

1914

* 1000), self._reset_approved)

1837

1915

self.send_changedstate()

1838

1839

## D-Bus methods, signals & properties

1840

1841

## Interfaces

1842

1843

## Signals

1844

1916

1917

# D-Bus methods, signals & properties

1918

1919

# Interfaces

1920

1921

# Signals

1922

1845

1923

# CheckerCompleted - signal

1846

1924

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

1847

1925

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

1848

1926

"D-Bus signal"

1849

1927

pass

1850

1928

1851

1929

# CheckerStarted - signal

1852

1930

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

1853

1931

def CheckerStarted(self, command):

1854

1932

"D-Bus signal"

1855

1933

pass

1856

1934

1857

1935

# PropertyChanged - signal

1858

1936

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

1859

1937

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

1860

1938

def PropertyChanged(self, property, value):

1861

1939

"D-Bus signal"

1862

1940

pass

1863

1941

1864

1942

# GotSecret - signal

1865

1943

@dbus.service.signal(_interface)

1866

1944

def GotSecret(self):

1869

1947

server to mandos-client

1870

1948

"""

1871

1949

pass

1872

1950

1873

1951

# Rejected - signal

1874

1952

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

1875

1953

def Rejected(self, reason):

1876

1954

"D-Bus signal"

1877

1955

pass

1878

1956

1879

1957

# NeedApproval - signal

1880

1958

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

1881

1959

def NeedApproval(self, timeout, default):

1882

1960

"D-Bus signal"

1883

1961

return self.need_approval()

1884

1885

## Methods

1886

1962

1963

# Methods

1964

1887

1965

# Approve - method

1888

1966

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

1889

1967

def Approve(self, value):

1890

1968

self.approve(value)

1891

1969

1892

1970

# CheckedOK - method

1893

1971

@dbus.service.method(_interface)

1894

1972

def CheckedOK(self):

1895

1973

self.checked_ok()

1896

1974

1897

1975

# Enable - method

1898

1976

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

1899

1977

@dbus.service.method(_interface)

1900

1978

def Enable(self):

1901

1979

"D-Bus method"

1902

1980

self.enable()

1903

1981

1904

1982

# StartChecker - method

1905

1983

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

1906

1984

@dbus.service.method(_interface)

1907

1985

def StartChecker(self):

1908

1986

"D-Bus method"

1909

1987

self.start_checker()

1910

1988

1911

1989

# Disable - method

1912

1990

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

1913

1991

@dbus.service.method(_interface)

1914

1992

def Disable(self):

1915

1993

"D-Bus method"

1916

1994

self.disable()

1917

1995

1918

1996

# StopChecker - method

1919

1997

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

1920

1998

@dbus.service.method(_interface)

1921

1999

def StopChecker(self):

1922

2000

self.stop_checker()

1923

1924

## Properties

1925

2001

2002

# Properties

2003

1926

2004

# ApprovalPending - property

1927

2005

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

1928

2006

def ApprovalPending_dbus_property(self):

1929

2007

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

1930

2008

1931

2009

# ApprovedByDefault - property

1932

2010

@dbus_service_property(_interface,

1933

2011

signature="b",

1936

2014

if value is None: # get

1937

2015

return dbus.Boolean(self.approved_by_default)

1938

2016

self.approved_by_default = bool(value)

1939

2017

1940

2018

# ApprovalDelay - property

1941

2019

@dbus_service_property(_interface,

1942

2020

signature="t",

1946

2024

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

1947

2025

* 1000)

1948

2026

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

1949

2027

1950

2028

# ApprovalDuration - property

1951

2029

@dbus_service_property(_interface,

1952

2030

signature="t",

1956

2034

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

1957

2035

* 1000)

1958

2036

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

1959

2037

1960

2038

# Name - property

1961

2039

@dbus_annotations(

1962

2040

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

1963

2041

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

1964

2042

def Name_dbus_property(self):

1965

2043

return dbus.String(self.name)

1966

2044

2045

# KeyID - property

2046

@dbus_annotations(

2047

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

2048

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

2049

def KeyID_dbus_property(self):

2050

return dbus.String(self.key_id)

2051

1967

2052

# Fingerprint - property

1968

2053

@dbus_annotations(

1969

2054

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

1970

2055

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

1971

2056

def Fingerprint_dbus_property(self):

1972

2057

return dbus.String(self.fingerprint)

1973

2058

1974

2059

# Host - property

1975

2060

@dbus_service_property(_interface,

1976

2061

signature="s",

1979

2064

if value is None: # get

1980

2065

return dbus.String(self.host)

1981

2066

self.host = str(value)

1982

2067

1983

2068

# Created - property

1984

2069

@dbus_annotations(

1985

2070

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

1986

2071

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

1987

2072

def Created_dbus_property(self):

1988

2073

return datetime_to_dbus(self.created)

1989

2074

1990

2075

# LastEnabled - property

1991

2076

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

1992

2077

def LastEnabled_dbus_property(self):

1993

2078

return datetime_to_dbus(self.last_enabled)

1994

2079

1995

2080

# Enabled - property

1996

2081

@dbus_service_property(_interface,

1997

2082

signature="b",

2003

2088

self.enable()

2004

2089

else:

2005

2090

self.disable()

2006

2091

2007

2092

# LastCheckedOK - property

2008

2093

@dbus_service_property(_interface,

2009

2094

signature="s",

2013

2098

self.checked_ok()

2014

2099

return

2015

2100

return datetime_to_dbus(self.last_checked_ok)

2016

2101

2017

2102

# LastCheckerStatus - property

2018

2103

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

2019

2104

def LastCheckerStatus_dbus_property(self):

2020

2105

return dbus.Int16(self.last_checker_status)

2021

2106

2022

2107

# Expires - property

2023

2108

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

2024

2109

def Expires_dbus_property(self):

2025

2110

return datetime_to_dbus(self.expires)

2026

2111

2027

2112

# LastApprovalRequest - property

2028

2113

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

2029

2114

def LastApprovalRequest_dbus_property(self):

2030

2115

return datetime_to_dbus(self.last_approval_request)

2031

2116

2032

2117

# Timeout - property

2033

2118

@dbus_service_property(_interface,

2034

2119

signature="t",

2049

2134

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

2050

2135

is None):

2051

2136

return

2052

GObject.source_remove(self.disable_initiator_tag)

2053

self.disable_initiator_tag = GObject.timeout_add(

2137

GLib.source_remove(self.disable_initiator_tag)

2138

self.disable_initiator_tag = GLib.timeout_add(

2054

2139

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

2055

2140

self.disable)

2056

2141

2057

2142

# ExtendedTimeout - property

2058

2143

@dbus_service_property(_interface,

2059

2144

signature="t",

2063

2148

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

2064

2149

* 1000)

2065

2150

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

2066

2151

2067

2152

# Interval - property

2068

2153

@dbus_service_property(_interface,

2069

2154

signature="t",

2076

2161

return

2077

2162

if self.enabled:

2078

2163

# Reschedule checker run

2079

GObject.source_remove(self.checker_initiator_tag)

2080

self.checker_initiator_tag = GObject.timeout_add(

2164

GLib.source_remove(self.checker_initiator_tag)

2165

self.checker_initiator_tag = GLib.timeout_add(

2081

2166

value, self.start_checker)

2082

self.start_checker() # Start one now, too

2083

2167

self.start_checker() # Start one now, too

2168

2084

2169

# Checker - property

2085

2170

@dbus_service_property(_interface,

2086

2171

signature="s",

2089

2174

if value is None: # get

2090

2175

return dbus.String(self.checker_command)

2091

2176

self.checker_command = str(value)

2092

2177

2093

2178

# CheckerRunning - property

2094

2179

@dbus_service_property(_interface,

2095

2180

signature="b",

2101

2186

self.start_checker()

2102

2187

else:

2103

2188

self.stop_checker()

2104

2189

2105

2190

# ObjectPath - property

2106

2191

@dbus_annotations(

2107

2192

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

2108

2193

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

2109

2194

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

2110

2195

def ObjectPath_dbus_property(self):

2111

return self.dbus_object_path # is already a dbus.ObjectPath

2112

2196

return self.dbus_object_path # is already a dbus.ObjectPath

2197

2113

2198

# Secret = property

2114

2199

@dbus_annotations(

2115

2200

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

2120

2205

byte_arrays=True)

2121

2206

def Secret_dbus_property(self, value):

2122

2207

self.secret = bytes(value)

2123

2208

2124

2209

del _interface

2125

2210

2126

2211

2127

2212

class ProxyClient(object):

2128

def __init__(self, child_pipe, fpr, address):

2213

def __init__(self, child_pipe, key_id, fpr, address):

2129

2214

self._pipe = child_pipe

2130

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

2215

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

2131

2216

if not self._pipe.recv():

2132

raise KeyError(fpr)

2133

2217

raise KeyError(key_id or fpr)

2218

2134

2219

def __getattribute__(self, name):

2135

2220

if name == '_pipe':

2136

2221

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

2139

2224

if data[0] == 'data':

2140

2225

return data[1]

2141

2226

if data[0] == 'function':

2142

2227

2143

2228

def func(*args, **kwargs):

2144

2229

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

2145

2230

return self._pipe.recv()[1]

2146

2231

2147

2232

return func

2148

2233

2149

2234

def __setattr__(self, name, value):

2150

2235

if name == '_pipe':

2151

2236

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

2154

2239

2155

2240

class ClientHandler(socketserver.BaseRequestHandler, object):

2156

2241

"""A class to handle client connections.

2157

2242

2158

2243

Instantiated once for each connection to handle it.

2159

2244

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

2160

2245

2161

2246

def handle(self):

2162

2247

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

2163

2248

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

2164

2249

str(self.client_address))

2165

2250

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

2166

2251

self.server.child_pipe.fileno())

2167

2252

2168

2253

session = gnutls.ClientSession(self.request)

2169

2170

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

2171

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

2172

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

2173

# "+DHE-DSS"))

2254

2255

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

2256

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

2257

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

2258

# "+DHE-DSS"))

2174

2259

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

2175

2260

priority = self.server.gnutls_priority

2176

2261

if priority is None:

2177

2262

priority = "NORMAL"

2178

gnutls.priority_set_direct(session._c_object, priority,

2263

gnutls.priority_set_direct(session._c_object,

2264

priority.encode("utf-8"),

2179

2265

None)

2180

2266

2181

2267

# Start communication using the Mandos protocol

2182

2268

# Get protocol number

2183

2269

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

2188

2274

except (ValueError, IndexError, RuntimeError) as error:

2189

2275

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

2190

2276

return

2191

2277

2192

2278

# Start GnuTLS connection

2193

2279

try:

2194

2280

session.handshake()

2198

2284

# established. Just abandon the request.

2199

2285

return

2200

2286

logger.debug("Handshake succeeded")

2201

2287

2202

2288

approval_required = False

2203

2289

try:

2204

try:

2205

fpr = self.fingerprint(

2206

self.peer_certificate(session))

2207

except (TypeError, gnutls.Error) as error:

2208

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

2209

return

2210

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

2211

2212

try:

2213

client = ProxyClient(child_pipe, fpr,

2290

if gnutls.has_rawpk:

2291

fpr = b""

2292

try:

2293

key_id = self.key_id(

2294

self.peer_certificate(session))

2295

except (TypeError, gnutls.Error) as error:

2296

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

2297

return

2298

logger.debug("Key ID: %s", key_id)

2299

2300

else:

2301

key_id = b""

2302

try:

2303

fpr = self.fingerprint(

2304

self.peer_certificate(session))

2305

except (TypeError, gnutls.Error) as error:

2306

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

2307

return

2308

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

2309

2310

try:

2311

client = ProxyClient(child_pipe, key_id, fpr,

2214

2312

self.client_address)

2215

2313

except KeyError:

2216

2314

return

2217

2315

2218

2316

if client.approval_delay:

2219

2317

delay = client.approval_delay

2220

2318

client.approvals_pending += 1

2221

2319

approval_required = True

2222

2320

2223

2321

while True:

2224

2322

if not client.enabled:

2225

2323

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

2228

2326

# Emit D-Bus signal

2229

2327

client.Rejected("Disabled")

2230

2328

return

2231

2329

2232

2330

if client.approved or not client.approval_delay:

2233

#We are approved or approval is disabled

2331

# We are approved or approval is disabled

2234

2332

break

2235

2333

elif client.approved is None:

2236

2334

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

2247

2345

# Emit D-Bus signal

2248

2346

client.Rejected("Denied")

2249

2347

return

2250

2251

#wait until timeout or approved

2348

2349

# wait until timeout or approved

2252

2350

time = datetime.datetime.now()

2253

2351

client.changedstate.acquire()

2254

2352

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

2267

2365

break

2268

2366

else:

2269

2367

delay -= time2 - time

2270

2368

2271

2369

try:

2272

2370

session.send(client.secret)

2273

2371

except gnutls.Error as error:

2274

2372

logger.warning("gnutls send failed",

2275

exc_info = error)

2373

exc_info=error)

2276

2374

return

2277

2375

2278

2376

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

2279

2377

# bump the timeout using extended_timeout

2280

2378

client.bump_timeout(client.extended_timeout)

2281

2379

if self.server.use_dbus:

2282

2380

# Emit D-Bus signal

2283

2381

client.GotSecret()

2284

2382

2285

2383

finally:

2286

2384

if approval_required:

2287

2385

client.approvals_pending -= 1

2290

2388

except gnutls.Error as error:

2291

2389

logger.warning("GnuTLS bye failed",

2292

2390

exc_info=error)

2293

2391

2294

2392

@staticmethod

2295

2393

def peer_certificate(session):

2296

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

2297

# If not an OpenPGP certificate...

2298

if (gnutls.certificate_type_get(session._c_object)

2299

!= gnutls.CRT_OPENPGP):

2394

"Return the peer's certificate as a bytestring"

2395

try:

2396

cert_type = gnutls.certificate_type_get2(session._c_object,

2397

gnutls.CTYPE_PEERS)

2398

except AttributeError:

2399

cert_type = gnutls.certificate_type_get(session._c_object)

2400

if gnutls.has_rawpk:

2401

valid_cert_types = frozenset((gnutls.CRT_RAWPK,))

2402

else:

2403

valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))

2404

# If not a valid certificate type...

2405

if cert_type not in valid_cert_types:

2406

logger.info("Cert type %r not in %r", cert_type,

2407

valid_cert_types)

2300

2408

# ...return invalid data

2301

2409

return b""

2302

2410

list_size = ctypes.c_uint(1)

2308

2416

return None

2309

2417

cert = cert_list[0]

2310

2418

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

2311

2419

2420

@staticmethod

2421

def key_id(certificate):

2422

"Convert a certificate bytestring to a hexdigit key ID"

2423

# New GnuTLS "datum" with the public key

2424

datum = gnutls.datum_t(

2425

ctypes.cast(ctypes.c_char_p(certificate),

2426

ctypes.POINTER(ctypes.c_ubyte)),

2427

ctypes.c_uint(len(certificate)))

2428

# XXX all these need to be created in the gnutls "module"

2429

# New empty GnuTLS certificate

2430

pubkey = gnutls.pubkey_t()

2431

gnutls.pubkey_init(ctypes.byref(pubkey))

2432

# Import the raw public key into the certificate

2433

gnutls.pubkey_import(pubkey,

2434

ctypes.byref(datum),

2435

gnutls.X509_FMT_DER)

2436

# New buffer for the key ID

2437

buf = ctypes.create_string_buffer(32)

2438

buf_len = ctypes.c_size_t(len(buf))

2439

# Get the key ID from the raw public key into the buffer

2440

gnutls.pubkey_get_key_id(pubkey,

2441

gnutls.KEYID_USE_SHA256,

2442

ctypes.cast(ctypes.byref(buf),

2443

ctypes.POINTER(ctypes.c_ubyte)),

2444

ctypes.byref(buf_len))

2445

# Deinit the certificate

2446

gnutls.pubkey_deinit(pubkey)

2447

2448

# Convert the buffer to a Python bytestring

2449

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

2450

# Convert the bytestring to hexadecimal notation

2451

hex_key_id = binascii.hexlify(key_id).upper()

2452

return hex_key_id

2453

2312

2454

@staticmethod

2313

2455

def fingerprint(openpgp):

2314

2456

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2329

2471

ctypes.byref(crtverify))

2330

2472

if crtverify.value != 0:

2331

2473

gnutls.openpgp_crt_deinit(crt)

2332

raise gnutls.CertificateSecurityError("Verify failed")

2474

raise gnutls.CertificateSecurityError(code

2475

=crtverify.value)

2333

2476

# New buffer for the fingerprint

2334

2477

buf = ctypes.create_string_buffer(20)

2335

2478

buf_len = ctypes.c_size_t()

2347

2490

2348

2491

class MultiprocessingMixIn(object):

2349

2492

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

2350

2493

2351

2494

def sub_process_main(self, request, address):

2352

2495

try:

2353

2496

self.finish_request(request, address)

2354

2497

except Exception:

2355

2498

self.handle_error(request, address)

2356

2499

self.close_request(request)

2357

2500

2358

2501

def process_request(self, request, address):

2359

2502

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

2360

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

2361

args = (request, address))

2503

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

2504

args=(request, address))

2362

2505

proc.start()

2363

2506

return proc

2364

2507

2365

2508

2366

2509

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2367

2510

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

2368

2511

2369

2512

def process_request(self, request, client_address):

2370

2513

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

2371

2514

2372

2515

This function creates a new pipe in self.pipe

2373

2516

"""

2374

2517

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2375

2518

2376

2519

proc = MultiprocessingMixIn.process_request(self, request,

2377

2520

client_address)

2378

2521

self.child_pipe.close()

2379

2522

self.add_pipe(parent_pipe, proc)

2380

2523

2381

2524

def add_pipe(self, parent_pipe, proc):

2382

2525

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

2383

2526

raise NotImplementedError()

2386

2529

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2387

2530

socketserver.TCPServer, object):

2388

2531

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

2389

2532

2390

2533

Attributes:

2391

2534

enabled: Boolean; whether this server is activated yet

2392

2535

interface: None or a network interface name (string)

2393

2536

use_ipv6: Boolean; to use IPv6 or not

2394

2537

"""

2395

2538

2396

2539

def __init__(self, server_address, RequestHandlerClass,

2397

2540

interface=None,

2398

2541

use_ipv6=True,

2408

2551

self.socketfd = socketfd

2409

2552

# Save the original socket.socket() function

2410

2553

self.socket_socket = socket.socket

2554

2411

2555

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

2412

#

2556

#

2413

2557

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

2414

2558

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

2415

2559

# patching socket.socket.)

2416

#

2560

#

2417

2561

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

2418

2562

@functools.wraps(socket.socket)

2419

2563

def socket_wrapper(*args, **kwargs):

2431

2575

# socket_wrapper(), if socketfd was set.

2432

2576

socketserver.TCPServer.__init__(self, server_address,

2433

2577

RequestHandlerClass)

2434

2578

2435

2579

def server_bind(self):

2436

2580

"""This overrides the normal server_bind() function

2437

2581

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

2438

2582

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

2583

global SO_BINDTODEVICE

2439

2584

if self.interface is not None:

2440

2585

if SO_BINDTODEVICE is None:

2441

logger.error("SO_BINDTODEVICE does not exist;"

2442

" cannot bind to interface %s",

2443

self.interface)

2444

else:

2445

try:

2446

self.socket.setsockopt(

2447

socket.SOL_SOCKET, SO_BINDTODEVICE,

2448

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

2449

except socket.error as error:

2450

if error.errno == errno.EPERM:

2451

logger.error("No permission to bind to"

2452

" interface %s", self.interface)

2453

elif error.errno == errno.ENOPROTOOPT:

2454

logger.error("SO_BINDTODEVICE not available;"

2455

" cannot bind to interface %s",

2456

self.interface)

2457

elif error.errno == errno.ENODEV:

2458

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

2459

" cannot bind", self.interface)

2460

else:

2461

raise

2586

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

2587

# common enough.

2588

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

2589

SO_BINDTODEVICE = 25

2590

try:

2591

self.socket.setsockopt(

2592

socket.SOL_SOCKET, SO_BINDTODEVICE,

2593

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

2594

except socket.error as error:

2595

if error.errno == errno.EPERM:

2596

logger.error("No permission to bind to"

2597

" interface %s", self.interface)

2598

elif error.errno == errno.ENOPROTOOPT:

2599

logger.error("SO_BINDTODEVICE not available;"

2600

" cannot bind to interface %s",

2601

self.interface)

2602

elif error.errno == errno.ENODEV:

2603

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

2604

" cannot bind", self.interface)

2605

else:

2606

raise

2462

2607

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

2463

2608

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

2609

if self.server_address[1]:

2610

self.allow_reuse_address = True

2464

2611

if not self.server_address[0]:

2465

2612

if self.address_family == socket.AF_INET6:

2466

any_address = "::" # in6addr_any

2613

any_address = "::" # in6addr_any

2467

2614

else:

2468

any_address = "0.0.0.0" # INADDR_ANY

2615

any_address = "0.0.0.0" # INADDR_ANY

2469

2616

self.server_address = (any_address,

2470

2617

self.server_address[1])

2471

2618

elif not self.server_address[1]:

2481

2628

2482

2629

class MandosServer(IPv6_TCPServer):

2483

2630

"""Mandos server.

2484

2631

2485

2632

Attributes:

2486

2633

clients: set of Client objects

2487

2634

gnutls_priority GnuTLS priority string

2488

2635

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

2489

2490

Assumes a GObject.MainLoop event loop.

2636

2637

Assumes a GLib.MainLoop event loop.

2491

2638

"""

2492

2639

2493

2640

def __init__(self, server_address, RequestHandlerClass,

2494

2641

interface=None,

2495

2642

use_ipv6=True,

2505

2652

self.gnutls_priority = gnutls_priority

2506

2653

IPv6_TCPServer.__init__(self, server_address,

2507

2654

RequestHandlerClass,

2508

interface = interface,

2509

use_ipv6 = use_ipv6,

2510

socketfd = socketfd)

2511

2655

interface=interface,

2656

use_ipv6=use_ipv6,

2657

socketfd=socketfd)

2658

2512

2659

def server_activate(self):

2513

2660

if self.enabled:

2514

2661

return socketserver.TCPServer.server_activate(self)

2515

2662

2516

2663

def enable(self):

2517

2664

self.enabled = True

2518

2665

2519

2666

def add_pipe(self, parent_pipe, proc):

2520

2667

# Call "handle_ipc" for both data and EOF events

2521

GObject.io_add_watch(

2668

GLib.io_add_watch(

2522

2669

parent_pipe.fileno(),

2523

GObject.IO_IN | GObject.IO_HUP,

2670

GLib.IO_IN | GLib.IO_HUP,

2524

2671

functools.partial(self.handle_ipc,

2525

parent_pipe = parent_pipe,

2526

proc = proc))

2527

2672

parent_pipe=parent_pipe,

2673

proc=proc))

2674

2528

2675

def handle_ipc(self, source, condition,

2529

2676

parent_pipe=None,

2530

proc = None,

2677

proc=None,

2531

2678

client_object=None):

2532

2679

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

2533

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

2680

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

2534

2681

# Wait for other process to exit

2535

2682

proc.join()

2536

2683

return False

2537

2684

2538

2685

# Read a request from the child

2539

2686

request = parent_pipe.recv()

2540

2687

command = request[0]

2541

2688

2542

2689

if command == 'init':

2543

fpr = request[1]

2544

address = request[2]

2545

2690

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

2691

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

2692

address = request[3]

2693

2546

2694

for c in self.clients.values():

2547

if c.fingerprint == fpr:

2695

if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":

2696

continue

2697

if key_id and c.key_id == key_id:

2698

client = c

2699

break

2700

if fpr and c.fingerprint == fpr:

2548

2701

client = c

2549

2702

break

2550

2703

else:

2551

logger.info("Client not found for fingerprint: %s, ad"

2552

"dress: %s", fpr, address)

2704

logger.info("Client not found for key ID: %s, address"

2705

": %s", key_id or fpr, address)

2553

2706

if self.use_dbus:

2554

2707

# Emit D-Bus signal

2555

mandos_dbus_service.ClientNotFound(fpr,

2708

mandos_dbus_service.ClientNotFound(key_id or fpr,

2556

2709

address[0])

2557

2710

parent_pipe.send(False)

2558

2711

return False

2559

2560

GObject.io_add_watch(

2712

2713

GLib.io_add_watch(

2561

2714

parent_pipe.fileno(),

2562

GObject.IO_IN | GObject.IO_HUP,

2715

GLib.IO_IN | GLib.IO_HUP,

2563

2716

functools.partial(self.handle_ipc,

2564

parent_pipe = parent_pipe,

2565

proc = proc,

2566

client_object = client))

2717

parent_pipe=parent_pipe,

2718

proc=proc,

2719

client_object=client))

2567

2720

parent_pipe.send(True)

2568

2721

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

2569

2722

# same fileno

2572

2725

funcname = request[1]

2573

2726

args = request[2]

2574

2727

kwargs = request[3]

2575

2728

2576

2729

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

2577

2730

funcname)(*args,

2578

2731

**kwargs)))

2579

2732

2580

2733

if command == 'getattr':

2581

2734

attrname = request[1]

2582

2735

if isinstance(client_object.__getattribute__(attrname),

2585

2738

else:

2586

2739

parent_pipe.send((

2587

2740

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

2588

2741

2589

2742

if command == 'setattr':

2590

2743

attrname = request[1]

2591

2744

value = request[2]

2592

2745

setattr(client_object, attrname, value)

2593

2746

2594

2747

return True

2595

2748

2596

2749

2597

2750

def rfc3339_duration_to_delta(duration):

2598

2751

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

2599

2752

2600

2753

>>> rfc3339_duration_to_delta("P7D")

2601

2754

datetime.timedelta(7)

2602

2755

>>> rfc3339_duration_to_delta("PT60S")

2612

2765

>>> rfc3339_duration_to_delta("P1DT3M20S")

2613

2766

datetime.timedelta(1, 200)

2614

2767

"""

2615

2768

2616

2769

# Parsing an RFC 3339 duration with regular expressions is not

2617

2770

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

2618

2771

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

2619

2772

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

2620

2773

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

2621

2774

# avoid excessive use of external libraries.

2622

2775

2623

2776

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

2624

2777

Token = collections.namedtuple("Token", (

2625

2778

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

2658

2811

frozenset((token_year, token_month,

2659

2812

token_day, token_time,

2660

2813

token_week)))

2661

# Define starting values

2662

value = datetime.timedelta() # Value so far

2814

# Define starting values:

2815

# Value so far

2816

value = datetime.timedelta()

2663

2817

found_token = None

2664

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

2665

s = duration # String left to parse

2818

# Following valid tokens

2819

followers = frozenset((token_duration, ))

2820

# String left to parse

2821

s = duration

2666

2822

# Loop until end token is found

2667

2823

while found_token is not token_end:

2668

2824

# Search for any currently valid tokens

2692

2848

2693

2849

def string_to_delta(interval):

2694

2850

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

2695

2851

2696

2852

>>> string_to_delta('7d')

2697

2853

datetime.timedelta(7)

2698

2854

>>> string_to_delta('60s')

2706

2862

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

2707

2863

datetime.timedelta(0, 330)

2708

2864

"""

2709

2865

2710

2866

try:

2711

2867

return rfc3339_duration_to_delta(interval)

2712

2868

except ValueError:

2713

2869

pass

2714

2870

2715

2871

timevalue = datetime.timedelta(0)

2716

2872

for s in interval.split():

2717

2873

try:

2735

2891

return timevalue

2736

2892

2737

2893

2738

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

2894

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

2739

2895

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

2740

2896

2741

2897

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

2742

2898

if os.fork():

2743

2899

sys.exit()

2761

2917

2762

2918

2763

2919

def main():

2764

2920

2765

2921

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

2766

2922

# Parsing of options, both command line and config file

2767

2923

2768

2924

parser = argparse.ArgumentParser()

2769

2925

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

2770

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

2926

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

2771

2927

help="show version number and exit")

2772

2928

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

2773

2929

help="Bind to interface IF")

2809

2965

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

2810

2966

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

2811

2967

default=None)

2812

2968

2813

2969

options = parser.parse_args()

2814

2970

2815

2971

if options.check:

2816

2972

import doctest

2817

2973

fail_count, test_count = doctest.testmod()

2818

2974

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

2819

2975

2820

2976

# Default values for config file for server-global settings

2821

server_defaults = { "interface": "",

2822

"address": "",

2823

"port": "",

2824

"debug": "False",

2825

"priority":

2826

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

2827

":+SIGN-DSA-SHA256",

2828

"servicename": "Mandos",

2829

"use_dbus": "True",

2830

"use_ipv6": "True",

2831

"debuglevel": "",

2832

"restore": "True",

2833

"socket": "",

2834

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

2835

"foreground": "False",

2836

"zeroconf": "True",

2837

}

2838

2977

if gnutls.has_rawpk:

2978

priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"

2979

":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")

2980

else:

2981

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

2982

":+SIGN-DSA-SHA256")

2983

server_defaults = {"interface": "",

2984

"address": "",

2985

"port": "",

2986

"debug": "False",

2987

"priority": priority,

2988

"servicename": "Mandos",

2989

"use_dbus": "True",

2990

"use_ipv6": "True",

2991

"debuglevel": "",

2992

"restore": "True",

2993

"socket": "",

2994

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

2995

"foreground": "False",

2996

"zeroconf": "True",

2997

}

2998

del priority

2999

2839

3000

# Parse config file for server-global settings

2840

3001

server_config = configparser.SafeConfigParser(server_defaults)

2841

3002

del server_defaults

2843

3004

# Convert the SafeConfigParser object to a dict

2844

3005

server_settings = server_config.defaults()

2845

3006

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

2846

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

3007

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

3008

"foreground", "zeroconf"):

2847

3009

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

2848

3010

option)

2849

3011

if server_settings["port"]:

2859

3021

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

2860

3022

["socket"])

2861

3023

del server_config

2862

3024

2863

3025

# Override the settings from the config file with command line

2864

3026

# options, if set.

2865

3027

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

2883

3045

if server_settings["debug"]:

2884

3046

server_settings["foreground"] = True

2885

3047

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

2886

3048

2887

3049

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

2888

3050

2889

3051

if (not server_settings["zeroconf"]

2890

3052

and not (server_settings["port"]

2891

3053

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

2892

3054

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

2893

3055

2894

3056

# For convenience

2895

3057

debug = server_settings["debug"]

2896

3058

debuglevel = server_settings["debuglevel"]

2900

3062

stored_state_file)

2901

3063

foreground = server_settings["foreground"]

2902

3064

zeroconf = server_settings["zeroconf"]

2903

3065

2904

3066

if debug:

2905

3067

initlogger(debug, logging.DEBUG)

2906

3068

else:

2909

3071

else:

2910

3072

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

2911

3073

initlogger(debug, level)

2912

3074

2913

3075

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

2914

3076

syslogger.setFormatter(

2915

3077

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

2916

3078

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

2917

3079

server_settings["servicename"])))

2918

3080

2919

3081

# Parse config file with clients

2920

3082

client_config = configparser.SafeConfigParser(Client

2921

3083

.client_defaults)

2922

3084

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

2923

3085

"clients.conf"))

2924

3086

2925

3087

global mandos_dbus_service

2926

3088

mandos_dbus_service = None

2927

3089

2928

3090

socketfd = None

2929

3091

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

2930

3092

socketfd = server_settings["socket"]

2946

3108

except IOError as e:

2947

3109

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

2948

3110

exc_info=e)

2949

3111

2950

3112

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

2951

3113

("mandos", "mandos"),

2952

3114

("nobody", "nogroup")):

2970

3132

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

2971

3133

if error.errno != errno.EPERM:

2972

3134

raise

2973

3135

2974

3136

if debug:

2975

3137

# Enable all possible GnuTLS debugging

2976

3138

2977

3139

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

2978

3140

# - GnuTLS manual

2979

3141

gnutls.global_set_log_level(11)

2980

3142

2981

3143

@gnutls.log_func

2982

3144

def debug_gnutls(level, string):

2983

3145

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

2984

3146

2985

3147

gnutls.global_set_log_function(debug_gnutls)

2986

3148

2987

3149

# Redirect stdin so all checkers get /dev/null

2988

3150

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

2989

3151

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

2990

3152

if null > 2:

2991

3153

os.close(null)

2992

3154

2993

3155

# Need to fork before connecting to D-Bus

2994

3156

if not foreground:

2995

3157

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

2996

3158

daemon()

2997

2998

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

2999

# need to inform GObject that threads will be used.

3000

GObject.threads_init()

3001

3159

3160

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

3161

# to inform GLib that threads will be used.

3162

GLib.threads_init()

3163

3002

3164

global main_loop

3003

3165

# From the Avahi example code

3004

3166

DBusGMainLoop(set_as_default=True)

3005

main_loop = GObject.MainLoop()

3167

main_loop = GLib.MainLoop()

3006

3168

bus = dbus.SystemBus()

3007

3169

# End of Avahi example code

3008

3170

if use_dbus:

3021

3183

if zeroconf:

3022

3184

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

3023

3185

service = AvahiServiceToSyslog(

3024

name = server_settings["servicename"],

3025

servicetype = "_mandos._tcp",

3026

protocol = protocol,

3027

bus = bus)

3186

name=server_settings["servicename"],

3187

servicetype="_mandos._tcp",

3188

protocol=protocol,

3189

bus=bus)

3028

3190

if server_settings["interface"]:

3029

3191

service.interface = if_nametoindex(

3030

3192

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

3031

3193

3032

3194

global multiprocessing_manager

3033

3195

multiprocessing_manager = multiprocessing.Manager()

3034

3196

3035

3197

client_class = Client

3036

3198

if use_dbus:

3037

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

3038

3199

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

3200

3039

3201

client_settings = Client.config_parser(client_config)

3040

3202

old_client_settings = {}

3041

3203

clients_data = {}

3042

3204

3043

3205

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

3044

3206

global wnull

3045

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

3207

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

3046

3208

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

3047

3209

# mode

3048

3210

if debug or not foreground:

3049

3211

wnull.close()

3050

3212

3051

3213

# Get client data and settings from last running state.

3052

3214

if server_settings["restore"]:

3053

3215

try:

3054

3216

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

3055

if sys.version_info.major == 2:

3217

if sys.version_info.major == 2:

3056

3218

clients_data, old_client_settings = pickle.load(

3057

3219

stored_state)

3058

3220

else:

3059

3221

bytes_clients_data, bytes_old_client_settings = (

3060

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

3061

### Fix bytes to strings

3062

## clients_data

3222

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

3223

# Fix bytes to strings

3224

# clients_data

3063

3225

# .keys()

3064

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

3065

if isinstance(key, bytes)

3066

else key): value

3067

for key, value in

3068

bytes_clients_data.items() }

3226

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

3227

if isinstance(key, bytes)

3228

else key): value

3229

for key, value in

3230

bytes_clients_data.items()}

3231

del bytes_clients_data

3069

3232

for key in clients_data:

3070

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

3071

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

3072

for k, v in

3073

clients_data[key].items() }

3233

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

3234

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

3235

for k, v in

3236

clients_data[key].items()}

3074

3237

clients_data[key] = value

3075

3238

# .client_structure

3076

3239

value["client_structure"] = [

3077

3240

(s.decode("utf-8")

3078

3241

if isinstance(s, bytes)

3079

3242

else s) for s in

3080

value["client_structure"] ]

3243

value["client_structure"]]

3081

3244

# .name & .host

3082

3245

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

3083

3246

if isinstance(value[k], bytes):

3084

3247

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

3085

## old_client_settings

3086

# .keys

3248

if "key_id" not in value:

3249

value["key_id"] = ""

3250

elif "fingerprint" not in value:

3251

value["fingerprint"] = ""

3252

# old_client_settings

3253

# .keys()

3087

3254

old_client_settings = {

3088

3255

(key.decode("utf-8")

3089

3256

if isinstance(key, bytes)

3090

3257

else key): value

3091

3258

for key, value in

3092

bytes_old_client_settings.items() }

3259

bytes_old_client_settings.items()}

3260

del bytes_old_client_settings

3093

3261

# .host

3094

3262

for value in old_client_settings.values():

3095

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

3263

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

3264

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

3265

.decode("utf-8"))

3096

3266

os.remove(stored_state_path)

3097

3267

except IOError as e:

3098

3268

if e.errno == errno.ENOENT:

3106

3276

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

3107

3277

"EOFError:",

3108

3278

exc_info=e)

3109

3279

3110

3280

with PGPEngine() as pgp:

3111

3281

for client_name, client in clients_data.items():

3112

3282

# Skip removed clients

3113

3283

if client_name not in client_settings:

3114

3284

continue

3115

3285

3116

3286

# Decide which value to use after restoring saved state.

3117

3287

# We have three different values: Old config file,

3118

3288

# new config file, and saved state.

3129

3299

client[name] = value

3130

3300

except KeyError:

3131

3301

pass

3132

3302

3133

3303

# Clients who has passed its expire date can still be

3134

3304

# enabled if its last checker was successful. A Client

3135

3305

# whose checker succeeded before we stored its state is

3168

3338

client_name))

3169

3339

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

3170

3340

["secret"])

3171

3341

3172

3342

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

3173

3343

for client_name in (set(old_client_settings)

3174

3344

- set(client_settings)):

3176

3346

for client_name in (set(client_settings)

3177

3347

- set(old_client_settings)):

3178

3348

clients_data[client_name] = client_settings[client_name]

3179

3349

3180

3350

# Create all client objects

3181

3351

for client_name, client in clients_data.items():

3182

3352

tcp_server.clients[client_name] = client_class(

3183

name = client_name,

3184

settings = client,

3185

server_settings = server_settings)

3186

3353

name=client_name,

3354

settings=client,

3355

server_settings=server_settings)

3356

3187

3357

if not tcp_server.clients:

3188

3358

logger.warning("No clients defined")

3189

3359

3190

3360

if not foreground:

3191

3361

if pidfile is not None:

3192

3362

pid = os.getpid()

3198

3368

pidfilename, pid)

3199

3369

del pidfile

3200

3370

del pidfilename

3201

3202

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

3203

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

3204

3371

3372

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

3373

GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,

3374

lambda: main_loop.quit() and False)

3375

3205

3376

if use_dbus:

3206

3377

3207

3378

@alternate_dbus_interfaces(

3208

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

3379

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

3209

3380

class MandosDBusService(DBusObjectWithObjectManager):

3210

3381

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

3211

3382

3212

3383

def __init__(self):

3213

3384

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

3214

3385

3215

3386

_interface = "se.recompile.Mandos"

3216

3387

3217

3388

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

3218

3389

def ClientAdded(self, objpath):

3219

3390

"D-Bus signal"

3220

3391

pass

3221

3392

3222

3393

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

3223

def ClientNotFound(self, fingerprint, address):

3394

def ClientNotFound(self, key_id, address):

3224

3395

"D-Bus signal"

3225

3396

pass

3226

3397

3227

3398

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

3228

3399

"true"})

3229

3400

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

3230

3401

def ClientRemoved(self, objpath, name):

3231

3402

"D-Bus signal"

3232

3403

pass

3233

3404

3234

3405

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

3235

3406

"true"})

3236

3407

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

3238

3409

"D-Bus method"

3239

3410

return dbus.Array(c.dbus_object_path for c in

3240

3411

tcp_server.clients.values())

3241

3412

3242

3413

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

3243

3414

"true"})

3244

3415

@dbus.service.method(_interface,

3246

3417

def GetAllClientsWithProperties(self):

3247

3418

"D-Bus method"

3248

3419

return dbus.Dictionary(

3249

{ c.dbus_object_path: c.GetAll(

3420

{c.dbus_object_path: c.GetAll(

3250

3421

"se.recompile.Mandos.Client")

3251

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

3422

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

3252

3423

signature="oa{sv}")

3253

3424

3254

3425

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

3255

3426

def RemoveClient(self, object_path):

3256

3427

"D-Bus method"

3264

3435

self.client_removed_signal(c)

3265

3436

return

3266

3437

raise KeyError(object_path)

3267

3438

3268

3439

del _interface

3269

3440

3270

3441

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3271

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

3442

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

3272

3443

def GetManagedObjects(self):

3273

3444

"""D-Bus method"""

3274

3445

return dbus.Dictionary(

3275

{ client.dbus_object_path:

3276

dbus.Dictionary(

3277

{ interface: client.GetAll(interface)

3278

for interface in

3279

client._get_all_interface_names()})

3280

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

3281

3446

{client.dbus_object_path:

3447

dbus.Dictionary(

3448

{interface: client.GetAll(interface)

3449

for interface in

3450

client._get_all_interface_names()})

3451

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

3452

3282

3453

def client_added_signal(self, client):

3283

3454

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

3284

3455

if use_dbus:

3286

3457

self.InterfacesAdded(

3287

3458

client.dbus_object_path,

3288

3459

dbus.Dictionary(

3289

{ interface: client.GetAll(interface)

3290

for interface in

3291

client._get_all_interface_names()}))

3460

{interface: client.GetAll(interface)

3461

for interface in

3462

client._get_all_interface_names()}))

3292

3463

# Old signal

3293

3464

self.ClientAdded(client.dbus_object_path)

3294

3465

3295

3466

def client_removed_signal(self, client):

3296

3467

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

3297

3468

if use_dbus:

3302

3473

# Old signal

3303

3474

self.ClientRemoved(client.dbus_object_path,

3304

3475

client.name)

3305

3476

3306

3477

mandos_dbus_service = MandosDBusService()

3307

3478

3479

# Save modules to variables to exempt the modules from being

3480

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

3481

mp = multiprocessing

3482

wn = wnull

3483

3308

3484

def cleanup():

3309

3485

"Cleanup function; run on exit"

3310

3486

if zeroconf:

3311

3487

service.cleanup()

3312

3313

multiprocessing.active_children()

3314

wnull.close()

3488

3489

mp.active_children()

3490

wn.close()

3315

3491

if not (tcp_server.clients or client_settings):

3316

3492

return

3317

3493

3318

3494

# Store client before exiting. Secrets are encrypted with key

3319

3495

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

3320

3496

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

3325

3501

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

3326

3502

key)

3327

3503

client_dict = {}

3328

3504

3329

3505

# A list of attributes that can not be pickled

3330

3506

# + secret.

3331

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

3332

"checker", "server_settings" }

3507

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

3508

"checker", "server_settings"}

3333

3509

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

3334

3510

.Object):

3335

3511

exclude.add(name)

3336

3512

3337

3513

client_dict["encrypted_secret"] = (client

3338

3514

.encrypted_secret)

3339

3515

for attr in client.client_structure:

3340

3516

if attr not in exclude:

3341

3517

client_dict[attr] = getattr(client, attr)

3342

3518

3343

3519

clients[client.name] = client_dict

3344

3520

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

3345

3521

3346

3522

try:

3347

3523

with tempfile.NamedTemporaryFile(

3348

3524

mode='wb',

3351

3527

dir=os.path.dirname(stored_state_path),

3352

3528

delete=False) as stored_state:

3353

3529

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

3354

protocol = 2)

3530

protocol=2)

3355

3531

tempname = stored_state.name

3356

3532

os.rename(tempname, stored_state_path)

3357

3533

except (IOError, OSError) as e:

3367

3543

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

3368

3544

exc_info=e)

3369

3545

raise

3370

3546

3371

3547

# Delete all clients, and settings from config

3372

3548

while tcp_server.clients:

3373

3549

name, client = tcp_server.clients.popitem()

3379

3555

if use_dbus:

3380

3556

mandos_dbus_service.client_removed_signal(client)

3381

3557

client_settings.clear()

3382

3558

3383

3559

atexit.register(cleanup)

3384

3560

3385

3561

for client in tcp_server.clients.values():

3386

3562

if use_dbus:

3387

3563

# Emit D-Bus signal for adding

3389

3565

# Need to initiate checking of clients

3390

3566

if client.enabled:

3391

3567

client.init_checker()

3392

3568

3393

3569

tcp_server.enable()

3394

3570

tcp_server.server_activate()

3395

3571

3396

3572

# Find out what port we got

3397

3573

if zeroconf:

3398

3574

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

3403

3579

else: # IPv4

3404

3580

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

3405

3581

*tcp_server.socket.getsockname())

3406

3407

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

3408

3582

3583

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

3584

3409

3585

try:

3410

3586

if zeroconf:

3411

3587

# From the Avahi example code

3416

3592

cleanup()

3417

3593

sys.exit(1)

3418

3594

# End of Avahi example code

3419

3420

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

3421

lambda *args, **kwargs:

3422

(tcp_server.handle_request

3423

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

3424

3595

3596

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

3597

lambda *args, **kwargs:

3598

(tcp_server.handle_request

3599

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

3600

3425

3601

logger.debug("Starting main loop")

3426

3602

main_loop.run()

3427

3603

except AvahiError as error: