/mandos/trunk : revision 582

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

68

import binascii

69

import tempfile

70

import itertools

71

import collections

72

71

73

72

import dbus

74

73

import dbus.service

79

78

import ctypes.util

80

79

import xml.dom.minidom

81

80

import inspect

81

import GnuPGInterface

82

83

try:

84

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

88

except ImportError:

89

SO_BINDTODEVICE = None

90

91

version = "1.6.7"

91

version = "1.5.3"

92

stored_state_file = "clients.pickle"

93

94

logger = logging.getLogger()

95

syslogger = None

95

syslogger = (logging.handlers.SysLogHandler

96

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

97

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

96

98

97

99

try:

98

100

if_nametoindex = (ctypes.cdll.LoadLibrary

114

116

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

115

117

"""init logger and add loglevel"""

116

118

117

global syslogger

118

syslogger = (logging.handlers.SysLogHandler

119

(facility =

120

logging.handlers.SysLogHandler.LOG_DAEMON,

121

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

122

119

syslogger.setFormatter(logging.Formatter

123

120

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

124

121

' %(message)s'))

142

139

class PGPEngine(object):

143

140

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

144

141

def __init__(self):

142

self.gnupg = GnuPGInterface.GnuPG()

145

143

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

146

self.gnupgargs = ['--batch',

147

'--home', self.tempdir,

148

'--force-mdc',

149

'--quiet',

150

'--no-use-agent']

144

self.gnupg = GnuPGInterface.GnuPG()

145

self.gnupg.options.meta_interactive = False

146

self.gnupg.options.homedir = self.tempdir

147

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

148

'--quiet',

149

'--no-use-agent'])

151

150

152

151

def __enter__(self):

153

152

return self

154

153

155

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

154

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

156

155

self._cleanup()

157

156

return False

158

157

175

174

def password_encode(self, password):

176

175

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

177

176

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

178

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

179

if len(encoded) > 2048:

180

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

181

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

182

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

183

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

184

return encoded

177

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

185

178

186

179

def encrypt(self, data, password):

187

passphrase = self.password_encode(password)

188

with tempfile.NamedTemporaryFile(dir=self.tempdir

189

) as passfile:

190

passfile.write(passphrase)

191

passfile.flush()

192

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

193

'--passphrase-file',

194

passfile.name]

195

+ self.gnupgargs,

196

stdin = subprocess.PIPE,

197

stdout = subprocess.PIPE,

198

stderr = subprocess.PIPE)

199

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

200

if proc.returncode != 0:

201

raise PGPError(err)

180

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

181

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

182

try:

183

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

184

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

185

attach_fhs={'stderr': devnull})

186

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

187

f.write(data)

188

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

189

ciphertext = f.read()

190

proc.wait()

191

except IOError as e:

192

raise PGPError(e)

193

self.gnupg.passphrase = None

202

194

return ciphertext

203

195

204

196

def decrypt(self, data, password):

205

passphrase = self.password_encode(password)

206

with tempfile.NamedTemporaryFile(dir = self.tempdir

207

) as passfile:

208

passfile.write(passphrase)

209

passfile.flush()

210

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

211

'--passphrase-file',

212

passfile.name]

213

+ self.gnupgargs,

214

stdin = subprocess.PIPE,

215

stdout = subprocess.PIPE,

216

stderr = subprocess.PIPE)

217

decrypted_plaintext, err = proc.communicate(input

218

= data)

219

if proc.returncode != 0:

220

raise PGPError(err)

197

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

198

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

199

try:

200

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

201

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

202

attach_fhs={'stderr': devnull})

203

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

204

f.write(data)

205

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

206

decrypted_plaintext = f.read()

207

proc.wait()

208

except IOError as e:

209

raise PGPError(e)

210

self.gnupg.passphrase = None

221

211

return decrypted_plaintext

222

212

223

213

243

233

Used to optionally bind to the specified interface.

244

234

name: string; Example: 'Mandos'

245

235

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

246

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

236

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

247

237

port: integer; what port to announce

248

238

TXT: list of strings; TXT record for the service

249

239

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

449

439

runtime_expansions: Allowed attributes for runtime expansion.

450

440

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

451

441

disabled, or None

452

server_settings: The server_settings dict from main()

453

442

"""

454

443

455

444

runtime_expansions = ("approval_delay", "approval_duration",

456

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

457

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

458

"last_approval_request", "last_checked_ok",

445

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

446

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

459

447

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

460

client_defaults = { "timeout": "PT5M",

461

"extended_timeout": "PT15M",

462

"interval": "PT2M",

448

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

449

"extended_timeout": "15m",

450

"interval": "2m",

463

451

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

464

452

"host": "",

465

"approval_delay": "PT0S",

466

"approval_duration": "PT1S",

453

"approval_delay": "0s",

454

"approval_duration": "1s",

467

455

"approved_by_default": "True",

468

456

"enabled": "True",

469

457

}

530

518

531

519

return settings

532

520

533

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

521

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

534

522

self.name = name

535

if server_settings is None:

536

server_settings = {}

537

self.server_settings = server_settings

538

523

# adding all client settings

539

524

for setting, value in settings.iteritems():

540

525

setattr(self, setting, value)

693

678

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

694

679

try:

695

680

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

696

except AttributeError:

697

pass

698

except OSError as error:

699

if error.errno != errno.ECHILD:

700

raise

681

except (AttributeError, OSError) as error:

682

if (isinstance(error, OSError)

683

and error.errno != errno.ECHILD):

684

raise error

701

685

else:

702

686

if pid:

703

687

logger.warning("Checker was a zombie")

706

690

self.current_checker_command)

707

691

# Start a new checker if needed

708

692

if self.checker is None:

709

# Escape attributes for the shell

710

escaped_attrs = dict(

711

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

712

for attr in

713

self.runtime_expansions)

714

693

try:

715

command = self.checker_command % escaped_attrs

716

except TypeError as error:

717

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

718

self.checker_command, exc_info=error)

719

return True # Try again later

694

# In case checker_command has exactly one % operator

695

command = self.checker_command % self.host

696

except TypeError:

697

# Escape attributes for the shell

698

escaped_attrs = dict(

699

(attr,

700

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

701

errors=

702

'replace')))

703

for attr in

704

self.runtime_expansions)

705

706

try:

707

command = self.checker_command % escaped_attrs

708

except TypeError as error:

709

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

710

self.checker_command, exc_info=error)

711

return True # Try again later

720

712

self.current_checker_command = command

721

713

try:

722

714

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

725

717

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

726

718

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

727

719

# always replaced by /dev/null.)

728

# The exception is when not debugging but nevertheless

729

# running in the foreground; use the previously

730

# created wnull.

731

popen_args = {}

732

if (not self.server_settings["debug"]

733

and self.server_settings["foreground"]):

734

popen_args.update({"stdout": wnull,

735

"stderr": wnull })

736

720

self.checker = subprocess.Popen(command,

737

721

close_fds=True,

738

shell=True, cwd="/",

739

**popen_args)

722

shell=True, cwd="/")

723

self.checker_callback_tag = (gobject.child_watch_add

724

(self.checker.pid,

725

self.checker_callback,

726

data=command))

727

# The checker may have completed before the gobject

728

# watch was added. Check for this.

729

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

730

if pid:

731

gobject.source_remove(self.checker_callback_tag)

732

self.checker_callback(pid, status, command)

740

733

except OSError as error:

741

734

logger.error("Failed to start subprocess",

742

735

exc_info=error)

743

return True

744

self.checker_callback_tag = (gobject.child_watch_add

745

(self.checker.pid,

746

self.checker_callback,

747

data=command))

748

# The checker may have completed before the gobject

749

# watch was added. Check for this.

750

try:

751

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

752

except OSError as error:

753

if error.errno == errno.ECHILD:

754

# This should never happen

755

logger.error("Child process vanished",

756

exc_info=error)

757

return True

758

raise

759

if pid:

760

gobject.source_remove(self.checker_callback_tag)

761

self.checker_callback(pid, status, command)

762

736

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

763

737

return True

764

738

937

911

# The byte_arrays option is not supported yet on

938

912

# signatures other than "ay".

939

913

if prop._dbus_signature != "ay":

940

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

941

"'ay' signature {0!r}"

942

.format(prop._dbus_signature))

914

raise ValueError

943

915

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

944

916

for byte in value))

945

917

prop(value)

1051

1023

return xmlstring

1052

1024

1053

1025

1054

def datetime_to_dbus(dt, variant_level=0):

1026

def datetime_to_dbus (dt, variant_level=0):

1055

1027

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

1056

1028

if dt is None:

1057

1029

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

1065

1037

interface names according to the "alt_interface_names" mapping.

1066

1038

Usage:

1067

1039

1068

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

1069

"net.example.AlternateInterface"})

1040

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

1041

"net.example.AlternateInterface"})

1070

1042

class SampleDBusObject(dbus.service.Object):

1071

1043

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

1072

1044

def SampleDBusMethod():

1103

1075

interface_names.add(alt_interface)

1104

1076

# Is this a D-Bus signal?

1105

1077

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

1106

# Extract the original non-method undecorated

1107

# function by black magic

1078

# Extract the original non-method function by

1079

# black magic

1108

1080

nonmethod_func = (dict(

1109

1081

zip(attribute.func_code.co_freevars,

1110

1082

attribute.__closure__))["func"]

1353

1325

*args, **kwargs)

1354

1326

1355

1327

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

1356

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

1328

old_checker = self.checker

1329

if self.checker is not None:

1330

old_checker_pid = self.checker.pid

1331

else:

1332

old_checker_pid = None

1357

1333

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

1358

1334

# Only if new checker process was started

1359

1335

if (self.checker is not None

1704

1680

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

1705

1681

try:

1706

1682

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

1707

raise RuntimeError(line)

1683

raise RuntimeError

1708

1684

except (ValueError, IndexError, RuntimeError) as error:

1709

1685

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

1710

1686

return

1917

1893

1918

1894

def add_pipe(self, parent_pipe, proc):

1919

1895

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

1920

raise NotImplementedError()

1896

raise NotImplementedError

1921

1897

1922

1898

1923

1899

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1930

1906

use_ipv6: Boolean; to use IPv6 or not

1931

1907

"""

1932

1908

def __init__(self, server_address, RequestHandlerClass,

1933

interface=None, use_ipv6=True, socketfd=None):

1934

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

1935

creating a new one with socket.socket().

1936

"""

1909

interface=None, use_ipv6=True):

1937

1910

self.interface = interface

1938

1911

if use_ipv6:

1939

1912

self.address_family = socket.AF_INET6

1940

if socketfd is not None:

1941

# Save the file descriptor

1942

self.socketfd = socketfd

1943

# Save the original socket.socket() function

1944

self.socket_socket = socket.socket

1945

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

1946

#

1947

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

1948

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

1949

# patching socket.socket.)

1950

#

1951

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

1952

@functools.wraps(socket.socket)

1953

def socket_wrapper(*args, **kwargs):

1954

# Restore original function so subsequent calls are

1955

# not affected.

1956

socket.socket = self.socket_socket

1957

del self.socket_socket

1958

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

1959

# saved file descriptor.

1960

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

1961

# Replace socket.socket() function with wrapper

1962

socket.socket = socket_wrapper

1963

# The socketserver.TCPServer.__init__ will call

1964

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

1965

# socket_wrapper(), if socketfd was set.

1966

1913

socketserver.TCPServer.__init__(self, server_address,

1967

1914

RequestHandlerClass)

1968

1969

1915

def server_bind(self):

1970

1916

"""This overrides the normal server_bind() function

