/mandos/trunk : revision 729

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

79

import ctypes.util

80

import xml.dom.minidom

81

import inspect

82

import GnuPGInterface

83

82

84

83

try:

85

84

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

89

88

except ImportError:

90

89

SO_BINDTODEVICE = None

91

90

92

version = "1.6.0"

91

version = "1.6.8"

93

92

stored_state_file = "clients.pickle"

94

93

95

94

logger = logging.getLogger()

96

syslogger = (logging.handlers.SysLogHandler

97

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

98

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

95

syslogger = None

99

96

100

97

try:

101

98

if_nametoindex = (ctypes.cdll.LoadLibrary

107

104

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

108

105

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

109

106

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

110

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

111

interface))

112

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

113

ifreq[16:20])[0]

107

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

108

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

114

109

return interface_index

115

110

116

111

117

112

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

118

113

"""init logger and add loglevel"""

119

114

115

global syslogger

116

syslogger = (logging.handlers.SysLogHandler

117

(facility =

118

logging.handlers.SysLogHandler.LOG_DAEMON,

119

address = "/dev/log"))

120

syslogger.setFormatter(logging.Formatter

121

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

122

' %(message)s'))

140

class PGPEngine(object):

141

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

142

def __init__(self):

143

self.gnupg = GnuPGInterface.GnuPG()

144

143

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

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

144

self.gnupgargs = ['--batch',

145

'--home', self.tempdir,

146

'--force-mdc',

147

'--quiet',

148

'--no-use-agent']

151

149

152

150

def __enter__(self):

153

151

return self

175

173

def password_encode(self, password):

176

174

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

177

175

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

178

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

176

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

177

if len(encoded) > 2048:

178

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

179

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

180

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

181

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

182

return encoded

179

183

180

184

def encrypt(self, data, password):

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

185

passphrase = self.password_encode(password)

186

with tempfile.NamedTemporaryFile(dir=self.tempdir

187

) as passfile:

188

passfile.write(passphrase)

189

passfile.flush()

190

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

191

'--passphrase-file',

192

passfile.name]

193

+ self.gnupgargs,

194

stdin = subprocess.PIPE,

195

stdout = subprocess.PIPE,

196

stderr = subprocess.PIPE)

197

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

198

if proc.returncode != 0:

199

raise PGPError(err)

195

200

return ciphertext

196

201

197

202

def decrypt(self, data, password):

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

203

passphrase = self.password_encode(password)

204

with tempfile.NamedTemporaryFile(dir = self.tempdir

205

) as passfile:

206

passfile.write(passphrase)

207

passfile.flush()

208

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

209

'--passphrase-file',

210

passfile.name]

211

+ self.gnupgargs,

212

stdin = subprocess.PIPE,

213

stdout = subprocess.PIPE,

214

stderr = subprocess.PIPE)

215

decrypted_plaintext, err = proc.communicate(input

216

= data)

217

if proc.returncode != 0:

218

raise PGPError(err)

212

219

return decrypted_plaintext

213

220

214

221

215

222

class AvahiError(Exception):

216

223

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

217

224

self.value = value

218

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

219

def __unicode__(self):

220

return unicode(repr(self.value))

225

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

226

**kwargs)

221

227

222

228

class AvahiServiceError(AvahiError):

223

229

pass

234

240

Used to optionally bind to the specified interface.

235

241

name: string; Example: 'Mandos'

236

242

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

237

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

243

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

238

244

port: integer; what port to announce

239

245

TXT: list of strings; TXT record for the service

240

246

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

329

335

elif state == avahi.ENTRY_GROUP_FAILURE:

330

336

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

331

337

unicode(error))

332

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

338

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

333

339

.format(error))

334

340

335

341

def cleanup(self):

386

392

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

387

393

ret = AvahiService.rename(self)

388

394

syslogger.setFormatter(logging.Formatter

389

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

395

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

390

396

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

391

397

.format(self.name)))

392

398

return ret

393

399

394

400

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

402

401

class Client(object):

403

402

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

404

403

440

439

runtime_expansions: Allowed attributes for runtime expansion.

441

440

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

442

441

disabled, or None

442

server_settings: The server_settings dict from main()

443

"""

444

445

runtime_expansions = ("approval_delay", "approval_duration",

458

"enabled": "True",

459

}

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

476

461

@staticmethod

477

462

def config_parser(config):

478

463

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

503

488

"rb") as secfile:

504

489

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

505

490

else:

506

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

491

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

507

492

.format(section))

508

493

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

509

494

client["extended_timeout"] = string_to_delta(

520

505

521

506

return settings

522

507

523

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

508

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

524

509

self.name = name

510

if server_settings is None:

511

server_settings = {}

512

self.server_settings = server_settings

525

513

# adding all client settings

526

for setting, value in settings.iteritems():

514

for setting, value in settings.items():

527

515

setattr(self, setting, value)

528

516

529

517

if self.enabled:

612

600

if self.checker_initiator_tag is not None:

613

601

gobject.source_remove(self.checker_initiator_tag)

614

602

self.checker_initiator_tag = (gobject.timeout_add

615

(self.interval_milliseconds(),

603

(int(self.interval

604

.total_seconds() * 1000),

616

605

self.start_checker))

617

606

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

618

607

if self.disable_initiator_tag is not None:

619

608

gobject.source_remove(self.disable_initiator_tag)

620

609

self.disable_initiator_tag = (gobject.timeout_add

621

(self.timeout_milliseconds(),

622

self.disable))

610

(int(self.timeout

611

.total_seconds() * 1000),

612

self.disable))

623

613

# Also start a new checker *right now*.

624

614

self.start_checker()

625

615

656

646

self.disable_initiator_tag = None

657

647

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

658

648

self.disable_initiator_tag = (gobject.timeout_add

659

(timedelta_to_milliseconds

660

(timeout), self.disable))

649

(int(timeout.total_seconds()

650

* 1000), self.disable))

661

651

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

662

652

663

653

def need_approval(self):

680

670

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

681

671

try:

682

672

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

683

except (AttributeError, OSError) as error:

684

if (isinstance(error, OSError)

685

and error.errno != errno.ECHILD):

686

raise error

673

except AttributeError:

674

pass

675

except OSError as error:

676

if error.errno != errno.ECHILD:

677

raise

687

678

else:

688

679

if pid:

689

680

logger.warning("Checker was a zombie")

693

684

# Start a new checker if needed

694

685

if self.checker is None:

695

686

# Escape attributes for the shell

696

escaped_attrs = dict(

697

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

698

for attr in

699

self.runtime_expansions)

687

escaped_attrs = { attr:

688

re.escape(unicode(getattr(self,

689

attr)))

690

for attr in self.runtime_expansions }

700

691

try:

701

692

command = self.checker_command % escaped_attrs

702

693

except TypeError as error:

711

702

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

712

703

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

713

704

# always replaced by /dev/null.)

705

# The exception is when not debugging but nevertheless

706

# running in the foreground; use the previously

707

# created wnull.

708

popen_args = {}

709

if (not self.server_settings["debug"]

710

and self.server_settings["foreground"]):

711

popen_args.update({"stdout": wnull,

712

"stderr": wnull })

714

713

self.checker = subprocess.Popen(command,

715

714

close_fds=True,

716

shell=True, cwd="/")

715

shell=True, cwd="/",

716

**popen_args)

717

except OSError as error:

718

logger.error("Failed to start subprocess",

719

exc_info=error)

774

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

775

if byte_arrays and signature != "ay":

776

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

777

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

777

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

778

def decorator(func):

779

func._dbus_is_property = True

780

func._dbus_interface = dbus_interface

828

class DBusPropertyException(dbus.exceptions.DBusException):

829

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

830

"""

831

def __unicode__(self):

832

return unicode(str(self))

833

831

pass

834

832

835

833

class DBusPropertyAccessException(DBusPropertyException):

