/mandos/trunk : revision 636

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

71

72

73

import dbus

73

74

import dbus.service

78

79

import ctypes.util

79

80

import xml.dom.minidom

80

81

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.0"

91

version = "1.6.2"

92

stored_state_file = "clients.pickle"

93

94

logger = logging.getLogger()

139

class PGPEngine(object):

140

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

141

def __init__(self):

142

self.gnupg = GnuPGInterface.GnuPG()

143

142

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

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

143

self.gnupgargs = ['--batch',

144

'--home', self.tempdir,

145

'--force-mdc',

146

'--quiet',

147

'--no-use-agent']

150

148

151

149

def __enter__(self):

152

150

return self

174

172

def password_encode(self, password):

175

173

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

176

174

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

177

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

175

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

176

if len(encoded) > 2048:

177

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

178

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

179

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

180

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

181

return encoded

178

182

179

183

def encrypt(self, data, password):

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

184

passphrase = self.password_encode(password)

185

with tempfile.NamedTemporaryFile(dir=self.tempdir

186

) as passfile:

187

passfile.write(passphrase)

188

passfile.flush()

189

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

190

'--passphrase-file',

191

passfile.name]

192

+ self.gnupgargs,

193

stdin = subprocess.PIPE,

194

stdout = subprocess.PIPE,

195

stderr = subprocess.PIPE)

196

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

197

if proc.returncode != 0:

198

raise PGPError(err)

194

199

return ciphertext

195

200

196

201

def decrypt(self, data, password):

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

202

passphrase = self.password_encode(password)

203

with tempfile.NamedTemporaryFile(dir = self.tempdir

204

) as passfile:

205

passfile.write(passphrase)

206

passfile.flush()

207

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

208

'--passphrase-file',

209

passfile.name]

210

+ self.gnupgargs,

211

stdin = subprocess.PIPE,

212

stdout = subprocess.PIPE,

213

stderr = subprocess.PIPE)

214

decrypted_plaintext, err = proc.communicate(input

215

= data)

216

if proc.returncode != 0:

217

raise PGPError(err)

211

218

return decrypted_plaintext

212

219

213

220

233

240

Used to optionally bind to the specified interface.

234

241

name: string; Example: 'Mandos'

235

242

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

236

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

243

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

237

244

port: integer; what port to announce

238

245

TXT: list of strings; TXT record for the service

239

246

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

439

446

runtime_expansions: Allowed attributes for runtime expansion.

440

447

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

441

448

disabled, or None

449

server_settings: The server_settings dict from main()

442

450

"""

443

451

444

452

runtime_expansions = ("approval_delay", "approval_duration",

446

454

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

447

455

"last_approval_request", "last_checked_ok",

448

456

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

449

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

450

"extended_timeout": "15m",

451

"interval": "2m",

457

client_defaults = { "timeout": "PT5M",

458

"extended_timeout": "PT15M",

459

"interval": "PT2M",

452

460

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

453

461

"host": "",

454

"approval_delay": "0s",

455

"approval_duration": "1s",

462

"approval_delay": "PT0S",

463

"approval_duration": "PT1S",

456

464

"approved_by_default": "True",

457

465

"enabled": "True",

458

466

}

519

527

520

528

return settings

521

529

522

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

530

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

523

531

self.name = name

532

if server_settings is None:

533

server_settings = {}

534

self.server_settings = server_settings

524

535

# adding all client settings

525

536

for setting, value in settings.iteritems():

526

537

setattr(self, setting, value)

710

721

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

711

722

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

712

723

# always replaced by /dev/null.)

724

# The exception is when not debugging but nevertheless

725

# running in the foreground; use the previously

726

# created wnull.

727

popen_args = {}

728

if (not self.server_settings["debug"]

729

and self.server_settings["foreground"]):

730

popen_args.update({"stdout": wnull,

731

"stderr": wnull })

713

732

self.checker = subprocess.Popen(command,

714

733

close_fds=True,

715

shell=True, cwd="/")

734

shell=True, cwd="/",

735

**popen_args)

716

736

except OSError as error:

717

737

logger.error("Failed to start subprocess",

718

738

exc_info=error)

739

return True

719

740

self.checker_callback_tag = (gobject.child_watch_add

720

741

(self.checker.pid,

721

742

self.checker_callback,

722

743

data=command))

723

744

# The checker may have completed before the gobject

724

745

# watch was added. Check for this.

725

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

746

try:

747

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

748

except OSError as error:

749

if error.errno == errno.ECHILD:

750

# This should never happen

751

logger.error("Child process vanished",

752

exc_info=error)

753

return True

754

raise

726

755

if pid:

727

756

gobject.source_remove(self.checker_callback_tag)

728

757

self.checker_callback(pid, status, command)

1068

1097

interface_names.add(alt_interface)

1069

1098

# Is this a D-Bus signal?

1070

1099

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

1071

# Extract the original non-method function by

1072

# black magic

1100

# Extract the original non-method undecorated

1101

# function by black magic

1073

1102

nonmethod_func = (dict(

1074

1103

zip(attribute.func_code.co_freevars,

1075

1104

attribute.__closure__))["func"]

1968

1997

if self.address_family == socket.AF_INET6:

1969

1998

any_address = "::" # in6addr_any

1970

1999

else:

1971

any_address = socket.INADDR_ANY

2000

any_address = "0.0.0.0" # INADDR_ANY

1972

2001

self.server_address = (any_address,

1973

2002

self.server_address[1])

1974

2003

elif not self.server_address[1]:

2090

2119

return True

2091

2120

2092

2121

2122

def rfc3339_duration_to_delta(duration):

2123

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

2124

2125

>>> rfc3339_duration_to_delta("P7D")

2126

datetime.timedelta(7)

2127

>>> rfc3339_duration_to_delta("PT60S")

2128

datetime.timedelta(0, 60)

2129

>>> rfc3339_duration_to_delta("PT60M")

2130

datetime.timedelta(0, 3600)

2131

>>> rfc3339_duration_to_delta("PT24H")

2132

datetime.timedelta(1)

2133

>>> rfc3339_duration_to_delta("P1W")

2134

datetime.timedelta(7)

2135

>>> rfc3339_duration_to_delta("PT5M30S")

2136

datetime.timedelta(0, 330)

2137

>>> rfc3339_duration_to_delta("P1DT3M20S")

2138

datetime.timedelta(1, 200)

2139

"""

2140

2141

# Parsing an RFC 3339 duration with regular expressions is not

2142

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

2143

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

2144

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

2145

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

2146

# avoid excessive use of external libraries.

2147

2148

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

2149

Token = collections.namedtuple("Token",

2150

("regexp", # To match token; if

2151

# "value" is not None,

2152

# must have a "group"

2153

# containing digits

2154

"value", # datetime.timedelta or

2155

# None

2156

"followers")) # Tokens valid after

2157

# this token

2158

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

2159

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

2160

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

2161

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

2162

datetime.timedelta(seconds=1),

2163

frozenset((token_end,)))

2164

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

2165

datetime.timedelta(minutes=1),

2166

frozenset((token_second, token_end)))

2167

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

2168

datetime.timedelta(hours=1),

2169

frozenset((token_minute, token_end)))

2170

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

2171

None,

2172

frozenset((token_hour, token_minute,

2173

token_second)))

2174

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

2175

datetime.timedelta(days=1),

2176

frozenset((token_time, token_end)))

2177

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

2178

datetime.timedelta(weeks=4),

2179

frozenset((token_day, token_end)))

2180

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

2181

datetime.timedelta(weeks=52),

2182

frozenset((token_month, token_end)))

2183

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

2184

datetime.timedelta(weeks=1),

2185

frozenset((token_end,)))

2186

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

2187

frozenset((token_year, token_month,

2188

token_day, token_time,

2189

token_week))),

2190

# Define starting values

2191

value = datetime.timedelta() # Value so far

2192

found_token = None

2193

followers = frozenset(token_duration,) # Following valid tokens

2194

s = duration # String left to parse

2195

# Loop until end token is found

2196

while found_token is not token_end:

2197

# Search for any currently valid tokens

2198

for token in followers:

2199

match = token.regexp.match(s)

2200

if match is not None:

2201

# Token found

2202

if token.value is not None:

2203

# Value found, parse digits

2204

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

2205

# Add to value so far

2206

value += factor * token.value

2207

# Strip token from string

2208

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

2209

# Go to found token

2210

found_token = token

2211

# Set valid next tokens

2212

followers = found_token.followers

2213

break

2214

else:

2215

# No currently valid tokens were found

2216

raise ValueError("Invalid RFC 3339 duration")

2217

# End token found

2218

return value

2219

2220

2093

2221

def string_to_delta(interval):

2094

2222

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

2095

2223

2106

2234

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

2107

2235

datetime.timedelta(0, 330)

2108

2236

"""

2237

2238

try:

2239

return rfc3339_duration_to_delta(interval)

2240

except ValueError:

2241

pass

2242

2109

2243

timevalue = datetime.timedelta(0)

2110

2244

for s in interval.split():

2111

2245

try:

2174

2308

help="Run self-test")

2175

2309

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

2176

2310

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

2177

" to terminal")

2311

" to terminal", default=None)

2178

2312

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

2179

2313

help="Debug level for stdout output")

2180

2314

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

2187

2321

" files")

2188

2322

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

2189

2323

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

2190

" system bus interface")

2324

" system bus interface", default=None)

2191

2325

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

2192

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

2326

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

2327

default=None)

2193

2328

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

2194

2329

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

2195

" state")

2330

" state", default=None)

2196

2331

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

2197

2332

help="Specify a file descriptor to a network"

2198

2333

" socket to use instead of creating one")

2199

2334

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

2200

2335

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

2201

2336

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

2202

help="Run in foreground")

2337

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

2203

2338

2204

2339

options = parser.parse_args()

2205

2340

2214

2349

"port": "",

2215

2350

"debug": "False",

2216

2351

"priority":

2217

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

2352

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

2218

2353

"servicename": "Mandos",

2219

2354

"use_dbus": "True",

2220

2355

"use_ipv6": "True",

2264

2399

for option in server_settings.keys():

2265

2400

if type(server_settings[option]) is str:

2266

2401

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

2402

# Force all boolean options to be boolean

2403

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

2404

"foreground"):

2405

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

2267

2406

# Debug implies foreground

2268

2407

if server_settings["debug"]:

2269

2408

server_settings["foreground"] = True

2317

2456

socketfd=(server_settings["socket"]

2318

2457

or None))

2319

2458

if not foreground:

2320

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

2459

pidfilename = "/run/mandos.pid"

2460

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

2461

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

2321

2462

pidfile = None

2322

2463

try:

2323

2464

pidfile = open(pidfilename, "w")

2409

2550

old_client_settings = {}

2410

2551

clients_data = {}

2411

2552

2553

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

2554

global wnull

2555

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

2556

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

2557

# mode

2558

if debug or not foreground:

2559

wnull.close()

2560

2412

2561

# Get client data and settings from last running state.

2413

2562

if server_settings["restore"]:

2414

2563

try:

2430

2579

2431

2580

with PGPEngine() as pgp:

2432

2581

for client_name, client in clients_data.iteritems():

2582

# Skip removed clients

2583

if client_name not in client_settings:

2584

continue

2585

2433

2586

# Decide which value to use after restoring saved state.

2434

2587

# We have three different values: Old config file,

2435

2588

# new config file, and saved state.

2497

2650

# Create all client objects

2498

2651

for client_name, client in clients_data.iteritems():

2499

2652

tcp_server.clients[client_name] = client_class(

2500

name = client_name, settings = client)

2653

name = client_name, settings = client,

2654

server_settings = server_settings)

2501

2655

2502

2656

if not tcp_server.clients:

2503

2657

logger.warning("No clients defined")

2586

2740

service.cleanup()

2587

2741

2588

2742

multiprocessing.active_children()

2743

wnull.close()

2589

2744

if not (tcp_server.clients or client_settings):

2590

2745

return

2591

2746

2603

2758

# A list of attributes that can not be pickled

2604

2759

# + secret.

2605

2760

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

2606

"checker"))

2761

"checker", "server_settings"))

2607

2762

for name, typ in (inspect.getmembers

2608

2763

(dbus.service.Object)):

2609

2764

exclude.add(name)