/mandos/release : revision 237.7.159

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.

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

276

self.name = unicode(self.server

277

.GetAlternativeServiceName(self.name))

287

278

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

288

279

self.name)

289

280

self.remove()

337

328

self.rename()

338

329

elif state == avahi.ENTRY_GROUP_FAILURE:

339

330

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

340

str(error))

341

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

331

unicode(error))

332

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

342

333

.format(error))

343

334

344

335

def cleanup(self):

395

386

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

396

387

ret = AvahiService.rename(self)

397

388

syslogger.setFormatter(logging.Formatter

398

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

389

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

399

390

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

400

391

.format(self.name)))

401

392

return ret

402

393

403

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

404

402

class Client(object):

405

403

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

406

404

442

440

runtime_expansions: Allowed attributes for runtime expansion.

443

441

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

444

442

disabled, or None

445

server_settings: The server_settings dict from main()

446

443

"""

447

444

448

445

runtime_expansions = ("approval_delay", "approval_duration",

461

458

"enabled": "True",

462

459

}

463

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

464

476

@staticmethod

465

477

def config_parser(config):

466

478

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

491

503

"rb") as secfile:

492

504

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

493

505

else:

494

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

506

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

495

507

.format(section))

496

508

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

497

509

client["extended_timeout"] = string_to_delta(

508

520

509

521

return settings

510

522

511

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

523

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

512

524

self.name = name

513

if server_settings is None:

514

server_settings = {}

515

self.server_settings = server_settings

516

525

# adding all client settings

517

for setting, value in settings.items():

526

for setting, value in settings.iteritems():

518

527

setattr(self, setting, value)

519

528

520

529

if self.enabled:

603

612

if self.checker_initiator_tag is not None:

604

613

gobject.source_remove(self.checker_initiator_tag)

605

614

self.checker_initiator_tag = (gobject.timeout_add

606

(int(self.interval

607

.total_seconds() * 1000),

615

(self.interval_milliseconds(),

608

616

self.start_checker))

609

617

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

610

618

if self.disable_initiator_tag is not None:

611

619

gobject.source_remove(self.disable_initiator_tag)

612

620

self.disable_initiator_tag = (gobject.timeout_add

613

(int(self.timeout

614

.total_seconds() * 1000),

615

self.disable))

621

(self.timeout_milliseconds(),

622

self.disable))

616

623

# Also start a new checker *right now*.

617

624

self.start_checker()

618

625

649

656

self.disable_initiator_tag = None

650

657

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

651

658

self.disable_initiator_tag = (gobject.timeout_add

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

659

(timedelta_to_milliseconds

660

(timeout), self.disable))

654

661

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

655

662

656

663

def need_approval(self):

673

680

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

674

681

try:

675

682

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

676

except AttributeError:

677

pass

678

except OSError as error:

679

if error.errno != errno.ECHILD:

680

raise

683

except (AttributeError, OSError) as error:

684

if (isinstance(error, OSError)

685

and error.errno != errno.ECHILD):

686

raise error

681

687

else:

682

688

if pid:

683

689

logger.warning("Checker was a zombie")

687

693

# Start a new checker if needed

688

694

if self.checker is None:

689

695

# Escape attributes for the shell

690

escaped_attrs = { attr:

691

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

692

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)

693

700

try:

694

701

command = self.checker_command % escaped_attrs

695

702

except TypeError as error:

704

711

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

705

712

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

706

713

# always replaced by /dev/null.)

707

# The exception is when not debugging but nevertheless

708

# running in the foreground; use the previously

709

# created wnull.

710

popen_args = {}

711

if (not self.server_settings["debug"]

712

and self.server_settings["foreground"]):

713

popen_args.update({"stdout": wnull,

714

"stderr": wnull })

715

714

self.checker = subprocess.Popen(command,

716

715

close_fds=True,

717

shell=True, cwd="/",

718

**popen_args)

716

shell=True, cwd="/")

719

717

except OSError as error:

720

718

logger.error("Failed to start subprocess",

721

719

exc_info=error)

776

774

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

777

775

if byte_arrays and signature != "ay":

778

776

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

779

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

777

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

780

778

def decorator(func):

781

779

func._dbus_is_property = True

782

780

func._dbus_interface = dbus_interface

813

811

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

814

812

Usage:

815

813

816

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

817

"org.freedesktop.DBus.Property."

818

"EmitsChangedSignal": "false"})

819

814

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

820

815

access="r")

816

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

817

"org.freedesktop.DBus.Property."

818

"EmitsChangedSignal": "false"})

821

819

def Property_dbus_property(self):

822

820

return dbus.Boolean(False)

823

821

"""