836

834

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

859

857

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

860

858

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

861

859

"""

862

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

860

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

863

861

False)

864

862

865

863

def _get_all_dbus_things(self, thing):

914

912

# The byte_arrays option is not supported yet on

915

913

# signatures other than "ay".

916

914

if prop._dbus_signature != "ay":

917

raise ValueError

915

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

916

"'ay' signature {!r}"

917

.format(prop._dbus_signature))

918

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

919

for byte in value))

920

prop(value)

984

(prop,

985

"_dbus_annotations",

986

{}))

987

for name, value in annots.iteritems():

987

for name, value in annots.items():

988

ann_tag = document.createElement(

989

"annotation")

990

ann_tag.setAttribute("name", name)

993

# Add interface annotation tags

994

for annotation, value in dict(

995

itertools.chain.from_iterable(

996

annotations().iteritems()

996

annotations().items()

997

for name, annotations in

998

self._get_all_dbus_things("interface")

999

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

1000

)).iteritems():

1000

)).items():

1001

ann_tag = document.createElement("annotation")

1002

ann_tag.setAttribute("name", annotation)

1003

ann_tag.setAttribute("value", value)

1059

"""

1060

def wrapper(cls):

1061

for orig_interface_name, alt_interface_name in (

1062

alt_interface_names.iteritems()):

1062

alt_interface_names.items()):

1063

attr = {}

1064

interface_names = set()

1065

# Go though all attributes of the class

1078

interface_names.add(alt_interface)

1079

# Is this a D-Bus signal?

1080

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

1081

# Extract the original non-method function by

1082

# black magic

1081

# Extract the original non-method undecorated

1082

# function by black magic

1083

nonmethod_func = (dict(

1084

zip(attribute.func_code.co_freevars,

1085

attribute.__closure__))["func"]

1182

attribute.func_closure)))

1183

if deprecate:

1184

# Deprecate all alternate interfaces

1185

iname="_AlternateDBusNames_interface_annotation{0}"

1185

iname="_AlternateDBusNames_interface_annotation{}"

1186

for interface_name in interface_names:

1187

@dbus_interface_annotations(interface_name)

1188

def func(self):

1197

if interface_names:

1198

# Replace the class with a new subclass of it with

1199

# methods, signals, etc. as created above.

1200

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

1200

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

1201

(cls,), attr)

1202

return cls

1203

return wrapper

1244

to the D-Bus. Default: no transform

1245

variant_level: D-Bus variant level. Default: 1

1246

