Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : PyDoc_STRVAR(_ssl__SSLSocket_do_handshake__doc__,
6 : : "do_handshake($self, /)\n"
7 : : "--\n"
8 : : "\n");
9 : :
10 : : #define _SSL__SSLSOCKET_DO_HANDSHAKE_METHODDEF \
11 : : {"do_handshake", (PyCFunction)_ssl__SSLSocket_do_handshake, METH_NOARGS, _ssl__SSLSocket_do_handshake__doc__},
12 : :
13 : : static PyObject *
14 : : _ssl__SSLSocket_do_handshake_impl(PySSLSocket *self);
15 : :
16 : : static PyObject *
17 : 1954 : _ssl__SSLSocket_do_handshake(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
18 : : {
19 : 1954 : return _ssl__SSLSocket_do_handshake_impl(self);
20 : : }
21 : :
22 : : PyDoc_STRVAR(_ssl__test_decode_cert__doc__,
23 : : "_test_decode_cert($module, path, /)\n"
24 : : "--\n"
25 : : "\n");
26 : :
27 : : #define _SSL__TEST_DECODE_CERT_METHODDEF \
28 : : {"_test_decode_cert", (PyCFunction)_ssl__test_decode_cert, METH_O, _ssl__test_decode_cert__doc__},
29 : :
30 : : static PyObject *
31 : : _ssl__test_decode_cert_impl(PyObject *module, PyObject *path);
32 : :
33 : : static PyObject *
34 : 6 : _ssl__test_decode_cert(PyObject *module, PyObject *arg)
35 : : {
36 : 6 : PyObject *return_value = NULL;
37 : : PyObject *path;
38 : :
39 [ - + ]: 6 : if (!PyUnicode_FSConverter(arg, &path)) {
40 : 0 : goto exit;
41 : : }
42 : 6 : return_value = _ssl__test_decode_cert_impl(module, path);
43 : :
44 : 6 : exit:
45 : 6 : return return_value;
46 : : }
47 : :
48 : : PyDoc_STRVAR(_ssl__SSLSocket_getpeercert__doc__,
49 : : "getpeercert($self, der=False, /)\n"
50 : : "--\n"
51 : : "\n"
52 : : "Returns the certificate for the peer.\n"
53 : : "\n"
54 : : "If no certificate was provided, returns None. If a certificate was\n"
55 : : "provided, but not validated, returns an empty dictionary. Otherwise\n"
56 : : "returns a dict containing information about the peer certificate.\n"
57 : : "\n"
58 : : "If the optional argument is True, returns a DER-encoded copy of the\n"
59 : : "peer certificate, or None if no certificate was provided. This will\n"
60 : : "return the certificate even if it wasn\'t validated.");
61 : :
62 : : #define _SSL__SSLSOCKET_GETPEERCERT_METHODDEF \
63 : : {"getpeercert", _PyCFunction_CAST(_ssl__SSLSocket_getpeercert), METH_FASTCALL, _ssl__SSLSocket_getpeercert__doc__},
64 : :
65 : : static PyObject *
66 : : _ssl__SSLSocket_getpeercert_impl(PySSLSocket *self, int binary_mode);
67 : :
68 : : static PyObject *
69 : 338 : _ssl__SSLSocket_getpeercert(PySSLSocket *self, PyObject *const *args, Py_ssize_t nargs)
70 : : {
71 : 338 : PyObject *return_value = NULL;
72 : 338 : int binary_mode = 0;
73 : :
74 [ + - - + : 338 : if (!_PyArg_CheckPositional("getpeercert", nargs, 0, 1)) {
- - ]
75 : 0 : goto exit;
76 : : }
77 [ - + ]: 338 : if (nargs < 1) {
78 : 0 : goto skip_optional;
79 : : }
80 : 338 : binary_mode = PyObject_IsTrue(args[0]);
81 [ - + ]: 338 : if (binary_mode < 0) {
82 : 0 : goto exit;
83 : : }
84 : 338 : skip_optional:
85 : 338 : return_value = _ssl__SSLSocket_getpeercert_impl(self, binary_mode);
86 : :
87 : 338 : exit:
88 : 338 : return return_value;
89 : : }
90 : :
91 : : PyDoc_STRVAR(_ssl__SSLSocket_get_verified_chain__doc__,
92 : : "get_verified_chain($self, /)\n"
93 : : "--\n"
94 : : "\n");
95 : :
96 : : #define _SSL__SSLSOCKET_GET_VERIFIED_CHAIN_METHODDEF \
97 : : {"get_verified_chain", (PyCFunction)_ssl__SSLSocket_get_verified_chain, METH_NOARGS, _ssl__SSLSocket_get_verified_chain__doc__},
98 : :
99 : : static PyObject *
100 : : _ssl__SSLSocket_get_verified_chain_impl(PySSLSocket *self);
101 : :
102 : : static PyObject *
103 : 2 : _ssl__SSLSocket_get_verified_chain(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
104 : : {
105 : 2 : return _ssl__SSLSocket_get_verified_chain_impl(self);
106 : : }
107 : :
108 : : PyDoc_STRVAR(_ssl__SSLSocket_get_unverified_chain__doc__,
109 : : "get_unverified_chain($self, /)\n"
110 : : "--\n"
111 : : "\n");
112 : :
113 : : #define _SSL__SSLSOCKET_GET_UNVERIFIED_CHAIN_METHODDEF \
114 : : {"get_unverified_chain", (PyCFunction)_ssl__SSLSocket_get_unverified_chain, METH_NOARGS, _ssl__SSLSocket_get_unverified_chain__doc__},
115 : :
116 : : static PyObject *
117 : : _ssl__SSLSocket_get_unverified_chain_impl(PySSLSocket *self);
118 : :
119 : : static PyObject *
120 : 2 : _ssl__SSLSocket_get_unverified_chain(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
121 : : {
122 : 2 : return _ssl__SSLSocket_get_unverified_chain_impl(self);
123 : : }
124 : :
125 : : PyDoc_STRVAR(_ssl__SSLSocket_shared_ciphers__doc__,
126 : : "shared_ciphers($self, /)\n"
127 : : "--\n"
128 : : "\n");
129 : :
130 : : #define _SSL__SSLSOCKET_SHARED_CIPHERS_METHODDEF \
131 : : {"shared_ciphers", (PyCFunction)_ssl__SSLSocket_shared_ciphers, METH_NOARGS, _ssl__SSLSocket_shared_ciphers__doc__},
132 : :
133 : : static PyObject *
134 : : _ssl__SSLSocket_shared_ciphers_impl(PySSLSocket *self);
135 : :
136 : : static PyObject *
137 : 97 : _ssl__SSLSocket_shared_ciphers(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
138 : : {
139 : 97 : return _ssl__SSLSocket_shared_ciphers_impl(self);
140 : : }
141 : :
142 : : PyDoc_STRVAR(_ssl__SSLSocket_cipher__doc__,
143 : : "cipher($self, /)\n"
144 : : "--\n"
145 : : "\n");
146 : :
147 : : #define _SSL__SSLSOCKET_CIPHER_METHODDEF \
148 : : {"cipher", (PyCFunction)_ssl__SSLSocket_cipher, METH_NOARGS, _ssl__SSLSocket_cipher__doc__},
149 : :
150 : : static PyObject *
151 : : _ssl__SSLSocket_cipher_impl(PySSLSocket *self);
152 : :
153 : : static PyObject *
154 : 378 : _ssl__SSLSocket_cipher(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
155 : : {
156 : 378 : return _ssl__SSLSocket_cipher_impl(self);
157 : : }
158 : :
159 : : PyDoc_STRVAR(_ssl__SSLSocket_version__doc__,
160 : : "version($self, /)\n"
161 : : "--\n"
162 : : "\n");
163 : :
164 : : #define _SSL__SSLSOCKET_VERSION_METHODDEF \
165 : : {"version", (PyCFunction)_ssl__SSLSocket_version, METH_NOARGS, _ssl__SSLSocket_version__doc__},
166 : :
167 : : static PyObject *
168 : : _ssl__SSLSocket_version_impl(PySSLSocket *self);
169 : :
170 : : static PyObject *
171 : 32 : _ssl__SSLSocket_version(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
172 : : {
173 : 32 : return _ssl__SSLSocket_version_impl(self);
174 : : }
175 : :
176 : : PyDoc_STRVAR(_ssl__SSLSocket_selected_alpn_protocol__doc__,
177 : : "selected_alpn_protocol($self, /)\n"
178 : : "--\n"
179 : : "\n");
180 : :
181 : : #define _SSL__SSLSOCKET_SELECTED_ALPN_PROTOCOL_METHODDEF \
182 : : {"selected_alpn_protocol", (PyCFunction)_ssl__SSLSocket_selected_alpn_protocol, METH_NOARGS, _ssl__SSLSocket_selected_alpn_protocol__doc__},
183 : :
184 : : static PyObject *
185 : : _ssl__SSLSocket_selected_alpn_protocol_impl(PySSLSocket *self);
186 : :
187 : : static PyObject *
188 : 121 : _ssl__SSLSocket_selected_alpn_protocol(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
189 : : {
190 : 121 : return _ssl__SSLSocket_selected_alpn_protocol_impl(self);
191 : : }
192 : :
193 : : PyDoc_STRVAR(_ssl__SSLSocket_compression__doc__,
194 : : "compression($self, /)\n"
195 : : "--\n"
196 : : "\n");
197 : :
198 : : #define _SSL__SSLSOCKET_COMPRESSION_METHODDEF \
199 : : {"compression", (PyCFunction)_ssl__SSLSocket_compression, METH_NOARGS, _ssl__SSLSocket_compression__doc__},
200 : :
201 : : static PyObject *
202 : : _ssl__SSLSocket_compression_impl(PySSLSocket *self);
203 : :
204 : : static PyObject *
205 : 294 : _ssl__SSLSocket_compression(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
206 : : {
207 : 294 : return _ssl__SSLSocket_compression_impl(self);
208 : : }
209 : :
210 : : PyDoc_STRVAR(_ssl__SSLSocket_write__doc__,
211 : : "write($self, b, /)\n"
212 : : "--\n"
213 : : "\n"
214 : : "Writes the bytes-like object b into the SSL object.\n"
215 : : "\n"
216 : : "Returns the number of bytes written.");
217 : :
218 : : #define _SSL__SSLSOCKET_WRITE_METHODDEF \
219 : : {"write", (PyCFunction)_ssl__SSLSocket_write, METH_O, _ssl__SSLSocket_write__doc__},
220 : :
221 : : static PyObject *
222 : : _ssl__SSLSocket_write_impl(PySSLSocket *self, Py_buffer *b);
223 : :
224 : : static PyObject *
225 : 5096 : _ssl__SSLSocket_write(PySSLSocket *self, PyObject *arg)
226 : : {
227 : 5096 : PyObject *return_value = NULL;
228 : 5096 : Py_buffer b = {NULL, NULL};
229 : :
230 [ - + ]: 5096 : if (PyObject_GetBuffer(arg, &b, PyBUF_SIMPLE) != 0) {
231 : 0 : goto exit;
232 : : }
233 [ - + ]: 5096 : if (!PyBuffer_IsContiguous(&b, 'C')) {
234 : 0 : _PyArg_BadArgument("write", "argument", "contiguous buffer", arg);
235 : 0 : goto exit;
236 : : }
237 : 5096 : return_value = _ssl__SSLSocket_write_impl(self, &b);
238 : :
239 : 5096 : exit:
240 : : /* Cleanup for b */
241 [ + - ]: 5096 : if (b.obj) {
242 : 5096 : PyBuffer_Release(&b);
243 : : }
244 : :
245 : 5096 : return return_value;
246 : : }
247 : :
248 : : PyDoc_STRVAR(_ssl__SSLSocket_pending__doc__,
249 : : "pending($self, /)\n"
250 : : "--\n"
251 : : "\n"
252 : : "Returns the number of already decrypted bytes available for read, pending on the connection.");
253 : :
254 : : #define _SSL__SSLSOCKET_PENDING_METHODDEF \
255 : : {"pending", (PyCFunction)_ssl__SSLSocket_pending, METH_NOARGS, _ssl__SSLSocket_pending__doc__},
256 : :
257 : : static PyObject *
258 : : _ssl__SSLSocket_pending_impl(PySSLSocket *self);
259 : :
260 : : static PyObject *
261 : 4 : _ssl__SSLSocket_pending(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
262 : : {
263 : 4 : return _ssl__SSLSocket_pending_impl(self);
264 : : }
265 : :
266 : : PyDoc_STRVAR(_ssl__SSLSocket_read__doc__,
267 : : "read(size, [buffer])\n"
268 : : "Read up to size bytes from the SSL socket.");
269 : :
270 : : #define _SSL__SSLSOCKET_READ_METHODDEF \
271 : : {"read", (PyCFunction)_ssl__SSLSocket_read, METH_VARARGS, _ssl__SSLSocket_read__doc__},
272 : :
273 : : static PyObject *
274 : : _ssl__SSLSocket_read_impl(PySSLSocket *self, Py_ssize_t len,
275 : : int group_right_1, Py_buffer *buffer);
276 : :
277 : : static PyObject *
278 : 26457 : _ssl__SSLSocket_read(PySSLSocket *self, PyObject *args)
279 : : {
280 : 26457 : PyObject *return_value = NULL;
281 : : Py_ssize_t len;
282 : 26457 : int group_right_1 = 0;
283 : 26457 : Py_buffer buffer = {NULL, NULL};
284 : :
285 [ + + - ]: 26457 : switch (PyTuple_GET_SIZE(args)) {
286 : 21468 : case 1:
287 [ - + ]: 21468 : if (!PyArg_ParseTuple(args, "n:read", &len)) {
288 : 0 : goto exit;
289 : : }
290 : 21468 : break;
291 : 4989 : case 2:
292 [ - + ]: 4989 : if (!PyArg_ParseTuple(args, "nw*:read", &len, &buffer)) {
293 : 0 : goto exit;
294 : : }
295 : 4989 : group_right_1 = 1;
296 : 4989 : break;
297 : 0 : default:
298 : 0 : PyErr_SetString(PyExc_TypeError, "_ssl._SSLSocket.read requires 1 to 2 arguments");
299 : 0 : goto exit;
300 : : }
301 : 26457 : return_value = _ssl__SSLSocket_read_impl(self, len, group_right_1, &buffer);
302 : :
303 : 26457 : exit:
304 : : /* Cleanup for buffer */
305 [ + + ]: 26457 : if (buffer.obj) {
306 : 4989 : PyBuffer_Release(&buffer);
307 : : }
308 : :
309 : 26457 : return return_value;
310 : : }
311 : :
312 : : PyDoc_STRVAR(_ssl__SSLSocket_shutdown__doc__,
313 : : "shutdown($self, /)\n"
314 : : "--\n"
315 : : "\n"
316 : : "Does the SSL shutdown handshake with the remote end.");
317 : :
318 : : #define _SSL__SSLSOCKET_SHUTDOWN_METHODDEF \
319 : : {"shutdown", (PyCFunction)_ssl__SSLSocket_shutdown, METH_NOARGS, _ssl__SSLSocket_shutdown__doc__},
320 : :
321 : : static PyObject *
322 : : _ssl__SSLSocket_shutdown_impl(PySSLSocket *self);
323 : :
324 : : static PyObject *
325 : 620 : _ssl__SSLSocket_shutdown(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
326 : : {
327 : 620 : return _ssl__SSLSocket_shutdown_impl(self);
328 : : }
329 : :
330 : : PyDoc_STRVAR(_ssl__SSLSocket_get_channel_binding__doc__,
331 : : "get_channel_binding($self, /, cb_type=\'tls-unique\')\n"
332 : : "--\n"
333 : : "\n"
334 : : "Get channel binding data for current connection.\n"
335 : : "\n"
336 : : "Raise ValueError if the requested `cb_type` is not supported. Return bytes\n"
337 : : "of the data or None if the data is not available (e.g. before the handshake).\n"
338 : : "Only \'tls-unique\' channel binding data from RFC 5929 is supported.");
339 : :
340 : : #define _SSL__SSLSOCKET_GET_CHANNEL_BINDING_METHODDEF \
341 : : {"get_channel_binding", _PyCFunction_CAST(_ssl__SSLSocket_get_channel_binding), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLSocket_get_channel_binding__doc__},
342 : :
343 : : static PyObject *
344 : : _ssl__SSLSocket_get_channel_binding_impl(PySSLSocket *self,
345 : : const char *cb_type);
346 : :
347 : : static PyObject *
348 : 7 : _ssl__SSLSocket_get_channel_binding(PySSLSocket *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
349 : : {
350 : 7 : PyObject *return_value = NULL;
351 : : static const char * const _keywords[] = {"cb_type", NULL};
352 : : static _PyArg_Parser _parser = {NULL, _keywords, "get_channel_binding", 0};
353 : : PyObject *argsbuf[1];
354 [ - + ]: 7 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
355 : 7 : const char *cb_type = "tls-unique";
356 : :
357 [ + - + - : 7 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+ - - + ]
358 [ - + ]: 7 : if (!args) {
359 : 0 : goto exit;
360 : : }
361 [ - + ]: 7 : if (!noptargs) {
362 : 0 : goto skip_optional_pos;
363 : : }
364 [ - + ]: 7 : if (!PyUnicode_Check(args[0])) {
365 : 0 : _PyArg_BadArgument("get_channel_binding", "argument 'cb_type'", "str", args[0]);
366 : 0 : goto exit;
367 : : }
368 : : Py_ssize_t cb_type_length;
369 : 7 : cb_type = PyUnicode_AsUTF8AndSize(args[0], &cb_type_length);
370 [ - + ]: 7 : if (cb_type == NULL) {
371 : 0 : goto exit;
372 : : }
373 [ - + ]: 7 : if (strlen(cb_type) != (size_t)cb_type_length) {
374 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
375 : 0 : goto exit;
376 : : }
377 : 7 : skip_optional_pos:
378 : 7 : return_value = _ssl__SSLSocket_get_channel_binding_impl(self, cb_type);
379 : :
380 : 7 : exit:
381 : 7 : return return_value;
382 : : }
383 : :
384 : : PyDoc_STRVAR(_ssl__SSLSocket_verify_client_post_handshake__doc__,
385 : : "verify_client_post_handshake($self, /)\n"
386 : : "--\n"
387 : : "\n"
388 : : "Initiate TLS 1.3 post-handshake authentication");
389 : :
390 : : #define _SSL__SSLSOCKET_VERIFY_CLIENT_POST_HANDSHAKE_METHODDEF \
391 : : {"verify_client_post_handshake", (PyCFunction)_ssl__SSLSocket_verify_client_post_handshake, METH_NOARGS, _ssl__SSLSocket_verify_client_post_handshake__doc__},
392 : :
393 : : static PyObject *
394 : : _ssl__SSLSocket_verify_client_post_handshake_impl(PySSLSocket *self);
395 : :
396 : : static PyObject *
397 : 10 : _ssl__SSLSocket_verify_client_post_handshake(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
398 : : {
399 : 10 : return _ssl__SSLSocket_verify_client_post_handshake_impl(self);
400 : : }
401 : :
402 : : static PyObject *
403 : : _ssl__SSLContext_impl(PyTypeObject *type, int proto_version);
404 : :
405 : : static PyObject *
406 : 946 : _ssl__SSLContext(PyTypeObject *type, PyObject *args, PyObject *kwargs)
407 : : {
408 : 946 : PyObject *return_value = NULL;
409 : : int proto_version;
410 : :
411 [ + - ]: 946 : if ((type == get_state_type(type)->PySSLContext_Type ||
412 [ + - - + ]: 946 : type->tp_init == get_state_type(type)->PySSLContext_Type->tp_init) &&
413 [ # # ]: 0 : !_PyArg_NoKeywords("_SSLContext", kwargs)) {
414 : 0 : goto exit;
415 : : }
416 [ + - - + : 946 : if (!_PyArg_CheckPositional("_SSLContext", PyTuple_GET_SIZE(args), 1, 1)) {
- - ]
417 : 0 : goto exit;
418 : : }
419 : 946 : proto_version = _PyLong_AsInt(PyTuple_GET_ITEM(args, 0));
420 [ + + - + ]: 946 : if (proto_version == -1 && PyErr_Occurred()) {
421 : 0 : goto exit;
422 : : }
423 : 946 : return_value = _ssl__SSLContext_impl(type, proto_version);
424 : :
425 : 946 : exit:
426 : 946 : return return_value;
427 : : }
428 : :
429 : : PyDoc_STRVAR(_ssl__SSLContext_set_ciphers__doc__,
430 : : "set_ciphers($self, cipherlist, /)\n"
431 : : "--\n"
432 : : "\n");
433 : :
434 : : #define _SSL__SSLCONTEXT_SET_CIPHERS_METHODDEF \
435 : : {"set_ciphers", (PyCFunction)_ssl__SSLContext_set_ciphers, METH_O, _ssl__SSLContext_set_ciphers__doc__},
436 : :
437 : : static PyObject *
438 : : _ssl__SSLContext_set_ciphers_impl(PySSLContext *self, const char *cipherlist);
439 : :
440 : : static PyObject *
441 : 24 : _ssl__SSLContext_set_ciphers(PySSLContext *self, PyObject *arg)
442 : : {
443 : 24 : PyObject *return_value = NULL;
444 : : const char *cipherlist;
445 : :
446 [ - + ]: 24 : if (!PyUnicode_Check(arg)) {
447 : 0 : _PyArg_BadArgument("set_ciphers", "argument", "str", arg);
448 : 0 : goto exit;
449 : : }
450 : : Py_ssize_t cipherlist_length;
451 : 24 : cipherlist = PyUnicode_AsUTF8AndSize(arg, &cipherlist_length);
452 [ - + ]: 24 : if (cipherlist == NULL) {
453 : 0 : goto exit;
454 : : }
455 [ - + ]: 24 : if (strlen(cipherlist) != (size_t)cipherlist_length) {
456 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
457 : 0 : goto exit;
458 : : }
459 : 24 : return_value = _ssl__SSLContext_set_ciphers_impl(self, cipherlist);
460 : :
461 : 24 : exit:
462 : 24 : return return_value;
463 : : }
464 : :
465 : : PyDoc_STRVAR(_ssl__SSLContext_get_ciphers__doc__,
466 : : "get_ciphers($self, /)\n"
467 : : "--\n"
468 : : "\n");
469 : :
470 : : #define _SSL__SSLCONTEXT_GET_CIPHERS_METHODDEF \
471 : : {"get_ciphers", (PyCFunction)_ssl__SSLContext_get_ciphers, METH_NOARGS, _ssl__SSLContext_get_ciphers__doc__},
472 : :
473 : : static PyObject *
474 : : _ssl__SSLContext_get_ciphers_impl(PySSLContext *self);
475 : :
476 : : static PyObject *
477 : 2 : _ssl__SSLContext_get_ciphers(PySSLContext *self, PyObject *Py_UNUSED(ignored))
478 : : {
479 : 2 : return _ssl__SSLContext_get_ciphers_impl(self);
480 : : }
481 : :
482 : : PyDoc_STRVAR(_ssl__SSLContext__set_alpn_protocols__doc__,
483 : : "_set_alpn_protocols($self, protos, /)\n"
484 : : "--\n"
485 : : "\n");
486 : :
487 : : #define _SSL__SSLCONTEXT__SET_ALPN_PROTOCOLS_METHODDEF \
488 : : {"_set_alpn_protocols", (PyCFunction)_ssl__SSLContext__set_alpn_protocols, METH_O, _ssl__SSLContext__set_alpn_protocols__doc__},
489 : :
490 : : static PyObject *
491 : : _ssl__SSLContext__set_alpn_protocols_impl(PySSLContext *self,
492 : : Py_buffer *protos);
493 : :
494 : : static PyObject *
495 : 113 : _ssl__SSLContext__set_alpn_protocols(PySSLContext *self, PyObject *arg)
496 : : {
497 : 113 : PyObject *return_value = NULL;
498 : 113 : Py_buffer protos = {NULL, NULL};
499 : :
500 [ - + ]: 113 : if (PyObject_GetBuffer(arg, &protos, PyBUF_SIMPLE) != 0) {
501 : 0 : goto exit;
502 : : }
503 [ - + ]: 113 : if (!PyBuffer_IsContiguous(&protos, 'C')) {
504 : 0 : _PyArg_BadArgument("_set_alpn_protocols", "argument", "contiguous buffer", arg);
505 : 0 : goto exit;
506 : : }
507 : 113 : return_value = _ssl__SSLContext__set_alpn_protocols_impl(self, &protos);
508 : :
509 : 113 : exit:
510 : : /* Cleanup for protos */
511 [ + - ]: 113 : if (protos.obj) {
512 : 113 : PyBuffer_Release(&protos);
513 : : }
514 : :
515 : 113 : return return_value;
516 : : }
517 : :
518 : : PyDoc_STRVAR(_ssl__SSLContext_load_cert_chain__doc__,
519 : : "load_cert_chain($self, /, certfile, keyfile=None, password=None)\n"
520 : : "--\n"
521 : : "\n");
522 : :
523 : : #define _SSL__SSLCONTEXT_LOAD_CERT_CHAIN_METHODDEF \
524 : : {"load_cert_chain", _PyCFunction_CAST(_ssl__SSLContext_load_cert_chain), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_cert_chain__doc__},
525 : :
526 : : static PyObject *
527 : : _ssl__SSLContext_load_cert_chain_impl(PySSLContext *self, PyObject *certfile,
528 : : PyObject *keyfile, PyObject *password);
529 : :
530 : : static PyObject *
531 : 441 : _ssl__SSLContext_load_cert_chain(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
532 : : {
533 : 441 : PyObject *return_value = NULL;
534 : : static const char * const _keywords[] = {"certfile", "keyfile", "password", NULL};
535 : : static _PyArg_Parser _parser = {NULL, _keywords, "load_cert_chain", 0};
536 : : PyObject *argsbuf[3];
537 [ + + ]: 441 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
538 : : PyObject *certfile;
539 : 441 : PyObject *keyfile = Py_None;
540 : 441 : PyObject *password = Py_None;
541 : :
542 [ + + + - : 441 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
+ - - + ]
543 [ + + ]: 441 : if (!args) {
544 : 1 : goto exit;
545 : : }
546 : 440 : certfile = args[0];
547 [ + + ]: 440 : if (!noptargs) {
548 : 325 : goto skip_optional_pos;
549 : : }
550 [ + + ]: 115 : if (args[1]) {
551 : 99 : keyfile = args[1];
552 [ + + ]: 99 : if (!--noptargs) {
553 : 96 : goto skip_optional_pos;
554 : : }
555 : : }
556 : 19 : password = args[2];
557 : 440 : skip_optional_pos:
558 : 440 : return_value = _ssl__SSLContext_load_cert_chain_impl(self, certfile, keyfile, password);
559 : :
560 : 441 : exit:
561 : 441 : return return_value;
562 : : }
563 : :
564 : : PyDoc_STRVAR(_ssl__SSLContext_load_verify_locations__doc__,
565 : : "load_verify_locations($self, /, cafile=None, capath=None, cadata=None)\n"
566 : : "--\n"
567 : : "\n");
568 : :
569 : : #define _SSL__SSLCONTEXT_LOAD_VERIFY_LOCATIONS_METHODDEF \
570 : : {"load_verify_locations", _PyCFunction_CAST(_ssl__SSLContext_load_verify_locations), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_verify_locations__doc__},
571 : :
572 : : static PyObject *
573 : : _ssl__SSLContext_load_verify_locations_impl(PySSLContext *self,
574 : : PyObject *cafile,
575 : : PyObject *capath,
576 : : PyObject *cadata);
577 : :
578 : : static PyObject *
579 : 189 : _ssl__SSLContext_load_verify_locations(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
580 : : {
581 : 189 : PyObject *return_value = NULL;
582 : : static const char * const _keywords[] = {"cafile", "capath", "cadata", NULL};
583 : : static _PyArg_Parser _parser = {NULL, _keywords, "load_verify_locations", 0};
584 : : PyObject *argsbuf[3];
585 [ + + ]: 189 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
586 : 189 : PyObject *cafile = Py_None;
587 : 189 : PyObject *capath = Py_None;
588 : 189 : PyObject *cadata = Py_None;
589 : :
590 [ + + + - : 189 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 3, 0, argsbuf);
+ - - + ]
591 [ - + ]: 189 : if (!args) {
592 : 0 : goto exit;
593 : : }
594 [ + + ]: 189 : if (!noptargs) {
595 : 1 : goto skip_optional_pos;
596 : : }
597 [ + + ]: 188 : if (args[0]) {
598 : 169 : cafile = args[0];
599 [ + + ]: 169 : if (!--noptargs) {
600 : 150 : goto skip_optional_pos;
601 : : }
602 : : }
603 [ + + ]: 38 : if (args[1]) {
604 : 24 : capath = args[1];
605 [ + + ]: 24 : if (!--noptargs) {
606 : 10 : goto skip_optional_pos;
607 : : }
608 : : }
609 : 28 : cadata = args[2];
610 : 189 : skip_optional_pos:
611 : 189 : return_value = _ssl__SSLContext_load_verify_locations_impl(self, cafile, capath, cadata);
612 : :
613 : 189 : exit:
614 : 189 : return return_value;
615 : : }
616 : :
617 : : PyDoc_STRVAR(_ssl__SSLContext_load_dh_params__doc__,
618 : : "load_dh_params($self, path, /)\n"
619 : : "--\n"
620 : : "\n");
621 : :
622 : : #define _SSL__SSLCONTEXT_LOAD_DH_PARAMS_METHODDEF \
623 : : {"load_dh_params", (PyCFunction)_ssl__SSLContext_load_dh_params, METH_O, _ssl__SSLContext_load_dh_params__doc__},
624 : :
625 : : PyDoc_STRVAR(_ssl__SSLContext__wrap_socket__doc__,
626 : : "_wrap_socket($self, /, sock, server_side, server_hostname=None, *,\n"
627 : : " owner=None, session=None)\n"
628 : : "--\n"
629 : : "\n");
630 : :
631 : : #define _SSL__SSLCONTEXT__WRAP_SOCKET_METHODDEF \
632 : : {"_wrap_socket", _PyCFunction_CAST(_ssl__SSLContext__wrap_socket), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_socket__doc__},
633 : :
634 : : static PyObject *
635 : : _ssl__SSLContext__wrap_socket_impl(PySSLContext *self, PyObject *sock,
636 : : int server_side, PyObject *hostname_obj,
637 : : PyObject *owner, PyObject *session);
638 : :
639 : : static PyObject *
640 : 852 : _ssl__SSLContext__wrap_socket(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
641 : : {
642 : 852 : PyObject *return_value = NULL;
643 : : static const char * const _keywords[] = {"sock", "server_side", "server_hostname", "owner", "session", NULL};
644 : : static _PyArg_Parser _parser = {NULL, _keywords, "_wrap_socket", 0};
645 : : PyObject *argsbuf[5];
646 [ + - ]: 852 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
647 : : PyObject *sock;
648 : : int server_side;
649 : 852 : PyObject *hostname_obj = Py_None;
650 : 852 : PyObject *owner = Py_None;
651 : 852 : PyObject *session = Py_None;
652 : :
653 [ - + - - : 852 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 3, 0, argsbuf);
- - - - ]
654 [ - + ]: 852 : if (!args) {
655 : 0 : goto exit;
656 : : }
657 [ - + ]: 852 : if (!PyObject_TypeCheck(args[0], get_state_ctx(self)->Sock_Type)) {
658 : 0 : _PyArg_BadArgument("_wrap_socket", "argument 'sock'", (get_state_ctx(self)->Sock_Type)->tp_name, args[0]);
659 : 0 : goto exit;
660 : : }
661 : 852 : sock = args[0];
662 : 852 : server_side = _PyLong_AsInt(args[1]);
663 [ - + - - ]: 852 : if (server_side == -1 && PyErr_Occurred()) {
664 : 0 : goto exit;
665 : : }
666 [ - + ]: 852 : if (!noptargs) {
667 : 0 : goto skip_optional_pos;
668 : : }
669 [ - + ]: 852 : if (args[2]) {
670 : 852 : hostname_obj = args[2];
671 [ + - ]: 852 : if (!--noptargs) {
672 : 0 : goto skip_optional_pos;
673 : : }
674 : : }
675 : 852 : skip_optional_pos:
676 [ - + ]: 852 : if (!noptargs) {
677 : 0 : goto skip_optional_kwonly;
678 : : }
679 [ + - ]: 852 : if (args[3]) {
680 : 852 : owner = args[3];
681 [ - + ]: 852 : if (!--noptargs) {
682 : 0 : goto skip_optional_kwonly;
683 : : }
684 : : }
685 : 852 : session = args[4];
686 : 852 : skip_optional_kwonly:
687 : 852 : return_value = _ssl__SSLContext__wrap_socket_impl(self, sock, server_side, hostname_obj, owner, session);
688 : :
689 : 852 : exit:
690 : 852 : return return_value;
691 : : }
692 : :
693 : : PyDoc_STRVAR(_ssl__SSLContext__wrap_bio__doc__,
694 : : "_wrap_bio($self, /, incoming, outgoing, server_side,\n"
695 : : " server_hostname=None, *, owner=None, session=None)\n"
696 : : "--\n"
697 : : "\n");
698 : :
699 : : #define _SSL__SSLCONTEXT__WRAP_BIO_METHODDEF \
700 : : {"_wrap_bio", _PyCFunction_CAST(_ssl__SSLContext__wrap_bio), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_bio__doc__},
701 : :
702 : : static PyObject *
703 : : _ssl__SSLContext__wrap_bio_impl(PySSLContext *self, PySSLMemoryBIO *incoming,
704 : : PySSLMemoryBIO *outgoing, int server_side,
705 : : PyObject *hostname_obj, PyObject *owner,
706 : : PyObject *session);
707 : :
708 : : static PyObject *
709 : 307 : _ssl__SSLContext__wrap_bio(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
710 : : {
711 : 307 : PyObject *return_value = NULL;
712 : : static const char * const _keywords[] = {"incoming", "outgoing", "server_side", "server_hostname", "owner", "session", NULL};
713 : : static _PyArg_Parser _parser = {NULL, _keywords, "_wrap_bio", 0};
714 : : PyObject *argsbuf[6];
715 [ + - ]: 307 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 3;
716 : : PySSLMemoryBIO *incoming;
717 : : PySSLMemoryBIO *outgoing;
718 : : int server_side;
719 : 307 : PyObject *hostname_obj = Py_None;
720 : 307 : PyObject *owner = Py_None;
721 : 307 : PyObject *session = Py_None;
722 : :
723 [ - + - - : 307 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 4, 0, argsbuf);
- - - - ]
724 [ - + ]: 307 : if (!args) {
725 : 0 : goto exit;
726 : : }
727 [ - + ]: 307 : if (!PyObject_TypeCheck(args[0], get_state_ctx(self)->PySSLMemoryBIO_Type)) {
728 : 0 : _PyArg_BadArgument("_wrap_bio", "argument 'incoming'", (get_state_ctx(self)->PySSLMemoryBIO_Type)->tp_name, args[0]);
729 : 0 : goto exit;
730 : : }
731 : 307 : incoming = (PySSLMemoryBIO *)args[0];
732 [ - + ]: 307 : if (!PyObject_TypeCheck(args[1], get_state_ctx(self)->PySSLMemoryBIO_Type)) {
733 : 0 : _PyArg_BadArgument("_wrap_bio", "argument 'outgoing'", (get_state_ctx(self)->PySSLMemoryBIO_Type)->tp_name, args[1]);
734 : 0 : goto exit;
735 : : }
736 : 307 : outgoing = (PySSLMemoryBIO *)args[1];
737 : 307 : server_side = _PyLong_AsInt(args[2]);
738 [ - + - - ]: 307 : if (server_side == -1 && PyErr_Occurred()) {
739 : 0 : goto exit;
740 : : }
741 [ - + ]: 307 : if (!noptargs) {
742 : 0 : goto skip_optional_pos;
743 : : }
744 [ - + ]: 307 : if (args[3]) {
745 : 307 : hostname_obj = args[3];
746 [ + - ]: 307 : if (!--noptargs) {
747 : 0 : goto skip_optional_pos;
748 : : }
749 : : }
750 : 307 : skip_optional_pos:
751 [ - + ]: 307 : if (!noptargs) {
752 : 0 : goto skip_optional_kwonly;
753 : : }
754 [ + - ]: 307 : if (args[4]) {
755 : 307 : owner = args[4];
756 [ - + ]: 307 : if (!--noptargs) {
757 : 0 : goto skip_optional_kwonly;
758 : : }
759 : : }
760 : 307 : session = args[5];
761 : 307 : skip_optional_kwonly:
762 : 307 : return_value = _ssl__SSLContext__wrap_bio_impl(self, incoming, outgoing, server_side, hostname_obj, owner, session);
763 : :
764 : 307 : exit:
765 : 307 : return return_value;
766 : : }
767 : :
768 : : PyDoc_STRVAR(_ssl__SSLContext_session_stats__doc__,
769 : : "session_stats($self, /)\n"
770 : : "--\n"
771 : : "\n");
772 : :
773 : : #define _SSL__SSLCONTEXT_SESSION_STATS_METHODDEF \
774 : : {"session_stats", (PyCFunction)_ssl__SSLContext_session_stats, METH_NOARGS, _ssl__SSLContext_session_stats__doc__},
775 : :
776 : : static PyObject *
777 : : _ssl__SSLContext_session_stats_impl(PySSLContext *self);
778 : :
779 : : static PyObject *
780 : 6 : _ssl__SSLContext_session_stats(PySSLContext *self, PyObject *Py_UNUSED(ignored))
781 : : {
782 : 6 : return _ssl__SSLContext_session_stats_impl(self);
783 : : }
784 : :
785 : : PyDoc_STRVAR(_ssl__SSLContext_set_default_verify_paths__doc__,
786 : : "set_default_verify_paths($self, /)\n"
787 : : "--\n"
788 : : "\n");
789 : :
790 : : #define _SSL__SSLCONTEXT_SET_DEFAULT_VERIFY_PATHS_METHODDEF \
791 : : {"set_default_verify_paths", (PyCFunction)_ssl__SSLContext_set_default_verify_paths, METH_NOARGS, _ssl__SSLContext_set_default_verify_paths__doc__},
792 : :
793 : : static PyObject *
794 : : _ssl__SSLContext_set_default_verify_paths_impl(PySSLContext *self);
795 : :
796 : : static PyObject *
797 : 133 : _ssl__SSLContext_set_default_verify_paths(PySSLContext *self, PyObject *Py_UNUSED(ignored))
798 : : {
799 : 133 : return _ssl__SSLContext_set_default_verify_paths_impl(self);
800 : : }
801 : :
802 : : PyDoc_STRVAR(_ssl__SSLContext_set_ecdh_curve__doc__,
803 : : "set_ecdh_curve($self, name, /)\n"
804 : : "--\n"
805 : : "\n");
806 : :
807 : : #define _SSL__SSLCONTEXT_SET_ECDH_CURVE_METHODDEF \
808 : : {"set_ecdh_curve", (PyCFunction)_ssl__SSLContext_set_ecdh_curve, METH_O, _ssl__SSLContext_set_ecdh_curve__doc__},
809 : :
810 : : PyDoc_STRVAR(_ssl__SSLContext_cert_store_stats__doc__,
811 : : "cert_store_stats($self, /)\n"
812 : : "--\n"
813 : : "\n"
814 : : "Returns quantities of loaded X.509 certificates.\n"
815 : : "\n"
816 : : "X.509 certificates with a CA extension and certificate revocation lists\n"
817 : : "inside the context\'s cert store.\n"
818 : : "\n"
819 : : "NOTE: Certificates in a capath directory aren\'t loaded unless they have\n"
820 : : "been used at least once.");
821 : :
822 : : #define _SSL__SSLCONTEXT_CERT_STORE_STATS_METHODDEF \
823 : : {"cert_store_stats", (PyCFunction)_ssl__SSLContext_cert_store_stats, METH_NOARGS, _ssl__SSLContext_cert_store_stats__doc__},
824 : :
825 : : static PyObject *
826 : : _ssl__SSLContext_cert_store_stats_impl(PySSLContext *self);
827 : :
828 : : static PyObject *
829 : 14 : _ssl__SSLContext_cert_store_stats(PySSLContext *self, PyObject *Py_UNUSED(ignored))
830 : : {
831 : 14 : return _ssl__SSLContext_cert_store_stats_impl(self);
832 : : }
833 : :
834 : : PyDoc_STRVAR(_ssl__SSLContext_get_ca_certs__doc__,
835 : : "get_ca_certs($self, /, binary_form=False)\n"
836 : : "--\n"
837 : : "\n"
838 : : "Returns a list of dicts with information of loaded CA certs.\n"
839 : : "\n"
840 : : "If the optional argument is True, returns a DER-encoded copy of the CA\n"
841 : : "certificate.\n"
842 : : "\n"
843 : : "NOTE: Certificates in a capath directory aren\'t loaded unless they have\n"
844 : : "been used at least once.");
845 : :
846 : : #define _SSL__SSLCONTEXT_GET_CA_CERTS_METHODDEF \
847 : : {"get_ca_certs", _PyCFunction_CAST(_ssl__SSLContext_get_ca_certs), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_get_ca_certs__doc__},
848 : :
849 : : static PyObject *
850 : : _ssl__SSLContext_get_ca_certs_impl(PySSLContext *self, int binary_form);
851 : :
852 : : static PyObject *
853 : 6 : _ssl__SSLContext_get_ca_certs(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
854 : : {
855 : 6 : PyObject *return_value = NULL;
856 : : static const char * const _keywords[] = {"binary_form", NULL};
857 : : static _PyArg_Parser _parser = {NULL, _keywords, "get_ca_certs", 0};
858 : : PyObject *argsbuf[1];
859 [ - + ]: 6 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
860 : 6 : int binary_form = 0;
861 : :
862 [ + - + - : 6 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+ - - + ]
863 [ - + ]: 6 : if (!args) {
864 : 0 : goto exit;
865 : : }
866 [ + + ]: 6 : if (!noptargs) {
867 : 5 : goto skip_optional_pos;
868 : : }
869 : 1 : binary_form = PyObject_IsTrue(args[0]);
870 [ - + ]: 1 : if (binary_form < 0) {
871 : 0 : goto exit;
872 : : }
873 : 1 : skip_optional_pos:
874 : 6 : return_value = _ssl__SSLContext_get_ca_certs_impl(self, binary_form);
875 : :
876 : 6 : exit:
877 : 6 : return return_value;
878 : : }
879 : :
880 : : static PyObject *
881 : : _ssl_MemoryBIO_impl(PyTypeObject *type);
882 : :
883 : : static PyObject *
884 : 622 : _ssl_MemoryBIO(PyTypeObject *type, PyObject *args, PyObject *kwargs)
885 : : {
886 : 622 : PyObject *return_value = NULL;
887 : :
888 [ - + ]: 622 : if ((type == get_state_type(type)->PySSLMemoryBIO_Type ||
889 [ - - + - ]: 622 : type->tp_init == get_state_type(type)->PySSLMemoryBIO_Type->tp_init) &&
890 [ - + ]: 622 : !_PyArg_NoPositional("MemoryBIO", args)) {
891 : 0 : goto exit;
892 : : }
893 [ - + ]: 622 : if ((type == get_state_type(type)->PySSLMemoryBIO_Type ||
894 [ - - - + ]: 622 : type->tp_init == get_state_type(type)->PySSLMemoryBIO_Type->tp_init) &&
895 [ # # ]: 0 : !_PyArg_NoKeywords("MemoryBIO", kwargs)) {
896 : 0 : goto exit;
897 : : }
898 : 622 : return_value = _ssl_MemoryBIO_impl(type);
899 : :
900 : 622 : exit:
901 : 622 : return return_value;
902 : : }
903 : :
904 : : PyDoc_STRVAR(_ssl_MemoryBIO_read__doc__,
905 : : "read($self, size=-1, /)\n"
906 : : "--\n"
907 : : "\n"
908 : : "Read up to size bytes from the memory BIO.\n"
909 : : "\n"
910 : : "If size is not specified, read the entire buffer.\n"
911 : : "If the return value is an empty bytes instance, this means either\n"
912 : : "EOF or that no data is available. Use the \"eof\" property to\n"
913 : : "distinguish between the two.");
914 : :
915 : : #define _SSL_MEMORYBIO_READ_METHODDEF \
916 : : {"read", _PyCFunction_CAST(_ssl_MemoryBIO_read), METH_FASTCALL, _ssl_MemoryBIO_read__doc__},
917 : :
918 : : static PyObject *
919 : : _ssl_MemoryBIO_read_impl(PySSLMemoryBIO *self, int len);
920 : :
921 : : static PyObject *
922 : 4847 : _ssl_MemoryBIO_read(PySSLMemoryBIO *self, PyObject *const *args, Py_ssize_t nargs)
923 : : {
924 : 4847 : PyObject *return_value = NULL;
925 : 4847 : int len = -1;
926 : :
927 [ + - - + : 4847 : if (!_PyArg_CheckPositional("read", nargs, 0, 1)) {
- - ]
928 : 0 : goto exit;
929 : : }
930 [ + + ]: 4847 : if (nargs < 1) {
931 : 4839 : goto skip_optional;
932 : : }
933 : 8 : len = _PyLong_AsInt(args[0]);
934 [ - + - - ]: 8 : if (len == -1 && PyErr_Occurred()) {
935 : 0 : goto exit;
936 : : }
937 : 8 : skip_optional:
938 : 4847 : return_value = _ssl_MemoryBIO_read_impl(self, len);
939 : :
940 : 4847 : exit:
941 : 4847 : return return_value;
942 : : }
943 : :
944 : : PyDoc_STRVAR(_ssl_MemoryBIO_write__doc__,
945 : : "write($self, b, /)\n"
946 : : "--\n"
947 : : "\n"
948 : : "Writes the bytes b into the memory BIO.\n"
949 : : "\n"
950 : : "Returns the number of bytes written.");
951 : :
952 : : #define _SSL_MEMORYBIO_WRITE_METHODDEF \
953 : : {"write", (PyCFunction)_ssl_MemoryBIO_write, METH_O, _ssl_MemoryBIO_write__doc__},
954 : :
955 : : static PyObject *
956 : : _ssl_MemoryBIO_write_impl(PySSLMemoryBIO *self, Py_buffer *b);
957 : :
958 : : static PyObject *
959 : 3201 : _ssl_MemoryBIO_write(PySSLMemoryBIO *self, PyObject *arg)
960 : : {
961 : 3201 : PyObject *return_value = NULL;
962 : 3201 : Py_buffer b = {NULL, NULL};
963 : :
964 [ + + ]: 3201 : if (PyObject_GetBuffer(arg, &b, PyBUF_SIMPLE) != 0) {
965 : 4 : goto exit;
966 : : }
967 [ - + ]: 3197 : if (!PyBuffer_IsContiguous(&b, 'C')) {
968 : 0 : _PyArg_BadArgument("write", "argument", "contiguous buffer", arg);
969 : 0 : goto exit;
970 : : }
971 : 3197 : return_value = _ssl_MemoryBIO_write_impl(self, &b);
972 : :
973 : 3201 : exit:
974 : : /* Cleanup for b */
975 [ + + ]: 3201 : if (b.obj) {
976 : 3197 : PyBuffer_Release(&b);
977 : : }
978 : :
979 : 3201 : return return_value;
980 : : }
981 : :
982 : : PyDoc_STRVAR(_ssl_MemoryBIO_write_eof__doc__,
983 : : "write_eof($self, /)\n"
984 : : "--\n"
985 : : "\n"
986 : : "Write an EOF marker to the memory BIO.\n"
987 : : "\n"
988 : : "When all data has been read, the \"eof\" property will be True.");
989 : :
990 : : #define _SSL_MEMORYBIO_WRITE_EOF_METHODDEF \
991 : : {"write_eof", (PyCFunction)_ssl_MemoryBIO_write_eof, METH_NOARGS, _ssl_MemoryBIO_write_eof__doc__},
992 : :
993 : : static PyObject *
994 : : _ssl_MemoryBIO_write_eof_impl(PySSLMemoryBIO *self);
995 : :
996 : : static PyObject *
997 : 1 : _ssl_MemoryBIO_write_eof(PySSLMemoryBIO *self, PyObject *Py_UNUSED(ignored))
998 : : {
999 : 1 : return _ssl_MemoryBIO_write_eof_impl(self);
1000 : : }
1001 : :
1002 : : PyDoc_STRVAR(_ssl_RAND_add__doc__,
1003 : : "RAND_add($module, string, entropy, /)\n"
1004 : : "--\n"
1005 : : "\n"
1006 : : "Mix string into the OpenSSL PRNG state.\n"
1007 : : "\n"
1008 : : "entropy (a float) is a lower bound on the entropy contained in\n"
1009 : : "string. See RFC 4086.");
1010 : :
1011 : : #define _SSL_RAND_ADD_METHODDEF \
1012 : : {"RAND_add", _PyCFunction_CAST(_ssl_RAND_add), METH_FASTCALL, _ssl_RAND_add__doc__},
1013 : :
1014 : : static PyObject *
1015 : : _ssl_RAND_add_impl(PyObject *module, Py_buffer *view, double entropy);
1016 : :
1017 : : static PyObject *
1018 : 3 : _ssl_RAND_add(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1019 : : {
1020 : 3 : PyObject *return_value = NULL;
1021 : 3 : Py_buffer view = {NULL, NULL};
1022 : : double entropy;
1023 : :
1024 [ + - - + : 3 : if (!_PyArg_CheckPositional("RAND_add", nargs, 2, 2)) {
- - ]
1025 : 0 : goto exit;
1026 : : }
1027 [ + + ]: 3 : if (PyUnicode_Check(args[0])) {
1028 : : Py_ssize_t len;
1029 : 1 : const char *ptr = PyUnicode_AsUTF8AndSize(args[0], &len);
1030 [ - + ]: 1 : if (ptr == NULL) {
1031 : 0 : goto exit;
1032 : : }
1033 : 1 : PyBuffer_FillInfo(&view, args[0], (void *)ptr, len, 1, 0);
1034 : : }
1035 : : else { /* any bytes-like object */
1036 [ - + ]: 2 : if (PyObject_GetBuffer(args[0], &view, PyBUF_SIMPLE) != 0) {
1037 : 0 : goto exit;
1038 : : }
1039 [ - + ]: 2 : if (!PyBuffer_IsContiguous(&view, 'C')) {
1040 : 0 : _PyArg_BadArgument("RAND_add", "argument 1", "contiguous buffer", args[0]);
1041 : 0 : goto exit;
1042 : : }
1043 : : }
1044 [ + - ]: 3 : if (PyFloat_CheckExact(args[1])) {
1045 : 3 : entropy = PyFloat_AS_DOUBLE(args[1]);
1046 : : }
1047 : : else
1048 : : {
1049 : 0 : entropy = PyFloat_AsDouble(args[1]);
1050 [ # # # # ]: 0 : if (entropy == -1.0 && PyErr_Occurred()) {
1051 : 0 : goto exit;
1052 : : }
1053 : : }
1054 : 3 : return_value = _ssl_RAND_add_impl(module, &view, entropy);
1055 : :
1056 : 3 : exit:
1057 : : /* Cleanup for view */
1058 [ + - ]: 3 : if (view.obj) {
1059 : 3 : PyBuffer_Release(&view);
1060 : : }
1061 : :
1062 : 3 : return return_value;
1063 : : }
1064 : :
1065 : : PyDoc_STRVAR(_ssl_RAND_bytes__doc__,
1066 : : "RAND_bytes($module, n, /)\n"
1067 : : "--\n"
1068 : : "\n"
1069 : : "Generate n cryptographically strong pseudo-random bytes.");
1070 : :
1071 : : #define _SSL_RAND_BYTES_METHODDEF \
1072 : : {"RAND_bytes", (PyCFunction)_ssl_RAND_bytes, METH_O, _ssl_RAND_bytes__doc__},
1073 : :
1074 : : static PyObject *
1075 : : _ssl_RAND_bytes_impl(PyObject *module, int n);
1076 : :
1077 : : static PyObject *
1078 : 2 : _ssl_RAND_bytes(PyObject *module, PyObject *arg)
1079 : : {
1080 : 2 : PyObject *return_value = NULL;
1081 : : int n;
1082 : :
1083 : 2 : n = _PyLong_AsInt(arg);
1084 [ - + - - ]: 2 : if (n == -1 && PyErr_Occurred()) {
1085 : 0 : goto exit;
1086 : : }
1087 : 2 : return_value = _ssl_RAND_bytes_impl(module, n);
1088 : :
1089 : 2 : exit:
1090 : 2 : return return_value;
1091 : : }
1092 : :
1093 : : PyDoc_STRVAR(_ssl_RAND_status__doc__,
1094 : : "RAND_status($module, /)\n"
1095 : : "--\n"
1096 : : "\n"
1097 : : "Returns True if the OpenSSL PRNG has been seeded with enough data and False if not.\n"
1098 : : "\n"
1099 : : "It is necessary to seed the PRNG with RAND_add() on some platforms before\n"
1100 : : "using the ssl() function.");
1101 : :
1102 : : #define _SSL_RAND_STATUS_METHODDEF \
1103 : : {"RAND_status", (PyCFunction)_ssl_RAND_status, METH_NOARGS, _ssl_RAND_status__doc__},
1104 : :
1105 : : static PyObject *
1106 : : _ssl_RAND_status_impl(PyObject *module);
1107 : :
1108 : : static PyObject *
1109 : 1 : _ssl_RAND_status(PyObject *module, PyObject *Py_UNUSED(ignored))
1110 : : {
1111 : 1 : return _ssl_RAND_status_impl(module);
1112 : : }
1113 : :
1114 : : PyDoc_STRVAR(_ssl_get_default_verify_paths__doc__,
1115 : : "get_default_verify_paths($module, /)\n"
1116 : : "--\n"
1117 : : "\n"
1118 : : "Return search paths and environment vars that are used by SSLContext\'s set_default_verify_paths() to load default CAs.\n"
1119 : : "\n"
1120 : : "The values are \'cert_file_env\', \'cert_file\', \'cert_dir_env\', \'cert_dir\'.");
1121 : :
1122 : : #define _SSL_GET_DEFAULT_VERIFY_PATHS_METHODDEF \
1123 : : {"get_default_verify_paths", (PyCFunction)_ssl_get_default_verify_paths, METH_NOARGS, _ssl_get_default_verify_paths__doc__},
1124 : :
1125 : : static PyObject *
1126 : : _ssl_get_default_verify_paths_impl(PyObject *module);
1127 : :
1128 : : static PyObject *
1129 : 2 : _ssl_get_default_verify_paths(PyObject *module, PyObject *Py_UNUSED(ignored))
1130 : : {
1131 : 2 : return _ssl_get_default_verify_paths_impl(module);
1132 : : }
1133 : :
1134 : : PyDoc_STRVAR(_ssl_txt2obj__doc__,
1135 : : "txt2obj($module, /, txt, name=False)\n"
1136 : : "--\n"
1137 : : "\n"
1138 : : "Lookup NID, short name, long name and OID of an ASN1_OBJECT.\n"
1139 : : "\n"
1140 : : "By default objects are looked up by OID. With name=True short and\n"
1141 : : "long name are also matched.");
1142 : :
1143 : : #define _SSL_TXT2OBJ_METHODDEF \
1144 : : {"txt2obj", _PyCFunction_CAST(_ssl_txt2obj), METH_FASTCALL|METH_KEYWORDS, _ssl_txt2obj__doc__},
1145 : :
1146 : : static PyObject *
1147 : : _ssl_txt2obj_impl(PyObject *module, const char *txt, int name);
1148 : :
1149 : : static PyObject *
1150 : 1732 : _ssl_txt2obj(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1151 : : {
1152 : 1732 : PyObject *return_value = NULL;
1153 : : static const char * const _keywords[] = {"txt", "name", NULL};
1154 : : static _PyArg_Parser _parser = {NULL, _keywords, "txt2obj", 0};
1155 : : PyObject *argsbuf[2];
1156 [ + - ]: 1732 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
1157 : : const char *txt;
1158 : 1732 : int name = 0;
1159 : :
1160 [ - + - - : 1732 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
- - - - ]
1161 [ - + ]: 1732 : if (!args) {
1162 : 0 : goto exit;
1163 : : }
1164 [ - + ]: 1732 : if (!PyUnicode_Check(args[0])) {
1165 : 0 : _PyArg_BadArgument("txt2obj", "argument 'txt'", "str", args[0]);
1166 : 0 : goto exit;
1167 : : }
1168 : : Py_ssize_t txt_length;
1169 : 1732 : txt = PyUnicode_AsUTF8AndSize(args[0], &txt_length);
1170 [ - + ]: 1732 : if (txt == NULL) {
1171 : 0 : goto exit;
1172 : : }
1173 [ - + ]: 1732 : if (strlen(txt) != (size_t)txt_length) {
1174 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1175 : 0 : goto exit;
1176 : : }
1177 [ - + ]: 1732 : if (!noptargs) {
1178 : 0 : goto skip_optional_pos;
1179 : : }
1180 : 1732 : name = PyObject_IsTrue(args[1]);
1181 [ - + ]: 1732 : if (name < 0) {
1182 : 0 : goto exit;
1183 : : }
1184 : 1732 : skip_optional_pos:
1185 : 1732 : return_value = _ssl_txt2obj_impl(module, txt, name);
1186 : :
1187 : 1732 : exit:
1188 : 1732 : return return_value;
1189 : : }
1190 : :
1191 : : PyDoc_STRVAR(_ssl_nid2obj__doc__,
1192 : : "nid2obj($module, nid, /)\n"
1193 : : "--\n"
1194 : : "\n"
1195 : : "Lookup NID, short name, long name and OID of an ASN1_OBJECT by NID.");
1196 : :
1197 : : #define _SSL_NID2OBJ_METHODDEF \
1198 : : {"nid2obj", (PyCFunction)_ssl_nid2obj, METH_O, _ssl_nid2obj__doc__},
1199 : :
1200 : : static PyObject *
1201 : : _ssl_nid2obj_impl(PyObject *module, int nid);
1202 : :
1203 : : static PyObject *
1204 : 1003 : _ssl_nid2obj(PyObject *module, PyObject *arg)
1205 : : {
1206 : 1003 : PyObject *return_value = NULL;
1207 : : int nid;
1208 : :
1209 : 1003 : nid = _PyLong_AsInt(arg);
1210 [ + + - + ]: 1003 : if (nid == -1 && PyErr_Occurred()) {
1211 : 0 : goto exit;
1212 : : }
1213 : 1003 : return_value = _ssl_nid2obj_impl(module, nid);
1214 : :
1215 : 1003 : exit:
1216 : 1003 : return return_value;
1217 : : }
1218 : :
1219 : : #if defined(_MSC_VER)
1220 : :
1221 : : PyDoc_STRVAR(_ssl_enum_certificates__doc__,
1222 : : "enum_certificates($module, /, store_name)\n"
1223 : : "--\n"
1224 : : "\n"
1225 : : "Retrieve certificates from Windows\' cert store.\n"
1226 : : "\n"
1227 : : "store_name may be one of \'CA\', \'ROOT\' or \'MY\'. The system may provide\n"
1228 : : "more cert storages, too. The function returns a list of (bytes,\n"
1229 : : "encoding_type, trust) tuples. The encoding_type flag can be interpreted\n"
1230 : : "with X509_ASN_ENCODING or PKCS_7_ASN_ENCODING. The trust setting is either\n"
1231 : : "a set of OIDs or the boolean True.");
1232 : :
1233 : : #define _SSL_ENUM_CERTIFICATES_METHODDEF \
1234 : : {"enum_certificates", _PyCFunction_CAST(_ssl_enum_certificates), METH_FASTCALL|METH_KEYWORDS, _ssl_enum_certificates__doc__},
1235 : :
1236 : : static PyObject *
1237 : : _ssl_enum_certificates_impl(PyObject *module, const char *store_name);
1238 : :
1239 : : static PyObject *
1240 : : _ssl_enum_certificates(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1241 : : {
1242 : : PyObject *return_value = NULL;
1243 : : static const char * const _keywords[] = {"store_name", NULL};
1244 : : static _PyArg_Parser _parser = {NULL, _keywords, "enum_certificates", 0};
1245 : : PyObject *argsbuf[1];
1246 : : const char *store_name;
1247 : :
1248 : : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
1249 : : if (!args) {
1250 : : goto exit;
1251 : : }
1252 : : if (!PyUnicode_Check(args[0])) {
1253 : : _PyArg_BadArgument("enum_certificates", "argument 'store_name'", "str", args[0]);
1254 : : goto exit;
1255 : : }
1256 : : Py_ssize_t store_name_length;
1257 : : store_name = PyUnicode_AsUTF8AndSize(args[0], &store_name_length);
1258 : : if (store_name == NULL) {
1259 : : goto exit;
1260 : : }
1261 : : if (strlen(store_name) != (size_t)store_name_length) {
1262 : : PyErr_SetString(PyExc_ValueError, "embedded null character");
1263 : : goto exit;
1264 : : }
1265 : : return_value = _ssl_enum_certificates_impl(module, store_name);
1266 : :
1267 : : exit:
1268 : : return return_value;
1269 : : }
1270 : :
1271 : : #endif /* defined(_MSC_VER) */
1272 : :
1273 : : #if defined(_MSC_VER)
1274 : :
1275 : : PyDoc_STRVAR(_ssl_enum_crls__doc__,
1276 : : "enum_crls($module, /, store_name)\n"
1277 : : "--\n"
1278 : : "\n"
1279 : : "Retrieve CRLs from Windows\' cert store.\n"
1280 : : "\n"
1281 : : "store_name may be one of \'CA\', \'ROOT\' or \'MY\'. The system may provide\n"
1282 : : "more cert storages, too. The function returns a list of (bytes,\n"
1283 : : "encoding_type) tuples. The encoding_type flag can be interpreted with\n"
1284 : : "X509_ASN_ENCODING or PKCS_7_ASN_ENCODING.");
1285 : :
1286 : : #define _SSL_ENUM_CRLS_METHODDEF \
1287 : : {"enum_crls", _PyCFunction_CAST(_ssl_enum_crls), METH_FASTCALL|METH_KEYWORDS, _ssl_enum_crls__doc__},
1288 : :
1289 : : static PyObject *
1290 : : _ssl_enum_crls_impl(PyObject *module, const char *store_name);
1291 : :
1292 : : static PyObject *
1293 : : _ssl_enum_crls(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1294 : : {
1295 : : PyObject *return_value = NULL;
1296 : : static const char * const _keywords[] = {"store_name", NULL};
1297 : : static _PyArg_Parser _parser = {NULL, _keywords, "enum_crls", 0};
1298 : : PyObject *argsbuf[1];
1299 : : const char *store_name;
1300 : :
1301 : : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
1302 : : if (!args) {
1303 : : goto exit;
1304 : : }
1305 : : if (!PyUnicode_Check(args[0])) {
1306 : : _PyArg_BadArgument("enum_crls", "argument 'store_name'", "str", args[0]);
1307 : : goto exit;
1308 : : }
1309 : : Py_ssize_t store_name_length;
1310 : : store_name = PyUnicode_AsUTF8AndSize(args[0], &store_name_length);
1311 : : if (store_name == NULL) {
1312 : : goto exit;
1313 : : }
1314 : : if (strlen(store_name) != (size_t)store_name_length) {
1315 : : PyErr_SetString(PyExc_ValueError, "embedded null character");
1316 : : goto exit;
1317 : : }
1318 : : return_value = _ssl_enum_crls_impl(module, store_name);
1319 : :
1320 : : exit:
1321 : : return return_value;
1322 : : }
1323 : :
1324 : : #endif /* defined(_MSC_VER) */
1325 : :
1326 : : #ifndef _SSL_ENUM_CERTIFICATES_METHODDEF
1327 : : #define _SSL_ENUM_CERTIFICATES_METHODDEF
1328 : : #endif /* !defined(_SSL_ENUM_CERTIFICATES_METHODDEF) */
1329 : :
1330 : : #ifndef _SSL_ENUM_CRLS_METHODDEF
1331 : : #define _SSL_ENUM_CRLS_METHODDEF
1332 : : #endif /* !defined(_SSL_ENUM_CRLS_METHODDEF) */
1333 : : /*[clinic end generated code: output=9d806f8ff4a06ed3 input=a9049054013a1b77]*/
|
