Debian Codegraph @

Modules/_ssl/debughelpers.c

raw
1 /* Debug helpers */
2
3 #ifndef SSL3_MT_CHANGE_CIPHER_SPEC
4 /* Dummy message type for handling CCS like a normal handshake message
5 * not defined in OpenSSL 1.0.2
6 */
7 #define SSL3_MT_CHANGE_CIPHER_SPEC 0x0101
8 #endif
9
10 static void
11 _PySSL_msg_callback(int write_p, int version, int content_type,
12 const void *buf, size_t len, SSL *ssl, void *arg)
13 {
14 const char *cbuf = (const char *)buf;
15 PyGILState_STATE threadstate;
16 PyObject *res = NULL;
17 PySSLSocket *ssl_obj = NULL; /* ssl._SSLSocket, borrowed ref */
18 int msg_type;
19
20 threadstate = PyGILState_Ensure();
21
22 ssl_obj = (PySSLSocket *)SSL_get_app_data(ssl);
23 assert(Py_IS_TYPE(ssl_obj, get_state_sock(ssl_obj)->PySSLSocket_Type));
24 if (ssl_obj->ctx->msg_cb == NULL) {
25 PyGILState_Release(threadstate);
26 return;
27 }
28
29 PyObject *ssl_socket; /* ssl.SSLSocket or ssl.SSLObject */
30 if (ssl_obj->owner)
31 PyWeakref_GetRef(ssl_obj->owner, &ssl_socket);
32 else if (ssl_obj->Socket)
33 PyWeakref_GetRef(ssl_obj->Socket, &ssl_socket);
34 else
35 ssl_socket = (PyObject *)Py_NewRef(ssl_obj);
36 assert(ssl_socket != NULL); // PyWeakref_GetRef() can return NULL
37
38 /* assume that OpenSSL verifies all payload and buf len is of sufficient
39 length */
40 switch(content_type) {
41 case SSL3_RT_CHANGE_CIPHER_SPEC:
42 msg_type = SSL3_MT_CHANGE_CIPHER_SPEC;
43 break;
44 case SSL3_RT_ALERT:
45 /* byte 0: level */
46 /* byte 1: alert type */
47 msg_type = (int)cbuf[1];
48 break;
49 case SSL3_RT_HANDSHAKE:
50 msg_type = (int)cbuf[0];
51 break;
52 #ifdef SSL3_RT_HEADER
53 case SSL3_RT_HEADER:
54 /* frame header encodes version in bytes 1..2 */
55 version = cbuf[1] << 8 | cbuf[2];
56 msg_type = (int)cbuf[0];
57 break;
58 #endif
59 #ifdef SSL3_RT_INNER_CONTENT_TYPE
60 case SSL3_RT_INNER_CONTENT_TYPE:
61 msg_type = (int)cbuf[0];
62 break;
63 #endif
64 default:
65 /* never SSL3_RT_APPLICATION_DATA */
66 msg_type = -1;
67 break;
68 }
69
70 res = PyObject_CallFunction(
71 ssl_obj->ctx->msg_cb, "Osiiiy#",
72 ssl_socket, write_p ? "write" : "read",
73 version, content_type, msg_type,
74 buf, len
75 );
76 if (res == NULL) {
77 ssl_obj->exc = PyErr_GetRaisedException();
78 } else {
79 Py_DECREF(res);
80 }
81 Py_XDECREF(ssl_socket);
82
83 PyGILState_Release(threadstate);
84 }
85
86
87 static PyObject *
88 _PySSLContext_get_msg_callback(PyObject *op, void *Py_UNUSED(closure))
89 {
90 PySSLContext *self = PySSLContext_CAST(op);
91 if (self->msg_cb != NULL) {
92 return Py_NewRef(self->msg_cb);
93 } else {
94 Py_RETURN_NONE;
95 }
96 }
97
98 static int
99 _PySSLContext_set_msg_callback(PyObject *op, PyObject *arg,
100 void *Py_UNUSED(closure))
101 {
102 PySSLContext *self = PySSLContext_CAST(op);
103 Py_CLEAR(self->msg_cb);
104 if (arg == Py_None) {
105 SSL_CTX_set_msg_callback(self->ctx, NULL);
106 }
107 else {
108 if (!PyCallable_Check(arg)) {
109 SSL_CTX_set_msg_callback(self->ctx, NULL);
110 PyErr_SetString(PyExc_TypeError,
111 "not a callable object");
112 return -1;
113 }
114 self->msg_cb = Py_NewRef(arg);
115 SSL_CTX_set_msg_callback(self->ctx, _PySSL_msg_callback);
116 }
117 return 0;
118 }
119
120 static void
121 _PySSL_keylog_callback(const SSL *ssl, const char *line)
122 {
123 PyGILState_STATE threadstate;
124 PySSLSocket *ssl_obj = NULL; /* ssl._SSLSocket, borrowed ref */
125 int res, e;
126
127 threadstate = PyGILState_Ensure();
128
129 ssl_obj = (PySSLSocket *)SSL_get_app_data(ssl);
130 assert(Py_IS_TYPE(ssl_obj, get_state_sock(ssl_obj)->PySSLSocket_Type));
131 PyThread_type_lock lock = get_state_sock(ssl_obj)->keylog_lock;
132 assert(lock != NULL);
133 if (ssl_obj->ctx->keylog_bio == NULL) {
134 return;
135 }
136 /*
137 * The lock is neither released on exit nor on fork(). The lock is
138 * also shared between all SSLContexts although contexts may write to
139 * their own files. IMHO that's good enough for a non-performance
140 * critical debug helper.
141 */
142
143 Py_BEGIN_ALLOW_THREADS
144 PyThread_acquire_lock(lock, 1);
145 res = BIO_printf(ssl_obj->ctx->keylog_bio, "%s\n", line);
146 e = errno;
147 (void)BIO_flush(ssl_obj->ctx->keylog_bio);
148 PyThread_release_lock(lock);
149 Py_END_ALLOW_THREADS
150 _PySSL_FIX_ERRNO;
151
152 if (res == -1) {
153 errno = e;
154 PyErr_SetFromErrnoWithFilenameObject(PyExc_OSError,
155 ssl_obj->ctx->keylog_filename);
156 ssl_obj->exc = PyErr_GetRaisedException();
157 }
158 PyGILState_Release(threadstate);
159 }
160
161 static PyObject *
162 _PySSLContext_get_keylog_filename(PyObject *op, void *Py_UNUSED(closure))
163 {
164 PySSLContext *self = PySSLContext_CAST(op);
165 if (self->keylog_filename != NULL) {
166 return Py_NewRef(self->keylog_filename);
167 } else {
168 Py_RETURN_NONE;
169 }
170 }
171
172 static int
173 _PySSLContext_set_keylog_filename(PyObject *op, PyObject *arg,
174 void *Py_UNUSED(closure))
175 {
176 PySSLContext *self = PySSLContext_CAST(op);
177 FILE *fp;
178
179 #if defined(MS_WINDOWS) && defined(_DEBUG)
180 PyErr_SetString(PyExc_NotImplementedError,
181 "set_keylog_filename: unavailable on Windows debug build");
182 return -1;
183 #endif
184
185 /* Reset variables and callback first */
186 SSL_CTX_set_keylog_callback(self->ctx, NULL);
187 Py_CLEAR(self->keylog_filename);
188 if (self->keylog_bio != NULL) {
189 BIO *bio = self->keylog_bio;
190 self->keylog_bio = NULL;
191 Py_BEGIN_ALLOW_THREADS
192 BIO_free_all(bio);
193 Py_END_ALLOW_THREADS
194 _PySSL_FIX_ERRNO;
195 }
196
197 if (arg == Py_None) {
198 /* None disables the callback */
199 return 0;
200 }
201
202 /* Py_fopen() also checks that arg is of proper type. */
203 fp = Py_fopen(arg, "a" PY_STDIOTEXTMODE);
204 if (fp == NULL)
205 return -1;
206
207 self->keylog_bio = BIO_new_fp(fp, BIO_CLOSE | BIO_FP_TEXT);
208 if (self->keylog_bio == NULL) {
209 PyErr_SetString(get_state_ctx(self)->PySSLErrorObject,
210 "Can't malloc memory for keylog file");
211 return -1;
212 }
213 self->keylog_filename = Py_NewRef(arg);
214
215 /* Write a header for seekable, empty files (this excludes pipes). */
216 PySSL_BEGIN_ALLOW_THREADS(self)
217 if (BIO_tell(self->keylog_bio) == 0) {
218 BIO_puts(self->keylog_bio,
219 "# TLS secrets log file, generated by OpenSSL / Python\n");
220 (void)BIO_flush(self->keylog_bio);
221 }
222 PySSL_END_ALLOW_THREADS(self)
223 SSL_CTX_set_keylog_callback(self->ctx, _PySSL_keylog_callback);
224 return 0;
225 }