830

828

class DBusPropertyException(dbus.exceptions.DBusException):

831

829

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

832

830

"""

833

pass

831

def __unicode__(self):

832

return unicode(str(self))

833

834

835

class DBusPropertyAccessException(DBusPropertyException):

836

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

859

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

860

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

861

"""

862

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

862

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

863

False)

864

865

def _get_all_dbus_things(self, thing):

914

# The byte_arrays option is not supported yet on

915

# signatures other than "ay".

916

if prop._dbus_signature != "ay":

917

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

918

"'ay' signature {!r}"

919

.format(prop._dbus_signature))

917

raise ValueError

920

918

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

921

919

for byte in value))

922

920

prop(value)

946

944

value.variant_level+1)

947

945

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

948

946

949

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

950

def PropertiesChanged(self, interface_name, changed_properties,

951

invalidated_properties):

952

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

953

standard.

954

"""

955

pass

956

957

947

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

958

948

out_signature="s",

959

949

path_keyword='object_path',

994

984

(prop,

995

985

"_dbus_annotations",

996

986

{}))

997

for name, value in annots.items():

987

for name, value in annots.iteritems():

998

988

ann_tag = document.createElement(

999

989

"annotation")

1000

990

ann_tag.setAttribute("name", name)

1003

993

# Add interface annotation tags

1004

994

for annotation, value in dict(

1005

995

itertools.chain.from_iterable(

1006

annotations().items()

996

annotations().iteritems()

1007

997

for name, annotations in

1008

998

self._get_all_dbus_things("interface")

1009

999

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

1010

)).items():

1000

)).iteritems():

1011

1001

ann_tag = document.createElement("annotation")

1012

1002

ann_tag.setAttribute("name", annotation)

1013

1003

ann_tag.setAttribute("value", value)

1069

1059

"""

1070

1060

def wrapper(cls):

1071

1061

for orig_interface_name, alt_interface_name in (

1072

alt_interface_names.items()):

1062

alt_interface_names.iteritems()):

1073

1063

attr = {}

1074

1064

interface_names = set()

1075

1065

# Go though all attributes of the class

1088

1078

interface_names.add(alt_interface)

1089

1079

# Is this a D-Bus signal?

1090

1080

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

1091

# Extract the original non-method undecorated

1092

# function by black magic

1081

# Extract the original non-method function by

1082

# black magic

1093

1083

nonmethod_func = (dict(

1094

1084

zip(attribute.func_code.co_freevars,

1095

1085

attribute.__closure__))["func"]

1192

1182

attribute.func_closure)))

1193

1183

if deprecate:

1194

1184

# Deprecate all alternate interfaces

1195

iname="_AlternateDBusNames_interface_annotation{}"

1185

iname="_AlternateDBusNames_interface_annotation{0}"

1196

1186

for interface_name in interface_names:

1197

1187

@dbus_interface_annotations(interface_name)

1198

1188

def func(self):

1207

1197

if interface_names:

1208

1198

# Replace the class with a new subclass of it with

1209

1199

# methods, signals, etc. as created above.

1210

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

1200

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

1211

1201

(cls,), attr)

1212

1202

return cls

1213

1203

return wrapper

1226

1216

runtime_expansions = (Client.runtime_expansions

1227

1217

+ ("dbus_object_path",))

1228

1218

1229

_interface = "se.recompile.Mandos.Client"

1230

1231

1219

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

1232

1220

1233

1221

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

1235

1223

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

1236

1224

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

1237

1225

# the D-Bus

1238

client_object_name = str(self.name).translate(

1226

client_object_name = unicode(self.name).translate(

1239

1227

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

1240

1228

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

1241

1229

self.dbus_object_path = (dbus.ObjectPath

1245

1233

1246

1234

def notifychangeproperty(transform_func,

1247

1235

dbus_name, type_func=lambda x: x,

1248

variant_level=1, invalidate_only=False,

1249

_interface=_interface):

1236

variant_level=1):

1250

1237

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

1251

1238

its changes to DBus.

1252

1239

1257

1244

to the D-Bus. Default: no transform

1258

1245

variant_level: D-Bus variant level. Default: 1

1259

1246

"""

1260

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

1247

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

1261

1248

def setter(self, value):

1262

1249

if hasattr(self, "dbus_object_path"):

1263

1250

if (not hasattr(self, attrname) or

1264

1251

type_func(getattr(self, attrname, None))

1265

1252

!= type_func(value)):

1266

if invalidate_only:

1267

self.PropertiesChanged(_interface,

1268

dbus.Dictionary(),

1269

dbus.Array

1270

((dbus_name,)))

1271

else:

1272

dbus_value = transform_func(type_func(value),

1273

variant_level

1274

=variant_level)

1275

self.PropertyChanged(dbus.String(dbus_name),

1276

dbus_value)

1277

self.PropertiesChanged(_interface,

1278

dbus.Dictionary({

1279

dbus.String(dbus_name):

1280

dbus_value }), dbus.Array())

1253

dbus_value = transform_func(type_func(value),

1254

variant_level

1255

=variant_level)

1256

self.PropertyChanged(dbus.String(dbus_name),

1257

dbus_value)

1281

1258

setattr(self, attrname, value)

1282

1259

1283

1260

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

1303

1280

approval_delay = notifychangeproperty(dbus.UInt64,

1304

1281

"ApprovalDelay",

1305

1282

type_func =

1306

lambda td: td.total_seconds()

1307

* 1000)

1283

timedelta_to_milliseconds)

1308

1284

approval_duration = notifychangeproperty(

1309

1285

dbus.UInt64, "ApprovalDuration",

1310

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

1286

type_func = timedelta_to_milliseconds)

1311

1287

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

1312

1288

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

1313

type_func = lambda td:

1314

td.total_seconds() * 1000)

1289

type_func =

1290

timedelta_to_milliseconds)

1315

1291

extended_timeout = notifychangeproperty(

1316

1292

dbus.UInt64, "ExtendedTimeout",

1317

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

1293

type_func = timedelta_to_milliseconds)

1318

1294

interval = notifychangeproperty(dbus.UInt64,

1319

1295

"Interval",

1320

1296

type_func =

1321

lambda td: td.total_seconds()

1322

* 1000)

1297

timedelta_to_milliseconds)

1323

1298

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

1324

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

1325

invalidate_only=True)

1326

1299

1327

1300

del notifychangeproperty

1328

1301

1355

1328

*args, **kwargs)

1356

1329

1357

1330

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

1358

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

1331

old_checker = self.checker

1332

if self.checker is not None:

1333

old_checker_pid = self.checker.pid

1334

else:

1335

old_checker_pid = None

1359

1336

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

1360

1337

# Only if new checker process was started

1361

1338

if (self.checker is not None

1370

1347

1371

1348

def approve(self, value=True):

1372

1349

self.approved = value

1373

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

1374

* 1000), self._reset_approved)

1350

gobject.timeout_add(timedelta_to_milliseconds

1351

(self.approval_duration),

1352

self._reset_approved)

1375

1353

self.send_changedstate()

1376

1354

1377

1355

## D-Bus methods, signals & properties

1356

_interface = "se.recompile.Mandos.Client"

1378

1357

1379

1358

## Interfaces

1380

1359

1360

@dbus_interface_annotations(_interface)

1361

def _foo(self):

1362

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

1363

"false"}

1364

1381

1365

## Signals

1382

1366

1383

1367

# CheckerCompleted - signal

1393

1377

pass

1394

1378

1395

1379

# PropertyChanged - signal

1396

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

1397

1380

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

1398

1381

def PropertyChanged(self, property, value):

1399

1382

"D-Bus signal"

1475

1458

access="readwrite")

1476

1459

def ApprovalDelay_dbus_property(self, value=None):

1477

1460

if value is None: # get

1478

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

1479

* 1000)

1461

return dbus.UInt64(self.approval_delay_milliseconds())

1480

1462

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

1481

1463

1482

1464

# ApprovalDuration - property

1484

1466

access="readwrite")

1485

1467

def ApprovalDuration_dbus_property(self, value=None):

1486

1468

if value is None: # get

1487

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

1488

* 1000)

1469

return dbus.UInt64(timedelta_to_milliseconds(

1470

self.approval_duration))

1489

1471

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

1490

1472

1491

1473

# Name - property

1504

1486

def Host_dbus_property(self, value=None):

1505

1487

if value is None: # get

1506

1488

return dbus.String(self.host)

1507

self.host = str(value)

1489

self.host = unicode(value)

1508

1490

1509

1491

# Created - property

1510

1492

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

1557

1539

access="readwrite")

1558

1540

def Timeout_dbus_property(self, value=None):

1559

1541

if value is None: # get

1560

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

1542

return dbus.UInt64(self.timeout_milliseconds())

1561

1543

old_timeout = self.timeout

1562

1544

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

1563

1545

# Reschedule disabling

1574

1556

gobject.source_remove(self.disable_initiator_tag)

1575

1557

self.disable_initiator_tag = (

1576

1558

gobject.timeout_add(

1577

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

1578

* 1000), self.disable))

1559

timedelta_to_milliseconds(self.expires - now),

1560

self.disable))

1579

1561

1580

1562

# ExtendedTimeout - property

1581

1563

@dbus_service_property(_interface, signature="t",

1582

1564

access="readwrite")

1583

1565

def ExtendedTimeout_dbus_property(self, value=None):

1584

1566

if value is None: # get

1585

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

1586

* 1000)

1567

return dbus.UInt64(self.extended_timeout_milliseconds())

1587

1568

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

1588

1569

1589

1570

# Interval - property

1591

1572

access="readwrite")

1592

1573

def Interval_dbus_property(self, value=None):

1593

1574

if value is None: # get

1594

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

1575

return dbus.UInt64(self.interval_milliseconds())

1595

1576

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

1596

1577

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

1597

1578

return

1608

1589

def Checker_dbus_property(self, value=None):

1609

1590

if value is None: # get

1610

1591

return dbus.String(self.checker_command)

1611

self.checker_command = str(value)

1592

self.checker_command = unicode(value)

1612

1593

1613

1594

# CheckerRunning - property

1614

1595

@dbus_service_property(_interface, signature="b",

1630

1611

@dbus_service_property(_interface, signature="ay",

1631

1612

access="write", byte_arrays=True)

1632

1613

def Secret_dbus_property(self, value):

1633

self.secret = bytes(value)

1614

self.secret = str(value)

1634

1615

1635

1616

del _interface

1636

1617

1670

1651

def handle(self):

1671

1652

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

1672

1653

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

1673

str(self.client_address))

1654

unicode(self.client_address))

1674

1655

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

1675

1656

self.server.child_pipe.fileno())

1676

1657

1702

1683

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

1703

1684

try:

1704

1685

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

1705

raise RuntimeError(line)

1686

raise RuntimeError

1706

1687

except (ValueError, IndexError, RuntimeError) as error:

1707

1688

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

1708

1689

return

1757

1738

if self.server.use_dbus:

1758

1739

# Emit D-Bus signal

1759

1740

client.NeedApproval(

1760

client.approval_delay.total_seconds()

1761

* 1000, client.approved_by_default)

1741

client.approval_delay_milliseconds(),

1742

client.approved_by_default)

1762

1743

else:

1763

1744

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

1764

1745

client.name)

1770

1751

#wait until timeout or approved

1771

1752

time = datetime.datetime.now()

1772

1753

client.changedstate.acquire()

1773

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

1754

client.changedstate.wait(

1755

float(timedelta_to_milliseconds(delay)

1756

/ 1000))

1774

1757

client.changedstate.release()

1775

1758

time2 = datetime.datetime.now()

1776

1759

if (time2 - time) >= delay:

1913

1896

1914

1897

def add_pipe(self, parent_pipe, proc):

1915

1898

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

1916

raise NotImplementedError()

1899

raise NotImplementedError

1917

1900

1918

1901

1919

1902

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1975

1958

try:

1976

1959

self.socket.setsockopt(socket.SOL_SOCKET,

1977

1960

SO_BINDTODEVICE,

1978

(self.interface + "\0")

1979

.encode("utf-8"))

1961

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

1980

1962

except socket.error as error:

1981

1963

if error.errno == errno.EPERM:

1982

1964

logger.error("No permission to bind to"

1996

1978

if self.address_family == socket.AF_INET6:

1997

1979

any_address = "::" # in6addr_any

1998

1980

else:

1999

any_address = "0.0.0.0" # INADDR_ANY

1981

any_address = socket.INADDR_ANY

2000

1982

self.server_address = (any_address,

2001

1983

self.server_address[1])

2002

1984

elif not self.server_address[1]:

2185

2167

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

2186

2168

frozenset((token_year, token_month,

2187

2169

token_day, token_time,

2188

token_week)))

2170

token_week))),

2189

2171

# Define starting values

2190

2172

value = datetime.timedelta() # Value so far

2191

2173

found_token = None

2192

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

2174

followers = frozenset(token_duration,) # Following valid tokens

2193

2175

s = duration # String left to parse

2194

2176

# Loop until end token is found

2195

2177

while found_token is not token_end:

2242

2224

timevalue = datetime.timedelta(0)

2243

2225

for s in interval.split():

2244

2226

try:

2245

suffix = s[-1]

2227

suffix = unicode(s[-1])

2246

2228

value = int(s[:-1])

2247

2229

if suffix == "d":

2248

2230

delta = datetime.timedelta(value)

2255

2237

elif suffix == "w":

2256

2238

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

2257

2239

else:

2258

raise ValueError("Unknown suffix {!r}"

2240

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

2259

2241

.format(suffix))

2260

except IndexError as e:

2242

except (ValueError, IndexError) as e:

2261

2243

raise ValueError(*(e.args))

2262

2244

timevalue += delta

2263

2245

return timevalue

2278

2260

# Close all standard open file descriptors

2279

2261

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

2280

2262

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

2281

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

2263

raise OSError(errno.ENODEV,

2264

"{0} not a character device"

2282

2265

.format(os.devnull))

2283

2266

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

2284

2267

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

2294

2277

2295

2278

parser = argparse.ArgumentParser()

2296

2279

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

2297

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

2280

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

2298

2281

help="show version number and exit")

2299

2282

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

2300

2283

help="Bind to interface IF")

2306

2289

help="Run self-test")

2307

2290

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

2308

2291

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

2309

" to terminal", default=None)

2292

" to terminal")

2310

2293

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

2311

2294

help="Debug level for stdout output")

2312

2295

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

2319

2302

" files")

2320

2303

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

2321

2304

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

2322

" system bus interface", default=None)

2305

" system bus interface")

2323

2306

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

2324

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

2325

default=None)

2307

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

2326

2308

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

2327

2309

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

2328

" state", default=None)

2310

" state")

2329

2311

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

2330

2312

help="Specify a file descriptor to a network"

2331

2313

" socket to use instead of creating one")

2332

2314

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

2333

2315

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

2334

2316

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

2335

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

2336

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

2337

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

2338

default=None)

2317

help="Run in foreground")

2339

2318

2340

2319

options = parser.parse_args()

2341

2320

2342

2321

if options.check:

2343

2322

import doctest

2344

fail_count, test_count = doctest.testmod()

2345

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

2323

doctest.testmod()

2324

sys.exit()

2346

2325

2347

2326

# Default values for config file for server-global settings

2348

2327

server_defaults = { "interface": "",

2350

2329

"port": "",

2351

2330

"debug": "False",

2352

2331

"priority":

2353

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

2332

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

2354

2333

"servicename": "Mandos",

2355

2334

"use_dbus": "True",

2356

2335

"use_ipv6": "True",

2359

2338

"socket": "",

2360

2339

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

2361

2340

"foreground": "False",

2362

"zeroconf": "True",

2363

2341

}

2364

2342

2365

2343

# Parse config file for server-global settings

2392

2370

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

2393

2371

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

2394

2372

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

2395

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

2373

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

2396

2374

value = getattr(options, option)

2397

2375

if value is not None:

2398

2376

server_settings[option] = value

2399

2377

del options

2400

2378

# Force all strings to be unicode

2401

2379

for option in server_settings.keys():

2402

if isinstance(server_settings[option], bytes):

2403

server_settings[option] = (server_settings[option]

2404

.decode("utf-8"))

2405

# Force all boolean options to be boolean

2406

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

2407

"foreground", "zeroconf"):

2408

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

2380

if type(server_settings[option]) is str:

2381

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

2409

2382

# Debug implies foreground

2410

2383

if server_settings["debug"]:

2411

2384

server_settings["foreground"] = True

2413

2386

2414

2387

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

2415

2388

2416

if (not server_settings["zeroconf"] and

2417

not (server_settings["port"]

2418

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

2419

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

2420

" Zeroconf")

2421

2422

2389

# For convenience

2423

2390

debug = server_settings["debug"]

2424

2391

debuglevel = server_settings["debuglevel"]

2427

2394

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

2428

2395

stored_state_file)

2429

2396

foreground = server_settings["foreground"]

2430

zeroconf = server_settings["zeroconf"]

2431

2397

2432

2398

if debug:

2433

2399

initlogger(debug, logging.DEBUG)

2440

2406

2441

2407

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

2442

2408

syslogger.setFormatter(logging.Formatter

2443

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

2409

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

2444

2410

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

2445

2411

.format(server_settings

2446

2412

["servicename"])))

2454

2420

global mandos_dbus_service

2455

2421

mandos_dbus_service = None

2456

2422

2457

socketfd = None

2458

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

2459

socketfd = server_settings["socket"]

2460

2423

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

2461

2424

server_settings["port"]),

2462

2425

ClientHandler,

2466

2429

gnutls_priority=

2467

2430

server_settings["priority"],

2468

2431

use_dbus=use_dbus,

2469

socketfd=socketfd)

2432

socketfd=(server_settings["socket"]

2433

or None))

2470

2434

if not foreground:

2471

pidfilename = "/run/mandos.pid"

2472

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

2473

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

2435

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

2474

2436

pidfile = None

2475

2437

try:

2476

2438

pidfile = open(pidfilename, "w")

2493

2455

os.setuid(uid)

2494

2456

except OSError as error:

2495

2457

if error.errno != errno.EPERM:

2496

raise

2458

raise error

2497

2459

2498

2460

if debug:

2499

2461

# Enable all possible GnuTLS debugging

2542

2504

use_dbus = False

2543

2505

server_settings["use_dbus"] = False

2544

2506

tcp_server.use_dbus = False

2545

if zeroconf:

2546

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2547

service = AvahiServiceToSyslog(name =

2548

server_settings["servicename"],

2549

servicetype = "_mandos._tcp",

2550

protocol = protocol, bus = bus)

2551

if server_settings["interface"]:

2552

service.interface = (if_nametoindex

2553

(server_settings["interface"]

2554

.encode("utf-8")))

2507

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2508

service = AvahiServiceToSyslog(name =

2509

server_settings["servicename"],

2510

servicetype = "_mandos._tcp",

2511

protocol = protocol, bus = bus)

2512

if server_settings["interface"]:

2513

service.interface = (if_nametoindex

2514

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

2555

2515

2556

2516

global multiprocessing_manager

2557

2517

multiprocessing_manager = multiprocessing.Manager()

2564

2524

old_client_settings = {}

2565

2525

clients_data = {}

2566

2526

2567

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

2568

global wnull

2569

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

2570

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

2571

# mode

2572

if debug or not foreground:

2573

wnull.close()

2574

2575

2527

# Get client data and settings from last running state.

2576

2528

if server_settings["restore"]:

2577

2529

try:

2581

2533

os.remove(stored_state_path)

2582

2534

except IOError as e:

2583

2535

if e.errno == errno.ENOENT:

2584

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

2536

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

2585

2537

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

2586

2538

else:

2587

2539

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

2592

2544

"EOFError:", exc_info=e)

2593

2545

2594

2546

with PGPEngine() as pgp:

2595

for client_name, client in clients_data.items():

2596

# Skip removed clients

2597

if client_name not in client_settings:

2598

continue

2599

2547

for client_name, client in clients_data.iteritems():

2600

2548

# Decide which value to use after restoring saved state.

2601

2549

# We have three different values: Old config file,

2602

2550

# new config file, and saved state.

2623

2571

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

2624

2572

if not client["last_checked_ok"]:

2625

2573

logger.warning(

2626

"disabling client {} - Client never "

2574

"disabling client {0} - Client never "

2627

2575

"performed a successful checker"

2628

2576

.format(client_name))

2629

2577

client["enabled"] = False

2630

2578

elif client["last_checker_status"] != 0:

2631

2579

logger.warning(

2632

"disabling client {} - Client last"

2633

" checker failed with error code {}"

2580

"disabling client {0} - Client "

2581

"last checker failed with error code {1}"

2634

2582

.format(client_name,

2635

2583

client["last_checker_status"]))

2636

2584

client["enabled"] = False

2639

2587

.utcnow()

2640

2588

+ client["timeout"])

2641

2589

logger.debug("Last checker succeeded,"

2642

" keeping {} enabled"

2590

" keeping {0} enabled"

2643

2591

.format(client_name))

2644

2592

try:

2645

2593

client["secret"] = (

2648

2596

["secret"]))

2649

2597

except PGPError:

2650

2598

# If decryption fails, we use secret from new settings

2651

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

2599

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

2652

2600

.format(client_name))

2653

2601

client["secret"] = (

2654

2602

client_settings[client_name]["secret"])

2662

2610

clients_data[client_name] = client_settings[client_name]

2663

2611

2664

2612

# Create all client objects

2665

for client_name, client in clients_data.items():

2613

for client_name, client in clients_data.iteritems():

2666

2614

tcp_server.clients[client_name] = client_class(

2667

name = client_name, settings = client,

2668

server_settings = server_settings)

2615

name = client_name, settings = client)

2669

2616

2670

2617

if not tcp_server.clients:

2671

2618

logger.warning("No clients defined")

2675

2622

try:

2676

2623

with pidfile:

2677

2624

pid = os.getpid()

2678

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

2625

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

2679

2626

except IOError:

2680

2627

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

2681

2628

pidfilename, pid)

2727

2674

def GetAllClientsWithProperties(self):

2728

2675

"D-Bus method"

2729

2676

return dbus.Dictionary(

2730

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

2731

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

2677

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

2678

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

2732

2679

signature="oa{sv}")

2733

2680

2734

2681

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

2751

2698

2752

2699

def cleanup():

2753

2700

"Cleanup function; run on exit"

2754

if zeroconf:

2755

service.cleanup()

2701

service.cleanup()

2756

2702

2757

2703

multiprocessing.active_children()

2758

wnull.close()

2759

2704

if not (tcp_server.clients or client_settings):

2760

2705

return

2761

2706

2772

2717

2773

2718

# A list of attributes that can not be pickled

2774

2719

# + secret.

2775

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

2776

"checker", "server_settings" }

2720

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

2721

"checker"))

2777

2722

for name, typ in (inspect.getmembers

2778

2723

(dbus.service.Object)):

2779

2724

exclude.add(name)

2802

2747

except NameError:

2803

2748

pass

2804

2749

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

2805

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

2750

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

2806

2751

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

2807

2752

else:

2808

2753

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

2809

2754

exc_info=e)

2810

raise

2755

raise e

2811

2756

2812

2757

# Delete all clients, and settings from config

2813

2758

while tcp_server.clients:

2837

2782

tcp_server.server_activate()

2838

2783

2839

2784

# Find out what port we got

2840

if zeroconf:

2841

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

2785

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

2842

2786

if use_ipv6:

2843

2787

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

2844

2788

" flowinfo %d, scope_id %d",

2850

2794

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

2851

2795

2852

2796

try:

2853

if zeroconf:

2854

# From the Avahi example code

2855

try:

2856

service.activate()

2857

except dbus.exceptions.DBusException as error:

2858

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

2859

cleanup()

2860

sys.exit(1)

2861

# End of Avahi example code

2797

# From the Avahi example code

2798

try:

2799

service.activate()

2800

except dbus.exceptions.DBusException as error:

2801

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

2802

cleanup()

2803

sys.exit(1)

2804

# End of Avahi example code

2862

2805

2863

2806

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

2864

2807

lambda *args, **kwargs: