/mandos/release : revision 237.7.350

1

#!/usr/bin/python

1

#!/usr/bin/python2.7

2

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

3

#

4

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

11

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

12

#

13

# Everything else is

14

15

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

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

import SocketServer as socketserver

37

from future_builtins import *

38

39

try:

40

import SocketServer as socketserver

41

except ImportError:

42

import socketserver

38

43

import socket

39

44

import argparse

40

45

import datetime

41

46

import errno

42

import gnutls.crypto

43

import gnutls.connection

44

import gnutls.errors

45

import gnutls.library.functions

46

import gnutls.library.constants

47

import gnutls.library.types

48

import ConfigParser as configparser

47

try:

48

import ConfigParser as configparser

49

except ImportError:

50

import configparser

49

51

import sys

50

52

import re

51

53

import os

60

62

import struct

61

63

import fcntl

62

64

import functools

63

import cPickle as pickle

65

try:

66

import cPickle as pickle

67

except ImportError:

68

import pickle

64

69

import multiprocessing

65

70

import types

66

71

import binascii

67

72

import tempfile

73

import itertools

74

import collections

75

import codecs

68

76

69

77

import dbus

70

78

import dbus.service

71

import gobject

79

try:

80

import gobject

81

except ImportError:

82

from gi.repository import GObject as gobject

72

83

import avahi

73

84

from dbus.mainloop.glib import DBusGMainLoop

74

85

import ctypes

75

86

import ctypes.util

76

87

import xml.dom.minidom

77

88

import inspect

78

import GnuPGInterface

79

89

80

90

try:

81

91

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

85

95

except ImportError:

86

96

SO_BINDTODEVICE = None

87

97

88

version = "1.4.1"

98

if sys.version_info.major == 2:

99

str = unicode

100

101

version = "1.7.1"

89

102

stored_state_file = "clients.pickle"

90

103

91

104

logger = logging.getLogger()

92

syslogger = (logging.handlers.SysLogHandler

93

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

94

address = str("/dev/log")))

105

syslogger = None

95

106

96

107

try:

97

if_nametoindex = (ctypes.cdll.LoadLibrary

98

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

99

.if_nametoindex)

108

if_nametoindex = ctypes.cdll.LoadLibrary(

109

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

100

110

except (OSError, AttributeError):

111

101

112

def if_nametoindex(interface):

102

113

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

103

114

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

104

115

with contextlib.closing(socket.socket()) as s:

105

116

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

106

struct.pack(str("16s16x"),

107

interface))

108

interface_index = struct.unpack(str("I"),

109

ifreq[16:20])[0]

117

struct.pack(b"16s16x", interface))

118

interface_index = struct.unpack("I", ifreq[16:20])[0]

110

119

return interface_index

111

120

112

121

113

122

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

114

123

"""init logger and add loglevel"""

115

124

125

global syslogger

126

syslogger = (logging.handlers.SysLogHandler(

127

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

128

address = "/dev/log"))

116

129

syslogger.setFormatter(logging.Formatter

117

130

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

118

131

' %(message)s'))

135

148

136

149

class PGPEngine(object):

137

150

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

151

138

152

def __init__(self):

139

self.gnupg = GnuPGInterface.GnuPG()

140

153

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

141

self.gnupg = GnuPGInterface.GnuPG()

142

self.gnupg.options.meta_interactive = False

143

self.gnupg.options.homedir = self.tempdir

144

self.gnupg.options.extra_args.extend(['--force-mdc',

145

'--quiet',

146

'--no-use-agent'])

154

self.gnupgargs = ['--batch',

155

'--home', self.tempdir,

156

'--force-mdc',

157

'--quiet',

158

'--no-use-agent']

147

159

148

160

def __enter__(self):

149

161

return self

150

162

151

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

163

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

152

164

self._cleanup()

153

165

return False

154

166

171

183

def password_encode(self, password):

172

184

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

173

185

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

174

return b"mandos" + binascii.hexlify(password)

186

encoded = b"mandos" + binascii.hexlify(password)

187

if len(encoded) > 2048:

188

# GnuPG can't handle long passwords, so encode differently

189

encoded = (b"mandos" + password.replace(b"\\", b"\\\\")

190

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

191

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

192

return encoded

175

193

176

194

def encrypt(self, data, password):

177

self.gnupg.passphrase = self.password_encode(password)

178

with open(os.devnull) as devnull:

179

try:

180

proc = self.gnupg.run(['--symmetric'],

181

create_fhs=['stdin', 'stdout'],

182

attach_fhs={'stderr': devnull})

183

with contextlib.closing(proc.handles['stdin']) as f:

184

f.write(data)

185

with contextlib.closing(proc.handles['stdout']) as f:

186

ciphertext = f.read()

187

proc.wait()

188

except IOError as e:

189

raise PGPError(e)

190

self.gnupg.passphrase = None

195

passphrase = self.password_encode(password)

196

with tempfile.NamedTemporaryFile(

197

dir=self.tempdir) as passfile:

198

passfile.write(passphrase)

199

passfile.flush()

200

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

201

'--passphrase-file',

202

passfile.name]

203

+ self.gnupgargs,

204

stdin = subprocess.PIPE,

205

stdout = subprocess.PIPE,

206

stderr = subprocess.PIPE)

207

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

208

if proc.returncode != 0:

209

raise PGPError(err)

191

210

return ciphertext

192

211

193

212

def decrypt(self, data, password):

194

self.gnupg.passphrase = self.password_encode(password)

195

with open(os.devnull) as devnull:

196

try:

197

proc = self.gnupg.run(['--decrypt'],

198

create_fhs=['stdin', 'stdout'],

199

attach_fhs={'stderr': devnull})

200

with contextlib.closing(proc.handles['stdin'] ) as f:

201

f.write(data)

202

with contextlib.closing(proc.handles['stdout']) as f:

203

decrypted_plaintext = f.read()

204

proc.wait()

205

except IOError as e:

206

raise PGPError(e)

207

self.gnupg.passphrase = None

213

passphrase = self.password_encode(password)

214

with tempfile.NamedTemporaryFile(

215

dir = self.tempdir) as passfile:

216

passfile.write(passphrase)

217

passfile.flush()

218

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

219

'--passphrase-file',

220

passfile.name]

221

+ self.gnupgargs,

222

stdin = subprocess.PIPE,

223

stdout = subprocess.PIPE,

224

stderr = subprocess.PIPE)

225

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

226

if proc.returncode != 0:

227

raise PGPError(err)

208

228

return decrypted_plaintext

209

229

210

230

211

212

231

class AvahiError(Exception):

213

232

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

214

233

self.value = value

215

super(AvahiError, self).__init__(value, *args, **kwargs)

216

def __unicode__(self):

217

return unicode(repr(self.value))

234

return super(AvahiError, self).__init__(value, *args,

235

**kwargs)

236

218

237

219

238

class AvahiServiceError(AvahiError):

220

239

pass

221

240

241

222

242

class AvahiGroupError(AvahiError):

223

243

pass

224

244

231

251

Used to optionally bind to the specified interface.

232

252

name: string; Example: 'Mandos'

233

253

type: string; Example: '_mandos._tcp'.

234

See <http://www.dns-sd.org/ServiceTypes.html>

254

See <https://www.iana.org/assignments/service-names-port-numbers>

235

255

port: integer; what port to announce

236

256

TXT: list of strings; TXT record for the service

237

257

domain: string; Domain to publish on, default to .local if empty.

243

263

server: D-Bus Server

244

264

bus: dbus.SystemBus()

245

265

"""

246

def __init__(self, interface = avahi.IF_UNSPEC, name = None,

247

servicetype = None, port = None, TXT = None,

248

domain = "", host = "", max_renames = 32768,

249

protocol = avahi.PROTO_UNSPEC, bus = None):

266

267

def __init__(self,

268

interface = avahi.IF_UNSPEC,

269

name = None,

270

servicetype = None,

271

port = None,

272

TXT = None,

273

domain = "",

274

host = "",

275

max_renames = 32768,

276

protocol = avahi.PROTO_UNSPEC,

277

bus = None):

250

278

self.interface = interface

251

279

self.name = name

252

280

self.type = servicetype

261

289

self.server = None

262

290

self.bus = bus

263

291

self.entry_group_state_changed_match = None

264

def rename(self):

292

293

def rename(self, remove=True):

265

294

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

266

295

if self.rename_count >= self.max_renames:

267

296

logger.critical("No suitable Zeroconf service name found"

268

297

" after %i retries, exiting.",

269

298

self.rename_count)

270

299

raise AvahiServiceError("Too many renames")

271

self.name = unicode(self.server

272

.GetAlternativeServiceName(self.name))

300

self.name = str(

301

self.server.GetAlternativeServiceName(self.name))

302

self.rename_count += 1

273

303

logger.info("Changing Zeroconf service name to %r ...",

274

304

self.name)

275

self.remove()

305

if remove:

306

self.remove()

276

307

try:

277

308

self.add()

278

309

except dbus.exceptions.DBusException as error:

279

logger.critical("DBusException: %s", error)

280

self.cleanup()

281

os._exit(1)

282

self.rename_count += 1

310

if (error.get_dbus_name()

311

== "org.freedesktop.Avahi.CollisionError"):

312

logger.info("Local Zeroconf service name collision.")

313

return self.rename(remove=False)

314

else:

315

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

316

self.cleanup()

317

os._exit(1)

318

283

319

def remove(self):

284

320

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

285

321

if self.entry_group_state_changed_match is not None:

287

323

self.entry_group_state_changed_match = None

288

324

if self.group is not None:

289

325

self.group.Reset()

326

290

327

def add(self):

291

328

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

292

329

self.remove()

309

346

dbus.UInt16(self.port),

310

347

avahi.string_array_to_txt_array(self.TXT))

311

348

self.group.Commit()

349

312

350

def entry_group_state_changed(self, state, error):

313

351

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

314

352

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

320

358

self.rename()

321

359

elif state == avahi.ENTRY_GROUP_FAILURE:

322

360

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

323

unicode(error))

324

raise AvahiGroupError("State changed: %s"

325

% unicode(error))

361

str(error))

362

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

363

326

364

def cleanup(self):

327

365

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

328

366

if self.group is not None:

333

371

pass

334

372

self.group = None

335

373

self.remove()

374

336

375

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

337

376

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

338

377

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

339

bad_states = { avahi.SERVER_INVALID:

340

"Zeroconf server invalid",

341

avahi.SERVER_REGISTERING: None,

342

avahi.SERVER_COLLISION:

343

"Zeroconf server name collision",

344

avahi.SERVER_FAILURE:

345

"Zeroconf server failure" }

378

bad_states = {

379

avahi.SERVER_INVALID: "Zeroconf server invalid",

380

avahi.SERVER_REGISTERING: None,

381

avahi.SERVER_COLLISION: "Zeroconf server name collision",

382

avahi.SERVER_FAILURE: "Zeroconf server failure",

383

}

346

384

if state in bad_states:

347

385

if bad_states[state] is not None:

348

386

if error is None:

351

389

logger.error(bad_states[state] + ": %r", error)

352

390

self.cleanup()

353

391

elif state == avahi.SERVER_RUNNING:

354

self.add()

392

try:

393

self.add()

394

except dbus.exceptions.DBusException as error:

395

if (error.get_dbus_name()

396

== "org.freedesktop.Avahi.CollisionError"):

397

logger.info("Local Zeroconf service name"

398

" collision.")

399

return self.rename(remove=False)

400

else:

401

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

402

self.cleanup()

403

os._exit(1)

355

404

else:

356

405

if error is None:

357

406

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

358

407

else:

359

408

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

409

360

410

def activate(self):

361

411

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

362

412

if self.server is None:

366

416

follow_name_owner_changes=True),

367

417

avahi.DBUS_INTERFACE_SERVER)

368

418

self.server.connect_to_signal("StateChanged",

369

self.server_state_changed)

419

self.server_state_changed)

370

420

self.server_state_changed(self.server.GetState())

371

421

422

372

423

class AvahiServiceToSyslog(AvahiService):

373

def rename(self):

424

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

374

425

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

375

ret = AvahiService.rename(self)

376

syslogger.setFormatter(logging.Formatter

377

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

378

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

379

% self.name))

426

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

427

syslogger.setFormatter(logging.Formatter(

428

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

429

.format(self.name)))

380

430

return ret

381

431

382

def timedelta_to_milliseconds(td):

383

"Convert a datetime.timedelta() to milliseconds"

384

return ((td.days * 24 * 60 * 60 * 1000)

385

+ (td.seconds * 1000)

386

+ (td.microseconds // 1000))

387

432

# Pretend that we have a GnuTLS module

433

class GnuTLS(object):

434

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

435

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

436

437

_library = ctypes.cdll.LoadLibrary(

438

ctypes.util.find_library("gnutls"))

439

_need_version = "3.3.0"

440

def __init__(self):

441

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

442

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

443

# happens.

444

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

445

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

446

.format(self._need_version))

447

448

# Unless otherwise indicated, the constants and types below are

449

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

450

451

# Constants

452

E_SUCCESS = 0

453

E_INTERRUPTED = -52

454

E_AGAIN = -28

455

CRT_OPENPGP = 2

456

CLIENT = 2

457

SHUT_RDWR = 0

458

CRD_CERTIFICATE = 1

459

E_NO_CERTIFICATE_FOUND = -49

460

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

461

462

# Types

463

class session_int(ctypes.Structure):

464

_fields_ = []

465

session_t = ctypes.POINTER(session_int)

466

class certificate_credentials_st(ctypes.Structure):

467

_fields_ = []

468

certificate_credentials_t = ctypes.POINTER(

469

certificate_credentials_st)

470

certificate_type_t = ctypes.c_int

471

class datum_t(ctypes.Structure):

472

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

473

('size', ctypes.c_uint)]

474

class openpgp_crt_int(ctypes.Structure):

475

_fields_ = []

476

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

477

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

478

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

479

credentials_type_t = ctypes.c_int #

480

transport_ptr_t = ctypes.c_void_p

481

close_request_t = ctypes.c_int

482

483

# Exceptions

484

class Error(Exception):

485

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

486

# exception might be raised from within GnuTLS.__init__,

487

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

488

# global variable has happened.

489

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

490

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

491

# code is passed, convert it to a string with

492

# gnutls.strerror()

493

self.code = code

494

if message is None and code is not None:

495

message = GnuTLS.strerror(code)

496

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

497

message, *args)

498

499

class CertificateSecurityError(Error):

500

pass

501

502

# Classes

503

class Credentials(object):

504

def __init__(self):

505

self._c_object = gnutls.certificate_credentials_t()

506

gnutls.certificate_allocate_credentials(

507

ctypes.byref(self._c_object))

508

self.type = gnutls.CRD_CERTIFICATE

509

510

def __del__(self):

511

gnutls.certificate_free_credentials(self._c_object)

512

513

class ClientSession(object):

514

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

515

self._c_object = gnutls.session_t()

516

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

517

gnutls.set_default_priority(self._c_object)

518

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

519

gnutls.handshake_set_private_extensions(self._c_object,

520

True)

521

self.socket = socket

522

if credentials is None:

523

credentials = gnutls.Credentials()

524

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

525

ctypes.cast(credentials._c_object,

526

ctypes.c_void_p))

527

self.credentials = credentials

528

529

def __del__(self):

530

gnutls.deinit(self._c_object)

531

532

def handshake(self):

533

return gnutls.handshake(self._c_object)

534

535

def send(self, data):

536

data = bytes(data)

537

data_len = len(data)

538

while data_len > 0:

539

data_len -= gnutls.record_send(self._c_object,

540

data[-data_len:],

541

data_len)

542

543

def bye(self):

544

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

545

546

# Error handling functions

547

def _error_code(result):

548

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

549

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

550

if result >= 0:

551

return result

552

if result == gnutls.E_NO_CERTIFICATE_FOUND:

553

raise gnutls.CertificateSecurityError(code = result)

554

raise gnutls.Error(code = result)

555

556

def _retry_on_error(result, func, arguments):

557

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

558

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

559

while result < 0:

560

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

561

return _error_code(result)

562

result = func(*arguments)

563

return result

564

565

# Unless otherwise indicated, the function declarations below are

566

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

567

568

# Functions

569

priority_set_direct = _library.gnutls_priority_set_direct

570

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

571

ctypes.POINTER(ctypes.c_char_p)]

572

priority_set_direct.restype = _error_code

573

574

init = _library.gnutls_init

575

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

576

init.restype = _error_code

577

578

set_default_priority = _library.gnutls_set_default_priority

579

set_default_priority.argtypes = [session_t]

580

set_default_priority.restype = _error_code

581

582

record_send = _library.gnutls_record_send

583

record_send.argtypes = [session_t, ctypes.c_void_p,

584

ctypes.c_size_t]

585

record_send.restype = ctypes.c_ssize_t

586

record_send.errcheck = _retry_on_error

587

588

certificate_allocate_credentials = (

589

_library.gnutls_certificate_allocate_credentials)

590

certificate_allocate_credentials.argtypes = [

591

ctypes.POINTER(certificate_credentials_t)]

592

certificate_allocate_credentials.restype = _error_code

593

594

certificate_free_credentials = (

595

_library.gnutls_certificate_free_credentials)

596

certificate_free_credentials.argtypes = [certificate_credentials_t]

597

certificate_free_credentials.restype = None

598

599

handshake_set_private_extensions = (

600

_library.gnutls_handshake_set_private_extensions)

601

handshake_set_private_extensions.argtypes = [session_t,

602

ctypes.c_int]

603

handshake_set_private_extensions.restype = None

604

605

credentials_set = _library.gnutls_credentials_set

606

credentials_set.argtypes = [session_t, credentials_type_t,

607

ctypes.c_void_p]

608

credentials_set.restype = _error_code

609

610

strerror = _library.gnutls_strerror

611

strerror.argtypes = [ctypes.c_int]

612

strerror.restype = ctypes.c_char_p

613

614

certificate_type_get = _library.gnutls_certificate_type_get

615

certificate_type_get.argtypes = [session_t]

616

certificate_type_get.restype = _error_code

617

618

certificate_get_peers = _library.gnutls_certificate_get_peers

619

certificate_get_peers.argtypes = [session_t,

620

ctypes.POINTER(ctypes.c_uint)]

621

certificate_get_peers.restype = ctypes.POINTER(datum_t)

622

623

global_set_log_level = _library.gnutls_global_set_log_level

624

global_set_log_level.argtypes = [ctypes.c_int]

625

global_set_log_level.restype = None

626

627

global_set_log_function = _library.gnutls_global_set_log_function

628

global_set_log_function.argtypes = [log_func]

629

global_set_log_function.restype = None

630

631

deinit = _library.gnutls_deinit

632

deinit.argtypes = [session_t]

633

deinit.restype = None

634

635

handshake = _library.gnutls_handshake

636

handshake.argtypes = [session_t]

637

handshake.restype = _error_code

638

handshake.errcheck = _retry_on_error

639

640

transport_set_ptr = _library.gnutls_transport_set_ptr

641

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

642

transport_set_ptr.restype = None

643

644

bye = _library.gnutls_bye

645

bye.argtypes = [session_t, close_request_t]

646

bye.restype = _error_code

647

bye.errcheck = _retry_on_error

648

649

check_version = _library.gnutls_check_version

650

check_version.argtypes = [ctypes.c_char_p]

651

check_version.restype = ctypes.c_char_p

652

653

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

654

655

openpgp_crt_init = _library.gnutls_openpgp_crt_init

656

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

657

openpgp_crt_init.restype = _error_code

658

659

openpgp_crt_import = _library.gnutls_openpgp_crt_import

660

openpgp_crt_import.argtypes = [openpgp_crt_t,

661

ctypes.POINTER(datum_t),

662

openpgp_crt_fmt_t]

663

openpgp_crt_import.restype = _error_code

664

665

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

666

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

667

ctypes.POINTER(ctypes.c_uint)]

668

openpgp_crt_verify_self.restype = _error_code

669

670

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

671

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

672

openpgp_crt_deinit.restype = None

673

674

openpgp_crt_get_fingerprint = (

675

_library.gnutls_openpgp_crt_get_fingerprint)

676

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

677

ctypes.c_void_p,

678

ctypes.POINTER(

679

ctypes.c_size_t)]

680

openpgp_crt_get_fingerprint.restype = _error_code

681

682

# Remove non-public functions

683

del _error_code, _retry_on_error

684

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

685

gnutls = GnuTLS()

686

687

def call_pipe(connection, # : multiprocessing.Connection

688

func, *args, **kwargs):

689

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

690

691

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

692

return value on the provided multiprocessing.Connection.

693

"""

694

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

695

connection.close()

696

388

697

class Client(object):

389

698

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

390

699

415

724

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

416

725

last_checker_status: integer between 0 and 255 reflecting exit

417

726

status of last checker. -1 reflects crashed

418

checker, or None.

727

checker, -2 means no checker completed yet.

728

last_checker_signal: The signal which killed the last checker, if

729

last_checker_status is -1

419

730

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

420

731

name: string; from the config file, used in log messages and

421

732

D-Bus identifiers

422

733

secret: bytestring; sent verbatim (over TLS) to client

423

734

timeout: datetime.timedelta(); How long from last_checked_ok

424

735

until this client is disabled

425

extended_timeout: extra long timeout when password has been sent

736

extended_timeout: extra long timeout when secret has been sent

426

737

runtime_expansions: Allowed attributes for runtime expansion.

427

738

expires: datetime.datetime(); time (UTC) when a client will be

428

739

disabled, or None

740

server_settings: The server_settings dict from main()

429

741

"""

430

742

431

743

runtime_expansions = ("approval_delay", "approval_duration",

432

"created", "enabled", "fingerprint",

433

"host", "interval", "last_checked_ok",

744

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

745

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

746

"last_approval_request", "last_checked_ok",

434

747

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

435

client_defaults = { "timeout": "5m",

436

"extended_timeout": "15m",

437

"interval": "2m",

438

"checker": "fping -q -- %%(host)s",

439

"host": "",

440

"approval_delay": "0s",

441

"approval_duration": "1s",

442

"approved_by_default": "True",

443

"enabled": "True",

444

}

445

446

def timeout_milliseconds(self):

447

"Return the 'timeout' attribute in milliseconds"

448

return timedelta_to_milliseconds(self.timeout)

449

450

def extended_timeout_milliseconds(self):

451

"Return the 'extended_timeout' attribute in milliseconds"

452

return timedelta_to_milliseconds(self.extended_timeout)

453

454

def interval_milliseconds(self):

455

"Return the 'interval' attribute in milliseconds"

456

return timedelta_to_milliseconds(self.interval)

457

458

def approval_delay_milliseconds(self):

459

return timedelta_to_milliseconds(self.approval_delay)

460

748

client_defaults = {

749

"timeout": "PT5M",

750

"extended_timeout": "PT15M",

751

"interval": "PT2M",

752

"checker": "fping -q -- %%(host)s",

753

"host": "",

754

"approval_delay": "PT0S",

755

"approval_duration": "PT1S",

756

"approved_by_default": "True",

757

"enabled": "True",

758

}

759

461

760

@staticmethod

462

761

def config_parser(config):

463

762

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

478

777

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

479

778

"enabled")

480

779

780

# Uppercase and remove spaces from fingerprint for later

781

# comparison purposes with return value from the

782

# fingerprint() function

481

783

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

482

784

.replace(" ", ""))

483

785

if "secret" in section:

488

790

"rb") as secfile:

489

791

client["secret"] = secfile.read()

490

792

else:

491

raise TypeError("No secret or secfile for section %s"

492

% section)

793

raise TypeError("No secret or secfile for section {}"

794

.format(section))

493

795

client["timeout"] = string_to_delta(section["timeout"])

494

796

client["extended_timeout"] = string_to_delta(

495

797

section["extended_timeout"])

501

803

client["checker_command"] = section["checker"]

502

804

client["last_approval_request"] = None

503

805

client["last_checked_ok"] = None

504

client["last_checker_status"] = None

806

client["last_checker_status"] = -2

505

807

506

808

return settings

507

508

509

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

510

"""Note: the 'checker' key in 'config' sets the

511

'checker_command' attribute and *not* the 'checker'

512

attribute."""

809

810

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

513

811

self.name = name

812

if server_settings is None:

813

server_settings = {}

814

self.server_settings = server_settings

514

815

# adding all client settings

515

for setting, value in settings.iteritems():

816

for setting, value in settings.items():

516

817

setattr(self, setting, value)

517

818

518

819

if self.enabled:

524

825

else:

525

826

self.last_enabled = None

526

827

self.expires = None

527

828

528

829

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

529

# Uppercase and remove spaces from fingerprint for later

530

# comparison purposes with return value from the fingerprint()

531

# function

532

830

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

533

831

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

534

832

datetime.datetime.utcnow())

535

833

536

834

# attributes specific for this server instance

537

835

self.checker = None

538

836

self.checker_initiator_tag = None

541

839

self.current_checker_command = None

542

840

self.approved = None

543

841

self.approvals_pending = 0

544

self.changedstate = (multiprocessing_manager

545

.Condition(multiprocessing_manager

546

.Lock()))

547

self.client_structure = [attr for attr in

548

self.__dict__.iterkeys()

842

self.changedstate = multiprocessing_manager.Condition(

843

multiprocessing_manager.Lock())

844

self.client_structure = [attr

845

for attr in self.__dict__.iterkeys()

549

846

if not attr.startswith("_")]

550

847

self.client_structure.append("client_structure")

551

848

552

for name, t in inspect.getmembers(type(self),

553

lambda obj:

554

isinstance(obj,

555

property)):

849

for name, t in inspect.getmembers(

850

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

556

851

if not name.startswith("_"):

557

852

self.client_structure.append(name)

558

853

566

861

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

567

862

# Already enabled

568

863

return

569

self.send_changedstate()

570

864

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

571

865

self.enabled = True

572

866

self.last_enabled = datetime.datetime.utcnow()

573

867

self.init_checker()

868

self.send_changedstate()

574

869

575

870

def disable(self, quiet=True):

576

871

"""Disable this client."""

577

872

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

578

873

return False

579

874

if not quiet:

580

self.send_changedstate()

581

if not quiet:

582

875

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

583

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

876

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

584

877

gobject.source_remove(self.disable_initiator_tag)

585

878

self.disable_initiator_tag = None

586

879

self.expires = None

587

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

880

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

588

881

gobject.source_remove(self.checker_initiator_tag)

589

882

self.checker_initiator_tag = None

590

883

self.stop_checker()

591

884

self.enabled = False

885

if not quiet:

886

self.send_changedstate()

592

887

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

593

888

return False

594

889

598

893

def init_checker(self):

599

894

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

600

895

# and every interval from then on.

601

self.checker_initiator_tag = (gobject.timeout_add

602

(self.interval_milliseconds(),

603

self.start_checker))

896

if self.checker_initiator_tag is not None:

897

gobject.source_remove(self.checker_initiator_tag)

898

self.checker_initiator_tag = gobject.timeout_add(

899

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

900

self.start_checker)

604

901

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

605

self.disable_initiator_tag = (gobject.timeout_add

606

(self.timeout_milliseconds(),

607

self.disable))

902

if self.disable_initiator_tag is not None:

903

gobject.source_remove(self.disable_initiator_tag)

904

self.disable_initiator_tag = gobject.timeout_add(

905

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

608

906

# Also start a new checker *right now*.

609

907

self.start_checker()

610

908

611

def checker_callback(self, pid, condition, command):

909

def checker_callback(self, source, condition, connection,

910

command):

612

911

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

613

912

self.checker_callback_tag = None

614

913

self.checker = None

615

if os.WIFEXITED(condition):

616

self.last_checker_status = os.WEXITSTATUS(condition)

914

# Read return code from connection (see call_pipe)

915

returncode = connection.recv()

916

connection.close()

917

918

if returncode >= 0:

919

self.last_checker_status = returncode

920

self.last_checker_signal = None

617

921

if self.last_checker_status == 0:

618

922

logger.info("Checker for %(name)s succeeded",

619

923

vars(self))

620

924

self.checked_ok()

621

925

else:

622

logger.info("Checker for %(name)s failed",

623

vars(self))

926

logger.info("Checker for %(name)s failed", vars(self))

624

927

else:

625

928

self.last_checker_status = -1

929

self.last_checker_signal = -returncode

626

930

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

627

931

vars(self))

628

629

def checked_ok(self, timeout=None):

630

"""Bump up the timeout for this client.

631

632

This should only be called when the client has been seen,

633

alive and well.

634

"""

932

return False

933

934

def checked_ok(self):

935

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

936

self.last_checked_ok = datetime.datetime.utcnow()

937

self.last_checker_status = 0

938

self.last_checker_signal = None

939

self.bump_timeout()

940

941

def bump_timeout(self, timeout=None):

942

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

635

943

if timeout is None:

636

944

timeout = self.timeout

637

self.last_checked_ok = datetime.datetime.utcnow()

638

945

if self.disable_initiator_tag is not None:

639

946

gobject.source_remove(self.disable_initiator_tag)

947

self.disable_initiator_tag = None

640

948

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

641

self.disable_initiator_tag = (gobject.timeout_add

642

(timedelta_to_milliseconds

643

(timeout), self.disable))

949

self.disable_initiator_tag = gobject.timeout_add(

950

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

644

951

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

645

952

646

953

def need_approval(self):

652

959

If a checker already exists, leave it running and do

653

960

nothing."""

654

961

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

655

# did that, then if a checker (for some reason) started

656

# running slowly and taking more than 'interval' time, the

657

# client would inevitably timeout, since no checker would get

658

# a chance to run to completion. If we instead leave running

962

# did that, and if a checker (for some reason) started running

963

# slowly and taking more than 'interval' time, then the client

964

# would inevitably timeout, since no checker would get a

965

# chance to run to completion. If we instead leave running

659

966

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

660

967

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

661

968

# should be.

662

969

663

# If a checker exists, make sure it is not a zombie

664

try:

665

pid, status = os.waitpid(self.checker.pid, os.WNOHANG)

666

except (AttributeError, OSError) as error:

667

if (isinstance(error, OSError)

668

and error.errno != errno.ECHILD):

669

raise error

670

else:

671

if pid:

672

logger.warning("Checker was a zombie")

673

gobject.source_remove(self.checker_callback_tag)

674

self.checker_callback(pid, status,

675

self.current_checker_command)

970

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

971

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

972

self.checker.join()

973

self.checker = None

676

974

# Start a new checker if needed

677

975

if self.checker is None:

976

# Escape attributes for the shell

977

escaped_attrs = {

978

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

979

for attr in self.runtime_expansions }

678

980

try:

679

# In case checker_command has exactly one % operator

680

command = self.checker_command % self.host

681

except TypeError:

682

# Escape attributes for the shell

683

escaped_attrs = dict(

684

(attr,

685

re.escape(unicode(str(getattr(self, attr, "")),

686

errors=

687

'replace')))

688

for attr in

689

self.runtime_expansions)

690

691

try:

692

command = self.checker_command % escaped_attrs

693

except TypeError as error:

694

logger.error('Could not format string "%s":'

695

' %s', self.checker_command, error)

696

return True # Try again later

981

command = self.checker_command % escaped_attrs

982

except TypeError as error:

983

logger.error('Could not format string "%s"',

984

self.checker_command,

985

exc_info=error)

986

return True # Try again later

697

987

self.current_checker_command = command

698

try:

699

logger.info("Starting checker %r for %s",

700

command, self.name)

701

# We don't need to redirect stdout and stderr, since

702

# in normal mode, that is already done by daemon(),

703

# and in debug mode we don't want to. (Stdin is

704

# always replaced by /dev/null.)

705

self.checker = subprocess.Popen(command,

706

close_fds=True,

707

shell=True, cwd="/")

708

self.checker_callback_tag = (gobject.child_watch_add

709

(self.checker.pid,

710

self.checker_callback,

711

data=command))

712

# The checker may have completed before the gobject

713

# watch was added. Check for this.

714

pid, status = os.waitpid(self.checker.pid, os.WNOHANG)

715

if pid:

716

gobject.source_remove(self.checker_callback_tag)

717

self.checker_callback(pid, status, command)

718

except OSError as error:

719

logger.error("Failed to start subprocess: %s",

720

error)

988

logger.info("Starting checker %r for %s", command,

989

self.name)

990

# We don't need to redirect stdout and stderr, since

991

# in normal mode, that is already done by daemon(),

992

# and in debug mode we don't want to. (Stdin is

993

# always replaced by /dev/null.)

994

# The exception is when not debugging but nevertheless

995

# running in the foreground; use the previously

996

# created wnull.

997

popen_args = { "close_fds": True,

998

"shell": True,

999

"cwd": "/" }

1000

if (not self.server_settings["debug"]

1001

and self.server_settings["foreground"]):

1002

popen_args.update({"stdout": wnull,

1003

"stderr": wnull })

1004

pipe = multiprocessing.Pipe(duplex = False)

1005

self.checker = multiprocessing.Process(

1006

target = call_pipe,

1007

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

1008

kwargs = popen_args)

1009

self.checker.start()

1010

self.checker_callback_tag = gobject.io_add_watch(

1011

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

1012

self.checker_callback, pipe[0], command)

721

1013

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

722

1014

return True

723

1015

729

1021

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

730

1022

return

731

1023

logger.debug("Stopping checker for %(name)s", vars(self))

732

try:

733

os.kill(self.checker.pid, signal.SIGTERM)

734

#time.sleep(0.5)

735

#if self.checker.poll() is None:

736

# os.kill(self.checker.pid, signal.SIGKILL)

737

except OSError as error:

738

if error.errno != errno.ESRCH: # No such process

739

raise

1024

self.checker.terminate()

740

1025

self.checker = None

741

1026

742

1027

743

def dbus_service_property(dbus_interface, signature="v",

744

access="readwrite", byte_arrays=False):

1028

def dbus_service_property(dbus_interface,

1029

signature="v",

1030

access="readwrite",

1031

byte_arrays=False):

745

1032

"""Decorators for marking methods of a DBusObjectWithProperties to

746

1033

become properties on the D-Bus.

747

1034

756

1043

# "Set" method, so we fail early here:

757

1044

if byte_arrays and signature != "ay":

758

1045

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

759

" signature %r" % signature)

1046

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

1047

760

1048

def decorator(func):

761

1049

func._dbus_is_property = True

762

1050

func._dbus_interface = dbus_interface

767

1055

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

768

1056

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

769

1057

return func

1058

1059

return decorator

1060

1061

1062

def dbus_interface_annotations(dbus_interface):

1063

"""Decorator for marking functions returning interface annotations

1064

1065

Usage:

1066

1067

@dbus_interface_annotations("org.example.Interface")

1068

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

1069

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

1070

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

1071

"false"}

1072

"""

1073

1074

def decorator(func):

1075

func._dbus_is_interface = True

1076

func._dbus_interface = dbus_interface

1077

func._dbus_name = dbus_interface

1078

return func

1079

1080

return decorator

1081

1082

1083

def dbus_annotations(annotations):

1084

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

1085

Usage:

1086

1087

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

1088

"org.freedesktop.DBus.Property."

1089

"EmitsChangedSignal": "false"})

1090

@dbus_service_property("org.example.Interface", signature="b",

1091

access="r")

1092

def Property_dbus_property(self):

1093

return dbus.Boolean(False)

1094

1095

See also the DBusObjectWithAnnotations class.

1096

"""

1097

1098

def decorator(func):

1099

func._dbus_annotations = annotations

1100

return func

1101

770

1102

return decorator

771

1103

772

1104

773

1105

class DBusPropertyException(dbus.exceptions.DBusException):

774

1106

"""A base class for D-Bus property-related exceptions

775

1107

"""

776

def __unicode__(self):

777

return unicode(str(self))

1108

pass

778

1109

779

1110

780

1111

class DBusPropertyAccessException(DBusPropertyException):

789

1120

pass

790

1121

791

1122

792

class DBusObjectWithProperties(dbus.service.Object):

1123

class DBusObjectWithAnnotations(dbus.service.Object):

1124

"""A D-Bus object with annotations.

1125

1126

Classes inheriting from this can use the dbus_annotations

1127

decorator to add annotations to methods or signals.

1128

"""

1129

1130

@staticmethod

1131

def _is_dbus_thing(thing):

1132

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

1133

1134

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

1135

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

1136

"""

1137

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

1138

False)

1139

1140

def _get_all_dbus_things(self, thing):

1141

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

1142

"""

1143

return ((getattr(athing.__get__(self), "_dbus_name", name),

1144

athing.__get__(self))

1145

for cls in self.__class__.__mro__

1146

for name, athing in

1147

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

1148

1149

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1150

out_signature = "s",

1151

path_keyword = 'object_path',

1152

connection_keyword = 'connection')

1153

def Introspect(self, object_path, connection):

1154

"""Overloading of standard D-Bus method.

1155

1156

Inserts annotation tags on methods and signals.

1157

"""

1158

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

1159

connection)

1160

try:

1161

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

1162

1163

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

1164

# Add annotation tags

1165

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

1166

for tag in if_tag.getElementsByTagName(typ):

1167

annots = dict()

1168

for name, prop in (self.

1169

_get_all_dbus_things(typ)):

1170

if (name == tag.getAttribute("name")

1171

and prop._dbus_interface

1172

== if_tag.getAttribute("name")):

1173

annots.update(getattr(

1174

prop, "_dbus_annotations", {}))

1175

for name, value in annots.items():

1176

ann_tag = document.createElement(

1177

"annotation")

1178

ann_tag.setAttribute("name", name)

1179

ann_tag.setAttribute("value", value)

1180

tag.appendChild(ann_tag)

1181

# Add interface annotation tags

1182

for annotation, value in dict(

1183

itertools.chain.from_iterable(

1184

annotations().items()

1185

for name, annotations

1186

in self._get_all_dbus_things("interface")

1187

if name == if_tag.getAttribute("name")

1188

)).items():

1189

ann_tag = document.createElement("annotation")

1190

ann_tag.setAttribute("name", annotation)

1191

ann_tag.setAttribute("value", value)

1192

if_tag.appendChild(ann_tag)

1193

# Fix argument name for the Introspect method itself

1194

if (if_tag.getAttribute("name")

1195

== dbus.INTROSPECTABLE_IFACE):

1196

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

1197

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

1198

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

1199

if (arg.getAttribute("direction")

1200

== "out"):

1201

arg.setAttribute("name",

1202

"xml_data")

1203

xmlstring = document.toxml("utf-8")

1204

document.unlink()

1205

except (AttributeError, xml.dom.DOMException,

1206

xml.parsers.expat.ExpatError) as error:

1207

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

1208

exc_info=error)

1209

return xmlstring

1210

1211

1212

class DBusObjectWithProperties(DBusObjectWithAnnotations):

793

1213

"""A D-Bus object with properties.

794

1214

795

1215

Classes inheriting from this can use the dbus_service_property

797

1217

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

798

1218

"""

799

1219

800

@staticmethod

801

def _is_dbus_property(obj):

802

return getattr(obj, "_dbus_is_property", False)

803

804

def _get_all_dbus_properties(self):

805

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

806

"""

807

return ((prop.__get__(self)._dbus_name, prop.__get__(self))

808

for cls in self.__class__.__mro__

809

for name, prop in

810

inspect.getmembers(cls, self._is_dbus_property))

811

812

1220

def _get_dbus_property(self, interface_name, property_name):

813

1221

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

814

1222

property with the specified name and interface.

815

1223

"""

816

for cls in self.__class__.__mro__:

817

for name, value in (inspect.getmembers

818

(cls, self._is_dbus_property)):

1224

for cls in self.__class__.__mro__:

1225

for name, value in inspect.getmembers(

1226

cls, self._is_dbus_thing("property")):

819

1227

if (value._dbus_name == property_name

820

1228

and value._dbus_interface == interface_name):

821

1229

return value.__get__(self)

822

1230

823

1231

# No such property

824

raise DBusPropertyNotFound(self.dbus_object_path + ":"

825

+ interface_name + "."

826

+ property_name)

827

828

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",

1232

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

1233

self.dbus_object_path, interface_name, property_name))

1234

1235

@classmethod

1236

def _get_all_interface_names(cls):

1237

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

1238

return (name for name in set(getattr(getattr(x, attr),

1239

"_dbus_interface", None)

1240

for x in (inspect.getmro(cls))

1241

for attr in dir(x))

1242

if name is not None)

1243

1244

@dbus.service.method(dbus.PROPERTIES_IFACE,

1245

in_signature="ss",

829

1246

out_signature="v")

830

1247

def Get(self, interface_name, property_name):

831

1248

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

849

1266

# The byte_arrays option is not supported yet on

850

1267

# signatures other than "ay".

851

1268

if prop._dbus_signature != "ay":

852

raise ValueError

853

value = dbus.ByteArray(''.join(unichr(byte)

854

for byte in value))

1269

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

1270

"'ay' signature {!r}"

1271

.format(prop._dbus_signature))

1272

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

1273

for byte in value))

855

1274

prop(value)

856

1275

857

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",

1276

@dbus.service.method(dbus.PROPERTIES_IFACE,

1277

in_signature="s",

858

1278

out_signature="a{sv}")

859

1279

def GetAll(self, interface_name):

860

1280

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

863

1283

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

864

1284

"""

865

1285

properties = {}

866

for name, prop in self._get_all_dbus_properties():

1286

for name, prop in self._get_all_dbus_things("property"):

867

1287

if (interface_name

868

1288

and interface_name != prop._dbus_interface):

869

1289

# Interface non-empty but did not match

875

1295

if not hasattr(value, "variant_level"):

876

1296

properties[name] = value

877

1297

continue

878

properties[name] = type(value)(value, variant_level=

879

value.variant_level+1)

1298

properties[name] = type(value)(

1299

value, variant_level = value.variant_level + 1)

880

1300

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

881

1301

1302

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

1303

def PropertiesChanged(self, interface_name, changed_properties,

1304

invalidated_properties):

1305

"""Standard D-Bus PropertiesChanged() signal, see D-Bus

1306

standard.

1307

"""

1308

pass

1309

882

1310

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

883

1311

out_signature="s",

884

1312

path_keyword='object_path',

885

1313

connection_keyword='connection')

886

1314

def Introspect(self, object_path, connection):

887

"""Standard D-Bus method, overloaded to insert property tags.

1315

"""Overloading of standard D-Bus method.

1316

1317

Inserts property tags and interface annotation tags.

888

1318

"""

889

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

890

connection)

1319

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1320

object_path,

1321

connection)

891

1322

try:

892

1323

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

1324

893

1325

def make_tag(document, name, prop):

894

1326

e = document.createElement("property")

895

1327

e.setAttribute("name", name)

896

1328

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

897

1329

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

898

1330

return e

1331

899

1332

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

1333

# Add property tags

900

1334

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

901

1335

for name, prop

902

in self._get_all_dbus_properties()

1336

in self._get_all_dbus_things("property")

903

1337

if prop._dbus_interface

904

1338

== if_tag.getAttribute("name")):

905

1339

if_tag.appendChild(tag)

1340

# Add annotation tags for properties

1341

for tag in if_tag.getElementsByTagName("property"):

1342

annots = dict()

1343

for name, prop in self._get_all_dbus_things(

1344

"property"):

1345

if (name == tag.getAttribute("name")

1346

and prop._dbus_interface

1347

== if_tag.getAttribute("name")):

1348

annots.update(getattr(

1349

prop, "_dbus_annotations", {}))

1350

for name, value in annots.items():

1351

ann_tag = document.createElement(

1352

"annotation")

1353

ann_tag.setAttribute("name", name)

1354

ann_tag.setAttribute("value", value)

1355

tag.appendChild(ann_tag)

906

1356

# Add the names to the return values for the

907

1357

# "org.freedesktop.DBus.Properties" methods

908

1358

if (if_tag.getAttribute("name")

923

1373

except (AttributeError, xml.dom.DOMException,

924

1374

xml.parsers.expat.ExpatError) as error:

925

1375

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

926

error)

927

return xmlstring

928

929

930

def datetime_to_dbus (dt, variant_level=0):

1376

exc_info=error)

1377

return xmlstring

1378

1379

try:

1380

dbus.OBJECT_MANAGER_IFACE

1381

except AttributeError:

1382

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

1383

1384

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1385

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

1386

1387

Classes inheriting from this exposes the standard

1388

GetManagedObjects call and the InterfacesAdded and

1389

InterfacesRemoved signals on the standard

1390

"org.freedesktop.DBus.ObjectManager" interface.

1391

1392

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

1393

manually.

1394

"""

1395

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1396

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

1397

def GetManagedObjects(self):

1398

"""This function must be overridden"""

1399

raise NotImplementedError()

1400

1401

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1402

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

1403

def InterfacesAdded(self, object_path, interfaces_and_properties):

1404

pass

1405

1406

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

1407

def InterfacesRemoved(self, object_path, interfaces):

1408

pass

1409

1410

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1411

out_signature = "s",

1412

path_keyword = 'object_path',

1413

connection_keyword = 'connection')

1414

def Introspect(self, object_path, connection):

1415

"""Overloading of standard D-Bus method.

1416

1417

Override return argument name of GetManagedObjects to be

1418

"objpath_interfaces_and_properties"

1419

"""

1420

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1421

object_path,

1422

connection)

1423

try:

1424

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

1425

1426

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

1427

# Fix argument name for the GetManagedObjects method

1428

if (if_tag.getAttribute("name")

1429

== dbus.OBJECT_MANAGER_IFACE):

1430

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

1431

if (cn.getAttribute("name")

1432

== "GetManagedObjects"):

1433

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

1434

if (arg.getAttribute("direction")

1435

== "out"):

1436

arg.setAttribute(

1437

"name",

1438

"objpath_interfaces"

1439

"_and_properties")

1440

xmlstring = document.toxml("utf-8")

1441

document.unlink()

1442

except (AttributeError, xml.dom.DOMException,

1443

xml.parsers.expat.ExpatError) as error:

1444

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

1445

exc_info = error)

1446

return xmlstring

1447

1448

def datetime_to_dbus(dt, variant_level=0):

931

1449

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

932

1450

if dt is None:

933

1451

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

934

return dbus.String(dt.isoformat(),

935

variant_level=variant_level)

936

937

938

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

939

.__metaclass__):

940

"""Applied to an empty subclass of a D-Bus object, this metaclass

941

will add additional D-Bus attributes matching a certain pattern.

1452

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

1453

1454

1455

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1456

"""A class decorator; applied to a subclass of

1457

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

1458

interface names according to the "alt_interface_names" mapping.

1459

Usage:

1460

1461

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

1462

"net.example.AlternateInterface"})

1463

class SampleDBusObject(dbus.service.Object):

1464

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

1465

def SampleDBusMethod():

1466

pass

1467

1468

The above "SampleDBusMethod" on "SampleDBusObject" will be

1469

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

1470

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

1471

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

1472

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

1473

1474

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

1475

(from DBusObjectWithProperties) and interfaces (from the

1476

dbus_interface_annotations decorator).

942

1477

"""

943

def __new__(mcs, name, bases, attr):

944

# Go through all the base classes which could have D-Bus

945

# methods, signals, or properties in them

946

for base in (b for b in bases

947

if issubclass(b, dbus.service.Object)):

948

# Go though all attributes of the base class

949

for attrname, attribute in inspect.getmembers(base):

1478

1479

def wrapper(cls):

1480

for orig_interface_name, alt_interface_name in (

1481

alt_interface_names.items()):

1482

attr = {}

1483

interface_names = set()

1484

# Go though all attributes of the class

1485

for attrname, attribute in inspect.getmembers(cls):

950

1486

# Ignore non-D-Bus attributes, and D-Bus attributes

951

1487

# with the wrong interface name

952

1488

if (not hasattr(attribute, "_dbus_interface")

953

or not attribute._dbus_interface

954

.startswith("se.recompile.Mandos")):

1489

or not attribute._dbus_interface.startswith(

1490

orig_interface_name)):

955

1491

continue

956

1492

# Create an alternate D-Bus interface name based on

957

1493

# the current name

958

alt_interface = (attribute._dbus_interface

959

.replace("se.recompile.Mandos",

960

"se.bsnet.fukt.Mandos"))

1494

alt_interface = attribute._dbus_interface.replace(

1495

orig_interface_name, alt_interface_name)

1496

interface_names.add(alt_interface)

961

1497

# Is this a D-Bus signal?

962

1498

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

963

# Extract the original non-method function by

964

# black magic

965

nonmethod_func = (dict(

1499

if sys.version_info.major == 2:

1500

# Extract the original non-method undecorated

1501

# function by black magic

1502

nonmethod_func = (dict(

966

1503

zip(attribute.func_code.co_freevars,

967

attribute.__closure__))["func"]

968

.cell_contents)

1504

attribute.__closure__))

1505

["func"].cell_contents)

1506

else:

1507

nonmethod_func = attribute

969

1508

# Create a new, but exactly alike, function

970

1509

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

971

1510

# with the alternate D-Bus interface name

972

new_function = (dbus.service.signal

973

(alt_interface,

974

attribute._dbus_signature)

975

(types.FunctionType(

976

nonmethod_func.func_code,

977

nonmethod_func.func_globals,

978

nonmethod_func.func_name,

979

nonmethod_func.func_defaults,

980

nonmethod_func.func_closure)))

1511

if sys.version_info.major == 2:

1512

new_function = types.FunctionType(

1513

nonmethod_func.func_code,

1514

nonmethod_func.func_globals,

1515

nonmethod_func.func_name,

1516

nonmethod_func.func_defaults,

1517

nonmethod_func.func_closure)

1518

else:

1519

new_function = types.FunctionType(

1520

nonmethod_func.__code__,

1521

nonmethod_func.__globals__,

1522

nonmethod_func.__name__,

1523

nonmethod_func.__defaults__,

1524

nonmethod_func.__closure__)

1525

new_function = (dbus.service.signal(

1526

alt_interface,

1527

attribute._dbus_signature)(new_function))

1528

# Copy annotations, if any

1529

try:

1530

new_function._dbus_annotations = dict(

1531

attribute._dbus_annotations)

1532

except AttributeError:

1533

pass

981

1534

# Define a creator of a function to call both the

982

# old and new functions, so both the old and new

983

# signals gets sent when the function is called

1535

# original and alternate functions, so both the

1536

# original and alternate signals gets sent when

1537

# the function is called

984

1538

def fixscope(func1, func2):

985

1539

"""This function is a scope container to pass

986

1540

func1 and func2 to the "call_both" function

987

1541

outside of its arguments"""

1542

1543

@functools.wraps(func2)

988

1544

def call_both(*args, **kwargs):

989

1545

"""This function will emit two D-Bus

990

1546

signals by calling func1 and func2"""

991

1547

func1(*args, **kwargs)

992

1548

func2(*args, **kwargs)

1549

# Make wrapper function look like a D-Bus signal

1550

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

1551

if name.startswith("_dbus_"):

1552

setattr(call_both, name, attr)

1553

993

1554

return call_both

994

1555

# Create the "call_both" function and add it to

995

1556

# the class

996

attr[attrname] = fixscope(attribute,

997

new_function)

1557

attr[attrname] = fixscope(attribute, new_function)

998

1558

# Is this a D-Bus method?

999

1559

elif getattr(attribute, "_dbus_is_method", False):

1000

1560

# Create a new, but exactly alike, function

1001

1561

# object. Decorate it to be a new D-Bus method

1002

1562

# with the alternate D-Bus interface name. Add it

1003

1563

# to the class.

1004

attr[attrname] = (dbus.service.method

1005

(alt_interface,

1006

attribute._dbus_in_signature,

1007

attribute._dbus_out_signature)

1008

(types.FunctionType

1009

(attribute.func_code,

1010

attribute.func_globals,

1011

attribute.func_name,

1012

attribute.func_defaults,

1013

attribute.func_closure)))

1564

attr[attrname] = (

1565

dbus.service.method(

1566

alt_interface,

1567

attribute._dbus_in_signature,

1568

attribute._dbus_out_signature)

1569

(types.FunctionType(attribute.func_code,

1570

attribute.func_globals,

1571

attribute.func_name,

1572

attribute.func_defaults,

1573

attribute.func_closure)))

1574

# Copy annotations, if any

1575

try:

1576

attr[attrname]._dbus_annotations = dict(

1577

attribute._dbus_annotations)

1578

except AttributeError:

1579

pass

1014

1580

# Is this a D-Bus property?

1015

1581

elif getattr(attribute, "_dbus_is_property", False):

1016

1582

# Create a new, but exactly alike, function

1017

1583

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

1018

1584

# property with the alternate D-Bus interface

1019

1585

# name. Add it to the class.

1020

attr[attrname] = (dbus_service_property

1021

(alt_interface,

1022

attribute._dbus_signature,

1023

attribute._dbus_access,

1024

attribute

1025

._dbus_get_args_options

1026

["byte_arrays"])

1027

(types.FunctionType

1028

(attribute.func_code,

1029

attribute.func_globals,

1030

attribute.func_name,

1031

attribute.func_defaults,

1032

attribute.func_closure)))

1033

return type.__new__(mcs, name, bases, attr)

1034

1035

1586

attr[attrname] = (dbus_service_property(

1587

alt_interface, attribute._dbus_signature,

1588

attribute._dbus_access,

1589

attribute._dbus_get_args_options

1590

["byte_arrays"])

1591

(types.FunctionType(

1592

attribute.func_code,

1593

attribute.func_globals,

1594

attribute.func_name,

1595

attribute.func_defaults,

1596

attribute.func_closure)))

1597

# Copy annotations, if any

1598

try:

1599

attr[attrname]._dbus_annotations = dict(

1600

attribute._dbus_annotations)

1601

except AttributeError:

1602

pass

1603

# Is this a D-Bus interface?

1604

elif getattr(attribute, "_dbus_is_interface", False):

1605

# Create a new, but exactly alike, function

1606

# object. Decorate it to be a new D-Bus interface

1607

# with the alternate D-Bus interface name. Add it

1608

# to the class.

1609

attr[attrname] = (

1610

dbus_interface_annotations(alt_interface)

1611

(types.FunctionType(attribute.func_code,

1612

attribute.func_globals,

1613

attribute.func_name,

1614

attribute.func_defaults,

1615

attribute.func_closure)))

1616

if deprecate:

1617

# Deprecate all alternate interfaces

1618

iname="_AlternateDBusNames_interface_annotation{}"

1619

for interface_name in interface_names:

1620

1621

@dbus_interface_annotations(interface_name)

1622

def func(self):

1623

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

1624

"true" }

1625

# Find an unused name

1626

for aname in (iname.format(i)

1627

for i in itertools.count()):

1628

if aname not in attr:

1629

attr[aname] = func

1630

break

1631

if interface_names:

1632

# Replace the class with a new subclass of it with

1633

# methods, signals, etc. as created above.

1634

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

1635

(cls, ), attr)

1636

return cls

1637

1638

return wrapper

1639

1640

1641

@alternate_dbus_interfaces({"se.recompile.Mandos":

1642

"se.bsnet.fukt.Mandos"})

1036

1643

class ClientDBus(Client, DBusObjectWithProperties):

1037

1644

"""A Client class using D-Bus

1038

1645

1042

1649

"""

1043

1650

1044

1651

runtime_expansions = (Client.runtime_expansions

1045

+ ("dbus_object_path",))

1652

+ ("dbus_object_path", ))

1653

1654

_interface = "se.recompile.Mandos.Client"

1046

1655

1047

1656

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

1048

1657

1049

1658

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

1050

1659

self.bus = bus

1051

1660

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

1052

self._approvals_pending = 0

1053

1054

self._approvals_pending = 0

1055

1661

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

1056

1662

# the D-Bus

1057

client_object_name = unicode(self.name).translate(

1663

client_object_name = str(self.name).translate(

1058

1664

{ord("."): ord("_"),

1059

1665

ord("-"): ord("_")})

1060

self.dbus_object_path = (dbus.ObjectPath

1061

("/clients/" + client_object_name))

1666

self.dbus_object_path = dbus.ObjectPath(

1667

"/clients/" + client_object_name)

1062

1668

DBusObjectWithProperties.__init__(self, self.bus,

1063

1669

self.dbus_object_path)

1064

1065

def notifychangeproperty(transform_func,

1066

dbus_name, type_func=lambda x: x,

1067

variant_level=1):

1670

1671

def notifychangeproperty(transform_func, dbus_name,

1672

type_func=lambda x: x,

1673

variant_level=1,

1674

invalidate_only=False,

1675

_interface=_interface):

1068

1676

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

1069

1677

its changes to DBus.

1070

1678

1075

1683

to the D-Bus. Default: no transform

1076

1684

variant_level: D-Bus variant level. Default: 1

1077

1685

"""

1078

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

1686

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

1687

1079

1688

def setter(self, value):

1080

1689

if hasattr(self, "dbus_object_path"):

1081

1690

if (not hasattr(self, attrname) or

1082

1691

type_func(getattr(self, attrname, None))

1083

1692

!= type_func(value)):

1084

dbus_value = transform_func(type_func(value),

1085

variant_level

1086

=variant_level)

1087

self.PropertyChanged(dbus.String(dbus_name),

1088

dbus_value)

1693

if invalidate_only:

1694

self.PropertiesChanged(

1695

_interface, dbus.Dictionary(),

1696

dbus.Array((dbus_name, )))

1697

else:

1698

dbus_value = transform_func(

1699

type_func(value),

1700

variant_level = variant_level)

1701

self.PropertyChanged(dbus.String(dbus_name),

1702

dbus_value)

1703

self.PropertiesChanged(

1704

_interface,

1705

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

1706

dbus_value }),

1707

dbus.Array())

1089

1708

setattr(self, attrname, value)

1090

1709

1091

1710

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

1092

1711

1093

1094

1712

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1095

1713

approvals_pending = notifychangeproperty(dbus.Boolean,

1096

1714

"ApprovalPending",

1098

1716

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

1099

1717

last_enabled = notifychangeproperty(datetime_to_dbus,

1100

1718

"LastEnabled")

1101

checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",

1102

type_func = lambda checker:

1103

checker is not None)

1719

checker = notifychangeproperty(

1720

dbus.Boolean, "CheckerRunning",

1721

type_func = lambda checker: checker is not None)

1104

1722

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1105

1723

"LastCheckedOK")

1724

last_checker_status = notifychangeproperty(dbus.Int16,

1725

"LastCheckerStatus")

1106

1726

last_approval_request = notifychangeproperty(

1107

1727

datetime_to_dbus, "LastApprovalRequest")

1108

1728

approved_by_default = notifychangeproperty(dbus.Boolean,

1109

1729

"ApprovedByDefault")

1110

approval_delay = notifychangeproperty(dbus.UInt64,

1111

"ApprovalDelay",

1112

type_func =

1113

timedelta_to_milliseconds)

1730

approval_delay = notifychangeproperty(

1731

dbus.UInt64, "ApprovalDelay",

1732

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

1114

1733

approval_duration = notifychangeproperty(

1115

1734

dbus.UInt64, "ApprovalDuration",

1116

type_func = timedelta_to_milliseconds)

1735

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

1117

1736

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

1118

timeout = notifychangeproperty(dbus.UInt64, "Timeout",

1119

type_func =

1120

timedelta_to_milliseconds)

1737

timeout = notifychangeproperty(

1738

dbus.UInt64, "Timeout",

1739

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

1121

1740

extended_timeout = notifychangeproperty(

1122

1741

dbus.UInt64, "ExtendedTimeout",

1123

type_func = timedelta_to_milliseconds)

1124

interval = notifychangeproperty(dbus.UInt64,

1125

"Interval",

1126

type_func =

1127

timedelta_to_milliseconds)

1742

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

1743

interval = notifychangeproperty(

1744

dbus.UInt64, "Interval",

1745

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

1128

1746

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

1747

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

1748

invalidate_only=True)

1129

1749

1130

1750

del notifychangeproperty

1131

1751

1138

1758

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

1139

1759

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

1140

1760

1141

def checker_callback(self, pid, condition, command,

1142

*args, **kwargs):

1143

self.checker_callback_tag = None

1144

self.checker = None

1145

if os.WIFEXITED(condition):

1146

exitstatus = os.WEXITSTATUS(condition)

1761

def checker_callback(self, source, condition,

1762

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

1763

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

1764

connection, command, *args,

1765

**kwargs)

1766

exitstatus = self.last_checker_status

1767

if exitstatus >= 0:

1147

1768

# Emit D-Bus signal

1148

1769

self.CheckerCompleted(dbus.Int16(exitstatus),

1149

dbus.Int64(condition),

1770

# This is specific to GNU libC

1771

dbus.Int64(exitstatus << 8),

1150

1772

dbus.String(command))

1151

1773

else:

1152

1774

# Emit D-Bus signal

1153

1775

self.CheckerCompleted(dbus.Int16(-1),

1154

dbus.Int64(condition),

1776

dbus.Int64(

1777

# This is specific to GNU libC

1778

(exitstatus << 8)

1779

| self.last_checker_signal),

1155

1780

dbus.String(command))

1156

1157

return Client.checker_callback(self, pid, condition, command,

1158

*args, **kwargs)

1781

return ret

1159

1782

1160

1783

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

1161

old_checker = self.checker

1162

if self.checker is not None:

1163

old_checker_pid = self.checker.pid

1164

else:

1165

old_checker_pid = None

1784

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

1166

1785

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

1167

1786

# Only if new checker process was started

1168

1787

if (self.checker is not None

1176

1795

return False

1177

1796

1178

1797

def approve(self, value=True):

1179

self.send_changedstate()

1180

1798

self.approved = value

1181

gobject.timeout_add(timedelta_to_milliseconds

1182

(self.approval_duration),

1183

self._reset_approved)

1184

1799

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

1800

* 1000), self._reset_approved)

1801

self.send_changedstate()

1185

1802

1186

1803

## D-Bus methods, signals & properties

1187

_interface = "se.recompile.Mandos.Client"

1804

1805

## Interfaces

1188

1806

1189

1807

## Signals

1190

1808

1201

1819

pass

1202

1820

1203

1821

# PropertyChanged - signal

1822

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

1204

1823

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

1205

1824

def PropertyChanged(self, property, value):

1206

1825

"D-Bus signal"

1227

1846

"D-Bus signal"

1228

1847

return self.need_approval()

1229

1848

1230

# NeRwequest - signal

1231

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

1232

def NewRequest(self, ip):

1233

"""D-Bus signal

1234

Is sent after a client request a password.

1235

"""

1236

pass

1237

1238

1849

## Methods

1239

1850

1240

1851

# Approve - method

1248

1859

self.checked_ok()

1249

1860

1250

1861

# Enable - method

1862

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

1251

1863

@dbus.service.method(_interface)

1252

1864

def Enable(self):

1253

1865

"D-Bus method"

1254

1866

self.enable()

1255

1867

1256

1868

# StartChecker - method

1869

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

1257

1870

@dbus.service.method(_interface)

1258

1871

def StartChecker(self):

1259

1872

"D-Bus method"

1260

1873

self.start_checker()

1261

1874

1262

1875

# Disable - method

1876

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

1263

1877

@dbus.service.method(_interface)

1264

1878

def Disable(self):

1265

1879

"D-Bus method"

1266

1880

self.disable()

1267

1881

1268

1882

# StopChecker - method

1883

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

1269

1884

@dbus.service.method(_interface)

1270

1885

def StopChecker(self):

1271

1886

self.stop_checker()

1278

1893

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

1279

1894

1280

1895

# ApprovedByDefault - property

1281

@dbus_service_property(_interface, signature="b",

1896

@dbus_service_property(_interface,

1897

signature="b",

1282

1898

access="readwrite")

1283

1899

def ApprovedByDefault_dbus_property(self, value=None):

1284

1900

if value is None: # get

1286

1902

self.approved_by_default = bool(value)

1287

1903

1288

1904

# ApprovalDelay - property

1289

@dbus_service_property(_interface, signature="t",

1905

@dbus_service_property(_interface,

1906

signature="t",

1290

1907

access="readwrite")

1291

1908

def ApprovalDelay_dbus_property(self, value=None):

1292

1909

if value is None: # get

1293

return dbus.UInt64(self.approval_delay_milliseconds())

1910

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

1911

* 1000)

1294

1912

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

1295

1913

1296

1914

# ApprovalDuration - property

1297

@dbus_service_property(_interface, signature="t",

1915

@dbus_service_property(_interface,

1916

signature="t",

1298

1917

access="readwrite")

1299

1918

def ApprovalDuration_dbus_property(self, value=None):

1300

1919

if value is None: # get

1301

return dbus.UInt64(timedelta_to_milliseconds(

1302

self.approval_duration))

1920

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

1921

* 1000)

1303

1922

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

1304

1923

1305

1924

# Name - property

1925

@dbus_annotations(

1926

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

1306

1927

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

1307

1928

def Name_dbus_property(self):

1308

1929

return dbus.String(self.name)

1309

1930

1310

1931

# Fingerprint - property

1932

@dbus_annotations(

1933

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

1311

1934

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

1312

1935

def Fingerprint_dbus_property(self):

1313

1936

return dbus.String(self.fingerprint)

1314

1937

1315

1938

# Host - property

1316

@dbus_service_property(_interface, signature="s",

1939

@dbus_service_property(_interface,

1940

signature="s",

1317

1941

access="readwrite")

1318

1942

def Host_dbus_property(self, value=None):

1319

1943

if value is None: # get

1320

1944

return dbus.String(self.host)

1321

self.host = unicode(value)

1945

self.host = str(value)

1322

1946

1323

1947

# Created - property

1948

@dbus_annotations(

1949

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

1324

1950

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

1325

1951

def Created_dbus_property(self):

1326

1952

return datetime_to_dbus(self.created)

1331

1957

return datetime_to_dbus(self.last_enabled)

1332

1958

1333

1959

# Enabled - property

1334

@dbus_service_property(_interface, signature="b",

1960

@dbus_service_property(_interface,

1961

signature="b",

1335

1962

access="readwrite")

1336

1963

def Enabled_dbus_property(self, value=None):

1337

1964

if value is None: # get

1342

1969

self.disable()

1343

1970

1344

1971

# LastCheckedOK - property

1345

@dbus_service_property(_interface, signature="s",

1972

@dbus_service_property(_interface,

1973

signature="s",

1346

1974

access="readwrite")

1347

1975

def LastCheckedOK_dbus_property(self, value=None):

1348

1976

if value is not None:

1350

1978

return

1351

1979

return datetime_to_dbus(self.last_checked_ok)

1352

1980

1981

# LastCheckerStatus - property

1982

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

1983

def LastCheckerStatus_dbus_property(self):

1984

return dbus.Int16(self.last_checker_status)

1985

1353

1986

# Expires - property

1354

1987

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

1355

1988

def Expires_dbus_property(self):

1361

1994

return datetime_to_dbus(self.last_approval_request)

1362

1995

1363

1996

# Timeout - property

1364

@dbus_service_property(_interface, signature="t",

1997

@dbus_service_property(_interface,

1998

signature="t",

1365

1999

access="readwrite")

1366

2000

def Timeout_dbus_property(self, value=None):

1367

2001

if value is None: # get

1368

return dbus.UInt64(self.timeout_milliseconds())

2002

return dbus.UInt64(self.timeout.total_seconds() * 1000)

2003

old_timeout = self.timeout

1369

2004

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

1370

# Reschedule timeout

2005

# Reschedule disabling

1371

2006

if self.enabled:

1372

2007

now = datetime.datetime.utcnow()

1373

time_to_die = timedelta_to_milliseconds(

1374

(self.last_checked_ok + self.timeout) - now)

1375

if time_to_die <= 0:

2008

self.expires += self.timeout - old_timeout

2009

if self.expires <= now:

1376

2010

# The timeout has passed

1377

2011

self.disable()

1378

2012

else:

1379

self.expires = (now +

1380

datetime.timedelta(milliseconds =

1381

time_to_die))

1382

2013

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

1383

2014

is None):

1384

2015

return

1385

2016

gobject.source_remove(self.disable_initiator_tag)

1386

self.disable_initiator_tag = (gobject.timeout_add

1387

(time_to_die,

1388

self.disable))

2017

self.disable_initiator_tag = gobject.timeout_add(

2018

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

2019

self.disable)

1389

2020

1390

2021

# ExtendedTimeout - property

1391

@dbus_service_property(_interface, signature="t",

2022

@dbus_service_property(_interface,

2023

signature="t",

1392

2024

access="readwrite")

1393

2025

def ExtendedTimeout_dbus_property(self, value=None):

1394

2026

if value is None: # get

1395

return dbus.UInt64(self.extended_timeout_milliseconds())

2027

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

2028

* 1000)

1396

2029

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

1397

2030

1398

2031

# Interval - property

1399

@dbus_service_property(_interface, signature="t",

2032

@dbus_service_property(_interface,

2033

signature="t",

1400

2034

access="readwrite")

1401

2035

def Interval_dbus_property(self, value=None):

1402

2036

if value is None: # get

1403

return dbus.UInt64(self.interval_milliseconds())

2037

return dbus.UInt64(self.interval.total_seconds() * 1000)

1404

2038

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

1405

2039

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

1406

2040

return

1407

2041

if self.enabled:

1408

2042

# Reschedule checker run

1409

2043

gobject.source_remove(self.checker_initiator_tag)

1410

self.checker_initiator_tag = (gobject.timeout_add

1411

(value, self.start_checker))

1412

self.start_checker() # Start one now, too

2044

self.checker_initiator_tag = gobject.timeout_add(

2045

value, self.start_checker)

2046

self.start_checker() # Start one now, too

1413

2047

1414

2048

# Checker - property

1415

@dbus_service_property(_interface, signature="s",

2049

@dbus_service_property(_interface,

2050

signature="s",

1416

2051

access="readwrite")

1417

2052

def Checker_dbus_property(self, value=None):

1418

2053

if value is None: # get

1419

2054

return dbus.String(self.checker_command)

1420

self.checker_command = unicode(value)

2055

self.checker_command = str(value)

1421

2056

1422

2057

# CheckerRunning - property

1423

@dbus_service_property(_interface, signature="b",

2058

@dbus_service_property(_interface,

2059

signature="b",

1424

2060

access="readwrite")

1425

2061

def CheckerRunning_dbus_property(self, value=None):

1426

2062

if value is None: # get

1431

2067

self.stop_checker()

1432

2068

1433

2069

# ObjectPath - property

2070

@dbus_annotations(

2071

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

2072

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

1434

2073

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

1435

2074

def ObjectPath_dbus_property(self):

1436

2075

return self.dbus_object_path # is already a dbus.ObjectPath

1437

2076

1438

2077

# Secret = property

1439

@dbus_service_property(_interface, signature="ay",

1440

access="write", byte_arrays=True)

2078

@dbus_annotations(

2079

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

2080

"invalidates"})

2081

@dbus_service_property(_interface,

2082

signature="ay",

2083

access="write",

2084

byte_arrays=True)

1441

2085

def Secret_dbus_property(self, value):

1442

self.secret = str(value)

2086

self.secret = bytes(value)

1443

2087

1444

2088

del _interface

1445

2089

1449

2093

self._pipe = child_pipe

1450

2094

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

1451

2095

if not self._pipe.recv():

1452

raise KeyError()

2096

raise KeyError(fpr)

1453

2097

1454

2098

def __getattribute__(self, name):

1455

2099

if name == '_pipe':

1459

2103

if data[0] == 'data':

1460

2104

return data[1]

1461

2105

if data[0] == 'function':

2106

1462

2107

def func(*args, **kwargs):

1463

2108

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

1464

2109

return self._pipe.recv()[1]

2110

1465

2111

return func

1466

2112

1467

2113

def __setattr__(self, name, value):

1470

2116

self._pipe.send(('setattr', name, value))

1471

2117

1472

2118

1473

class ClientDBusTransitional(ClientDBus):

1474

__metaclass__ = AlternateDBusNamesMetaclass

1475

1476

1477

2119

class ClientHandler(socketserver.BaseRequestHandler, object):

1478

2120

"""A class to handle client connections.

1479

2121

1483

2125

def handle(self):

1484

2126

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

1485

2127

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

1486

unicode(self.client_address))

2128

str(self.client_address))

1487

2129

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

1488

2130

self.server.child_pipe.fileno())

1489

2131

1490

session = (gnutls.connection

1491

.ClientSession(self.request,

1492

gnutls.connection

1493

.X509Credentials()))

1494

1495

# Note: gnutls.connection.X509Credentials is really a

1496

# generic GnuTLS certificate credentials object so long as

1497

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

1498

# here despite using OpenPGP certificates.

2132

session = gnutls.ClientSession(self.request)

1499

2133

1500

2134

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

1501

2135

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

1505

2139

priority = self.server.gnutls_priority

1506

2140

if priority is None:

1507

2141

priority = "NORMAL"

1508

(gnutls.library.functions

1509

.gnutls_priority_set_direct(session._c_object,

1510

priority, None))

2142

gnutls.priority_set_direct(session._c_object, priority,

2143

None)

1511

2144

1512

2145

# Start communication using the Mandos protocol

1513

2146

# Get protocol number

1515

2148

logger.debug("Protocol version: %r", line)

1516

2149

try:

1517

2150

if int(line.strip().split()[0]) > 1:

1518

raise RuntimeError

2151

raise RuntimeError(line)

1519

2152

except (ValueError, IndexError, RuntimeError) as error:

1520

2153

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

1521

2154

return

1523

2156

# Start GnuTLS connection

1524

2157

try:

1525

2158

session.handshake()

1526

except gnutls.errors.GNUTLSError as error:

2159

except gnutls.Error as error:

1527

2160

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

1528

2161

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

1529

2162

# established. Just abandon the request.

1533

2166

approval_required = False

1534

2167

try:

1535

2168

try:

1536

fpr = self.fingerprint(self.peer_certificate

1537

(session))

1538

except (TypeError,

1539

gnutls.errors.GNUTLSError) as error:

2169

fpr = self.fingerprint(

2170

self.peer_certificate(session))

2171

except (TypeError, gnutls.Error) as error:

1540

2172

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

1541

2173

return

1542

2174

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

1547

2179

except KeyError:

1548

2180

return

1549

2181

1550

if self.server.use_dbus:

1551

# Emit D-Bus signal

1552

client.NewRequest(str(self.client_address))

1553

1554

2182

if client.approval_delay:

1555

2183

delay = client.approval_delay

1556

2184

client.approvals_pending += 1

1559

2187

while True:

1560

2188

if not client.enabled:

1561

2189

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

1562

client.name)

2190

client.name)

1563

2191

if self.server.use_dbus:

1564

2192

# Emit D-Bus signal

1565

2193

client.Rejected("Disabled")

1574

2202

if self.server.use_dbus:

1575

2203

# Emit D-Bus signal

1576

2204

client.NeedApproval(

1577

client.approval_delay_milliseconds(),

1578

client.approved_by_default)

2205

client.approval_delay.total_seconds()

2206

* 1000, client.approved_by_default)

1579

2207

else:

1580

2208

logger.warning("Client %s was not approved",

1581

2209

client.name)

1587

2215

#wait until timeout or approved

1588

2216

time = datetime.datetime.now()

1589

2217

client.changedstate.acquire()

1590

(client.changedstate.wait

1591

(float(client.timedelta_to_milliseconds(delay)

1592

/ 1000)))

2218

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

1593

2219

client.changedstate.release()

1594

2220

time2 = datetime.datetime.now()

1595

2221

if (time2 - time) >= delay:

1606

2232

else:

1607

2233

delay -= time2 - time

1608

2234

1609

sent_size = 0

1610

while sent_size < len(client.secret):

1611

try:

1612

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

1613

except gnutls.errors.GNUTLSError as error:

1614

logger.warning("gnutls send failed")

1615

return

1616

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

1617

sent, len(client.secret)

1618

- (sent_size + sent))

1619

sent_size += sent

2235

try:

2236

session.send(client.secret)

2237

except gnutls.Error as error:

2238

logger.warning("gnutls send failed",

2239

exc_info = error)

2240

return

1620

2241

1621

2242

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

1622

2243

# bump the timeout using extended_timeout

1623

client.checked_ok(client.extended_timeout)

2244

client.bump_timeout(client.extended_timeout)

1624

2245

if self.server.use_dbus:

1625

2246

# Emit D-Bus signal

1626

2247

client.GotSecret()

1630

2251

client.approvals_pending -= 1

1631

2252

try:

1632

2253

session.bye()

1633

except gnutls.errors.GNUTLSError as error:

1634

logger.warning("GnuTLS bye failed")

2254

except gnutls.Error as error:

2255

logger.warning("GnuTLS bye failed",

2256

exc_info=error)

1635

2257

1636

2258

@staticmethod

1637

2259

def peer_certificate(session):

1638

2260

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

1639

2261

# If not an OpenPGP certificate...

1640

if (gnutls.library.functions

1641

.gnutls_certificate_type_get(session._c_object)

1642

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1643

# ...do the normal thing

1644

return session.peer_certificate

2262

if (gnutls.certificate_type_get(session._c_object)

2263

!= gnutls.CRT_OPENPGP):

2264

# ...return invalid data

2265

return b""

1645

2266

list_size = ctypes.c_uint(1)

1646

cert_list = (gnutls.library.functions

1647

.gnutls_certificate_get_peers

2267

cert_list = (gnutls.certificate_get_peers

1648

2268

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

1649

2269

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

1650

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

1651

" certificate")

2270

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

1652

2271

if list_size.value == 0:

1653

2272

return None

1654

2273

cert = cert_list[0]

1658

2277

def fingerprint(openpgp):

1659

2278

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

1660

2279

# New GnuTLS "datum" with the OpenPGP public key

1661

datum = (gnutls.library.types

1662

.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),

1663

ctypes.POINTER

1664

(ctypes.c_ubyte)),

1665

ctypes.c_uint(len(openpgp))))

2280

datum = gnutls.datum_t(

2281

ctypes.cast(ctypes.c_char_p(openpgp),

2282

ctypes.POINTER(ctypes.c_ubyte)),

2283

ctypes.c_uint(len(openpgp)))

1666

2284

# New empty GnuTLS certificate

1667

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1668

(gnutls.library.functions

1669

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

2285

crt = gnutls.openpgp_crt_t()

2286

gnutls.openpgp_crt_init(ctypes.byref(crt))

1670

2287

# Import the OpenPGP public key into the certificate

1671

(gnutls.library.functions

1672

.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),

1673

gnutls.library.constants

1674

.GNUTLS_OPENPGP_FMT_RAW))

2288

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

2289

gnutls.OPENPGP_FMT_RAW)

1675

2290

# Verify the self signature in the key

1676

2291

crtverify = ctypes.c_uint()

1677

(gnutls.library.functions

1678

.gnutls_openpgp_crt_verify_self(crt, 0,

1679

ctypes.byref(crtverify)))

2292

gnutls.openpgp_crt_verify_self(crt, 0,

2293

ctypes.byref(crtverify))

1680

2294

if crtverify.value != 0:

1681

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1682

raise (gnutls.errors.CertificateSecurityError

1683

("Verify failed"))

2295

gnutls.openpgp_crt_deinit(crt)

2296

raise gnutls.CertificateSecurityError("Verify failed")

1684

2297

# New buffer for the fingerprint

1685

2298

buf = ctypes.create_string_buffer(20)

1686

2299

buf_len = ctypes.c_size_t()

1687

2300

# Get the fingerprint from the certificate into the buffer

1688

(gnutls.library.functions

1689

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

1690

ctypes.byref(buf_len)))

2301

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

2302

ctypes.byref(buf_len))

1691

2303

# Deinit the certificate

1692

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

2304

gnutls.openpgp_crt_deinit(crt)

1693

2305

# Convert the buffer to a Python bytestring

1694

2306

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

1695

2307

# Convert the bytestring to hexadecimal notation

1699

2311

1700

2312

class MultiprocessingMixIn(object):

1701

2313

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

2314

1702

2315

def sub_process_main(self, request, address):

1703

2316

try:

1704

2317

self.finish_request(request, address)

1709

2322

def process_request(self, request, address):

1710

2323

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

1711

2324

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

1712

args = (request,

1713

address))

2325

args = (request, address))

1714

2326

proc.start()

1715

2327

return proc

1716

2328

1717

2329

1718

2330

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1719

2331

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

2332

1720

2333

def process_request(self, request, client_address):

1721

2334

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

1722

2335

1731

2344

1732

2345

def add_pipe(self, parent_pipe, proc):

1733

2346

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

1734

raise NotImplementedError

2347

raise NotImplementedError()

1735

2348

1736

2349

1737

2350

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1743

2356

interface: None or a network interface name (string)

1744

2357

use_ipv6: Boolean; to use IPv6 or not

1745

2358

"""

2359

1746

2360

def __init__(self, server_address, RequestHandlerClass,

1747

interface=None, use_ipv6=True):

2361

interface=None,

2362

use_ipv6=True,

2363

socketfd=None):

2364

"""If socketfd is set, use that file descriptor instead of

2365

creating a new one with socket.socket().

2366

"""

1748

2367

self.interface = interface

1749

2368

if use_ipv6:

1750

2369

self.address_family = socket.AF_INET6

2370

if socketfd is not None:

2371

# Save the file descriptor

2372

self.socketfd = socketfd

2373

# Save the original socket.socket() function

2374

self.socket_socket = socket.socket

2375

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

2376

#

2377

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

2378

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

2379

# patching socket.socket.)

2380

#

2381

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

2382

@functools.wraps(socket.socket)

2383

def socket_wrapper(*args, **kwargs):

2384

# Restore original function so subsequent calls are

2385

# not affected.

2386

socket.socket = self.socket_socket

2387

del self.socket_socket

2388

# This time only, return a new socket object from the

2389

# saved file descriptor.

2390

return socket.fromfd(self.socketfd, *args, **kwargs)

2391

# Replace socket.socket() function with wrapper

2392

socket.socket = socket_wrapper

2393

# The socketserver.TCPServer.__init__ will call

2394

# socket.socket(), which might be our replacement,

2395

# socket_wrapper(), if socketfd was set.

1751

2396

socketserver.TCPServer.__init__(self, server_address,

1752

2397

RequestHandlerClass)

2398

1753

2399

def server_bind(self):

1754

2400

"""This overrides the normal server_bind() function

1755

2401

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

1761

2407

self.interface)

1762

2408

else:

1763

2409

try:

1764

self.socket.setsockopt(socket.SOL_SOCKET,

1765

SO_BINDTODEVICE,

1766

str(self.interface

1767

+ '\0'))

2410

self.socket.setsockopt(

2411

socket.SOL_SOCKET, SO_BINDTODEVICE,

2412

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

1768

2413

except socket.error as error:

1769

if error[0] == errno.EPERM:

1770

logger.error("No permission to"

1771

" bind to interface %s",

1772

self.interface)

1773

elif error[0] == errno.ENOPROTOOPT:

2414

if error.errno == errno.EPERM:

2415

logger.error("No permission to bind to"

2416

" interface %s", self.interface)

2417

elif error.errno == errno.ENOPROTOOPT:

1774

2418

logger.error("SO_BINDTODEVICE not available;"

1775

2419

" cannot bind to interface %s",

1776

2420

self.interface)

2421

elif error.errno == errno.ENODEV:

2422

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

2423

" cannot bind", self.interface)

1777

2424

else:

1778

2425

raise

1779

2426

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

1782

2429

if self.address_family == socket.AF_INET6:

1783

2430

any_address = "::" # in6addr_any

1784

2431

else:

1785

any_address = socket.INADDR_ANY

2432

any_address = "0.0.0.0" # INADDR_ANY

1786

2433

self.server_address = (any_address,

1787

2434

self.server_address[1])

1788

2435

elif not self.server_address[1]:

1789

self.server_address = (self.server_address[0],

1790

0)

2436

self.server_address = (self.server_address[0], 0)

1791

2437

# if self.interface:

1792

2438

# self.server_address = (self.server_address[0],

1793

2439

# 0, # port

1807

2453

1808

2454

Assumes a gobject.MainLoop event loop.

1809

2455

"""

2456

1810

2457

def __init__(self, server_address, RequestHandlerClass,

1811

interface=None, use_ipv6=True, clients=None,

1812

gnutls_priority=None, use_dbus=True):

2458

interface=None,

2459

use_ipv6=True,

2460

clients=None,

2461

gnutls_priority=None,

2462

use_dbus=True,

2463

socketfd=None):

1813

2464

self.enabled = False

1814

2465

self.clients = clients

1815

2466

if self.clients is None:

1819

2470

IPv6_TCPServer.__init__(self, server_address,

1820

2471

RequestHandlerClass,

1821

2472

interface = interface,

1822

use_ipv6 = use_ipv6)

2473

use_ipv6 = use_ipv6,

2474

socketfd = socketfd)

2475

1823

2476

def server_activate(self):

1824

2477

if self.enabled:

1825

2478

return socketserver.TCPServer.server_activate(self)

1829

2482

1830

2483

def add_pipe(self, parent_pipe, proc):

1831

2484

# Call "handle_ipc" for both data and EOF events

1832

gobject.io_add_watch(parent_pipe.fileno(),

1833

gobject.IO_IN | gobject.IO_HUP,

1834

functools.partial(self.handle_ipc,

1835

parent_pipe =

1836

parent_pipe,

1837

proc = proc))

2485

gobject.io_add_watch(

2486

parent_pipe.fileno(),

2487

gobject.IO_IN | gobject.IO_HUP,

2488

functools.partial(self.handle_ipc,

2489

parent_pipe = parent_pipe,

2490

proc = proc))

1838

2491

1839

def handle_ipc(self, source, condition, parent_pipe=None,

1840

proc = None, client_object=None):

1841

condition_names = {

1842

gobject.IO_IN: "IN", # There is data to read.

1843

gobject.IO_OUT: "OUT", # Data can be written (without

1844

# blocking).

1845

gobject.IO_PRI: "PRI", # There is urgent data to read.

1846

gobject.IO_ERR: "ERR", # Error condition.

1847

gobject.IO_HUP: "HUP" # Hung up (the connection has been

1848

# broken, usually for pipes and

1849

# sockets).

1850

}

1851

conditions_string = ' | '.join(name

1852

for cond, name in

1853

condition_names.iteritems()

1854

if cond & condition)

2492

def handle_ipc(self, source, condition,

2493

parent_pipe=None,

2494

proc = None,

2495

client_object=None):

1855

2496

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

1856

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

2497

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

1857

2498

# Wait for other process to exit

1858

2499

proc.join()

1859

2500

return False

1880

2521

parent_pipe.send(False)

1881

2522

return False

1882

2523

1883

gobject.io_add_watch(parent_pipe.fileno(),

1884

gobject.IO_IN | gobject.IO_HUP,

1885

functools.partial(self.handle_ipc,

1886

parent_pipe =

1887

parent_pipe,

1888

proc = proc,

1889

client_object =

1890

client))

2524

gobject.io_add_watch(

2525

parent_pipe.fileno(),

2526

gobject.IO_IN | gobject.IO_HUP,

2527

functools.partial(self.handle_ipc,

2528

parent_pipe = parent_pipe,

2529

proc = proc,

2530

client_object = client))

1891

2531

parent_pipe.send(True)

1892

2532

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

1893

2533

# same fileno

1899

2539

1900

2540

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

1901

2541

funcname)(*args,

1902

**kwargs)))

2542

**kwargs)))

1903

2543

1904

2544

if command == 'getattr':

1905

2545

attrname = request[1]

1906

if callable(client_object.__getattribute__(attrname)):

1907

parent_pipe.send(('function',))

2546

if isinstance(client_object.__getattribute__(attrname),

2547

collections.Callable):

2548

parent_pipe.send(('function', ))

1908

2549

else:

1909

parent_pipe.send(('data', client_object

1910

.__getattribute__(attrname)))

2550

parent_pipe.send((

2551

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

1911

2552

1912

2553

if command == 'setattr':

1913

2554

attrname = request[1]

1917

2558

return True

1918

2559

1919

2560

2561

def rfc3339_duration_to_delta(duration):

2562

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

2563

2564

>>> rfc3339_duration_to_delta("P7D")

2565

datetime.timedelta(7)

2566

>>> rfc3339_duration_to_delta("PT60S")

2567

datetime.timedelta(0, 60)

2568

>>> rfc3339_duration_to_delta("PT60M")

2569

datetime.timedelta(0, 3600)

2570

>>> rfc3339_duration_to_delta("PT24H")

2571

datetime.timedelta(1)

2572

>>> rfc3339_duration_to_delta("P1W")

2573

datetime.timedelta(7)

2574

>>> rfc3339_duration_to_delta("PT5M30S")

2575

datetime.timedelta(0, 330)

2576

>>> rfc3339_duration_to_delta("P1DT3M20S")

2577

datetime.timedelta(1, 200)

2578

"""

2579

2580

# Parsing an RFC 3339 duration with regular expressions is not

2581

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

2582

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

2583

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

2584

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

2585

# avoid excessive use of external libraries.

2586

2587

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

2588

Token = collections.namedtuple("Token", (

2589

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

2590

# a "group" containing digits

2591

"value", # datetime.timedelta or None

2592

"followers")) # Tokens valid after this token

2593

# RFC 3339 "duration" tokens, syntax, and semantics; taken from

2594

# the "duration" ABNF definition in RFC 3339, Appendix A.

2595

token_end = Token(re.compile(r"$"), None, frozenset())

2596

token_second = Token(re.compile(r"(\d+)S"),

2597

datetime.timedelta(seconds=1),

2598

frozenset((token_end, )))

2599

token_minute = Token(re.compile(r"(\d+)M"),

2600

datetime.timedelta(minutes=1),

2601

frozenset((token_second, token_end)))

2602

token_hour = Token(re.compile(r"(\d+)H"),

2603

datetime.timedelta(hours=1),

2604

frozenset((token_minute, token_end)))

2605

token_time = Token(re.compile(r"T"),

2606

None,

2607

frozenset((token_hour, token_minute,

2608

token_second)))

2609

token_day = Token(re.compile(r"(\d+)D"),

2610

datetime.timedelta(days=1),

2611

frozenset((token_time, token_end)))

2612

token_month = Token(re.compile(r"(\d+)M"),

2613

datetime.timedelta(weeks=4),

2614

frozenset((token_day, token_end)))

2615

token_year = Token(re.compile(r"(\d+)Y"),

2616

datetime.timedelta(weeks=52),

2617

frozenset((token_month, token_end)))

2618

token_week = Token(re.compile(r"(\d+)W"),

2619

datetime.timedelta(weeks=1),

2620

frozenset((token_end, )))

2621

token_duration = Token(re.compile(r"P"), None,

2622

frozenset((token_year, token_month,

2623

token_day, token_time,

2624

token_week)))

2625

# Define starting values

2626

value = datetime.timedelta() # Value so far

2627

found_token = None

2628

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

2629

s = duration # String left to parse

2630

# Loop until end token is found

2631

while found_token is not token_end:

2632

# Search for any currently valid tokens

2633

for token in followers:

2634

match = token.regexp.match(s)

2635

if match is not None:

2636

# Token found

2637

if token.value is not None:

2638

# Value found, parse digits

2639

factor = int(match.group(1), 10)

2640

# Add to value so far

2641

value += factor * token.value

2642

# Strip token from string

2643

s = token.regexp.sub("", s, 1)

2644

# Go to found token

2645

found_token = token

2646

# Set valid next tokens

2647

followers = found_token.followers

2648

break

2649

else:

2650

# No currently valid tokens were found

2651

raise ValueError("Invalid RFC 3339 duration: {!r}"

2652

.format(duration))

2653

# End token found

2654

return value

2655

2656

1920

2657

def string_to_delta(interval):

1921

2658

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

1922

2659

1933

2670

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

1934

2671

datetime.timedelta(0, 330)

1935

2672

"""

2673

2674

try:

2675

return rfc3339_duration_to_delta(interval)

2676

except ValueError:

2677

pass

2678

1936

2679

timevalue = datetime.timedelta(0)

1937

2680

for s in interval.split():

1938

2681

try:

1939

suffix = unicode(s[-1])

2682

suffix = s[-1]

1940

2683

value = int(s[:-1])

1941

2684

if suffix == "d":

1942

2685

delta = datetime.timedelta(value)

1949

2692

elif suffix == "w":

1950

2693

delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)

1951

2694

else:

1952

raise ValueError("Unknown suffix %r" % suffix)

1953

except (ValueError, IndexError) as e:

2695

raise ValueError("Unknown suffix {!r}".format(suffix))

2696

except IndexError as e:

1954

2697

raise ValueError(*(e.args))

1955

2698

timevalue += delta

1956

2699

return timevalue

1969

2712

sys.exit()

1970

2713

if not noclose:

1971

2714

# Close all standard open file descriptors

1972

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

2715

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

1973

2716

if not stat.S_ISCHR(os.fstat(null).st_mode):

1974

2717

raise OSError(errno.ENODEV,

1975

"%s not a character device"

1976

% os.path.devnull)

2718

"{} not a character device"

2719

.format(os.devnull))

1977

2720

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

1978

2721

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

1979

2722

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

1988

2731

1989

2732

parser = argparse.ArgumentParser()

1990

2733

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

1991

version = "%%(prog)s %s" % version,

2734

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

1992

2735

help="show version number and exit")

1993

2736

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

1994

2737

help="Bind to interface IF")

2000

2743

help="Run self-test")

2001

2744

parser.add_argument("--debug", action="store_true",

2002

2745

help="Debug mode; run in foreground and log"

2003

" to terminal")

2746

" to terminal", default=None)

2004

2747

parser.add_argument("--debuglevel", metavar="LEVEL",

2005

2748

help="Debug level for stdout output")

2006

2749

parser.add_argument("--priority", help="GnuTLS"

2013

2756

" files")

2014

2757

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

2015

2758

dest="use_dbus", help="Do not provide D-Bus"

2016

" system bus interface")

2759

" system bus interface", default=None)

2017

2760

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

2018

dest="use_ipv6", help="Do not use IPv6")

2761

dest="use_ipv6", help="Do not use IPv6",

2762

default=None)

2019

2763

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

2020

2764

dest="restore", help="Do not restore stored"

2021

" state")

2765

" state", default=None)

2766

parser.add_argument("--socket", type=int,

2767

help="Specify a file descriptor to a network"

2768

" socket to use instead of creating one")

2022

2769

parser.add_argument("--statedir", metavar="DIR",

2023

2770

help="Directory to save/restore state in")

2771

parser.add_argument("--foreground", action="store_true",

2772

help="Run in foreground", default=None)

2773

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

2774

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

2775

default=None)

2024

2776

2025

2777

options = parser.parse_args()

2026

2778

2027

2779

if options.check:

2028

2780

import doctest

2029

doctest.testmod()

2030

sys.exit()

2781

fail_count, test_count = doctest.testmod()

2782

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

2031

2783

2032

2784

# Default values for config file for server-global settings

2033

2785

server_defaults = { "interface": "",

2035

2787

"port": "",

2036

2788

"debug": "False",

2037

2789

"priority":

2038

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

2790

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

2791

":+SIGN-DSA-SHA256",

2039

2792

"servicename": "Mandos",

2040

2793

"use_dbus": "True",

2041

2794

"use_ipv6": "True",

2042

2795

"debuglevel": "",

2043

2796

"restore": "True",

2044

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

2045

}

2797

"socket": "",

2798

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

2799

"foreground": "False",

2800

"zeroconf": "True",

2801

}

2046

2802

2047

2803

# Parse config file for server-global settings

2048

2804

server_config = configparser.SafeConfigParser(server_defaults)

2049

2805

del server_defaults

2050

server_config.read(os.path.join(options.configdir,

2051

"mandos.conf"))

2806

server_config.read(os.path.join(options.configdir, "mandos.conf"))

2052

2807

# Convert the SafeConfigParser object to a dict

2053

2808

server_settings = server_config.defaults()

2054

2809

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

2055

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

2810

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

2056

2811

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

2057

2812

option)

2058

2813

if server_settings["port"]:

2059

2814

server_settings["port"] = server_config.getint("DEFAULT",

2060

2815

"port")

2816

if server_settings["socket"]:

2817

server_settings["socket"] = server_config.getint("DEFAULT",

2818

"socket")

2819

# Later, stdin will, and stdout and stderr might, be dup'ed

2820

# over with an opened os.devnull. But we don't want this to

2821

# happen with a supplied network socket.

2822

if 0 <= server_settings["socket"] <= 2:

2823

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

2824

["socket"])

2061

2825

del server_config

2062

2826

2063

2827

# Override the settings from the config file with command line

2064

2828

# options, if set.

2065

2829

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

2066

"priority", "servicename", "configdir",

2067

"use_dbus", "use_ipv6", "debuglevel", "restore",

2068

"statedir"):

2830

"priority", "servicename", "configdir", "use_dbus",

2831

"use_ipv6", "debuglevel", "restore", "statedir",

2832

"socket", "foreground", "zeroconf"):

2069

2833

value = getattr(options, option)

2070

2834

if value is not None:

2071

2835

server_settings[option] = value

2072

2836

del options

2073

2837

# Force all strings to be unicode

2074

2838

for option in server_settings.keys():

2075

if type(server_settings[option]) is str:

2076

server_settings[option] = unicode(server_settings[option])

2839

if isinstance(server_settings[option], bytes):

2840

server_settings[option] = (server_settings[option]

2841

.decode("utf-8"))

2842

# Force all boolean options to be boolean

2843

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

2844

"foreground", "zeroconf"):

2845

server_settings[option] = bool(server_settings[option])

2846

# Debug implies foreground

2847

if server_settings["debug"]:

2848

server_settings["foreground"] = True

2077

2849

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

2078

2850

2079

2851

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

2080

2852

2853

if (not server_settings["zeroconf"]

2854

and not (server_settings["port"]

2855

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

2856

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

2857

2081

2858

# For convenience

2082

2859

debug = server_settings["debug"]

2083

2860

debuglevel = server_settings["debuglevel"]

2085

2862

use_ipv6 = server_settings["use_ipv6"]

2086

2863

stored_state_path = os.path.join(server_settings["statedir"],

2087

2864

stored_state_file)

2865

foreground = server_settings["foreground"]

2866

zeroconf = server_settings["zeroconf"]

2088

2867

2089

2868

if debug:

2090

2869

initlogger(debug, logging.DEBUG)

2096

2875

initlogger(debug, level)

2097

2876

2098

2877

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

2099

syslogger.setFormatter(logging.Formatter

2100

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

2101

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

2102

% server_settings["servicename"]))

2878

syslogger.setFormatter(

2879

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

2880

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

2881

server_settings["servicename"])))

2103

2882

2104

2883

# Parse config file with clients

2105

2884

client_config = configparser.SafeConfigParser(Client

2110

2889

global mandos_dbus_service

2111

2890

mandos_dbus_service = None

2112

2891

2113

tcp_server = MandosServer((server_settings["address"],

2114

server_settings["port"]),

2115

ClientHandler,

2116

interface=(server_settings["interface"]

2117

or None),

2118

use_ipv6=use_ipv6,

2119

gnutls_priority=

2120

server_settings["priority"],

2121

use_dbus=use_dbus)

2122

if not debug:

2123

pidfilename = "/var/run/mandos.pid"

2892

socketfd = None

2893

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

2894

socketfd = server_settings["socket"]

2895

tcp_server = MandosServer(

2896

(server_settings["address"], server_settings["port"]),

2897

ClientHandler,

2898

interface=(server_settings["interface"] or None),

2899

use_ipv6=use_ipv6,

2900

gnutls_priority=server_settings["priority"],

2901

use_dbus=use_dbus,

2902

socketfd=socketfd)

2903

if not foreground:

2904

pidfilename = "/run/mandos.pid"

2905

if not os.path.isdir("/run/."):

2906

pidfilename = "/var/run/mandos.pid"

2907

pidfile = None

2124

2908

try:

2125

pidfile = open(pidfilename, "w")

2126

except IOError:

2127

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

2909

pidfile = codecs.open(pidfilename, "w", encoding="utf-8")

2910

except IOError as e:

2911

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

2912

exc_info=e)

2128

2913

2129

try:

2130

uid = pwd.getpwnam("_mandos").pw_uid

2131

gid = pwd.getpwnam("_mandos").pw_gid

2132

except KeyError:

2914

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

2133

2915

try:

2134

uid = pwd.getpwnam("mandos").pw_uid

2135

gid = pwd.getpwnam("mandos").pw_gid

2916

uid = pwd.getpwnam(name).pw_uid

2917

gid = pwd.getpwnam(name).pw_gid

2918

break

2136

2919

except KeyError:

2137

try:

2138

uid = pwd.getpwnam("nobody").pw_uid

2139

gid = pwd.getpwnam("nobody").pw_gid

2140

except KeyError:

2141

uid = 65534

2142

gid = 65534

2920

continue

2921

else:

2922

uid = 65534

2923

gid = 65534

2143

2924

try:

2144

2925

os.setgid(gid)

2145

2926

os.setuid(uid)

2146

2927

except OSError as error:

2147

if error[0] != errno.EPERM:

2148

raise error

2928

if error.errno != errno.EPERM:

2929

raise

2149

2930

2150

2931

if debug:

2151

2932

# Enable all possible GnuTLS debugging

2152

2933

2153

2934

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

2154

2935

# - GnuTLS manual

2155

gnutls.library.functions.gnutls_global_set_log_level(11)

2936

gnutls.global_set_log_level(11)

2156

2937

2157

@gnutls.library.types.gnutls_log_func

2938

@gnutls.log_func

2158

2939

def debug_gnutls(level, string):

2159

2940

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

2160

2941

2161

(gnutls.library.functions

2162

.gnutls_global_set_log_function(debug_gnutls))

2942

gnutls.global_set_log_function(debug_gnutls)

2163

2943

2164

2944

# Redirect stdin so all checkers get /dev/null

2165

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

2945

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

2166

2946

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

2167

2947

if null > 2:

2168

2948

os.close(null)

2169

2949

2170

2950

# Need to fork before connecting to D-Bus

2171

if not debug:

2951

if not foreground:

2172

2952

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

2173

2953

daemon()

2174

2954

2955

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

2956

# need to inform gobject that threads will be used.

2175

2957

gobject.threads_init()

2176

2958

2177

2959

global main_loop

2178

2960

# From the Avahi example code

2179

DBusGMainLoop(set_as_default=True )

2961

DBusGMainLoop(set_as_default=True)

2180

2962

main_loop = gobject.MainLoop()

2181

2963

bus = dbus.SystemBus()

2182

2964

# End of Avahi example code

2183

2965

if use_dbus:

2184

2966

try:

2185

2967

bus_name = dbus.service.BusName("se.recompile.Mandos",

2186

bus, do_not_queue=True)

2187

old_bus_name = (dbus.service.BusName

2188

("se.bsnet.fukt.Mandos", bus,

2189

do_not_queue=True))

2190

except dbus.exceptions.NameExistsException as e:

2191

logger.error(unicode(e) + ", disabling D-Bus")

2968

bus,

2969

do_not_queue=True)

2970

old_bus_name = dbus.service.BusName(

2971

"se.bsnet.fukt.Mandos", bus,

2972

do_not_queue=True)

2973

except dbus.exceptions.DBusException as e:

2974

logger.error("Disabling D-Bus:", exc_info=e)

2192

2975

use_dbus = False

2193

2976

server_settings["use_dbus"] = False

2194

2977

tcp_server.use_dbus = False

2195

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2196

service = AvahiServiceToSyslog(name =

2197

server_settings["servicename"],

2198

servicetype = "_mandos._tcp",

2199

protocol = protocol, bus = bus)

2200

if server_settings["interface"]:

2201

service.interface = (if_nametoindex

2202

(str(server_settings["interface"])))

2978

if zeroconf:

2979

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2980

service = AvahiServiceToSyslog(

2981

name = server_settings["servicename"],

2982

servicetype = "_mandos._tcp",

2983

protocol = protocol,

2984

bus = bus)

2985

if server_settings["interface"]:

2986

service.interface = if_nametoindex(

2987

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

2203

2988

2204

2989

global multiprocessing_manager

2205

2990

multiprocessing_manager = multiprocessing.Manager()

2206

2991

2207

2992

client_class = Client

2208

2993

if use_dbus:

2209

client_class = functools.partial(ClientDBusTransitional,

2210

bus = bus)

2994

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

2211

2995

2212

2996

client_settings = Client.config_parser(client_config)

2213

2997

old_client_settings = {}

2214

2998

clients_data = {}

2215

2999

3000

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

3001

global wnull

3002

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

3003

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

3004

# mode

3005

if debug or not foreground:

3006

wnull.close()

3007

2216

3008

# Get client data and settings from last running state.

2217

3009

if server_settings["restore"]:

2218

3010

try:

2219

3011

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

2220

clients_data, old_client_settings = (pickle.load

2221

(stored_state))

3012

clients_data, old_client_settings = pickle.load(

3013

stored_state)

2222

3014

os.remove(stored_state_path)

2223

3015

except IOError as e:

2224

logger.warning("Could not load persistent state: {0}"

2225

.format(e))

2226

if e.errno != errno.ENOENT:

3016

if e.errno == errno.ENOENT:

3017

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

3018

" {}".format(os.strerror(e.errno)))

3019

else:

3020

logger.critical("Could not load persistent state:",

3021

exc_info=e)

2227

3022

raise

2228

3023

except EOFError as e:

2229

3024

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

2230

"EOFError: {0}".format(e))

3025

"EOFError:",

3026

exc_info=e)

2231

3027

2232

3028

with PGPEngine() as pgp:

2233

for client_name, client in clients_data.iteritems():

3029

for client_name, client in clients_data.items():

3030

# Skip removed clients

3031

if client_name not in client_settings:

3032

continue

3033

2234

3034

# Decide which value to use after restoring saved state.

2235

3035

# We have three different values: Old config file,

2236

3036

# new config file, and saved state.

2241

3041

# For each value in new config, check if it

2242

3042

# differs from the old config value (Except for

2243

3043

# the "secret" attribute)

2244

if (name != "secret" and

2245

value != old_client_settings[client_name]

2246

[name]):

3044

if (name != "secret"

3045

and (value !=

3046

old_client_settings[client_name][name])):

2247

3047

client[name] = value

2248

3048

except KeyError:

2249

3049

pass

2250

3050

2251

3051

# Clients who has passed its expire date can still be

2252

# enabled if its last checker was successful. Clients

2253

# whose checker failed before we stored its state is

2254

# assumed to have failed all checkers during downtime.

3052

# enabled if its last checker was successful. A Client

3053

# whose checker succeeded before we stored its state is

3054

# assumed to have successfully run all checkers during

3055

# downtime.

2255

3056

if client["enabled"]:

2256

3057

if datetime.datetime.utcnow() >= client["expires"]:

2257

3058

if not client["last_checked_ok"]:

2258

3059

logger.warning(

2259

"disabling client {0} - Client never "

2260

"performed a successfull checker"

2261

.format(client["name"]))

3060

"disabling client {} - Client never "

3061

"performed a successful checker".format(

3062

client_name))

2262

3063

client["enabled"] = False

2263

3064

elif client["last_checker_status"] != 0:

2264

3065

logger.warning(

2265

"disabling client {0} - Client "

2266

"last checker failed with error code {1}"

2267

.format(client["name"],

2268

client["last_checker_status"]))

3066

"disabling client {} - Client last"

3067

" checker failed with error code"

3068

" {}".format(

3069

client_name,

3070

client["last_checker_status"]))

2269

3071

client["enabled"] = False

2270

3072

else:

2271

client["expires"] = (datetime.datetime

2272

.utcnow()

2273

+ client["timeout"])

3073

client["expires"] = (

3074

datetime.datetime.utcnow()

3075

+ client["timeout"])

2274

3076

logger.debug("Last checker succeeded,"

2275

" keeping {0} enabled"

2276

.format(client["name"]))

3077

" keeping {} enabled".format(

3078

client_name))

2277

3079

try:

2278

client["secret"] = (

2279

pgp.decrypt(client["encrypted_secret"],

2280

client_settings[client_name]

2281

["secret"]))

3080

client["secret"] = pgp.decrypt(

3081

client["encrypted_secret"],

3082

client_settings[client_name]["secret"])

2282

3083

except PGPError:

2283

3084

# If decryption fails, we use secret from new settings

2284

logger.debug("Failed to decrypt {0} old secret"

2285

.format(client_name))

2286

client["secret"] = (

2287

client_settings[client_name]["secret"])

2288

3085

logger.debug("Failed to decrypt {} old secret".format(

3086

client_name))

3087

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

3088

["secret"])

2289

3089

2290

3090

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

2291

3091

for client_name in (set(old_client_settings)

2294

3094

for client_name in (set(client_settings)

2295

3095

- set(old_client_settings)):

2296

3096

clients_data[client_name] = client_settings[client_name]

2297

2298

# Create clients all clients

2299

for client_name, client in clients_data.iteritems():

3097

3098

# Create all client objects

3099

for client_name, client in clients_data.items():

2300

3100

tcp_server.clients[client_name] = client_class(

2301

name = client_name, settings = client)

3101

name = client_name,

3102

settings = client,

3103

server_settings = server_settings)

2302

3104

2303

3105

if not tcp_server.clients:

2304

3106

logger.warning("No clients defined")

2305

2306

if not debug:

2307

try:

2308

with pidfile:

2309

pid = os.getpid()

2310

pidfile.write(str(pid) + "\n".encode("utf-8"))

2311

del pidfile

2312

except IOError:

2313

logger.error("Could not write to file %r with PID %d",

2314

pidfilename, pid)

2315

except NameError:

2316

# "pidfile" was never created

2317

pass

3107

3108

if not foreground:

3109

if pidfile is not None:

3110

pid = os.getpid()

3111

try:

3112

with pidfile:

3113

print(pid, file=pidfile)

3114

except IOError:

3115

logger.error("Could not write to file %r with PID %d",

3116

pidfilename, pid)

3117

del pidfile

2318

3118

del pidfilename

2319

signal.signal(signal.SIGINT, signal.SIG_IGN)

2320

3119

2321

3120

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

2322

3121

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

2323

3122

2324

3123

if use_dbus:

2325

class MandosDBusService(dbus.service.Object):

3124

3125

@alternate_dbus_interfaces(

3126

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

3127

class MandosDBusService(DBusObjectWithObjectManager):

2326

3128

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

3129

2327

3130

def __init__(self):

2328

3131

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

3132

2329

3133

_interface = "se.recompile.Mandos"

2330

3134

2331

3135

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

2338

3142

"D-Bus signal"

2339

3143

pass

2340

3144

3145

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

3146

"true"})

2341

3147

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

2342

3148

def ClientRemoved(self, objpath, name):

2343

3149

"D-Bus signal"

2344

3150

pass

2345

3151

3152

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

3153

"true"})

2346

3154

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

2347

3155

def GetAllClients(self):

2348

3156

"D-Bus method"

2349

return dbus.Array(c.dbus_object_path

2350

for c in

3157

return dbus.Array(c.dbus_object_path for c in

2351

3158

tcp_server.clients.itervalues())

2352

3159

3160

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

3161

"true"})

2353

3162

@dbus.service.method(_interface,

2354

3163

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

2355

3164

def GetAllClientsWithProperties(self):

2356

3165

"D-Bus method"

2357

3166

return dbus.Dictionary(

2358

((c.dbus_object_path, c.GetAll(""))

2359

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

3167

{ c.dbus_object_path: c.GetAll(

3168

"se.recompile.Mandos.Client")

3169

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

2360

3170

signature="oa{sv}")

2361

3171

2362

3172

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

2366

3176

if c.dbus_object_path == object_path:

2367

3177

del tcp_server.clients[c.name]

2368

3178

c.remove_from_connection()

2369

# Don't signal anything except ClientRemoved

3179

# Don't signal the disabling

2370

3180

c.disable(quiet=True)

2371

# Emit D-Bus signal

2372

self.ClientRemoved(object_path, c.name)

3181

# Emit D-Bus signal for removal

3182

self.client_removed_signal(c)

2373

3183

return

2374

3184

raise KeyError(object_path)

2375

3185

2376

3186

del _interface

3187

3188

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3189

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

3190

def GetManagedObjects(self):

3191

"""D-Bus method"""

3192

return dbus.Dictionary(

3193

{ client.dbus_object_path:

3194

dbus.Dictionary(

3195

{ interface: client.GetAll(interface)

3196

for interface in

3197

client._get_all_interface_names()})

3198

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

3199

3200

def client_added_signal(self, client):

3201

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

3202

if use_dbus:

3203

# New standard signal

3204

self.InterfacesAdded(

3205

client.dbus_object_path,

3206

dbus.Dictionary(

3207

{ interface: client.GetAll(interface)

3208

for interface in

3209

client._get_all_interface_names()}))

3210

# Old signal

3211

self.ClientAdded(client.dbus_object_path)

3212

3213

def client_removed_signal(self, client):

3214

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

3215

if use_dbus:

3216

# New standard signal

3217

self.InterfacesRemoved(

3218

client.dbus_object_path,

3219

client._get_all_interface_names())

3220

# Old signal

3221

self.ClientRemoved(client.dbus_object_path,

3222

client.name)

2377

3223

2378

class MandosDBusServiceTransitional(MandosDBusService):

2379

__metaclass__ = AlternateDBusNamesMetaclass

2380

mandos_dbus_service = MandosDBusServiceTransitional()

3224

mandos_dbus_service = MandosDBusService()

2381

3225

2382

3226

def cleanup():

2383

3227

"Cleanup function; run on exit"

2384

service.cleanup()

3228

if zeroconf:

3229

service.cleanup()

2385

3230

2386

3231

multiprocessing.active_children()

3232

wnull.close()

2387

3233

if not (tcp_server.clients or client_settings):

2388

3234

return

2389

3235

2400

3246

2401

3247

# A list of attributes that can not be pickled

2402

3248

# + secret.

2403

exclude = set(("bus", "changedstate", "secret",

2404

"checker"))

2405

for name, typ in (inspect.getmembers

2406

(dbus.service.Object)):

3249

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

3250

"checker", "server_settings" }

3251

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

3252

.Object):

2407

3253

exclude.add(name)

2408

3254

2409

3255

client_dict["encrypted_secret"] = (client

2416

3262

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

2417

3263

2418

3264

try:

2419

tempfd, tempname = tempfile.mkstemp(suffix=".pickle",

2420

prefix="clients-",

2421

dir=os.path.dirname

2422

(stored_state_path))

2423

with os.fdopen(tempfd, "wb") as stored_state:

3265

with tempfile.NamedTemporaryFile(

3266

mode='wb',

3267

suffix=".pickle",

3268

prefix='clients-',

3269

dir=os.path.dirname(stored_state_path),

3270

delete=False) as stored_state:

2424

3271

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

3272

tempname = stored_state.name

2425

3273

os.rename(tempname, stored_state_path)

2426

3274

except (IOError, OSError) as e:

2427

logger.warning("Could not save persistent state: {0}"

2428

.format(e))

2429

3275

if not debug:

2430

3276

try:

2431

3277

os.remove(tempname)

2432

3278

except NameError:

2433

3279

pass

2434

if e.errno not in set((errno.ENOENT, errno.EACCES,

2435

errno.EEXIST)):

2436

raise e

3280

if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):

3281

logger.warning("Could not save persistent state: {}"

3282

.format(os.strerror(e.errno)))

3283

else:

3284

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

3285

exc_info=e)

3286

raise

2437

3287

2438

3288

# Delete all clients, and settings from config

2439

3289

while tcp_server.clients:

2440

3290

name, client = tcp_server.clients.popitem()

2441

3291

if use_dbus:

2442

3292

client.remove_from_connection()

2443

# Don't signal anything except ClientRemoved

3293

# Don't signal the disabling

2444

3294

client.disable(quiet=True)

3295

# Emit D-Bus signal for removal

2445

3296

if use_dbus:

2446

# Emit D-Bus signal

2447

mandos_dbus_service.ClientRemoved(client

2448

.dbus_object_path,

2449

client.name)

3297

mandos_dbus_service.client_removed_signal(client)

2450

3298

client_settings.clear()

2451

3299

2452

3300

atexit.register(cleanup)

2453

3301

2454

3302

for client in tcp_server.clients.itervalues():

2455

3303

if use_dbus:

2456

# Emit D-Bus signal

2457

mandos_dbus_service.ClientAdded(client.dbus_object_path)

3304

# Emit D-Bus signal for adding

3305

mandos_dbus_service.client_added_signal(client)

2458

3306

# Need to initiate checking of clients

2459

3307

if client.enabled:

2460

3308

client.init_checker()

2463

3311

tcp_server.server_activate()

2464

3312

2465

3313

# Find out what port we got

2466

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

3314

if zeroconf:

3315

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

2467

3316

if use_ipv6:

2468

3317

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

2469

" flowinfo %d, scope_id %d"

2470

% tcp_server.socket.getsockname())

3318

" flowinfo %d, scope_id %d",

3319

*tcp_server.socket.getsockname())

2471

3320

else: # IPv4

2472

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

2473

% tcp_server.socket.getsockname())

3321

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

3322

*tcp_server.socket.getsockname())

2474

3323

2475

3324

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

2476

3325

2477

3326

try:

2478

# From the Avahi example code

2479

try:

2480

service.activate()

2481

except dbus.exceptions.DBusException as error:

2482

logger.critical("DBusException: %s", error)

2483

cleanup()

2484

sys.exit(1)

2485

# End of Avahi example code

3327

if zeroconf:

3328

# From the Avahi example code

3329

try:

3330

service.activate()

3331

except dbus.exceptions.DBusException as error:

3332

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

3333

cleanup()

3334

sys.exit(1)

3335

# End of Avahi example code

2486

3336

2487

3337

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

2488

3338

lambda *args, **kwargs:

2492

3342

logger.debug("Starting main loop")

2493

3343

main_loop.run()

2494

3344

except AvahiError as error:

2495

logger.critical("AvahiError: %s", error)

3345

logger.critical("Avahi Error", exc_info=error)

2496

3346

cleanup()

2497

3347

sys.exit(1)

2498

3348

except KeyboardInterrupt:

2503

3353

# Must run before the D-Bus bus name gets deregistered

2504

3354

cleanup()

2505

3355

3356

2506

3357

if __name__ == '__main__':

2507

3358

main()