/mandos/trunk : revision 610

1

#!/usr/bin/python2.7

1

#!/usr/bin/python

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

79

import ctypes.util

80

import xml.dom.minidom

81

import inspect

82

import GnuPGInterface

82

83

84

try:

84

85

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

88

89

except ImportError:

89

90

SO_BINDTODEVICE = None

90

91

if sys.version_info.major == 2:

92

str = unicode

93

94

version = "1.6.9"

92

version = "1.6.0"

95

93

stored_state_file = "clients.pickle"

96

94

97

95

logger = logging.getLogger()

98

syslogger = None

96

syslogger = (logging.handlers.SysLogHandler

97

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

98

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

99

100

try:

101

if_nametoindex = (ctypes.cdll.LoadLibrary

107

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

108

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

109

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

110

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

111

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

110

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

111

interface))

112

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

113

ifreq[16:20])[0]

112

114

return interface_index

113

115

114

116

115

117

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

116

118

"""init logger and add loglevel"""

117

119

118

global syslogger

119

syslogger = (logging.handlers.SysLogHandler

120

(facility =

121

logging.handlers.SysLogHandler.LOG_DAEMON,

122

address = "/dev/log"))

123

120

syslogger.setFormatter(logging.Formatter

124

121

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

125

122

' %(message)s'))

143

140

class PGPEngine(object):

144

141

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

145

142

def __init__(self):

143

self.gnupg = GnuPGInterface.GnuPG()

146

144

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

147

self.gnupgargs = ['--batch',

148

'--home', self.tempdir,

149

'--force-mdc',

150

'--quiet',

151

'--no-use-agent']

145

self.gnupg = GnuPGInterface.GnuPG()

146

self.gnupg.options.meta_interactive = False

147

self.gnupg.options.homedir = self.tempdir

148

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

149

'--quiet',

150

'--no-use-agent'])

152

151

153

152

def __enter__(self):

154

153

return self

176

175

def password_encode(self, password):

177

176

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

178

177

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

179

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

180

if len(encoded) > 2048:

181

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

182

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

183

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

184

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

185

return encoded

178

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

186

179

187

180

def encrypt(self, data, password):

188

passphrase = self.password_encode(password)

189

with tempfile.NamedTemporaryFile(dir=self.tempdir

190

) as passfile:

191

passfile.write(passphrase)

192

passfile.flush()

193

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

194

'--passphrase-file',

195

passfile.name]

196

+ self.gnupgargs,

197

stdin = subprocess.PIPE,

198

stdout = subprocess.PIPE,

199

stderr = subprocess.PIPE)

200

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

201

if proc.returncode != 0:

202

raise PGPError(err)

181

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

182

with open(os.devnull, "w") as devnull:

183

try:

184

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

185

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

186

attach_fhs={'stderr': devnull})

187

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

188

f.write(data)

189

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

190

ciphertext = f.read()

191

proc.wait()

192

except IOError as e:

193

raise PGPError(e)

194

self.gnupg.passphrase = None

203

195

return ciphertext

204

196

205

197

def decrypt(self, data, password):

206

passphrase = self.password_encode(password)

207

with tempfile.NamedTemporaryFile(dir = self.tempdir

208

) as passfile:

209

passfile.write(passphrase)

210

passfile.flush()

211

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

212

'--passphrase-file',

213

passfile.name]

214

+ self.gnupgargs,

215

stdin = subprocess.PIPE,

216

stdout = subprocess.PIPE,

217

stderr = subprocess.PIPE)

218

decrypted_plaintext, err = proc.communicate(input

219

= data)

220

if proc.returncode != 0:

221

raise PGPError(err)

198

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

199

with open(os.devnull, "w") as devnull:

200

try:

201

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

202

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

203

attach_fhs={'stderr': devnull})

204

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

205

f.write(data)

206

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

207

decrypted_plaintext = f.read()

208

proc.wait()

209

except IOError as e:

210

raise PGPError(e)

211

self.gnupg.passphrase = None

222

212

return decrypted_plaintext

223

213

224

214

225

215

class AvahiError(Exception):

226

216

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

227

217

self.value = value

228

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

229

**kwargs)

218

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

219

def __unicode__(self):

220

return unicode(repr(self.value))

230

221

231

222

class AvahiServiceError(AvahiError):

232

223

pass

243

234

Used to optionally bind to the specified interface.

244

235

name: string; Example: 'Mandos'

245

236

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

246

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

237

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

247

238

port: integer; what port to announce

248

239

TXT: list of strings; TXT record for the service

249

240

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

275

266

self.bus = bus

276

267

self.entry_group_state_changed_match = None

277

268

278

def rename(self, remove=True):

269

def rename(self):

279

270

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

280

271

if self.rename_count >= self.max_renames:

281

272

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

282

273

" after %i retries, exiting.",

283

274

self.rename_count)

284

275

raise AvahiServiceError("Too many renames")

285

self.name = str(self.server

286

.GetAlternativeServiceName(self.name))

287

self.rename_count += 1

276

self.name = unicode(self.server

277

.GetAlternativeServiceName(self.name))

288

278

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

289

279

self.name)

290

if remove:

291

self.remove()

280

self.remove()

292

281

try:

293

282

self.add()

294

283

except dbus.exceptions.DBusException as error:

295

if (error.get_dbus_name()

296

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

297

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

298

return self.rename(remove=False)

299

else:

300

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

301

self.cleanup()

302

os._exit(1)

284

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

285

self.cleanup()

286

os._exit(1)

287

self.rename_count += 1

303

288

304

289

def remove(self):

305

290

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

343

328

self.rename()

344

329

elif state == avahi.ENTRY_GROUP_FAILURE:

345

330

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

346

str(error))

347

raise AvahiGroupError("State changed: {!s}"

331

unicode(error))

332

raise AvahiGroupError("State changed: {0!s}"

348

333

.format(error))

349

334

350

335

def cleanup(self):

397

382

398

383

399

384

class AvahiServiceToSyslog(AvahiService):

400

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

385

def rename(self):

401

386

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

402

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

387

ret = AvahiService.rename(self)

403

388

syslogger.setFormatter(logging.Formatter

404

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

389

('Mandos ({0}) [%(process)d]:'

405

390

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

406

391

.format(self.name)))

407

392

return ret

408

393

409

394

395

def timedelta_to_milliseconds(td):

396

"Convert a datetime.timedelta() to milliseconds"

397

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

398

+ (td.seconds * 1000)

399

