1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
from __future__ import (absolute_import, print_function, division)
import traceback
from netlib import tcp
import netlib.http.http2
from ..exceptions import ProtocolException
from .layer import Layer
class TlsLayer(Layer):
def __init__(self, ctx, client_tls, server_tls):
super(TlsLayer, self).__init__(ctx)
self._client_tls = client_tls
self._server_tls = server_tls
self.client_sni = None
self._sni_from_server_change = None
self.client_alpn_protos = None
self.__server_tls_exception = None
# foo alpn protos = [netlib.http.http1.HTTP1Protocol.ALPN_PROTO_HTTP1, netlib.http.http2.HTTP2Protocol.ALPN_PROTO_H2], # TODO: read this from client_conn first
def __call__(self):
"""
The strategy for establishing SSL is as follows:
First, we determine whether we need the server cert to establish ssl with the client.
If so, we first connect to the server and then to the client.
If not, we only connect to the client and do the server_ssl lazily on a Connect message.
An additional complexity is that establish ssl with the server may require a SNI value from the client.
In an ideal world, we'd do the following:
1. Start the SSL handshake with the client
2. Check if the client sends a SNI.
3. Pause the client handshake, establish SSL with the server.
4. Finish the client handshake with the certificate from the server.
There's just one issue: We cannot get a callback from OpenSSL if the client doesn't send a SNI. :(
Thus, we resort to the following workaround when establishing SSL with the server:
1. Try to establish SSL with the server without SNI. If this fails, we ignore it.
2. Establish SSL with client.
- If there's a SNI callback, reconnect to the server with SNI.
- If not and the server connect failed, raise the original exception.
Further notes:
- OpenSSL 1.0.2 introduces a callback that would help here:
https://www.openssl.org/docs/ssl/SSL_CTX_set_cert_cb.html
- The original mitmproxy issue is https://github.com/mitmproxy/mitmproxy/issues/427
"""
client_tls_requires_server_cert = (
self._client_tls and self._server_tls and not self.config.no_upstream_cert
)
if client_tls_requires_server_cert:
self._establish_tls_with_client_and_server()
elif self._client_tls:
self._establish_tls_with_client()
layer = self.ctx.next_layer(self)
layer()
def connect(self):
if not self.server_conn:
self.ctx.connect()
if self._server_tls and not self._server_tls_established:
self._establish_tls_with_server()
def reconnect(self):
self.ctx.reconnect()
if self._server_tls and not self._server_tls_established:
self._establish_tls_with_server()
def set_server(self, address, server_tls, sni, depth=1):
self.ctx.set_server(address, server_tls, sni, depth)
if server_tls is not None:
self._sni_from_server_change = sni
self._server_tls = server_tls
@property
def _server_tls_established(self):
return self.server_conn and self.server_conn.tls_established
@property
def sni_for_upstream_connection(self):
if self._sni_from_server_change is False:
return None
else:
return self._sni_from_server_change or self.client_sni
def _establish_tls_with_client_and_server(self):
"""
This function deals with the problem that the server may require a SNI value from the client.
"""
# First, try to connect to the server.
self.ctx.connect()
server_err = None
try:
self._establish_tls_with_server()
except ProtocolException as e:
server_err = e
self._establish_tls_with_client()
if server_err and not self.client_sni:
raise server_err
def __handle_sni(self, connection):
"""
This callback gets called during the TLS handshake with the client.
The client has just sent the Sever Name Indication (SNI).
"""
old_upstream_sni = self.sni_for_upstream_connection
sn = connection.get_servername()
if not sn:
return
self.client_sni = sn.decode("utf8").encode("idna")
server_sni_changed = (old_upstream_sni != self.sni_for_upstream_connection)
server_conn_with_tls_exists = (self.server_conn and self._server_tls)
if server_sni_changed and server_conn_with_tls_exists:
try:
self.reconnect()
except Exception as e:
self.__server_tls_exception = e
# Now, change client context to reflect possibly changed certificate:
cert, key, chain_file = self._find_cert()
new_context = self.client_conn.create_ssl_context(
cert, key,
method=self.config.openssl_method_client,
options=self.config.openssl_options_client,
cipher_list=self.config.ciphers_client,
dhparams=self.config.certstore.dhparams,
chain_file=chain_file,
alpn_select_callback=self.__handle_alpn_select,
)
connection.set_context(new_context)
def __handle_alpn_select(self, conn_, options):
# TODO: change to something meaningful?
# alpn_preference = netlib.http.http1.HTTP1Protocol.ALPN_PROTO_HTTP1
alpn_preference = netlib.http.http2.HTTP2Protocol.ALPN_PROTO_H2
# TODO: Don't reconnect twice?
upstream_alpn_changed = (self.client_alpn_protos != options)
server_conn_with_tls_exists = (self.server_conn and self._server_tls)
if upstream_alpn_changed and server_conn_with_tls_exists:
try:
self.reconnect()
except Exception as e:
self.__server_tls_exception = e
self.client_alpn_protos = options
if alpn_preference in options:
return bytes(alpn_preference)
else: # pragma no cover
return options[0]
def _establish_tls_with_client(self):
self.log("Establish TLS with client", "debug")
cert, key, chain_file = self._find_cert()
try:
self.client_conn.convert_to_ssl(
cert, key,
method=self.config.openssl_method_client,
options=self.config.openssl_options_client,
handle_sni=self.__handle_sni,
cipher_list=self.config.ciphers_client,
dhparams=self.config.certstore.dhparams,
chain_file=chain_file,
alpn_select_callback=self.__handle_alpn_select,
)
except tcp.NetLibError as e:
print("alpn: %s" % self.client_alpn_protos)
raise ProtocolException(repr(e), e)
# Do not raise server tls exceptions immediately.
# We want to try to finish the client handshake so that other layers can send error messages over it.
if self.__server_tls_exception:
raise self.__server_tls_exception
def _establish_tls_with_server(self):
self.log("Establish TLS with server", "debug")
try:
self.server_conn.establish_ssl(
self.config.clientcerts,
self.sni_for_upstream_connection,
method=self.config.openssl_method_server,
options=self.config.openssl_options_server,
verify_options=self.config.openssl_verification_mode_server,
ca_path=self.config.openssl_trusted_cadir_server,
ca_pemfile=self.config.openssl_trusted_ca_server,
cipher_list=self.config.ciphers_server,
alpn_protos=self.client_alpn_protos,
)
tls_cert_err = self.server_conn.ssl_verification_error
if tls_cert_err is not None:
self.log(
"TLS verification failed for upstream server at depth %s with error: %s" %
(tls_cert_err['depth'], tls_cert_err['errno']),
"error")
self.log("Ignoring server verification error, continuing with connection", "error")
except tcp.NetLibInvalidCertificateError as e:
tls_cert_err = self.server_conn.ssl_verification_error
self.log(
"TLS verification failed for upstream server at depth %s with error: %s" %
(tls_cert_err['depth'], tls_cert_err['errno']),
"error")
self.log("Aborting connection attempt", "error")
raise ProtocolException(repr(e), e)
except tcp.NetLibError as e:
raise ProtocolException(repr(e), e)
def _find_cert(self):
host = self.server_conn.address.host
sans = set()
# Incorporate upstream certificate
if self.server_conn and self.server_conn.tls_established and (not self.config.no_upstream_cert):
upstream_cert = self.server_conn.cert
sans.update(upstream_cert.altnames)
if upstream_cert.cn:
sans.add(host)
host = upstream_cert.cn.decode("utf8").encode("idna")
# Also add SNI values.
if self.client_sni:
sans.add(self.client_sni)
if self._sni_from_server_change:
sans.add(self._sni_from_server_change)
sans.discard(host)
return self.config.certstore.get_cert(host, list(sans))
|