1971

1917

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

1979

1925

try:

1980

1926

self.socket.setsockopt(socket.SOL_SOCKET,

1981

1927

SO_BINDTODEVICE,

1982

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

1928

str(self.interface

1929

+ '\0'))

1983

1930

except socket.error as error:

1984

1931

if error.errno == errno.EPERM:

1985

logger.error("No permission to bind to"

1986

" interface %s", self.interface)

1932

logger.error("No permission to"

1933

" bind to interface %s",

1934

self.interface)

1987

1935

elif error.errno == errno.ENOPROTOOPT:

1988

1936

logger.error("SO_BINDTODEVICE not available;"

1989

1937

" cannot bind to interface %s",

1990

1938

self.interface)

1991

1939

elif error.errno == errno.ENODEV:

1992

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

1993

" cannot bind", self.interface)

1940

logger.error("Interface %s does not"

1941

" exist, cannot bind",

1942

self.interface)

1994

1943

else:

1995

1944

raise

1996

1945

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

1999

1948

if self.address_family == socket.AF_INET6:

2000

1949

any_address = "::" # in6addr_any

2001

1950

else:

2002

any_address = "0.0.0.0" # INADDR_ANY

1951

any_address = socket.INADDR_ANY

2003

1952

self.server_address = (any_address,

2004

1953

self.server_address[1])

2005

1954

elif not self.server_address[1]:

2026

1975

"""

2027

1976

def __init__(self, server_address, RequestHandlerClass,

2028

1977

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

2029

gnutls_priority=None, use_dbus=True, socketfd=None):

1978

gnutls_priority=None, use_dbus=True):

2030

1979

self.enabled = False

2031

1980

self.clients = clients

2032

1981

if self.clients is None:

2036

1985

IPv6_TCPServer.__init__(self, server_address,

2037

1986

RequestHandlerClass,

2038

1987

interface = interface,

2039

use_ipv6 = use_ipv6,

2040

socketfd = socketfd)

1988

use_ipv6 = use_ipv6)

2041

1989

def server_activate(self):

2042

1990

if self.enabled:

2043

1991

return socketserver.TCPServer.server_activate(self)

2121

2069

return True

2122

2070

2123

2071

2124

def rfc3339_duration_to_delta(duration):

2125

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

2126

2127

>>> rfc3339_duration_to_delta("P7D")

2128

datetime.timedelta(7)

2129

>>> rfc3339_duration_to_delta("PT60S")

2130

datetime.timedelta(0, 60)

2131

>>> rfc3339_duration_to_delta("PT60M")

2132

datetime.timedelta(0, 3600)

2133

>>> rfc3339_duration_to_delta("PT24H")

2134

datetime.timedelta(1)

2135

>>> rfc3339_duration_to_delta("P1W")

2136

datetime.timedelta(7)

2137

>>> rfc3339_duration_to_delta("PT5M30S")

2138

datetime.timedelta(0, 330)

2139

>>> rfc3339_duration_to_delta("P1DT3M20S")

2140

datetime.timedelta(1, 200)

2141

"""

2142

2143

# Parsing an RFC 3339 duration with regular expressions is not

2144

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

2145

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

2146

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

2147

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

2148

# avoid excessive use of external libraries.

2149

2150

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

2151

Token = collections.namedtuple("Token",

2152

("regexp", # To match token; if

2153

# "value" is not None,

2154

# must have a "group"

2155

# containing digits

2156

"value", # datetime.timedelta or

2157

# None

2158

"followers")) # Tokens valid after

2159

# this token

2160

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

2161

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

2162

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

2163

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

2164

datetime.timedelta(seconds=1),

2165

frozenset((token_end,)))

2166

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

2167

datetime.timedelta(minutes=1),

2168

frozenset((token_second, token_end)))

2169

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

2170

datetime.timedelta(hours=1),

2171

frozenset((token_minute, token_end)))

2172

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

2173

None,

2174

frozenset((token_hour, token_minute,

2175

token_second)))

2176

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

2177

datetime.timedelta(days=1),

2178

frozenset((token_time, token_end)))

2179

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

2180

datetime.timedelta(weeks=4),

2181

frozenset((token_day, token_end)))

2182

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

2183

datetime.timedelta(weeks=52),

2184

frozenset((token_month, token_end)))

2185

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

2186

datetime.timedelta(weeks=1),

2187

frozenset((token_end,)))

2188

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

2189

frozenset((token_year, token_month,

2190

token_day, token_time,

2191

token_week))),

2192

# Define starting values

2193

value = datetime.timedelta() # Value so far

2194

found_token = None

2195

followers = frozenset(token_duration,) # Following valid tokens

2196

s = duration # String left to parse

2197

# Loop until end token is found

2198

while found_token is not token_end:

2199

# Search for any currently valid tokens

2200

for token in followers:

2201

match = token.regexp.match(s)

2202

if match is not None:

2203

# Token found

2204

if token.value is not None:

2205

# Value found, parse digits

2206

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

2207

# Add to value so far

2208

value += factor * token.value

2209

# Strip token from string

2210

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

2211

# Go to found token

2212

found_token = token

2213

# Set valid next tokens

2214

followers = found_token.followers

2215

break

2216

else:

2217

# No currently valid tokens were found

2218

raise ValueError("Invalid RFC 3339 duration")

2219

# End token found

2220

return value

2221

2222

2223

2072

def string_to_delta(interval):

2224

2073

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

2225

2074

2236

2085

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

2237

2086

datetime.timedelta(0, 330)

2238

2087