+ (td.microseconds // 1000))

400

401

410

402

class Client(object):

411

403

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

412

404

448

440

runtime_expansions: Allowed attributes for runtime expansion.

449

441

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

450

442

disabled, or None

451

server_settings: The server_settings dict from main()

452

443

"""

453

444

454

445

runtime_expansions = ("approval_delay", "approval_duration",

467

458

"enabled": "True",

468

459

}

469

460

461

def timeout_milliseconds(self):

462

"Return the 'timeout' attribute in milliseconds"

463

return timedelta_to_milliseconds(self.timeout)

464

465

def extended_timeout_milliseconds(self):

466

"Return the 'extended_timeout' attribute in milliseconds"

467

return timedelta_to_milliseconds(self.extended_timeout)

468

469

def interval_milliseconds(self):

470

"Return the 'interval' attribute in milliseconds"

471

return timedelta_to_milliseconds(self.interval)

472

473

def approval_delay_milliseconds(self):

474

return timedelta_to_milliseconds(self.approval_delay)

475

470

476

@staticmethod

471

477

def config_parser(config):

472

478

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

497

503

"rb") as secfile:

498

504

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

499

505

else:

500

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

506

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

501

507

.format(section))

502

508

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

503

509

client["extended_timeout"] = string_to_delta(

514

520

515

521

return settings

516

522

517

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

523

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

518

524

self.name = name

519

if server_settings is None:

520

server_settings = {}

521

self.server_settings = server_settings

522

525

# adding all client settings

523

for setting, value in settings.items():

526

for setting, value in settings.iteritems():

524

527

setattr(self, setting, value)

525

528

526

529

if self.enabled:

609

612

if self.checker_initiator_tag is not None:

610

613

gobject.source_remove(self.checker_initiator_tag)

611

614

self.checker_initiator_tag = (gobject.timeout_add

612

(int(self.interval

613

.total_seconds() * 1000),

615

(self.interval_milliseconds(),

614

616

self.start_checker))

615

617

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

616

618

if self.disable_initiator_tag is not None:

617

619

gobject.source_remove(self.disable_initiator_tag)

618

620

self.disable_initiator_tag = (gobject.timeout_add

619

(int(self.timeout

620

.total_seconds() * 1000),

621

self.disable))

621

(self.timeout_milliseconds(),

622

self.disable))

622

623

# Also start a new checker *right now*.

623

624

self.start_checker()

624

625

655

656

self.disable_initiator_tag = None

656

657

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

657

658

self.disable_initiator_tag = (gobject.timeout_add

658

(int(timeout.total_seconds()

659

* 1000), self.disable))

659

(timedelta_to_milliseconds

660

(timeout), self.disable))

660

661

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

661

662

663

def need_approval(self):

679

680

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

680

681

try:

681

682

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

682

except AttributeError:

683

pass

684

except OSError as error:

685

if error.errno != errno.ECHILD:

686

raise

683

except (AttributeError, OSError) as error:

684

if (isinstance(error, OSError)

685

and error.errno != errno.ECHILD):

686

raise error

687

else:

688

if pid:

689

logger.warning("Checker was a zombie")

693

# Start a new checker if needed

694

if self.checker is None:

695

# Escape attributes for the shell

696

escaped_attrs = { attr:

697

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

698

for attr in self.runtime_expansions }

696

escaped_attrs = dict(

697

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

698

for attr in

699

self.runtime_expansions)

699

700

try:

700

701

command = self.checker_command % escaped_attrs

701

702

except TypeError as error:

710

711

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

711

712

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

712

713

# always replaced by /dev/null.)

713

# The exception is when not debugging but nevertheless

714

# running in the foreground; use the previously

715

# created wnull.

716

popen_args = {}

717

if (not self.server_settings["debug"]

718

and self.server_settings["foreground"]):

719

popen_args.update({"stdout": wnull,

720

"stderr": wnull })

721

714

self.checker = subprocess.Popen(command,

722

715

close_fds=True,

723

shell=True, cwd="/",

724

**popen_args)

716

shell=True, cwd="/")

725

717

except OSError as error:

726

718

logger.error("Failed to start subprocess",

727

719

exc_info=error)

736

728

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

737

729

except OSError as error:

738

730

if error.errno == errno.ECHILD:

739

# This should never happen

740

logger.error("Child process vanished",

741

exc_info=error)

731

logger.error("Child process vanished", exc_info=error)

742

732

return True

743

733

raise

744

734

if pid:

782

772

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

783

773

if byte_arrays and signature != "ay":

784

774

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

785

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

775

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

786

776

def decorator(func):

787

777

func._dbus_is_property = True

788

778

func._dbus_interface = dbus_interface

819

809

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

820

810

Usage:

821

811

822

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

823

"org.freedesktop.DBus.Property."

824

"EmitsChangedSignal": "false"})

825

812

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

826

813

access="r")

814

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

815

"org.freedesktop.DBus.Property."

816

"EmitsChangedSignal": "false"})

827

817

def Property_dbus_property(self):

828

818

return dbus.Boolean(False)

829

819

"""

836

826

class DBusPropertyException(dbus.exceptions.DBusException):

837

827

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

838

828

"""

839

pass

829

def __unicode__(self):

830

return unicode(str(self))

831

840

832

841

833

class DBusPropertyAccessException(DBusPropertyException):

842

834

"""A property's access permissions disallows an operation.

865

857

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

866

858

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

867

859

"""

868

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

860

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

869

861

False)

870

862

871

863

def _get_all_dbus_things(self, thing):

920

912

# The byte_arrays option is not supported yet on

921

913

# signatures other than "ay".

922

914

if prop._dbus_signature != "ay":

923

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

924

"'ay' signature {!r}"

925

.format(prop._dbus_signature))

915

raise ValueError

926

916

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

927

917

for byte in value))

928

918

prop(value)

952

942

value.variant_level+1)

953

943

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

954

944

955

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

956

def PropertiesChanged(self, interface_name, changed_properties,

957

invalidated_properties):

958

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

959

standard.

960

"""

961

pass

962

963

945

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

964

946

out_signature="s",

965

947

path_keyword='object_path',

1000

982

(prop,

1001

983

"_dbus_annotations",

1002

984

{}))

1003

for name, value in annots.items():

985

for name, value in annots.iteritems():

1004

986

ann_tag = document.createElement(

1005

987

"annotation")

1006

988

ann_tag.setAttribute("name", name)

1009

991

# Add interface annotation tags

1010

992

for annotation, value in dict(

1011

993

itertools.chain.from_iterable(

1012

annotations().items()

994

annotations().iteritems()

1013

995

for name, annotations in

1014

996

self._get_all_dbus_things("interface")

1015

997

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

1016

)).items():

998

)).iteritems():

1017

999

ann_tag = document.createElement("annotation")

1018

1000

ann_tag.setAttribute("name", annotation)

1019

1001

ann_tag.setAttribute("value", value)

1075

1057

"""

1076

1058

def wrapper(cls):

1077

1059

for orig_interface_name, alt_interface_name in (

1078

alt_interface_names.items()):

1060

alt_interface_names.iteritems()):

1079

1061

attr = {}

1080

1062

interface_names = set()

1081

1063

# Go though all attributes of the class

1094

1076

interface_names.add(alt_interface)

1095

1077

# Is this a D-Bus signal?

1096

1078

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

1097

# Extract the original non-method undecorated

1098

# function by black magic

1079

# Extract the original non-method function by

1080

# black magic

1099

1081

nonmethod_func = (dict(

1100

1082

zip(attribute.func_code.co_freevars,

1101

1083

attribute.__closure__))["func"]

1198

1180

attribute.func_closure)))

1199

1181

if deprecate:

1200

1182

# Deprecate all alternate interfaces

1201

iname="_AlternateDBusNames_interface_annotation{}"

1183

iname="_AlternateDBusNames_interface_annotation{0}"

1202

1184

for interface_name in interface_names:

1203

1185

@dbus_interface_annotations(interface_name)

1204

1186

def func(self):

1213

1195

if interface_names:

1214

1196

# Replace the class with a new subclass of it with

1215

1197

# methods, signals, etc. as created above.

1216

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

1198

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

1217

1199

(cls,), attr)

1218

1200

return cls

1219

1201

return wrapper

1232

1214

runtime_expansions = (Client.runtime_expansions

1233

1215

+ ("dbus_object_path",))

1234

1216

1235

_interface = "se.recompile.Mandos.Client"

1236

1237

1217

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

1238

1218

1239

1219

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

1241

1221

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

1242

1222

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

1243

1223

# the D-Bus

1244

client_object_name = str(self.name).translate(

1224

client_object_name = unicode(self.name).translate(

1245

1225

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

1246

1226

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

1247

1227

self.dbus_object_path = (dbus.ObjectPath

1251

1231

1252

1232

def notifychangeproperty(transform_func,

1253

1233

dbus_name, type_func=lambda x: x,

1254

variant_level=1, invalidate_only=False,

1255

_interface=_interface):

1234

variant_level=1):

1256

1235

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

1257

1236

its changes to DBus.

1258

1237

1263

1242

to the D-Bus. Default: no transform

1264

1243

variant_level: D-Bus variant level. Default: 1

1265

1244

"""

1266

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

1245

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

1267

1246

def setter(self, value):

1268

1247

if hasattr(self, "dbus_object_path"):

1269

1248

if (not hasattr(self, attrname) or

1270

1249

type_func(getattr(self, attrname, None))

1271

1250

!= type_func(value)):

1272

if invalidate_only:

1273

self.PropertiesChanged(_interface,

1274

dbus.Dictionary(),

1275

dbus.Array

1276

((dbus_name,)))

1277

else:

1278

dbus_value = transform_func(type_func(value),

1279

variant_level

1280

=variant_level)

1281

self.PropertyChanged(dbus.String(dbus_name),

1282

dbus_value)

1283

self.PropertiesChanged(_interface,

1284

dbus.Dictionary({

1285

dbus.String(dbus_name):

1286

dbus_value }), dbus.Array())

1251

dbus_value = transform_func(type_func(value),

1252

variant_level

1253

=variant_level)

1254

self.PropertyChanged(dbus.String(dbus_name),

1255

dbus_value)

1287

1256

setattr(self, attrname, value)

1288

1257

1289

1258

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

1309

1278

approval_delay = notifychangeproperty(dbus.UInt64,

1310

1279

"ApprovalDelay",

1311

1280

type_func =

1312

lambda td: td.total_seconds()

1313

* 1000)

1281

timedelta_to_milliseconds)

1314

1282

approval_duration = notifychangeproperty(

1315

1283

dbus.UInt64, "ApprovalDuration",

1316

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

1284

type_func = timedelta_to_milliseconds)

1317

1285

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

1318

1286

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

1319

type_func = lambda td:

1320

td.total_seconds() * 1000)

1287

type_func =

1288

timedelta_to_milliseconds)

1321

1289

extended_timeout = notifychangeproperty(

1322

1290

dbus.UInt64, "ExtendedTimeout",

1323

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

1291

type_func = timedelta_to_milliseconds)

1324

1292

interval = notifychangeproperty(dbus.UInt64,

1325

1293

"Interval",

1326

1294

type_func =

1327

lambda td: td.total_seconds()

1328

* 1000)

1295

timedelta_to_milliseconds)

1329

1296

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

1330

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

1331

invalidate_only=True)

1332

1297

1333

1298

del notifychangeproperty

1334

1299

1361

1326

*args, **kwargs)

1362

1327

1363

1328

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

1364

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

1329

old_checker = self.checker

1330

if self.checker is not None:

1331

old_checker_pid = self.checker.pid

1332

else:

1333

old_checker_pid = None

1365

1334

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

1366

1335

# Only if new checker process was started

1367

1336

if (self.checker is not None

1376

1345

1377

1346

def approve(self, value=True):

1378

1347

self.approved = value

1379

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

1380

* 1000), self._reset_approved)

1348

gobject.timeout_add(timedelta_to_milliseconds

1349

(self.approval_duration),

1350

self._reset_approved)

1381

1351

self.send_changedstate()

1382

1352

1383

1353

## D-Bus methods, signals & properties

1354

_interface = "se.recompile.Mandos.Client"

1384

1355

1385

1356

## Interfaces

1386

1357

1358

@dbus_interface_annotations(_interface)

1359

def _foo(self):

1360

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

1361

"false"}

1362

1387

1363

## Signals

1388

1364

1389

1365

# CheckerCompleted - signal

1399

1375

pass

1400

1376

1401

1377

# PropertyChanged - signal

1402

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

1403

1378

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

1404

1379

def PropertyChanged(self, property, value):

1405

1380

"D-Bus signal"

1481

1456

access="readwrite")

1482

1457

def ApprovalDelay_dbus_property(self, value=None):

1483

1458

if value is None: # get

1484

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

1485

* 1000)

1459

return dbus.UInt64(self.approval_delay_milliseconds())

1486

1460

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

1487

1461

1488

1462

# ApprovalDuration - property

1490

1464

access="readwrite")

1491

1465

def ApprovalDuration_dbus_property(self, value=None):

1492

1466

if value is None: # get

1493

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

1494

* 1000)

1467

return dbus.UInt64(timedelta_to_milliseconds(

1468

self.approval_duration))

1495

1469

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

1496

1470

1497

1471

# Name - property

1510

1484

def Host_dbus_property(self, value=None):

1511

1485

if value is None: # get

1512

1486

return dbus.String(self.host)

1513

self.host = str(value)

1487

self.host = unicode(value)

1514

1488

1515

1489

# Created - property

1516

1490

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

1563

1537

access="readwrite")

1564

1538

def Timeout_dbus_property(self, value=None):

1565

1539

if value is None: # get

1566

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

1540

return dbus.UInt64(self.timeout_milliseconds())

1567

1541

old_timeout = self.timeout

1568

1542

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

1569

1543

# Reschedule disabling

1580

1554

gobject.source_remove(self.disable_initiator_tag)

1581

1555

self.disable_initiator_tag = (

1582

1556

gobject.timeout_add(

1583

int((self.expires - now).total_seconds()

1584

* 1000), self.disable))

1557

timedelta_to_milliseconds(self.expires - now),

1558

self.disable))

1585

1559

1586

1560

# ExtendedTimeout - property

1587

1561

@dbus_service_property(_interface, signature="t",

1588

1562

access="readwrite")

1589

1563

def ExtendedTimeout_dbus_property(self, value=None):

1590

1564

if value is None: # get

1591

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

1592

* 1000)

1565

return dbus.UInt64(self.extended_timeout_milliseconds())

1593

1566

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

1594

1567

1595

1568

# Interval - property

1597

1570

access="readwrite")

1598

1571

def Interval_dbus_property(self, value=None):

1599

1572

if value is None: # get

1600

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

1573

return dbus.UInt64(self.interval_milliseconds())

1601

1574

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

1602

1575

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

1603

1576

return

1614

1587

def Checker_dbus_property(self, value=None):

1615

1588

if value is None: # get

1616

1589

return dbus.String(self.checker_command)

1617

self.checker_command = str(value)

1590

self.checker_command = unicode(value)

1618

1591

1619

1592

# CheckerRunning - property

1620

1593

@dbus_service_property(_interface, signature="b",

1636

1609

@dbus_service_property(_interface, signature="ay",

1637

1610

access="write", byte_arrays=True)

1638

1611

def Secret_dbus_property(self, value):

1639

self.secret = bytes(value)

1612

self.secret = str(value)

1640

1613

1641

1614

del _interface

1642

1615

1676

1649

def handle(self):

1677

1650

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

1678

1651

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

1679

str(self.client_address))

1652

unicode(self.client_address))

1680

1653

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

1681

1654

self.server.child_pipe.fileno())

1682

1655

1708

1681

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

1709

1682

try:

1710

1683

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

1711

raise RuntimeError(line)

1684

raise RuntimeError

1712

1685

except (ValueError, IndexError, RuntimeError) as error:

1713

1686

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

1714

1687

return

1763

1736

if self.server.use_dbus:

1764

1737

# Emit D-Bus signal

1765

1738

client.NeedApproval(

1766

client.approval_delay.total_seconds()

1767

* 1000, client.approved_by_default)

1739

client.approval_delay_milliseconds(),

1740

client.approved_by_default)

1768

1741

else:

1769

1742

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

1770

1743

client.name)

1776

1749

#wait until timeout or approved

1777

1750

time = datetime.datetime.now()

1778

1751

client.changedstate.acquire()

1779

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

1752

client.changedstate.wait(

1753

float(timedelta_to_milliseconds(delay)

1754

/ 1000))

1780

1755

client.changedstate.release()

1781

1756

time2 = datetime.datetime.now()

1782

1757

if (time2 - time) >= delay:

1919

1894

1920

1895

def add_pipe(self, parent_pipe, proc):

1921

1896

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

1922

raise NotImplementedError()

1897

raise NotImplementedError

1923

1898

1924

1899

1925

1900

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1981

1956

try:

1982

1957

self.socket.setsockopt(socket.SOL_SOCKET,

1983

1958

SO_BINDTODEVICE,

1984

(self.interface + "\0")

1985

.encode("utf-8"))

1959

str(self.interface + '\0'))

1986

1960

except socket.error as error:

1987

1961

if error.errno == errno.EPERM:

1988

1962

logger.error("No permission to bind to"

2002

1976

if self.address_family == socket.AF_INET6:

2003

1977

any_address = "::" # in6addr_any

2004

1978

else:

2005

any_address = "0.0.0.0" # INADDR_ANY

1979

any_address = socket.INADDR_ANY

2006

1980

self.server_address = (any_address,

2007

1981

self.server_address[1])

2008

1982

elif not self.server_address[1]:

2191

2165

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

2192

2166

frozenset((token_year, token_month,

2193

2167

token_day, token_time,

2194

token_week)))

2168

token_week))),

2195

2169

# Define starting values

2196

2170

value = datetime.timedelta() # Value so far

2197

2171

found_token = None

2198

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

2172

followers = frozenset(token_duration,) # Following valid tokens

2199

2173

s = duration # String left to parse

2200

2174

# Loop until end token is found

2201

2175

while found_token is not token_end:

2248

2222

timevalue = datetime.timedelta(0)

2249

2223

for s in interval.split():

2250

2224

try:

2251

suffix = s[-1]

2225

suffix = unicode(s[-1])

2252

2226

value = int(s[:-1])

2253

2227

if suffix == "d":

2254

2228

delta = datetime.timedelta(value)

2261

2235

elif suffix == "w":

2262

2236

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

2263

2237

else:

2264

raise ValueError("Unknown suffix {!r}"

2238

raise ValueError("Unknown suffix {0!r}"

2265

2239

.format(suffix))

2266

except IndexError as e:

2240

except (ValueError, IndexError) as e:

2267

2241

raise ValueError(*(e.args))

2268

2242

timevalue += delta

2269

2243

return timevalue

2284

2258

# Close all standard open file descriptors

2285

2259

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

2286

2260

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

2287

raise OSError(errno.ENODEV, "{} not a character device"

2261

raise OSError(errno.ENODEV,

2262

"{0} not a character device"

2288

2263

.format(os.devnull))

2289

2264

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

2290

2265

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

2300

2275

2301

2276

parser = argparse.ArgumentParser()

2302

2277

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

2303

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

2278

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

2304

2279

help="show version number and exit")

2305

2280

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

2306

2281

help="Bind to interface IF")

2312

2287

help="Run self-test")

2313

2288

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

2314

2289

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

2315

" to terminal", default=None)

2290

" to terminal")

2316

2291

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

2317

2292

help="Debug level for stdout output")

2318

2293

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

2325

2300

" files")

2326

2301

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

2327

2302

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

2328

" system bus interface", default=None)

2303

" system bus interface")

2329

2304

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

2330

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

2331

default=None)

2305

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

2332

2306

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

2333

2307

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

2334

" state", default=None)

2308

" state")

2335

2309

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

2336

2310

help="Specify a file descriptor to a network"

2337

2311

" socket to use instead of creating one")

2338

2312

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

2339

2313

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

2340

2314

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

2341

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

2342

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

2343

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

2344

default=None)

2315

help="Run in foreground")

2345

2316

2346

2317

options = parser.parse_args()

2347

2318

2348

2319

if options.check:

2349

2320

import doctest

2350

fail_count, test_count = doctest.testmod()

2351

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

2321

doctest.testmod()

2322

sys.exit()

2352

2323

2353

2324

# Default values for config file for server-global settings

2354

2325

server_defaults = { "interface": "",

2356

2327

"port": "",

2357

2328

"debug": "False",

2358

2329

"priority":

2359

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",

2330

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

2360

2331

"servicename": "Mandos",

2361

2332

"use_dbus": "True",

2362

2333

"use_ipv6": "True",

2365

2336

"socket": "",

2366

2337

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

2367

2338

"foreground": "False",

2368

"zeroconf": "True",

2369

2339

}

2370

2340

2371

2341

# Parse config file for server-global settings

2398

2368

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

2399

2369

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

2400

2370

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

2401

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

2371

"statedir", "socket", "foreground"):

2402

2372

value = getattr(options, option)

2403

2373

if value is not None:

2404

2374

server_settings[option] = value

2405

2375

del options

2406

2376

# Force all strings to be unicode

2407

2377

for option in server_settings.keys():

2408

if isinstance(server_settings[option], bytes):

2409

server_settings[option] = (server_settings[option]

2410

.decode("utf-8"))

2411

# Force all boolean options to be boolean

2412

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

2413

"foreground", "zeroconf"):

2414

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

2378

if type(server_settings[option]) is str:

2379

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

2415

2380

# Debug implies foreground

2416

2381

if server_settings["debug"]:

2417

2382

server_settings["foreground"] = True

2419

2384

2420

2385

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

2421

2386

2422

if (not server_settings["zeroconf"] and

2423

not (server_settings["port"]

2424

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

2425

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

2426

" Zeroconf")

2427

2428

2387

# For convenience

2429

2388

debug = server_settings["debug"]

2430

2389

debuglevel = server_settings["debuglevel"]

2433

2392

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

2434

2393

stored_state_file)

2435

2394

foreground = server_settings["foreground"]

2436

zeroconf = server_settings["zeroconf"]

2437

2395

2438

2396

if debug:

2439

2397

initlogger(debug, logging.DEBUG)

2446

2404

2447

2405

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

2448

2406

syslogger.setFormatter(logging.Formatter

2449

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

2407

('Mandos ({0}) [%(process)d]:'

2450

2408

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

2451

2409

.format(server_settings

2452

2410

["servicename"])))

2460

2418

global mandos_dbus_service

2461

2419

mandos_dbus_service = None

2462

2420

2463

socketfd = None

2464

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

2465

socketfd = server_settings["socket"]

2466

2421

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

2467

2422

server_settings["port"]),

2468

2423

ClientHandler,

2472

2427

gnutls_priority=

2473

2428

server_settings["priority"],

2474

2429

use_dbus=use_dbus,

2475

socketfd=socketfd)

2430

socketfd=(server_settings["socket"]

2431

or None))

2476

2432

if not foreground:

2477

pidfilename = "/run/mandos.pid"

2478

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

2479

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

2433

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

2480

2434

pidfile = None

2481

2435

try:

2482

2436

pidfile = open(pidfilename, "w")

2499

2453

os.setuid(uid)

2500

2454

except OSError as error:

2501

2455

if error.errno != errno.EPERM:

2502

raise

2456

raise error

2503

2457

2504

2458

if debug:

2505

2459

# Enable all possible GnuTLS debugging

2548

2502

use_dbus = False

2549

2503

server_settings["use_dbus"] = False

2550

2504

tcp_server.use_dbus = False

2551

if zeroconf:

2552

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2553

service = AvahiServiceToSyslog(name =

2554

server_settings["servicename"],

2555

servicetype = "_mandos._tcp",

2556

protocol = protocol, bus = bus)

2557

if server_settings["interface"]:

2558

service.interface = (if_nametoindex

2559

(server_settings["interface"]

2560

.encode("utf-8")))

2505

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2506

service = AvahiServiceToSyslog(name =

2507

server_settings["servicename"],

2508

servicetype = "_mandos._tcp",

2509

protocol = protocol, bus = bus)

2510

if server_settings["interface"]:

2511

service.interface = (if_nametoindex

2512

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

2561

2513

2562

2514

global multiprocessing_manager

2563

2515

multiprocessing_manager = multiprocessing.Manager()

2570

2522

old_client_settings = {}

2571

2523

clients_data = {}

2572

2524

2573

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

2574

global wnull

2575

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

2576

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

2577

# mode

2578

if debug or not foreground:

2579

wnull.close()

2580

2581

2525

# Get client data and settings from last running state.

2582

2526

if server_settings["restore"]:

2583

2527

try:

2587

2531

os.remove(stored_state_path)

2588

2532

except IOError as e:

2589

2533

if e.errno == errno.ENOENT:

2590

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

2534

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

2591

2535

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

2592

2536

else:

2593

2537

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

2598

2542

"EOFError:", exc_info=e)

2599

2543

2600

2544

with PGPEngine() as pgp:

2601

for client_name, client in clients_data.items():

2602

# Skip removed clients

2603

if client_name not in client_settings:

2604

continue

2605

2545

for client_name, client in clients_data.iteritems():

2606

2546

# Decide which value to use after restoring saved state.

2607

2547

# We have three different values: Old config file,

2608

2548

# new config file, and saved state.

2629

2569

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

2630

2570

if not client["last_checked_ok"]:

2631

2571

logger.warning(

2632

"disabling client {} - Client never "

2572

"disabling client {0} - Client never "

2633

2573

"performed a successful checker"

2634

2574

.format(client_name))

2635

2575

client["enabled"] = False

2636

2576

elif client["last_checker_status"] != 0:

2637

2577

logger.warning(

2638

"disabling client {} - Client last"

2639

" checker failed with error code {}"

2578

"disabling client {0} - Client "

2579

"last checker failed with error code {1}"

2640

2580

.format(client_name,

2641

2581

client["last_checker_status"]))

2642

2582

client["enabled"] = False

2645

2585

.utcnow()

2646

2586

+ client["timeout"])

2647

2587

logger.debug("Last checker succeeded,"

2648

" keeping {} enabled"

2588

" keeping {0} enabled"

2649

2589

.format(client_name))

2650

2590

try:

2651

2591

client["secret"] = (

2654

2594

["secret"]))

2655

2595

except PGPError:

2656

2596

# If decryption fails, we use secret from new settings

2657

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

2597

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

2658

2598

.format(client_name))

2659

2599

client["secret"] = (

2660

2600

client_settings[client_name]["secret"])

2668

2608

clients_data[client_name] = client_settings[client_name]

2669

2609

2670

2610

# Create all client objects

2671

for client_name, client in clients_data.items():

2611

for client_name, client in clients_data.iteritems():

2672

2612

tcp_server.clients[client_name] = client_class(

2673

name = client_name, settings = client,

2674

server_settings = server_settings)

2613

name = client_name, settings = client)

2675

2614

2676

2615

if not tcp_server.clients:

2677

2616

logger.warning("No clients defined")

2681

2620

try:

2682

2621

with pidfile:

2683

2622

pid = os.getpid()

2684

pidfile.write("{}\n".format(pid).encode("utf-8"))

2623

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

2685

2624

except IOError:

2686

2625

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

2687

2626

pidfilename, pid)

2733

2672

def GetAllClientsWithProperties(self):

2734

2673

"D-Bus method"

2735

2674

return dbus.Dictionary(

2736

{ c.dbus_object_path: c.GetAll("")

2737

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

2675

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

2676

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

2738

2677

signature="oa{sv}")

2739

2678

2740

2679

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

2757

2696

2758

2697

def cleanup():

2759

2698

"Cleanup function; run on exit"

2760

if zeroconf:

2761

service.cleanup()

2699

service.cleanup()

2762

2700

2763

2701

multiprocessing.active_children()

2764

wnull.close()

2765

2702

if not (tcp_server.clients or client_settings):

2766

2703

return

2767

2704

2778

2715

2779

2716

# A list of attributes that can not be pickled

2780

2717

# + secret.

2781

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

2782

"checker", "server_settings" }

2718

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

2719

"checker"))

2783

2720

for name, typ in (inspect.getmembers

2784

2721

(dbus.service.Object)):

2785

2722

exclude.add(name)

2808

2745

except NameError:

2809

2746

pass

2810

2747

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

2811

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

2748

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

2812

2749

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

2813

2750

else:

2814

2751

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

2815

2752

exc_info=e)

2816

raise

2753

raise e

2817

2754

2818

2755

# Delete all clients, and settings from config

2819

2756

while tcp_server.clients:

2843

2780

tcp_server.server_activate()

2844

2781

2845

2782

# Find out what port we got

2846

if zeroconf:

2847

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

2783

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

2848

2784

if use_ipv6:

2849

2785

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

2850

2786

" flowinfo %d, scope_id %d",

2856

2792

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

2857

2793

2858

2794

try:

2859

if zeroconf:

2860

# From the Avahi example code

2861

try:

2862

service.activate()

2863

except dbus.exceptions.DBusException as error:

2864

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

2865

cleanup()

2866

sys.exit(1)

2867

# End of Avahi example code

2795

# From the Avahi example code

2796

try:

2797

service.activate()

2798

except dbus.exceptions.DBusException as error:

2799

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

2800

cleanup()

2801

sys.exit(1)

2802

# End of Avahi example code

2868

2803

2869

2804

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

2870

2805

lambda *args, **kwargs: