/mandos/trunk : revision 1215

1

#!/usr/bin/python

1

#!/usr/bin/python3 -bI

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.

78

import collections

79

import codecs

80

import unittest

81

import random

82

import shlex

81

83

82

84

import dbus

83

85

import dbus.service

91

93

92

94

if sys.version_info.major == 2:

93

95

__metaclass__ = type

96

str = unicode

97

98

# Add collections.abc.Callable if it does not exist

99

try:

100

collections.abc.Callable

101

except AttributeError:

102

class abc:

103

Callable = collections.Callable

104

collections.abc = abc

105

del abc

106

107

# Add shlex.quote if it does not exist

108

try:

109

shlex.quote

110

except AttributeError:

111

shlex.quote = re.escape

94

112

95

113

# Show warnings by default

96

114

if not sys.warnoptions:

122

140

# No value found

123

141

SO_BINDTODEVICE = None

124

142

125

if sys.version_info.major == 2:

126

str = unicode

127

128

143

if sys.version_info < (3, 2):

129

144

configparser.Configparser = configparser.SafeConfigParser

130

145

131

version = "1.8.8"

146

version = "1.8.11"

132

147

stored_state_file = "clients.pickle"

133

148

134

149

logger = logging.getLogger()

203

218

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

204

219

for line in output.splitlines():

205

220

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

206

if name == "gpg":

221

if name == b"gpg":

207

222

self.gpg = path

208

223

break

209

224

except OSError as e:

214

229

'--force-mdc',

215

230

'--quiet']

216

231

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

217

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

232

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

218

233

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

219

234

220

235

def __enter__(self):

1037

1052

if self.checker_initiator_tag is not None:

1038

1053

GLib.source_remove(self.checker_initiator_tag)

1039

1054

self.checker_initiator_tag = GLib.timeout_add(

1040

int(self.interval.total_seconds() * 1000),

1055

random.randrange(int(self.interval.total_seconds() * 1000

1056

+ 1)),

1041

1057

self.start_checker)

1042

1058

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

1043

1059

if self.disable_initiator_tag is not None:

1053

1069

# Read return code from connection (see call_pipe)

1054

1070

returncode = connection.recv()

1055

1071

connection.close()

1056

self.checker.join()

1072

if self.checker is not None:

1073

self.checker.join()

1057

1074

self.checker_callback_tag = None

1058

1075

self.checker = None

1059

1076

1117

1134

if self.checker is None:

1118

1135

# Escape attributes for the shell

1119

1136

escaped_attrs = {

1120

attr: re.escape(str(getattr(self, attr)))

1137

attr: shlex.quote(str(getattr(self, attr)))

1121

1138

for attr in self.runtime_expansions}

1122

1139

try:

1123

1140

command = self.checker_command % escaped_attrs

1150

1167

kwargs=popen_args)

1151

1168

self.checker.start()

1152

1169

self.checker_callback_tag = GLib.io_add_watch(

1153

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

1170

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

1171

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

1154

1172

self.checker_callback, pipe[0], command)

1155

1173

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

1156

1174

return True

1411

1429

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

1412

1430

"'ay' signature {!r}"

1413

1431

.format(prop._dbus_signature))

1414

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

1415

for byte in value))

1432

value = dbus.ByteArray(bytes(value))

1416

1433

prop(value)

1417

1434

1418

1435

@dbus.service.method(dbus.PROPERTIES_IFACE,

2680

2697

def add_pipe(self, parent_pipe, proc):

2681

2698

# Call "handle_ipc" for both data and EOF events

2682

2699

GLib.io_add_watch(

2683

parent_pipe.fileno(), GLib.PRIORITY_DEFAULT,

2684

GLib.IO_IN | GLib.IO_HUP,

2700

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

2701

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

2685

2702

functools.partial(self.handle_ipc,

2686

2703

parent_pipe=parent_pipe,

2687

2704

proc=proc))

2725

2742

return False

2726

2743

2727

2744

GLib.io_add_watch(

2728

parent_pipe.fileno(), GLib.PRIORITY_DEFAULT,

2729

GLib.IO_IN | GLib.IO_HUP,

2745

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

2746

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

2730

2747

functools.partial(self.handle_ipc,

2731

2748

parent_pipe=parent_pipe,

2732

2749

proc=proc,

2747

2764

if command == 'getattr':

2748

2765

attrname = request[1]

2749

2766

if isinstance(client_object.__getattribute__(attrname),

2750

collections.Callable):

2767

collections.abc.Callable):

2751

2768

parent_pipe.send(('function', ))

2752

2769

else:

2753

2770

parent_pipe.send((

2764

2781

def rfc3339_duration_to_delta(duration):

2765

2782

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

2766

2783

2767

>>> rfc3339_duration_to_delta("P7D")

2768

datetime.timedelta(7)

2769

>>> rfc3339_duration_to_delta("PT60S")

2770

datetime.timedelta(0, 60)

2771

>>> rfc3339_duration_to_delta("PT60M")

2772

datetime.timedelta(0, 3600)

2773

>>> rfc3339_duration_to_delta("PT24H")

2774

datetime.timedelta(1)

2775

>>> rfc3339_duration_to_delta("P1W")

2776

datetime.timedelta(7)

2777

>>> rfc3339_duration_to_delta("PT5M30S")

2778

datetime.timedelta(0, 330)

2779

>>> rfc3339_duration_to_delta("P1DT3M20S")

2780

datetime.timedelta(1, 200)

2784

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

2785

True

2786

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

2787

True

2788

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

2789

True

2790

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

2791

True

2792

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

2793

True

2794

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

2795

True

2796

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

2797

True

2781

2798

"""

2782

2799

2783

2800

# Parsing an RFC 3339 duration with regular expressions is not

2863

2880

def string_to_delta(interval):

2864

2881

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

2865

2882

2866

>>> string_to_delta('7d')

2867

datetime.timedelta(7)

2868

>>> string_to_delta('60s')

2869

datetime.timedelta(0, 60)

2870

>>> string_to_delta('60m')

2871

datetime.timedelta(0, 3600)

2872

>>> string_to_delta('24h')

2873

datetime.timedelta(1)

2874

>>> string_to_delta('1w')

2875

datetime.timedelta(7)

2876

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

2877

datetime.timedelta(0, 330)

2883

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

2884

True

2885

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

2886

True

2887

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

2888

True

2889

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

2890

True

2891

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

2892

True

2893

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

2894

True

2878

2895

"""

2879

2896

2880

2897

try:

3250

3267

if isinstance(s, bytes)

3251

3268

else s) for s in

3252

3269

value["client_structure"]]

3253

# .name & .host

3254

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

3270

# .name, .host, and .checker_command

3271

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

3255

3272

if isinstance(value[k], bytes):

3256

3273

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

3257

3274

if "key_id" not in value:

3267

3284

for key, value in

3268

3285

bytes_old_client_settings.items()}

3269

3286

del bytes_old_client_settings

3270

# .host

3287

# .host and .checker_command

3271

3288

for value in old_client_settings.values():

3272

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

3273

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

3274

.decode("utf-8"))

3289

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

3290

if isinstance(value[attribute], bytes):

3291

value[attribute] = (value[attribute]

3292

.decode("utf-8"))

3275

3293

os.remove(stored_state_path)

3276

3294

except IOError as e:

3277

3295

if e.errno == errno.ENOENT:

3602

3620

sys.exit(1)

3603

3621

# End of Avahi example code

3604

3622

3605

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

3606

GLib.IO_IN,

3607

lambda *args, **kwargs:

3608

(tcp_server.handle_request

3609

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

3623

GLib.io_add_watch(

3624

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

3625

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

3626

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

3627

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

3610

3628

3611

3629

logger.debug("Starting main loop")

3612

3630

main_loop.run()