"""

2239

2240

try:

2241

return rfc3339_duration_to_delta(interval)

2242

except ValueError:

2243

pass

2244

2245

2088

timevalue = datetime.timedelta(0)

2246

2089

for s in interval.split():

2247

2090

try:

2260

2103

else:

2261

2104

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

2262

2105

.format(suffix))

2263

except IndexError as e:

2106

except (ValueError, IndexError) as e:

2264

2107

raise ValueError(*(e.args))

2265

2108

timevalue += delta

2266

2109

return timevalue

2310

2153

help="Run self-test")

2311

2154

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

2312

2155

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

2313

" to terminal", default=None)

2156

" to terminal")

2314

2157

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

2315

2158

help="Debug level for stdout output")

2316

2159

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

2323

2166

" files")

2324

2167

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

2325

2168

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

2326

" system bus interface", default=None)

2169

" system bus interface")

2327

2170

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

2328

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

2329

default=None)

2171

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

2330

2172

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

2331

2173

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

2332

" state", default=None)

2333

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

2334

help="Specify a file descriptor to a network"

2335

" socket to use instead of creating one")

2174

" state")

2336

2175

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

2337

2176

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

2338

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

2339

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

2340

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

2341

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

2342

default=None)

2343

2177

2344

2178

options = parser.parse_args()

2345

2179

2346

2180

if options.check:

2347

2181

import doctest

2348

fail_count, test_count = doctest.testmod()

2349

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

2182

doctest.testmod()

2183

sys.exit()

2350

2184

2351

2185

# Default values for config file for server-global settings

2352

2186

server_defaults = { "interface": "",

2354

2188

"port": "",

2355

2189

"debug": "False",

2356

2190

"priority":

2357

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

2191

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

2358

2192

"servicename": "Mandos",

2359

2193

"use_dbus": "True",

2360

2194

"use_ipv6": "True",

2361

2195

"debuglevel": "",

2362

2196

"restore": "True",

2363

"socket": "",

2364

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

2365

"foreground": "False",

2366

"zeroconf": "True",

2197

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

2367

2198

}

2368

2199

2369

2200

# Parse config file for server-global settings

2374

2205

# Convert the SafeConfigParser object to a dict

2375

2206

server_settings = server_config.defaults()

2376

2207

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

2377

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

2208

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

2378

2209

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

2379

2210

option)

2380

2211

if server_settings["port"]:

2381

2212

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

2382

2213

"port")

2383

if server_settings["socket"]:

2384

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

2385

"socket")

2386

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

2387

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

2388

# happen with a supplied network socket.

2389

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

2390

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

2391

["socket"])

2392

2214

del server_config

2393

2215

2394

2216

# Override the settings from the config file with command line

2396

2218

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

2397

2219

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

2398

2220

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

2399

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

2221

"statedir"):

2400

2222

value = getattr(options, option)

2401

2223

if value is not None:

2402

2224

server_settings[option] = value

2405

2227

for option in server_settings.keys():

2406

2228

if type(server_settings[option]) is str:

2407

2229

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

2408

# Force all boolean options to be boolean

2409

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

2410

"foreground", "zeroconf"):

2411

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

2412

# Debug implies foreground

2413

if server_settings["debug"]:

2414

server_settings["foreground"] = True

2415

2230

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

2416

2231

2417

2232

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

2418

2233

2419

if (not server_settings["zeroconf"] and

2420

not (server_settings["port"]

2421

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

2422

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

2423

" Zeroconf")

2424

2425

2234

# For convenience

2426

2235

debug = server_settings["debug"]

2427

2236

debuglevel = server_settings["debuglevel"]

2429

2238

use_ipv6 = server_settings["use_ipv6"]

2430

2239

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

2431

2240

stored_state_file)

2432

foreground = server_settings["foreground"]

2433

zeroconf = server_settings["zeroconf"]

2434

2241

2435

2242

if debug:

2436

2243

initlogger(debug, logging.DEBUG)

2457

2264

global mandos_dbus_service

2458

2265

mandos_dbus_service = None

2459

2266

2460

socketfd = None

2461

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

2462

socketfd = server_settings["socket"]

2463

2267

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

2464

2268

server_settings["port"]),

2465

2269

ClientHandler,

2468

2272

use_ipv6=use_ipv6,

2469

2273

gnutls_priority=

2470

2274

server_settings["priority"],

2471

use_dbus=use_dbus,

2472

socketfd=socketfd)

2473

if not foreground:

2474

pidfilename = "/run/mandos.pid"

2475

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

2476

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

2477

pidfile = None

2275

use_dbus=use_dbus)

2276

if not debug:

2277

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

2478

2278

try:

2479

2279

pidfile = open(pidfilename, "w")

2480

2280

except IOError as e:

2495

2295

os.setgid(gid)

2496

2296

os.setuid(uid)

2497

2297

except OSError as error:

2498

if error.errno != errno.EPERM:

2499

raise

2298

if error[0] != errno.EPERM:

2299

raise error

2500

2300

2501

2301

if debug:

2502

2302

# Enable all possible GnuTLS debugging

2519

2319

os.close(null)

2520

2320

2521

2321

# Need to fork before connecting to D-Bus

2522

if not foreground:

2322

if not debug:

2523

2323

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

2524

2324

daemon()

2525

2325

2526

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

2527

# need to inform gobject that threads will be used.

2528

2326

gobject.threads_init()

2529

2327

2530

2328

global main_loop

2545

2343

use_dbus = False

2546

2344

server_settings["use_dbus"] = False

2547

2345

tcp_server.use_dbus = False

2548

if zeroconf:

2549

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2550

service = AvahiServiceToSyslog(name =

2551

server_settings["servicename"],

2552

servicetype = "_mandos._tcp",

2553

protocol = protocol, bus = bus)

2554

if server_settings["interface"]:

2555

service.interface = (if_nametoindex

2556

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

2346

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2347

service = AvahiServiceToSyslog(name =

2348

server_settings["servicename"],

2349

servicetype = "_mandos._tcp",

2350

protocol = protocol, bus = bus)

2351

if server_settings["interface"]:

2352

service.interface = (if_nametoindex

2353

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

2557

2354

2558

2355

global multiprocessing_manager

2559

2356

multiprocessing_manager = multiprocessing.Manager()

2566

2363

old_client_settings = {}

2567

2364

clients_data = {}

2568

2365

2569

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

2570

global wnull

2571

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

2572

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

2573

# mode

2574

if debug or not foreground:

2575

wnull.close()

2576

2577

2366

# Get client data and settings from last running state.

2578

2367

if server_settings["restore"]:

2579

2368

try:

2595

2384

2596

2385

with PGPEngine() as pgp:

2597

2386

for client_name, client in clients_data.iteritems():

2598

# Skip removed clients

2599

if client_name not in client_settings:

2600

continue

2601

2602

2387

# Decide which value to use after restoring saved state.

2603

2388

# We have three different values: Old config file,

2604

2389

# new config file, and saved state.

2666

2451

# Create all client objects

2667

2452

for client_name, client in clients_data.iteritems():

2668

2453

tcp_server.clients[client_name] = client_class(

2669

name = client_name, settings = client,

2670

server_settings = server_settings)

2454

name = client_name, settings = client)

2671

2455

2672

2456

if not tcp_server.clients:

2673

2457

logger.warning("No clients defined")

2674

2458

2675

if not foreground:

2676

if pidfile is not None:

2677

try:

2678

with pidfile:

2679

pid = os.getpid()

2680

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

2681

except IOError:

2682

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

2683

pidfilename, pid)

2684

del pidfile

2459

if not debug:

2460

try:

2461

with pidfile:

2462

pid = os.getpid()

2463

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

2464

del pidfile

2465

except IOError:

2466

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

2467

pidfilename, pid)

2468

except NameError:

2469

# "pidfile" was never created

2470

pass

2685

2471

del pidfilename

2472

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

2686

2473

2687

2474

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

2688

2475

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

2753

2540

2754

2541

def cleanup():

2755

2542

"Cleanup function; run on exit"

2756

if zeroconf:

2757

service.cleanup()

2543

service.cleanup()

2758

2544

2759

2545

multiprocessing.active_children()

2760

wnull.close()

2761

2546

if not (tcp_server.clients or client_settings):

2762

2547

return

2763

2548

2775

2560

# A list of attributes that can not be pickled

2776

2561

# + secret.

2777

2562

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

2778

"checker", "server_settings"))

2563

"checker"))

2779

2564

for name, typ in (inspect.getmembers

2780

2565

(dbus.service.Object)):

2781

2566

exclude.add(name)

2809

2594

else:

2810

2595

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

2811

2596

exc_info=e)

2812

raise

2597

raise e

2813

2598

2814

2599

# Delete all clients, and settings from config

2815

2600

while tcp_server.clients:

2839

2624

tcp_server.server_activate()

2840

2625

2841

2626

# Find out what port we got

2842

if zeroconf:

2843

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

2627

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

2844

2628

if use_ipv6:

2845

2629

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

2846

2630

" flowinfo %d, scope_id %d",

2852

2636

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

2853

2637

2854

2638

try:

2855

if zeroconf:

2856

# From the Avahi example code

2857

try:

2858

service.activate()

2859

except dbus.exceptions.DBusException as error:

2860

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

2861

cleanup()

2862

sys.exit(1)

2863

# End of Avahi example code

2639

# From the Avahi example code

2640

try:

2641

service.activate()

2642

except dbus.exceptions.DBusException as error:

2643

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

2644

cleanup()

2645

sys.exit(1)

2646

# End of Avahi example code

2864

2647

2865

2648

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

2866

2649

lambda *args, **kwargs: