/mandos/release : revision 237.7.195

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

93

92

stored_state_file = "clients.pickle"

94

93

95

94

logger = logging.getLogger()

140

139

class PGPEngine(object):

141

140

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

142

141

def __init__(self):

143

self.gnupg = GnuPGInterface.GnuPG()

144

142

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

143

self.gnupgargs = ['--batch',

144

'--home', self.tempdir,

145

'--force-mdc',

146

'--quiet',

147

'--no-use-agent']

151

148

152

149

def __enter__(self):

153

150

return self

175

172

def password_encode(self, password):

176

173

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

177

174

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

178

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

179

182

180

183

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

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)

195

199

return ciphertext

196

200

197

201

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

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)

212

218

return decrypted_plaintext

213

219

214

220

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.

440

446

runtime_expansions: Allowed attributes for runtime expansion.

441

447

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

442

448

disabled, or None

449

server_settings: The server_settings dict from main()

443

450

"""

444

451

445

452

runtime_expansions = ("approval_delay", "approval_duration",

520

527

521

528

return settings

522

529

523

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

530

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

524

531

self.name = name

532

if server_settings is None:

533

server_settings = {}

534

self.server_settings = server_settings

525

535

# adding all client settings

526

536

for setting, value in settings.iteritems():

527

537

setattr(self, setting, value)

680

690

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

681

691

try:

682

692

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

693

except AttributeError:

694

pass

695

except OSError as error:

696

if error.errno != errno.ECHILD:

697

raise

687

698

else:

688

699

if pid:

689

700

logger.warning("Checker was a zombie")

711

722

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

712

723

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

713

724

# always replaced by /dev/null.)

725

# The exception is when not debugging but nevertheless

726

# running in the foreground; use the previously

727

# created wnull.

728

popen_args = {}

729

if (not self.server_settings["debug"]

730

and self.server_settings["foreground"]):

731

popen_args.update({"stdout": wnull,

732

"stderr": wnull })

714

733

self.checker = subprocess.Popen(command,

715

734

close_fds=True,

716

shell=True, cwd="/")

735

shell=True, cwd="/",

736

**popen_args)

717

737

except OSError as error:

718

738

logger.error("Failed to start subprocess",

719

739

exc_info=error)

740

return True

720

741

self.checker_callback_tag = (gobject.child_watch_add

721

742

(self.checker.pid,

722

743

self.checker_callback,

723

744

data=command))

724

745

# The checker may have completed before the gobject

725

746

# watch was added. Check for this.

726

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

747

try:

748

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

749

except OSError as error:

750

if error.errno == errno.ECHILD:

751

# This should never happen

752

logger.error("Child process vanished",

753

exc_info=error)

754

return True

755

raise

727

756

if pid:

728

757

gobject.source_remove(self.checker_callback_tag)

729

758

self.checker_callback(pid, status, command)

1069

1098

interface_names.add(alt_interface)

1070

1099

# Is this a D-Bus signal?

1071

1100

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

1072

# Extract the original non-method function by

1073

# black magic

1101

# Extract the original non-method undecorated

1102

# function by black magic

1074

1103

nonmethod_func = (dict(

1075

1104

zip(attribute.func_code.co_freevars,

1076

1105

attribute.__closure__))["func"]

1674

1703

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

1675

1704

try:

1676

1705

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

1677

raise RuntimeError

1706

raise RuntimeError(line)

1678

1707

except (ValueError, IndexError, RuntimeError) as error:

1679

1708

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

1680

1709

return

1887

1916

1888

1917

def add_pipe(self, parent_pipe, proc):

1889

1918

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

1890

raise NotImplementedError

1919

raise NotImplementedError()

1891

1920

1892

1921

1893

1922

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1969

1998

if self.address_family == socket.AF_INET6:

1970

1999

any_address = "::" # in6addr_any

1971

2000

else:

1972

any_address = socket.INADDR_ANY

2001

any_address = "0.0.0.0" # INADDR_ANY

1973

2002

self.server_address = (any_address,

1974

2003

self.server_address[1])

1975

2004

elif not self.server_address[1]:

2230

2259

else:

2231

2260

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

2232

2261

.format(suffix))

2233

except (ValueError, IndexError) as e:

2262

except IndexError as e:

2234

2263

raise ValueError(*(e.args))

2235

2264

timevalue += delta

2236

2265

return timevalue

2280

2309

help="Run self-test")

2281

2310

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

2282

2311

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

2283

" to terminal")

2312

" to terminal", default=None)

2284

2313

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

2285

2314

help="Debug level for stdout output")

2286

2315

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

2293

2322

" files")

2294

2323

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

2295

2324

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

2296

" system bus interface")

2325

" system bus interface", default=None)

2297

2326

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

2298

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

2327

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

2328

default=None)

2299

2329

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

2300

2330

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

2301

" state")

2331

" state", default=None)

2302

2332

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

2303

2333

help="Specify a file descriptor to a network"

2304

2334

" socket to use instead of creating one")

2305

2335

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

2306

2336

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

2307

2337

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

2308

help="Run in foreground")

2338

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

2309

2339

2310

2340

options = parser.parse_args()

2311

2341

2320

2350

"port": "",

2321

2351

"debug": "False",

2322

2352

"priority":

2323

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

2353

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

2324

2354

"servicename": "Mandos",

2325

2355

"use_dbus": "True",

2326

2356

"use_ipv6": "True",

2370

2400

for option in server_settings.keys():

2371

2401

if type(server_settings[option]) is str:

2372

2402

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

2403

# Force all boolean options to be boolean

2404

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

2405

"foreground"):

2406

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

2373

2407

# Debug implies foreground

2374

2408

if server_settings["debug"]:

2375

2409

server_settings["foreground"] = True

2423

2457

socketfd=(server_settings["socket"]

2424

2458

or None))

2425

2459

if not foreground:

2426

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

2460

pidfilename = "/run/mandos.pid"

2461

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

2462

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

2427

2463

pidfile = None

2428

2464

try:

2429

2465

pidfile = open(pidfilename, "w")

2446

2482

os.setuid(uid)

2447

2483

except OSError as error:

2448

2484

if error.errno != errno.EPERM:

2449

raise error

2485

raise

2450

2486

2451

2487

if debug:

2452

2488

# Enable all possible GnuTLS debugging

2515

2551

old_client_settings = {}

2516

2552

clients_data = {}

2517

2553

2554

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

2555

global wnull

2556

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

2557

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

2558

# mode

2559

if debug or not foreground:

2560

wnull.close()

2561

2518

2562

# Get client data and settings from last running state.

2519

2563

if server_settings["restore"]:

2520

2564

try:

2536

2580

2537

2581

with PGPEngine() as pgp:

2538

2582

for client_name, client in clients_data.iteritems():

2583

# Skip removed clients

2584

if client_name not in client_settings:

2585

continue

2586

2539

2587

# Decide which value to use after restoring saved state.

2540

2588

# We have three different values: Old config file,

2541

2589

# new config file, and saved state.

2603

2651

# Create all client objects

2604

2652

for client_name, client in clients_data.iteritems():

2605

2653

tcp_server.clients[client_name] = client_class(

2606

name = client_name, settings = client)

2654

name = client_name, settings = client,

2655

server_settings = server_settings)

2607

2656

2608

2657

if not tcp_server.clients:

2609

2658

logger.warning("No clients defined")

2692

2741

service.cleanup()

2693

2742

2694

2743

multiprocessing.active_children()

2744

wnull.close()

2695

2745

if not (tcp_server.clients or client_settings):

2696

2746

return

2697

2747

2709

2759

# A list of attributes that can not be pickled

2710

2760

# + secret.

2711

2761

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

2712

"checker"))

2762

"checker", "server_settings"))

2713

2763

for name, typ in (inspect.getmembers

2714

2764

(dbus.service.Object)):

2715

2765

exclude.add(name)

2743

2793

else:

2744

2794

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

2745

2795

exc_info=e)

2746

raise e

2796

raise

2747

2797

2748

2798

# Delete all clients, and settings from config

2749

2799

while tcp_server.clients: