| 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 |
} |