/mandos/trunk : revision 1173

1

#!/usr/bin/python

2

# -*- mode: python; coding: utf-8 -*-

1

#!/usr/bin/python3 -b

2

# -*- mode: python; after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --check" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-

3

#

4

# Mandos server - give out binary blobs to connecting clients.

5

#

77

import itertools

78

import collections

79

import codecs

80

import unittest

80

81

82

import dbus

82

83

import dbus.service

84

import gi

83

85

from gi.repository import GLib

84

86

from dbus.mainloop.glib import DBusGMainLoop

85

87

import ctypes

87

89

import xml.dom.minidom

88

90

import inspect

89

91

92

if sys.version_info.major == 2:

93

__metaclass__ = type

94

95

# Show warnings by default

96

if not sys.warnoptions:

97

import warnings

98

warnings.simplefilter("default")

99

90

100

# Try to find the value of SO_BINDTODEVICE:

91

101

try:

92

102

# This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and

115

125

if sys.version_info.major == 2:

116

126

str = unicode

117

127

118

version = "1.8.4"

128

if sys.version_info < (3, 2):

129

configparser.Configparser = configparser.SafeConfigParser

130

131

version = "1.8.8"

119

132

stored_state_file = "clients.pickle"

120

133

121

134

logger = logging.getLogger()

135

logging.captureWarnings(True) # Show warnings via the logging system

122

136

syslogger = None

123

137

124

138

try:

179

193

pass

180

194

181

195

182

class PGPEngine(object):

196

class PGPEngine:

183

197

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

184

198

185

199

def __init__(self):

189

203

output = subprocess.check_output(["gpgconf"])

190

204

for line in output.splitlines():

191

205

name, text, path = line.split(b":")

192

if name == "gpg":

206

if name == b"gpg":

193

207

self.gpg = path

194

208

break

195

209

except OSError as e:

200

214

'--force-mdc',

201

215

'--quiet']

202

216

# Only GPG version 1 has the --no-use-agent option.

203

if self.gpg == "gpg" or self.gpg.endswith("/gpg"):

217

if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):

204

218

self.gnupgargs.append("--no-use-agent")

205

219

206

220

def __enter__(self):

275

289

276

290

277

291

# Pretend that we have an Avahi module

278

class avahi(object):

292

class avahi:

279

293

"""This isn't so much a class as it is a module-like namespace."""

280

294

IF_UNSPEC = -1 # avahi-common/address.h

281

295

PROTO_UNSPEC = -1 # avahi-common/address.h

315

329

pass

316

330

317

331

318

class AvahiService(object):

332

class AvahiService:

319

333

"""An Avahi (Zeroconf) service.

320

334

321

335

Attributes:

503

517

504

518

505

519

# Pretend that we have a GnuTLS module

506

class gnutls(object):

520

class gnutls:

507

521

"""This isn't so much a class as it is a module-like namespace."""

508

522

509

523

library = ctypes.util.find_library("gnutls")

572

586

pass

573

587

574

588

# Classes

575

class Credentials(object):

589

class Credentials:

576

590

def __init__(self):

577

591

self._c_object = gnutls.certificate_credentials_t()

578

592

gnutls.certificate_allocate_credentials(

582

596

def __del__(self):

583

597

gnutls.certificate_free_credentials(self._c_object)

584

598

585

class ClientSession(object):

599

class ClientSession:

586

600

def __init__(self, socket, credentials=None):

587

601

self._c_object = gnutls.session_t()

588

602

gnutls_flags = gnutls.CLIENT

814

828

connection.close()

815

829

816

830

817

class Client(object):

831

class Client:

818

832

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

819

833

820

834

Attributes:

821

835

approved: bool(); 'None' if not yet approved/disapproved

822

836

approval_delay: datetime.timedelta(); Time to wait for approval

823

837

approval_duration: datetime.timedelta(); Duration of one approval

824

checker: subprocess.Popen(); a running checker process used

825

to see if the client lives.

826

'None' if no process is running.

838

checker: multiprocessing.Process(); a running checker process used

839

to see if the client lives. 'None' if no process is

840

running.

827

841

checker_callback_tag: a GLib event source tag, or None

828

842

checker_command: string; External command which is run to check

829

843

if client lives. %() expansions are done at

1036

1050

def checker_callback(self, source, condition, connection,

1037

1051

command):

1038

1052

"""The checker has completed, so take appropriate actions."""

1039

self.checker_callback_tag = None

1040

self.checker = None

1041

1053

# Read return code from connection (see call_pipe)

1042

1054

returncode = connection.recv()

1043

1055

connection.close()

1056

self.checker.join()

1057

self.checker_callback_tag = None

1058

self.checker = None

1044

1059

1045

1060

if returncode >= 0:

1046

1061

self.last_checker_status = returncode

1135

1150

kwargs=popen_args)

1136

1151

self.checker.start()

1137

1152

self.checker_callback_tag = GLib.io_add_watch(

1138

pipe[0].fileno(), GLib.IO_IN,

1153

GLib.IOChannel.unix_new(pipe[0].fileno()),

1154

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

1139

1155

self.checker_callback, pipe[0], command)

1140

1156

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

1141

1157

return True

2208

2224

del _interface

2209

2225

2210

2226

2211

class ProxyClient(object):

2227

class ProxyClient:

2212

2228

def __init__(self, child_pipe, key_id, fpr, address):

2213

2229

self._pipe = child_pipe

2214

2230

self._pipe.send(('init', key_id, fpr, address))

2487

2503

return hex_fpr

2488

2504

2489

2505

2490

class MultiprocessingMixIn(object):

2506

class MultiprocessingMixIn:

2491

2507

"""Like socketserver.ThreadingMixIn, but with multiprocessing"""

2492

2508

2493

2509

def sub_process_main(self, request, address):

2505

2521

return proc

2506

2522

2507

2523

2508

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2524

class MultiprocessingMixInWithPipe(MultiprocessingMixIn):

2509

2525

""" adds a pipe to the MixIn """

2510

2526

2511

2527

def process_request(self, request, client_address):

2526

2542

2527

2543

2528

2544

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2529

socketserver.TCPServer, object):

2545

socketserver.TCPServer):

2530

2546

"""IPv6-capable TCP server. Accepts 'None' as address and/or port

2531

2547

2532

2548

Attributes:

2665

2681

def add_pipe(self, parent_pipe, proc):

2666

2682

# Call "handle_ipc" for both data and EOF events

2667

2683

GLib.io_add_watch(

2668

parent_pipe.fileno(),

2669

GLib.IO_IN | GLib.IO_HUP,

2684

GLib.IOChannel.unix_new(parent_pipe.fileno()),

2685

GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,

2670

2686

functools.partial(self.handle_ipc,

2671

2687

parent_pipe=parent_pipe,

2672

2688

proc=proc))

2710

2726

return False

2711

2727

2712

2728

GLib.io_add_watch(

2713

parent_pipe.fileno(),

2714

GLib.IO_IN | GLib.IO_HUP,

2729

GLib.IOChannel.unix_new(parent_pipe.fileno()),

2730

GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,

2715

2731

functools.partial(self.handle_ipc,

2716

2732

parent_pipe=parent_pipe,

2717

2733

proc=proc,

2749

2765

def rfc3339_duration_to_delta(duration):

2750

2766

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

2751

2767

2752

>>> rfc3339_duration_to_delta("P7D")

2753

datetime.timedelta(7)

2754

>>> rfc3339_duration_to_delta("PT60S")

2755

datetime.timedelta(0, 60)

2756

>>> rfc3339_duration_to_delta("PT60M")

2757

datetime.timedelta(0, 3600)

2758

>>> rfc3339_duration_to_delta("PT24H")

2759

datetime.timedelta(1)

2760

>>> rfc3339_duration_to_delta("P1W")

2761

datetime.timedelta(7)

2762

>>> rfc3339_duration_to_delta("PT5M30S")

2763

datetime.timedelta(0, 330)

2764

>>> rfc3339_duration_to_delta("P1DT3M20S")

2765

datetime.timedelta(1, 200)

2768

>>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)

2769

True

2770

>>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)

2771

True

2772

>>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(0, 3600)

2773

True

2774

>>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)

2775

True

2776

>>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)

2777

True

2778

>>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)

2779

True

2780

>>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)

2781

True

2766

2782

"""

2767

2783

2768

2784

# Parsing an RFC 3339 duration with regular expressions is not

2848

2864

def string_to_delta(interval):

2849

2865

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

2850

2866

2851

>>> string_to_delta('7d')

2852

datetime.timedelta(7)

2853

>>> string_to_delta('60s')

2854

datetime.timedelta(0, 60)

2855

>>> string_to_delta('60m')

2856

datetime.timedelta(0, 3600)

2857

>>> string_to_delta('24h')

2858

datetime.timedelta(1)

2859

>>> string_to_delta('1w')

2860

datetime.timedelta(7)

2861

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

2862

datetime.timedelta(0, 330)

2867

>>> string_to_delta('7d') == datetime.timedelta(7)

2868

True

2869

>>> string_to_delta('60s') == datetime.timedelta(0, 60)

2870

True

2871

>>> string_to_delta('60m') == datetime.timedelta(0, 3600)

2872

True

2873

>>> string_to_delta('24h') == datetime.timedelta(1)

2874

True

2875

>>> string_to_delta('1w') == datetime.timedelta(7)

2876

True

2877

>>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)

2878

True

2863

2879

"""

2864

2880

2865

2881

try:

2967

2983

2968

2984

options = parser.parse_args()

2969

2985

2970

if options.check:

2971

import doctest

2972

fail_count, test_count = doctest.testmod()

2973

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

2974

2975

2986

# Default values for config file for server-global settings

2976

2987

if gnutls.has_rawpk:

2977

2988

priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"

2997

3008

del priority

2998

3009

2999

3010

# Parse config file for server-global settings

3000

server_config = configparser.SafeConfigParser(server_defaults)

3011

server_config = configparser.ConfigParser(server_defaults)

3001

3012

del server_defaults

3002

3013

server_config.read(os.path.join(options.configdir, "mandos.conf"))

3003

# Convert the SafeConfigParser object to a dict

3014

# Convert the ConfigParser object to a dict

3004

3015

server_settings = server_config.defaults()

3005

3016

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

3006

3017

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

3078

3089

server_settings["servicename"])))

3079

3090

3080

3091

# Parse config file with clients

3081

client_config = configparser.SafeConfigParser(Client

3082

.client_defaults)

3092

client_config = configparser.ConfigParser(Client.client_defaults)

3083

3093

client_config.read(os.path.join(server_settings["configdir"],

3084

3094

"clients.conf"))

3085

3095

3156

3166

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

3157

3167

daemon()

3158

3168

3159

# multiprocessing will use threads, so before we use GLib we need

3160

# to inform GLib that threads will be used.

3161

GLib.threads_init()

3169

if gi.version_info < (3, 10, 2):

3170

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

3171

# need to inform GLib that threads will be used.

3172

GLib.threads_init()

3162

3173

3163

3174

global main_loop

3164

3175

# From the Avahi example code

3240

3251

if isinstance(s, bytes)

3241

3252

else s) for s in

3242

3253

value["client_structure"]]

3243

# .name & .host

3244

for k in ("name", "host"):

3254

# .name, .host, and .checker_command

3255

for k in ("name", "host", "checker_command"):

3245

3256

if isinstance(value[k], bytes):

3246

3257

value[k] = value[k].decode("utf-8")

3247

3258

if "key_id" not in value:

3257

3268

for key, value in

3258

3269

bytes_old_client_settings.items()}

3259

3270

del bytes_old_client_settings

3260

# .host

3271

# .host and .checker_command

3261

3272

for value in old_client_settings.values():

3262

if isinstance(value["host"], bytes):

3263

value["host"] = (value["host"]

3264

.decode("utf-8"))

3273

for attribute in ("host", "checker_command"):

3274

if isinstance(value[attribute], bytes):

3275

value[attribute] = (value[attribute]

3276

.decode("utf-8"))

3265

3277

os.remove(stored_state_path)

3266

3278

except IOError as e:

3267

3279

if e.errno == errno.ENOENT:

3592

3604

sys.exit(1)

3593

3605

# End of Avahi example code

3594

3606

3595

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

3596

lambda *args, **kwargs:

3597

(tcp_server.handle_request

3598

(*args[2:], **kwargs) or True))

3607

GLib.io_add_watch(

3608

GLib.IOChannel.unix_new(tcp_server.fileno()),

3609

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

3610

lambda *args, **kwargs: (tcp_server.handle_request

3611

(*args[2:], **kwargs) or True))

3599

3612

3600

3613

logger.debug("Starting main loop")

3601

3614

main_loop.run()

3611

3624

# Must run before the D-Bus bus name gets deregistered

3612

3625

cleanup()

3613

3626

3627

3628

def should_only_run_tests():

3629

parser = argparse.ArgumentParser(add_help=False)

3630

parser.add_argument("--check", action='store_true')

3631

args, unknown_args = parser.parse_known_args()

3632

run_tests = args.check

3633

if run_tests:

3634

# Remove --check argument from sys.argv

3635

sys.argv[1:] = unknown_args

3636

return run_tests

3637

3638

# Add all tests from doctest strings

3639

def load_tests(loader, tests, none):

3640

import doctest

3641

tests.addTests(doctest.DocTestSuite())

3642

return tests

3614

3643

3615

3644

if __name__ == '__main__':

3616

main()

3645

try:

3646

if should_only_run_tests():

3647

# Call using ./mandos --check [--verbose]

3648

unittest.main()

3649

else:

3650

main()

3651

finally:

3652

logging.shutdown()