LCOV - code coverage report
Current view: top level - extmod - modussl_mbedtls.c (source / functions) Hit Total Coverage
Test: unix_coverage_v1.19.1-724-gfb7d21153.info Lines: 135 167 80.8 %
Date: 2022-12-01 09:37:31 Functions: 10 11 90.9 %
Branches: 33 66 50.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * This file is part of the MicroPython project, http://micropython.org/
       3                 :            :  *
       4                 :            :  * The MIT License (MIT)
       5                 :            :  *
       6                 :            :  * Copyright (c) 2016 Linaro Ltd.
       7                 :            :  * Copyright (c) 2019 Paul Sokolovsky
       8                 :            :  *
       9                 :            :  * Permission is hereby granted, free of charge, to any person obtaining a copy
      10                 :            :  * of this software and associated documentation files (the "Software"), to deal
      11                 :            :  * in the Software without restriction, including without limitation the rights
      12                 :            :  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
      13                 :            :  * copies of the Software, and to permit persons to whom the Software is
      14                 :            :  * furnished to do so, subject to the following conditions:
      15                 :            :  *
      16                 :            :  * The above copyright notice and this permission notice shall be included in
      17                 :            :  * all copies or substantial portions of the Software.
      18                 :            :  *
      19                 :            :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      20                 :            :  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      21                 :            :  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
      22                 :            :  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      23                 :            :  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
      24                 :            :  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
      25                 :            :  * THE SOFTWARE.
      26                 :            :  */
      27                 :            : 
      28                 :            : #include "py/mpconfig.h"
      29                 :            : #if MICROPY_PY_USSL && MICROPY_SSL_MBEDTLS
      30                 :            : 
      31                 :            : #include <stdio.h>
      32                 :            : #include <string.h>
      33                 :            : #include <errno.h> // needed because mp_is_nonblocking_error uses system error codes
      34                 :            : 
      35                 :            : #include "py/runtime.h"
      36                 :            : #include "py/stream.h"
      37                 :            : #include "py/objstr.h"
      38                 :            : 
      39                 :            : // mbedtls_time_t
      40                 :            : #include "mbedtls/platform.h"
      41                 :            : #include "mbedtls/ssl.h"
      42                 :            : #include "mbedtls/x509_crt.h"
      43                 :            : #include "mbedtls/pk.h"
      44                 :            : #include "mbedtls/entropy.h"
      45                 :            : #include "mbedtls/ctr_drbg.h"
      46                 :            : #include "mbedtls/debug.h"
      47                 :            : #include "mbedtls/error.h"
      48                 :            : 
      49                 :            : typedef struct _mp_obj_ssl_socket_t {
      50                 :            :     mp_obj_base_t base;
      51                 :            :     mp_obj_t sock;
      52                 :            :     mbedtls_entropy_context entropy;
      53                 :            :     mbedtls_ctr_drbg_context ctr_drbg;
      54                 :            :     mbedtls_ssl_context ssl;
      55                 :            :     mbedtls_ssl_config conf;
      56                 :            :     mbedtls_x509_crt cacert;
      57                 :            :     mbedtls_x509_crt cert;
      58                 :            :     mbedtls_pk_context pkey;
      59                 :            : } mp_obj_ssl_socket_t;
      60                 :            : 
      61                 :            : struct ssl_args {
      62                 :            :     mp_arg_val_t key;
      63                 :            :     mp_arg_val_t cert;
      64                 :            :     mp_arg_val_t server_side;
      65                 :            :     mp_arg_val_t server_hostname;
      66                 :            :     mp_arg_val_t cert_reqs;
      67                 :            :     mp_arg_val_t cadata;
      68                 :            :     mp_arg_val_t do_handshake;
      69                 :            : };
      70                 :            : 
      71                 :            : STATIC const mp_obj_type_t ussl_socket_type;
      72                 :            : 
      73                 :            : #ifdef MBEDTLS_DEBUG_C
      74                 :            : STATIC void mbedtls_debug(void *ctx, int level, const char *file, int line, const char *str) {
      75                 :            :     (void)ctx;
      76                 :            :     (void)level;
      77                 :            :     mp_printf(&mp_plat_print, "DBG:%s:%04d: %s\n", file, line, str);
      78                 :            : }
      79                 :            : #endif
      80                 :            : 
      81                 :          2 : STATIC NORETURN void mbedtls_raise_error(int err) {
      82                 :            :     // _mbedtls_ssl_send and _mbedtls_ssl_recv (below) turn positive error codes from the
      83                 :            :     // underlying socket into negative codes to pass them through mbedtls. Here we turn them
      84                 :            :     // positive again so they get interpreted as the OSError they really are. The
      85                 :            :     // cut-off of -256 is a bit hacky, sigh.
      86         [ -  + ]:          2 :     if (err < 0 && err > -256) {
      87                 :          0 :         mp_raise_OSError(-err);
      88                 :            :     }
      89                 :            : 
      90                 :            :     #if defined(MBEDTLS_ERROR_C)
      91                 :            :     // Including mbedtls_strerror takes about 1.5KB due to the error strings.
      92                 :            :     // MBEDTLS_ERROR_C is the define used by mbedtls to conditionally include mbedtls_strerror.
      93                 :            :     // It is set/unset in the MBEDTLS_CONFIG_FILE which is defined in the Makefile.
      94                 :            : 
      95                 :            :     // Try to allocate memory for the message
      96                 :            :     #define ERR_STR_MAX 80  // mbedtls_strerror truncates if it doesn't fit
      97                 :          2 :     mp_obj_str_t *o_str = m_new_obj_maybe(mp_obj_str_t);
      98                 :          2 :     byte *o_str_buf = m_new_maybe(byte, ERR_STR_MAX);
      99         [ -  + ]:          2 :     if (o_str == NULL || o_str_buf == NULL) {
     100                 :          0 :         mp_raise_OSError(err);
     101                 :            :     }
     102                 :            : 
     103                 :            :     // print the error message into the allocated buffer
     104                 :          2 :     mbedtls_strerror(err, (char *)o_str_buf, ERR_STR_MAX);
     105                 :          2 :     size_t len = strlen((char *)o_str_buf);
     106                 :            : 
     107                 :            :     // Put the exception object together
     108                 :          2 :     o_str->base.type = &mp_type_str;
     109                 :          2 :     o_str->data = o_str_buf;
     110                 :          2 :     o_str->len = len;
     111                 :          2 :     o_str->hash = qstr_compute_hash(o_str->data, o_str->len);
     112                 :            :     // raise
     113                 :          2 :     mp_obj_t args[2] = { MP_OBJ_NEW_SMALL_INT(err), MP_OBJ_FROM_PTR(o_str)};
     114                 :          2 :     nlr_raise(mp_obj_exception_make_new(&mp_type_OSError, 2, 0, args));
     115                 :            :     #else
     116                 :            :     // mbedtls is compiled without error strings so we simply return the err number
     117                 :            :     mp_raise_OSError(err); // err is typically a large negative number
     118                 :            :     #endif
     119                 :            : }
     120                 :            : 
     121                 :          2 : STATIC int _mbedtls_ssl_send(void *ctx, const byte *buf, size_t len) {
     122                 :          2 :     mp_obj_t sock = *(mp_obj_t *)ctx;
     123                 :            : 
     124                 :          2 :     const mp_stream_p_t *sock_stream = mp_get_stream(sock);
     125                 :          2 :     int err;
     126                 :            : 
     127                 :          2 :     mp_uint_t out_sz = sock_stream->write(sock, buf, len, &err);
     128         [ -  + ]:          2 :     if (out_sz == MP_STREAM_ERROR) {
     129         [ #  # ]:          0 :         if (mp_is_nonblocking_error(err)) {
     130                 :            :             return MBEDTLS_ERR_SSL_WANT_WRITE;
     131                 :            :         }
     132                 :          0 :         return -err; // convert an MP_ERRNO to something mbedtls passes through as error
     133                 :            :     } else {
     134                 :          2 :         return out_sz;
     135                 :            :     }
     136                 :            : }
     137                 :            : 
     138                 :            : // _mbedtls_ssl_recv is called by mbedtls to receive bytes from the underlying socket
     139                 :          6 : STATIC int _mbedtls_ssl_recv(void *ctx, byte *buf, size_t len) {
     140                 :          6 :     mp_obj_t sock = *(mp_obj_t *)ctx;
     141                 :            : 
     142                 :          6 :     const mp_stream_p_t *sock_stream = mp_get_stream(sock);
     143                 :          6 :     int err;
     144                 :            : 
     145                 :          6 :     mp_uint_t out_sz = sock_stream->read(sock, buf, len, &err);
     146         [ -  + ]:          6 :     if (out_sz == MP_STREAM_ERROR) {
     147         [ #  # ]:          0 :         if (mp_is_nonblocking_error(err)) {
     148                 :            :             return MBEDTLS_ERR_SSL_WANT_READ;
     149                 :            :         }
     150                 :          0 :         return -err;
     151                 :            :     } else {
     152                 :          6 :         return out_sz;
     153                 :            :     }
     154                 :            : }
     155                 :            : 
     156                 :            : 
     157                 :         10 : STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
     158                 :            :     // Verify the socket object has the full stream protocol
     159                 :         10 :     mp_get_stream_raise(sock, MP_STREAM_OP_READ | MP_STREAM_OP_WRITE | MP_STREAM_OP_IOCTL);
     160                 :            : 
     161                 :            :     #if MICROPY_PY_USSL_FINALISER
     162                 :            :     mp_obj_ssl_socket_t *o = m_new_obj_with_finaliser(mp_obj_ssl_socket_t);
     163                 :            :     #else
     164                 :         10 :     mp_obj_ssl_socket_t *o = m_new_obj(mp_obj_ssl_socket_t);
     165                 :            :     #endif
     166                 :         10 :     o->base.type = &ussl_socket_type;
     167                 :         10 :     o->sock = sock;
     168                 :            : 
     169                 :         10 :     int ret;
     170                 :         10 :     mbedtls_ssl_init(&o->ssl);
     171                 :         10 :     mbedtls_ssl_config_init(&o->conf);
     172                 :         10 :     mbedtls_x509_crt_init(&o->cacert);
     173                 :         10 :     mbedtls_x509_crt_init(&o->cert);
     174                 :         10 :     mbedtls_pk_init(&o->pkey);
     175                 :         10 :     mbedtls_ctr_drbg_init(&o->ctr_drbg);
     176                 :            :     #ifdef MBEDTLS_DEBUG_C
     177                 :            :     // Debug level (0-4) 1=warning, 2=info, 3=debug, 4=verbose
     178                 :            :     mbedtls_debug_set_threshold(3);
     179                 :            :     #endif
     180                 :            : 
     181                 :         10 :     mbedtls_entropy_init(&o->entropy);
     182                 :         10 :     const byte seed[] = "upy";
     183                 :         10 :     ret = mbedtls_ctr_drbg_seed(&o->ctr_drbg, mbedtls_entropy_func, &o->entropy, seed, sizeof(seed));
     184         [ -  + ]:         10 :     if (ret != 0) {
     185                 :          0 :         goto cleanup;
     186                 :            :     }
     187                 :            : 
     188                 :         20 :     ret = mbedtls_ssl_config_defaults(&o->conf,
     189                 :         10 :         args->server_side.u_bool ? MBEDTLS_SSL_IS_SERVER : MBEDTLS_SSL_IS_CLIENT,
     190                 :            :         MBEDTLS_SSL_TRANSPORT_STREAM,
     191                 :            :         MBEDTLS_SSL_PRESET_DEFAULT);
     192         [ -  + ]:         10 :     if (ret != 0) {
     193                 :          0 :         goto cleanup;
     194                 :            :     }
     195                 :            : 
     196                 :         10 :     mbedtls_ssl_conf_authmode(&o->conf, args->cert_reqs.u_int);
     197                 :         10 :     mbedtls_ssl_conf_rng(&o->conf, mbedtls_ctr_drbg_random, &o->ctr_drbg);
     198                 :            :     #ifdef MBEDTLS_DEBUG_C
     199                 :            :     mbedtls_ssl_conf_dbg(&o->conf, mbedtls_debug, NULL);
     200                 :            :     #endif
     201                 :            : 
     202                 :         10 :     ret = mbedtls_ssl_setup(&o->ssl, &o->conf);
     203         [ -  + ]:         10 :     if (ret != 0) {
     204                 :          0 :         goto cleanup;
     205                 :            :     }
     206                 :            : 
     207         [ +  + ]:         10 :     if (args->server_hostname.u_obj != mp_const_none) {
     208                 :          2 :         const char *sni = mp_obj_str_get_str(args->server_hostname.u_obj);
     209                 :          2 :         ret = mbedtls_ssl_set_hostname(&o->ssl, sni);
     210         [ -  + ]:          2 :         if (ret != 0) {
     211                 :          0 :             goto cleanup;
     212                 :            :         }
     213                 :            :     }
     214                 :            : 
     215                 :         10 :     mbedtls_ssl_set_bio(&o->ssl, &o->sock, _mbedtls_ssl_send, _mbedtls_ssl_recv, NULL);
     216                 :            : 
     217         [ +  + ]:         10 :     if (args->key.u_obj != mp_const_none) {
     218                 :          6 :         size_t key_len;
     219                 :          6 :         const byte *key = (const byte *)mp_obj_str_get_data(args->key.u_obj, &key_len);
     220                 :            :         // len should include terminating null
     221                 :          6 :         ret = mbedtls_pk_parse_key(&o->pkey, key, key_len + 1, NULL, 0);
     222         [ +  + ]:          6 :         if (ret != 0) {
     223                 :          2 :             ret = MBEDTLS_ERR_PK_BAD_INPUT_DATA; // use general error for all key errors
     224                 :          4 :             goto cleanup;
     225                 :            :         }
     226                 :            : 
     227                 :          4 :         size_t cert_len;
     228                 :          4 :         const byte *cert = (const byte *)mp_obj_str_get_data(args->cert.u_obj, &cert_len);
     229                 :            :         // len should include terminating null
     230                 :          2 :         ret = mbedtls_x509_crt_parse(&o->cert, cert, cert_len + 1);
     231         [ +  - ]:          2 :         if (ret != 0) {
     232                 :          2 :             ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA; // use general error for all cert errors
     233                 :          2 :             goto cleanup;
     234                 :            :         }
     235                 :            : 
     236                 :          0 :         ret = mbedtls_ssl_conf_own_cert(&o->conf, &o->cert, &o->pkey);
     237         [ #  # ]:          0 :         if (ret != 0) {
     238                 :          0 :             goto cleanup;
     239                 :            :         }
     240                 :            :     }
     241                 :            : 
     242         [ -  + ]:          4 :     if (args->cadata.u_obj != mp_const_none) {
     243                 :          0 :         size_t cacert_len;
     244                 :          0 :         const byte *cacert = (const byte *)mp_obj_str_get_data(args->cadata.u_obj, &cacert_len);
     245                 :            :         // len should include terminating null
     246                 :          0 :         ret = mbedtls_x509_crt_parse(&o->cacert, cacert, cacert_len + 1);
     247         [ #  # ]:          0 :         if (ret != 0) {
     248                 :          0 :             ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA; // use general error for all cert errors
     249                 :          0 :             goto cleanup;
     250                 :            :         }
     251                 :            : 
     252                 :          0 :         mbedtls_ssl_conf_ca_chain(&o->conf, &o->cacert, NULL);
     253                 :            :     }
     254                 :            : 
     255         [ +  + ]:          4 :     if (args->do_handshake.u_bool) {
     256         [ +  - ]:          2 :         while ((ret = mbedtls_ssl_handshake(&o->ssl)) != 0) {
     257         [ +  - ]:          2 :             if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
     258                 :          2 :                 goto cleanup;
     259                 :            :             }
     260                 :            :             #ifdef MICROPY_EVENT_POLL_HOOK
     261                 :          2 :             MICROPY_EVENT_POLL_HOOK
     262                 :            :             #endif
     263                 :            :         }
     264                 :            :     }
     265                 :            : 
     266                 :          2 :     return o;
     267                 :            : 
     268                 :          6 : cleanup:
     269                 :          6 :     mbedtls_pk_free(&o->pkey);
     270                 :          6 :     mbedtls_x509_crt_free(&o->cert);
     271                 :          6 :     mbedtls_x509_crt_free(&o->cacert);
     272                 :          6 :     mbedtls_ssl_free(&o->ssl);
     273                 :          6 :     mbedtls_ssl_config_free(&o->conf);
     274                 :          6 :     mbedtls_ctr_drbg_free(&o->ctr_drbg);
     275                 :          6 :     mbedtls_entropy_free(&o->entropy);
     276                 :            : 
     277         [ -  + ]:          6 :     if (ret == MBEDTLS_ERR_SSL_ALLOC_FAILED) {
     278                 :          0 :         mp_raise_OSError(MP_ENOMEM);
     279         [ +  + ]:          6 :     } else if (ret == MBEDTLS_ERR_PK_BAD_INPUT_DATA) {
     280                 :          2 :         mp_raise_ValueError(MP_ERROR_TEXT("invalid key"));
     281         [ +  + ]:          4 :     } else if (ret == MBEDTLS_ERR_X509_BAD_INPUT_DATA) {
     282                 :          2 :         mp_raise_ValueError(MP_ERROR_TEXT("invalid cert"));
     283                 :            :     } else {
     284                 :          2 :         mbedtls_raise_error(ret);
     285                 :            :     }
     286                 :            : }
     287                 :            : 
     288                 :          0 : STATIC mp_obj_t mod_ssl_getpeercert(mp_obj_t o_in, mp_obj_t binary_form) {
     289                 :          0 :     mp_obj_ssl_socket_t *o = MP_OBJ_TO_PTR(o_in);
     290         [ #  # ]:          0 :     if (!mp_obj_is_true(binary_form)) {
     291                 :          0 :         mp_raise_NotImplementedError(NULL);
     292                 :            :     }
     293                 :          0 :     const mbedtls_x509_crt *peer_cert = mbedtls_ssl_get_peer_cert(&o->ssl);
     294         [ #  # ]:          0 :     if (peer_cert == NULL) {
     295                 :            :         return mp_const_none;
     296                 :            :     }
     297                 :          0 :     return mp_obj_new_bytes(peer_cert->raw.p, peer_cert->raw.len);
     298                 :            : }
     299                 :            : STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_ssl_getpeercert_obj, mod_ssl_getpeercert);
     300                 :            : 
     301                 :          2 : STATIC void socket_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     302                 :          2 :     (void)kind;
     303                 :          2 :     mp_obj_ssl_socket_t *self = MP_OBJ_TO_PTR(self_in);
     304                 :          2 :     mp_printf(print, "<_SSLSocket %p>", self);
     305                 :          2 : }
     306                 :            : 
     307                 :          4 : STATIC mp_uint_t socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
     308                 :          4 :     mp_obj_ssl_socket_t *o = MP_OBJ_TO_PTR(o_in);
     309                 :            : 
     310                 :          4 :     int ret = mbedtls_ssl_read(&o->ssl, buf, size);
     311         [ +  - ]:          4 :     if (ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) {
     312                 :            :         // end of stream
     313                 :            :         return 0;
     314                 :            :     }
     315         [ -  + ]:          4 :     if (ret >= 0) {
     316                 :          0 :         return ret;
     317                 :            :     }
     318         [ +  - ]:          4 :     if (ret == MBEDTLS_ERR_SSL_WANT_READ) {
     319                 :            :         ret = MP_EWOULDBLOCK;
     320         [ -  + ]:          4 :     } else if (ret == MBEDTLS_ERR_SSL_WANT_WRITE) {
     321                 :            :         // If handshake is not finished, read attempt may end up in protocol
     322                 :            :         // wanting to write next handshake message. The same may happen with
     323                 :            :         // renegotation.
     324                 :          0 :         ret = MP_EWOULDBLOCK;
     325                 :            :     }
     326                 :          4 :     *errcode = ret;
     327                 :          4 :     return MP_STREAM_ERROR;
     328                 :            : }
     329                 :            : 
     330                 :          4 : STATIC mp_uint_t socket_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
     331                 :          4 :     mp_obj_ssl_socket_t *o = MP_OBJ_TO_PTR(o_in);
     332                 :            : 
     333                 :          4 :     int ret = mbedtls_ssl_write(&o->ssl, buf, size);
     334         [ -  + ]:          4 :     if (ret >= 0) {
     335                 :          0 :         return ret;
     336                 :            :     }
     337         [ +  - ]:          4 :     if (ret == MBEDTLS_ERR_SSL_WANT_WRITE) {
     338                 :            :         ret = MP_EWOULDBLOCK;
     339         [ -  + ]:          4 :     } else if (ret == MBEDTLS_ERR_SSL_WANT_READ) {
     340                 :            :         // If handshake is not finished, write attempt may end up in protocol
     341                 :            :         // wanting to read next handshake message. The same may happen with
     342                 :            :         // renegotation.
     343                 :          0 :         ret = MP_EWOULDBLOCK;
     344                 :            :     }
     345                 :          4 :     *errcode = ret;
     346                 :          4 :     return MP_STREAM_ERROR;
     347                 :            : }
     348                 :            : 
     349                 :          4 : STATIC mp_obj_t socket_setblocking(mp_obj_t self_in, mp_obj_t flag_in) {
     350                 :          4 :     mp_obj_ssl_socket_t *o = MP_OBJ_TO_PTR(self_in);
     351                 :          4 :     mp_obj_t sock = o->sock;
     352                 :          4 :     mp_obj_t dest[3];
     353                 :          4 :     mp_load_method(sock, MP_QSTR_setblocking, dest);
     354                 :          4 :     dest[2] = flag_in;
     355                 :          4 :     return mp_call_method_n_kw(1, 0, dest);
     356                 :            : }
     357                 :            : STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_setblocking_obj, socket_setblocking);
     358                 :            : 
     359                 :          4 : STATIC mp_uint_t socket_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
     360                 :          4 :     mp_obj_ssl_socket_t *self = MP_OBJ_TO_PTR(o_in);
     361         [ +  - ]:          4 :     if (request == MP_STREAM_CLOSE) {
     362                 :          4 :         mbedtls_pk_free(&self->pkey);
     363                 :          4 :         mbedtls_x509_crt_free(&self->cert);
     364                 :          4 :         mbedtls_x509_crt_free(&self->cacert);
     365                 :          4 :         mbedtls_ssl_free(&self->ssl);
     366                 :          4 :         mbedtls_ssl_config_free(&self->conf);
     367                 :          4 :         mbedtls_ctr_drbg_free(&self->ctr_drbg);
     368                 :          4 :         mbedtls_entropy_free(&self->entropy);
     369                 :            :     }
     370                 :            :     // Pass all requests down to the underlying socket
     371                 :          4 :     return mp_get_stream(self->sock)->ioctl(self->sock, request, arg, errcode);
     372                 :            : }
     373                 :            : 
     374                 :            : STATIC const mp_rom_map_elem_t ussl_socket_locals_dict_table[] = {
     375                 :            :     { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
     376                 :            :     { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
     377                 :            :     { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
     378                 :            :     { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
     379                 :            :     { MP_ROM_QSTR(MP_QSTR_setblocking), MP_ROM_PTR(&socket_setblocking_obj) },
     380                 :            :     { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
     381                 :            :     #if MICROPY_PY_USSL_FINALISER
     382                 :            :     { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
     383                 :            :     #endif
     384                 :            :     { MP_ROM_QSTR(MP_QSTR_getpeercert), MP_ROM_PTR(&mod_ssl_getpeercert_obj) },
     385                 :            : };
     386                 :            : 
     387                 :            : STATIC MP_DEFINE_CONST_DICT(ussl_socket_locals_dict, ussl_socket_locals_dict_table);
     388                 :            : 
     389                 :            : STATIC const mp_stream_p_t ussl_socket_stream_p = {
     390                 :            :     .read = socket_read,
     391                 :            :     .write = socket_write,
     392                 :            :     .ioctl = socket_ioctl,
     393                 :            : };
     394                 :            : 
     395                 :            : STATIC MP_DEFINE_CONST_OBJ_TYPE(
     396                 :            :     ussl_socket_type,
     397                 :            :     MP_QSTR_ussl,
     398                 :            :     MP_TYPE_FLAG_NONE,
     399                 :            :     // Save on qstr's, reuse same as for module
     400                 :            :     print, socket_print,
     401                 :            :     protocol, &ussl_socket_stream_p,
     402                 :            :     locals_dict, &ussl_socket_locals_dict
     403                 :            :     );
     404                 :            : 
     405                 :         10 : STATIC mp_obj_t mod_ssl_wrap_socket(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     406                 :            :     // TODO: Implement more args
     407                 :         10 :     static const mp_arg_t allowed_args[] = {
     408                 :            :         { MP_QSTR_key, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
     409                 :            :         { MP_QSTR_cert, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
     410                 :            :         { MP_QSTR_server_side, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
     411                 :            :         { MP_QSTR_server_hostname, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
     412                 :            :         { MP_QSTR_cert_reqs, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = MBEDTLS_SSL_VERIFY_NONE}},
     413                 :            :         { MP_QSTR_cadata, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
     414                 :            :         { MP_QSTR_do_handshake, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = true} },
     415                 :            :     };
     416                 :            : 
     417                 :            :     // TODO: Check that sock implements stream protocol
     418                 :         10 :     mp_obj_t sock = pos_args[0];
     419                 :            : 
     420                 :         10 :     struct ssl_args args;
     421                 :         10 :     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args,
     422                 :            :         MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t *)&args);
     423                 :            : 
     424                 :         10 :     return MP_OBJ_FROM_PTR(socket_new(sock, &args));
     425                 :            : }
     426                 :            : STATIC MP_DEFINE_CONST_FUN_OBJ_KW(mod_ssl_wrap_socket_obj, 1, mod_ssl_wrap_socket);
     427                 :            : 
     428                 :            : STATIC const mp_rom_map_elem_t mp_module_ssl_globals_table[] = {
     429                 :            :     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_ussl) },
     430                 :            :     { MP_ROM_QSTR(MP_QSTR_wrap_socket), MP_ROM_PTR(&mod_ssl_wrap_socket_obj) },
     431                 :            :     { MP_ROM_QSTR(MP_QSTR_CERT_NONE), MP_ROM_INT(MBEDTLS_SSL_VERIFY_NONE) },
     432                 :            :     { MP_ROM_QSTR(MP_QSTR_CERT_OPTIONAL), MP_ROM_INT(MBEDTLS_SSL_VERIFY_OPTIONAL) },
     433                 :            :     { MP_ROM_QSTR(MP_QSTR_CERT_REQUIRED), MP_ROM_INT(MBEDTLS_SSL_VERIFY_REQUIRED) },
     434                 :            : };
     435                 :            : 
     436                 :            : STATIC MP_DEFINE_CONST_DICT(mp_module_ssl_globals, mp_module_ssl_globals_table);
     437                 :            : 
     438                 :            : const mp_obj_module_t mp_module_ussl = {
     439                 :            :     .base = { &mp_type_module },
     440                 :            :     .globals = (mp_obj_dict_t *)&mp_module_ssl_globals,
     441                 :            : };
     442                 :            : 
     443                 :            : MP_REGISTER_MODULE(MP_QSTR_ussl, mp_module_ussl);
     444                 :            : 
     445                 :            : #endif // MICROPY_PY_USSL && MICROPY_SSL_MBEDTLS

Generated by: LCOV version 1.15-5-g462f71d