"""

1247

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

1247

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

1248

def setter(self, value):

1249

if hasattr(self, "dbus_object_path"):

1250

if (not hasattr(self, attrname) or

1280

approval_delay = notifychangeproperty(dbus.UInt64,

1281

"ApprovalDelay",

1282

type_func =

1283

timedelta_to_milliseconds)

1283

lambda td: td.total_seconds()

1284

* 1000)

1284

1285

approval_duration = notifychangeproperty(

1285

1286

dbus.UInt64, "ApprovalDuration",

1286

type_func = timedelta_to_milliseconds)

1287

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

1287

1288

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

1288

1289

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

1289

type_func =

1290

timedelta_to_milliseconds)

1290

type_func = lambda td:

1291

td.total_seconds() * 1000)

1291

1292

extended_timeout = notifychangeproperty(

1292

1293

dbus.UInt64, "ExtendedTimeout",

1293

type_func = timedelta_to_milliseconds)

1294

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

1294

1295

interval = notifychangeproperty(dbus.UInt64,

1295

1296

"Interval",

1296

1297

type_func =

1297

timedelta_to_milliseconds)

1298

lambda td: td.total_seconds()

1299

* 1000)

1298

1300

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

1299

1301

1300

1302

del notifychangeproperty

1328

1330

*args, **kwargs)

1329

1331

1330

1332

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

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

1333

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

1336

1334

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

1337

1335

# Only if new checker process was started

1338

1336

if (self.checker is not None

1347

1345

1348

1346

def approve(self, value=True):

1349

1347

self.approved = value

1350

gobject.timeout_add(timedelta_to_milliseconds

1351

(self.approval_duration),

1352

self._reset_approved)

1348

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

1349

* 1000), self._reset_approved)

1353

1350

self.send_changedstate()

1354

1351

1355

1352

## D-Bus methods, signals & properties

1458

1455

access="readwrite")

1459

1456

def ApprovalDelay_dbus_property(self, value=None):

1460

1457

if value is None: # get

1461

return dbus.UInt64(self.approval_delay_milliseconds())

1458

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

1459

* 1000)

1462

1460

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

1463

1461

1464

1462

# ApprovalDuration - property

1466

1464

access="readwrite")

1467

1465

def ApprovalDuration_dbus_property(self, value=None):

1468

1466

if value is None: # get

1469

return dbus.UInt64(timedelta_to_milliseconds(

1470

self.approval_duration))

1467

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

1468

* 1000)

1471

1469

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

1472

1470

1473

1471

# Name - property

1539

1537

access="readwrite")

1540

1538

def Timeout_dbus_property(self, value=None):

1541

1539

if value is None: # get

1542

return dbus.UInt64(self.timeout_milliseconds())

1540

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

1543

1541

old_timeout = self.timeout

1544

1542

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

1545

1543

# Reschedule disabling

1556

1554

gobject.source_remove(self.disable_initiator_tag)

1557

1555

self.disable_initiator_tag = (

1558

1556

gobject.timeout_add(

1559

timedelta_to_milliseconds(self.expires - now),

1560

self.disable))

1557

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

1558

* 1000), self.disable))

1561

1559

1562

1560

# ExtendedTimeout - property

1563

1561

@dbus_service_property(_interface, signature="t",

1564

1562

access="readwrite")

1565

1563

def ExtendedTimeout_dbus_property(self, value=None):

1566

1564

if value is None: # get

1567

return dbus.UInt64(self.extended_timeout_milliseconds())

1565

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

1566

* 1000)

1568

1567

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

1569

1568

1570

1569

# Interval - property

1572

1571

access="readwrite")

1573

1572

def Interval_dbus_property(self, value=None):

1574

1573

if value is None: # get

1575

return dbus.UInt64(self.interval_milliseconds())

1574

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

1576

1575

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

1577

1576

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

1578

1577

return

1611

1610

@dbus_service_property(_interface, signature="ay",

1612

1611

access="write", byte_arrays=True)

1613

1612

def Secret_dbus_property(self, value):

1614

self.secret = str(value)

1613

self.secret = bytes(value)

1615

1614

1616

1615

del _interface

1617

1616

1683

1682

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

1684

1683

try:

1685

1684

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

1686

raise RuntimeError

1685

raise RuntimeError(line)

1687

1686

except (ValueError, IndexError, RuntimeError) as error:

1688

1687

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

1689

1688

return

1738

1737

if self.server.use_dbus:

1739

1738

# Emit D-Bus signal

1740

1739

client.NeedApproval(

1741

client.approval_delay_milliseconds(),

1742

client.approved_by_default)

1740

client.approval_delay.total_seconds()

1741

* 1000, client.approved_by_default)

1743

1742

else:

1744

1743

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

1745

1744

client.name)

1751

1750

#wait until timeout or approved

1752

1751

time = datetime.datetime.now()

1753

1752

client.changedstate.acquire()

1754

client.changedstate.wait(

1755

float(timedelta_to_milliseconds(delay)

1756

/ 1000))

1753

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

1757

1754

client.changedstate.release()

1758

1755

time2 = datetime.datetime.now()

1759

1756

if (time2 - time) >= delay:

1896

1893

1897

1894

def add_pipe(self, parent_pipe, proc):

1898

1895

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

1899

raise NotImplementedError

1896

raise NotImplementedError()

1900

1897

1901

1898

1902

1899

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1958

1955

try:

1959

1956

self.socket.setsockopt(socket.SOL_SOCKET,

1960

1957

SO_BINDTODEVICE,

1961

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

1958

(self.interface + "\0")

1959

.encode("utf-8"))

1962

1960

except socket.error as error:

1963

1961

if error.errno == errno.EPERM:

1964

1962

logger.error("No permission to bind to"

1978

1976

if self.address_family == socket.AF_INET6:

1979

1977

any_address = "::" # in6addr_any

1980

1978

else:

1981

any_address = socket.INADDR_ANY

1979

any_address = "0.0.0.0" # INADDR_ANY

1982

1980

self.server_address = (any_address,

1983

1981

self.server_address[1])

1984

1982

elif not self.server_address[1]:

2167

2165

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

2168

2166

frozenset((token_year, token_month,

2169

2167

token_day, token_time,

2170

token_week))),

2168

token_week)))

2171

2169

# Define starting values

2172

2170

value = datetime.timedelta() # Value so far

2173

2171

found_token = None

2174

followers = frozenset(token_duration,) # Following valid tokens

2172

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

2175

2173

s = duration # String left to parse

2176

2174

# Loop until end token is found

2177

2175

while found_token is not token_end:

2224

2222

timevalue = datetime.timedelta(0)

2225

2223

for s in interval.split():

2226

2224

try:

2227

suffix = unicode(s[-1])

2225

suffix = s[-1]

2228

2226

value = int(s[:-1])

2229

2227

if suffix == "d":

2230

2228

delta = datetime.timedelta(value)

2237

2235

elif suffix == "w":

2238

2236

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

2239

2237

else:

2240

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

2238

raise ValueError("Unknown suffix {!r}"

2241

2239

.format(suffix))

2242

except (ValueError, IndexError) as e:

2240

except IndexError as e:

2243

2241

raise ValueError(*(e.args))

2244

2242

timevalue += delta

2245

2243

return timevalue

2260

2258

# Close all standard open file descriptors

2261

2259

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

2262

2260

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

2263

raise OSError(errno.ENODEV,

2264

"{0} not a character device"

2261

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

2265

2262

.format(os.devnull))

2266

2263

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

2267

2264

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

2277

2274

2278

2275

parser = argparse.ArgumentParser()

2279

2276

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

2280

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

2277

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

2281

2278

help="show version number and exit")

2282

2279

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

2283

2280

help="Bind to interface IF")

2289

2286

help="Run self-test")

2290

2287

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

2291

2288

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

2292

" to terminal")

2289

" to terminal", default=None)

2293

2290

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

2294

2291

help="Debug level for stdout output")

2295

2292

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

2302

2299

" files")

2303

2300

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

2304

2301

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

2305

" system bus interface")

2302

" system bus interface", default=None)

2306

2303

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

2307

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

2304

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

2305

default=None)

2308

2306

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

2309

2307

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

2310

" state")

2308

" state", default=None)

2311

2309

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

2312

2310

help="Specify a file descriptor to a network"

2313

2311

" socket to use instead of creating one")

2314

2312

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

2315

2313

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

2316

2314

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

2317

help="Run in foreground")

2315

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

2316

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

2317

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

2318

default=None)

2318

2319

2320

options = parser.parse_args()

2320

2321

2322

if options.check:

2322

2323

import doctest

2323

doctest.testmod()

2324

sys.exit()

2324

fail_count, test_count = doctest.testmod()

2325

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

2325

2326

2327

# Default values for config file for server-global settings

2327

2328

server_defaults = { "interface": "",

2329

2330

"port": "",

2330

2331

"debug": "False",

2331

2332

"priority":

2332

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

2333

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

2333

2334

"servicename": "Mandos",

2334

2335

"use_dbus": "True",

2335

2336

"use_ipv6": "True",

2338

2339

"socket": "",

2339

2340

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

2340

2341

"foreground": "False",

2342

"zeroconf": "True",

2341

2343

}

2342

2344

2343

2345

# Parse config file for server-global settings

2370

2372

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

2371

2373

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

2372

2374

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

2373

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

2375

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

2374

2376

value = getattr(options, option)

2375

2377

if value is not None:

2376

2378

server_settings[option] = value

2377

2379

del options

2378

2380

# Force all strings to be unicode

2379

2381

for option in server_settings.keys():

2380

if type(server_settings[option]) is str:

2381

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

2382

if isinstance(server_settings[option], bytes):

2383

server_settings[option] = (server_settings[option]

2384

.decode("utf-8"))

2385

# Force all boolean options to be boolean

2386

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

2387

"foreground", "zeroconf"):

2388

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

2382

2389

# Debug implies foreground

2383

2390

if server_settings["debug"]:

2384

2391

server_settings["foreground"] = True

2386

2393

2387

2394

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

2388

2395

2396

if (not server_settings["zeroconf"] and

2397

not (server_settings["port"]

2398

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

2399

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

2400

" Zeroconf")

2401

2389

2402

# For convenience

2390

2403

debug = server_settings["debug"]

2391

2404

debuglevel = server_settings["debuglevel"]

2394

2407

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

2395

2408

stored_state_file)

2396

2409

foreground = server_settings["foreground"]

2410

zeroconf = server_settings["zeroconf"]

2397

2411

2398

2412

if debug:

2399

2413

initlogger(debug, logging.DEBUG)

2406

2420

2407

2421

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

2408

2422

syslogger.setFormatter(logging.Formatter

2409

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

2423

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

2410

2424

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

2411

2425

.format(server_settings

2412

2426

["servicename"])))

2420

2434

global mandos_dbus_service

2421

2435

mandos_dbus_service = None

2422

2436

2437

socketfd = None

2438

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

2439

socketfd = server_settings["socket"]

2423

2440

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

2424

2441

server_settings["port"]),

2425

2442

ClientHandler,

2429

2446

gnutls_priority=

2430

2447

server_settings["priority"],

2431

2448

use_dbus=use_dbus,

2432

socketfd=(server_settings["socket"]

2433

or None))

2449

socketfd=socketfd)

2434

2450

if not foreground:

2435

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

2451

pidfilename = "/run/mandos.pid"

2452

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

2453

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

2436

2454

pidfile = None

2437

2455

try:

2438

2456

pidfile = open(pidfilename, "w")

2455

2473

os.setuid(uid)

2456

2474

except OSError as error:

2457

2475

if error.errno != errno.EPERM:

2458

raise error

2476

raise

2459

2477

2460

2478

if debug:

2461

2479

# Enable all possible GnuTLS debugging

2504

2522

use_dbus = False

2505

2523

server_settings["use_dbus"] = False

2506

2524

tcp_server.use_dbus = False

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

2525

if zeroconf:

2526

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2527

service = AvahiServiceToSyslog(name =

2528

server_settings["servicename"],

2529

servicetype = "_mandos._tcp",

2530

protocol = protocol, bus = bus)

2531

if server_settings["interface"]:

2532

service.interface = (if_nametoindex

2533

(server_settings["interface"]

2534

.encode("utf-8")))

2515

2535

2516

2536

global multiprocessing_manager

2517

2537

multiprocessing_manager = multiprocessing.Manager()

2524

2544

old_client_settings = {}

2525

2545

clients_data = {}

2526

2546

2547

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

2548

global wnull

2549

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

2550

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

2551

# mode

2552

if debug or not foreground:

2553

wnull.close()

2554

2527

2555

# Get client data and settings from last running state.

2528

2556

if server_settings["restore"]:

2529

2557

try:

2533

2561

os.remove(stored_state_path)

2534

2562

except IOError as e:

2535

2563

if e.errno == errno.ENOENT:

2536

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

2564

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

2537

2565

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

2538

2566

else:

2539

2567

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

2544

2572

"EOFError:", exc_info=e)

2545

2573

2546

2574

with PGPEngine() as pgp:

2547

for client_name, client in clients_data.iteritems():

2575

for client_name, client in clients_data.items():

2576

# Skip removed clients

2577

if client_name not in client_settings:

2578

continue

2579

2548

2580

# Decide which value to use after restoring saved state.

2549

2581

# We have three different values: Old config file,

2550

2582

# new config file, and saved state.

2571

2603

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

2572

2604

if not client["last_checked_ok"]:

2573

2605

logger.warning(

2574

"disabling client {0} - Client never "

2606

"disabling client {} - Client never "

2575

2607

"performed a successful checker"

2576

2608

.format(client_name))

2577

2609

client["enabled"] = False

2578

2610

elif client["last_checker_status"] != 0:

2579

2611

logger.warning(

2580

"disabling client {0} - Client "

2581

"last checker failed with error code {1}"

2612

"disabling client {} - Client last"

2613

" checker failed with error code {}"

2582

2614

.format(client_name,

2583

2615

client["last_checker_status"]))

2584

2616

client["enabled"] = False

2587

2619

.utcnow()

2588

2620

+ client["timeout"])

2589

2621

logger.debug("Last checker succeeded,"

2590

" keeping {0} enabled"

2622

" keeping {} enabled"

2591

2623

.format(client_name))

2592

2624

try:

2593

2625

client["secret"] = (

2596

2628

["secret"]))

2597

2629

except PGPError:

2598

2630

# If decryption fails, we use secret from new settings

2599

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

2631

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

2600

2632

.format(client_name))

2601

2633

client["secret"] = (

2602

2634

client_settings[client_name]["secret"])

2610

2642

clients_data[client_name] = client_settings[client_name]

2611

2643

2612

2644

# Create all client objects

2613

for client_name, client in clients_data.iteritems():

2645

for client_name, client in clients_data.items():

2614

2646

tcp_server.clients[client_name] = client_class(

2615

name = client_name, settings = client)

2647

name = client_name, settings = client,

2648

server_settings = server_settings)

2616

2649

2617

2650

if not tcp_server.clients:

2618

2651

logger.warning("No clients defined")

2622

2655

try:

2623

2656

with pidfile:

2624

2657

pid = os.getpid()

2625

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

2658

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

2626

2659

except IOError:

2627

2660

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

2628

2661

pidfilename, pid)

2698

2731

2699

2732

def cleanup():

2700

2733

"Cleanup function; run on exit"

2701

service.cleanup()

2734

if zeroconf:

2735

service.cleanup()

2702

2736

2703

2737

multiprocessing.active_children()

2738

wnull.close()

2704

2739

if not (tcp_server.clients or client_settings):

2705

2740

return

2706

2741

2717

2752

2718

2753

# A list of attributes that can not be pickled

2719

2754

# + secret.

2720

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

2721

"checker"))

2755

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

2756

"checker", "server_settings" }

2722

2757

for name, typ in (inspect.getmembers

2723

2758

(dbus.service.Object)):

2724

2759

exclude.add(name)

2747

2782

except NameError:

2748

2783

pass

2749

2784

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

2750

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

2785

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

2751

2786

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

2752

2787

else:

2753

2788

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

2754

2789

exc_info=e)

2755

raise e

2790

raise

2756

2791

2757

2792

# Delete all clients, and settings from config

2758

2793

while tcp_server.clients:

2782

2817

tcp_server.server_activate()

2783

2818

2784

2819

# Find out what port we got

2785

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

2820

if zeroconf:

2821

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

2786

2822

if use_ipv6:

2787

2823

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

2788

2824

" flowinfo %d, scope_id %d",

2794

2830

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

2795

2831

2796

2832

try:

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

2833

if zeroconf:

2834

# From the Avahi example code

2835

try:

2836

service.activate()

2837

except dbus.exceptions.DBusException as error:

2838

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

2839

cleanup()

2840

sys.exit(1)

2841

# End of Avahi example code

2805

2842

2806

2843

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

2807

2844

lambda *args, **kwargs: