2012-09-25 09:05:17 +00:00
/*
* SSL client with options
*
2015-07-27 09:11:48 +00:00
* Copyright ( C ) 2006 - 2015 , ARM Limited , All Rights Reserved
2015-09-04 12:21:07 +00:00
* SPDX - License - Identifier : Apache - 2.0
2012-09-25 09:05:17 +00:00
*
2015-09-04 12:21:07 +00:00
* Licensed under the Apache License , Version 2.0 ( the " License " ) ; you may
* not use this file except in compliance with the License .
* You may obtain a copy of the License at
2012-09-25 09:05:17 +00:00
*
2015-09-04 12:21:07 +00:00
* http : //www.apache.org/licenses/LICENSE-2.0
2012-09-25 09:05:17 +00:00
*
2015-09-04 12:21:07 +00:00
* Unless required by applicable law or agreed to in writing , software
* distributed under the License is distributed on an " AS IS " BASIS , WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND , either express or implied .
* See the License for the specific language governing permissions and
* limitations under the License .
2012-09-25 09:05:17 +00:00
*
2015-09-04 12:21:07 +00:00
* This file is part of mbed TLS ( https : //tls.mbed.org)
2012-09-25 09:05:17 +00:00
*/
2015-04-08 10:49:31 +00:00
# if !defined(MBEDTLS_CONFIG_FILE)
2015-03-09 17:05:11 +00:00
# include "mbedtls/config.h"
2014-04-29 10:39:06 +00:00
# else
2015-04-08 10:49:31 +00:00
# include MBEDTLS_CONFIG_FILE
2014-04-29 10:39:06 +00:00
# endif
2012-09-25 09:05:17 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_PLATFORM_C)
2015-03-09 17:05:11 +00:00
# include "mbedtls/platform.h"
2015-01-19 14:26:37 +00:00
# else
2015-02-11 14:06:19 +00:00
# include <stdio.h>
2016-04-27 00:26:50 +00:00
# include <stdlib.h>
2019-03-30 06:27:43 +00:00
# define mbedtls_calloc calloc
2015-04-08 10:49:31 +00:00
# define mbedtls_free free
2016-04-27 00:26:50 +00:00
# define mbedtls_time time
# define mbedtls_time_t time_t
2015-05-26 14:04:06 +00:00
# define mbedtls_calloc calloc
2015-04-08 10:49:31 +00:00
# define mbedtls_fprintf fprintf
# define mbedtls_printf printf
2019-01-31 13:20:20 +00:00
# define mbedtls_exit exit
# define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS
# define MBEDTLS_EXIT_FAILURE EXIT_FAILURE
2015-01-19 14:26:37 +00:00
# endif
2015-05-13 08:04:32 +00:00
# if !defined(MBEDTLS_ENTROPY_C) || \
! defined ( MBEDTLS_SSL_TLS_C ) | | ! defined ( MBEDTLS_SSL_SRV_C ) | | \
2015-05-13 11:58:56 +00:00
! defined ( MBEDTLS_NET_C ) | | ! defined ( MBEDTLS_CTR_DRBG_C )
2015-05-13 08:04:32 +00:00
int main ( void )
{
mbedtls_printf ( " MBEDTLS_ENTROPY_C and/or "
" MBEDTLS_SSL_TLS_C and/or MBEDTLS_SSL_SRV_C and/or "
2015-05-13 11:58:56 +00:00
" MBEDTLS_NET_C and/or MBEDTLS_CTR_DRBG_C and/or not defined. \n " ) ;
2015-05-13 08:04:32 +00:00
return ( 0 ) ;
}
# else
2012-09-25 09:05:17 +00:00
2016-09-14 13:32:09 +00:00
# include "mbedtls/net_sockets.h"
2015-03-09 17:05:11 +00:00
# include "mbedtls/ssl.h"
# include "mbedtls/entropy.h"
# include "mbedtls/ctr_drbg.h"
# include "mbedtls/certs.h"
# include "mbedtls/x509.h"
# include "mbedtls/error.h"
# include "mbedtls/debug.h"
2015-05-26 10:19:45 +00:00
# include "mbedtls/timing.h"
2012-09-25 09:05:17 +00:00
2018-11-12 17:47:48 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
# include "psa/crypto.h"
2018-11-15 13:06:09 +00:00
# include "mbedtls/psa_util.h"
2018-11-12 17:47:48 +00:00
# endif
2015-02-11 14:06:19 +00:00
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
2017-01-19 16:30:57 +00:00
# include <stdint.h>
2017-02-08 14:05:57 +00:00
# if !defined(_MSC_VER)
2017-01-19 16:30:57 +00:00
# include <inttypes.h>
2017-02-08 14:05:57 +00:00
# endif
2015-02-11 14:06:19 +00:00
# if !defined(_WIN32)
# include <signal.h>
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_CACHE_C)
2015-03-09 17:05:11 +00:00
# include "mbedtls/ssl_cache.h"
2012-09-25 21:55:46 +00:00
# endif
2015-05-19 13:28:00 +00:00
# if defined(MBEDTLS_SSL_TICKET_C)
# include "mbedtls/ssl_ticket.h"
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_COOKIE_C)
2015-03-09 17:05:11 +00:00
# include "mbedtls/ssl_cookie.h"
2014-07-23 14:56:27 +00:00
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
2015-03-09 17:05:11 +00:00
# include "mbedtls/memory_buffer_alloc.h"
2013-07-04 09:52:32 +00:00
# endif
2015-05-13 08:04:32 +00:00
# if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION) && defined(MBEDTLS_FS_IO)
# define SNI_OPTION
# endif
# if defined(_WIN32)
# include <windows.h>
# endif
2018-07-23 13:26:09 +00:00
/* Size of memory to be allocated for the heap, when using the library's memory
* management and MBEDTLS_MEMORY_BUFFER_ALLOC_C is enabled . */
# define MEMORY_HEAP_SIZE 120000
2013-12-13 15:21:41 +00:00
# define DFL_SERVER_ADDR NULL
2015-06-23 10:30:57 +00:00
# define DFL_SERVER_PORT "4433"
2017-10-12 11:50:29 +00:00
# define DFL_RESPONSE_SIZE -1
2012-09-25 09:05:17 +00:00
# define DFL_DEBUG_LEVEL 0
2014-02-26 12:47:08 +00:00
# define DFL_NBIO 0
2017-10-10 14:56:37 +00:00
# define DFL_EVENT 0
2014-10-01 16:29:03 +00:00
# define DFL_READ_TIMEOUT 0
2012-09-25 09:05:17 +00:00
# define DFL_CA_FILE ""
# define DFL_CA_PATH ""
# define DFL_CRT_FILE ""
# define DFL_KEY_FILE ""
2013-09-23 15:00:18 +00:00
# define DFL_CRT_FILE2 ""
# define DFL_KEY_FILE2 ""
2018-01-12 12:47:48 +00:00
# define DFL_ASYNC_OPERATIONS "-"
2018-01-05 20:15:57 +00:00
# define DFL_ASYNC_PRIVATE_DELAY1 ( -1 )
# define DFL_ASYNC_PRIVATE_DELAY2 ( -1 )
2018-01-05 20:22:12 +00:00
# define DFL_ASYNC_PRIVATE_ERROR ( 0 )
2013-04-17 17:10:21 +00:00
# define DFL_PSK ""
2018-11-15 13:06:09 +00:00
# define DFL_PSK_OPAQUE 0
# define DFL_PSK_LIST_OPAQUE 0
2013-04-17 17:10:21 +00:00
# define DFL_PSK_IDENTITY "Client_identity"
2015-09-16 09:08:34 +00:00
# define DFL_ECJPAKE_PW NULL
2014-06-10 12:01:52 +00:00
# define DFL_PSK_LIST NULL
2012-09-25 09:05:17 +00:00
# define DFL_FORCE_CIPHER 0
2014-06-11 11:50:34 +00:00
# define DFL_VERSION_SUITES NULL
2015-04-08 10:49:31 +00:00
# define DFL_RENEGOTIATION MBEDTLS_SSL_RENEGOTIATION_DISABLED
2014-11-03 19:10:36 +00:00
# define DFL_ALLOW_LEGACY -2
2014-02-20 16:19:59 +00:00
# define DFL_RENEGOTIATE 0
2014-07-04 12:32:27 +00:00
# define DFL_RENEGO_DELAY -2
2017-01-19 16:30:57 +00:00
# define DFL_RENEGO_PERIOD ( (uint64_t)-1 )
2014-08-15 09:17:27 +00:00
# define DFL_EXCHANGES 1
2015-03-31 12:21:11 +00:00
# define DFL_MIN_VERSION -1
2013-06-29 14:01:32 +00:00
# define DFL_MAX_VERSION -1
2015-03-20 19:44:04 +00:00
# define DFL_ARC4 -1
2017-05-09 13:59:24 +00:00
# define DFL_SHA1 -1
2019-04-09 16:28:10 +00:00
# define DFL_CID_ENABLED 0
# define DFL_CID_VALUE ""
2019-05-03 16:30:59 +00:00
# define DFL_CID_ENABLED_RENEGO -1
# define DFL_CID_VALUE_RENEGO NULL
2015-03-27 16:52:25 +00:00
# define DFL_AUTH_MODE -1
2017-04-10 12:44:33 +00:00
# define DFL_CERT_REQ_CA_LIST MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED
2015-04-08 10:49:31 +00:00
# define DFL_MFL_CODE MBEDTLS_SSL_MAX_FRAG_LEN_NONE
2015-01-09 11:39:35 +00:00
# define DFL_TRUNC_HMAC -1
2015-04-08 10:49:31 +00:00
# define DFL_TICKETS MBEDTLS_SSL_SESSION_TICKETS_ENABLED
2015-05-19 13:28:00 +00:00
# define DFL_TICKET_TIMEOUT 86400
2014-02-20 20:32:41 +00:00
# define DFL_CACHE_MAX -1
2014-02-20 21:50:56 +00:00
# define DFL_CACHE_TIMEOUT -1
2014-02-21 15:52:06 +00:00
# define DFL_SNI NULL
2014-04-05 12:34:07 +00:00
# define DFL_ALPN_STRING NULL
2017-05-15 15:05:15 +00:00
# define DFL_CURVES NULL
2014-06-09 09:29:50 +00:00
# define DFL_DHM_FILE NULL
2015-04-08 10:49:31 +00:00
# define DFL_TRANSPORT MBEDTLS_SSL_TRANSPORT_STREAM
2014-07-23 17:34:59 +00:00
# define DFL_COOKIES 1
2014-09-24 12:41:11 +00:00
# define DFL_ANTI_REPLAY -1
2014-10-01 12:40:56 +00:00
# define DFL_HS_TO_MIN 0
# define DFL_HS_TO_MAX 0
2018-08-12 11:28:53 +00:00
# define DFL_DTLS_MTU -1
2014-10-14 17:36:36 +00:00
# define DFL_BADMAC_LIMIT -1
2018-08-14 12:28:56 +00:00
# define DFL_DGRAM_PACKING 1
2014-10-20 16:40:56 +00:00
# define DFL_EXTENDED_MS -1
2014-10-27 12:57:03 +00:00
# define DFL_ETM -1
2019-05-29 10:33:32 +00:00
# define DFL_SERIALIZE 0
# define DFL_EXTENDED_MS_ENFORCE -1
2019-03-27 15:55:27 +00:00
# define DFL_CA_CALLBACK 0
2019-05-12 08:03:32 +00:00
# define DFL_EAP_TLS 0
2019-06-06 19:24:31 +00:00
# define DFL_REPRODUCIBLE 0
2019-08-29 05:31:22 +00:00
# define DFL_NSS_KEYLOG 0
# define DFL_NSS_KEYLOG_FILE NULL
2012-09-25 09:05:17 +00:00
2013-07-18 12:07:36 +00:00
# define LONG_RESPONSE "<p>01-blah-blah-blah-blah-blah-blah-blah-blah-blah\r\n" \
" 02-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah \r \n " \
" 03-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah \r \n " \
" 04-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah \r \n " \
" 05-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah \r \n " \
" 06-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah \r \n " \
" 07-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah-blah</p> \r \n "
2013-07-17 13:34:17 +00:00
2013-07-18 09:05:13 +00:00
/* Uncomment LONG_RESPONSE at the end of HTTP_RESPONSE to test sending longer
* packets ( for fragmentation purposes ) */
2012-09-25 09:05:17 +00:00
# define HTTP_RESPONSE \
" HTTP/1.0 200 OK \r \n Content-Type: text/html \r \n \r \n " \
2015-01-22 16:26:39 +00:00
" <h2>mbed TLS Test Server</h2> \r \n " \
2013-07-17 13:34:17 +00:00
" <p>Successful connection using: %s</p> \r \n " // LONG_RESPONSE
2012-09-25 09:05:17 +00:00
2014-06-11 16:32:36 +00:00
/*
* Size of the basic I / O buffer . Able to hold our default response .
*
2015-04-08 10:49:31 +00:00
* You will need to adapt the mbedtls_ssl_get_bytes_avail ( ) test in ssl - opt . sh
2014-06-11 16:32:36 +00:00
* if you change this value to something outside the range < = 100 or > 500
*/
2017-10-12 11:50:29 +00:00
# define DFL_IO_BUF_LEN 200
2014-06-11 16:21:20 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_X509_CRT_PARSE_C)
# if defined(MBEDTLS_FS_IO)
2012-09-25 09:05:17 +00:00
# define USAGE_IO \
2012-11-20 09:30:55 +00:00
" ca_file=%%s The single file containing the top-level CA(s) you fully trust \n " \
" default: \" \" (pre-loaded) \n " \
2019-05-01 10:16:28 +00:00
" use \" none \" to skip loading any top-level CAs. \n " \
2012-11-20 09:30:55 +00:00
" ca_path=%%s The path containing the top-level CA(s) you fully trust \n " \
" default: \" \" (pre-loaded) (overrides ca_file) \n " \
2019-05-01 10:16:28 +00:00
" use \" none \" to skip loading any top-level CAs. \n " \
2012-11-20 09:30:55 +00:00
" crt_file=%%s Your own cert and chain (in bottom to top order, top may be omitted) \n " \
2013-09-25 09:35:15 +00:00
" default: see note after key_file2 \n " \
" key_file=%%s default: see note after key_file2 \n " \
2013-09-23 15:00:18 +00:00
" crt_file2=%%s Your second cert and chain (in bottom to top order, top may be omitted) \n " \
2013-09-25 09:35:15 +00:00
" default: see note after key_file2 \n " \
" key_file2=%%s default: see note below \n " \
" note: if neither crt_file/key_file nor crt_file2/key_file2 are used, \n " \
2014-06-09 09:29:50 +00:00
" preloaded certificate(s) and key(s) are used if available \n " \
" dhm_file=%%s File containing Diffie-Hellman parameters \n " \
" default: preloaded parameters \n "
2012-09-25 09:05:17 +00:00
# else
# define USAGE_IO \
2013-04-18 20:46:23 +00:00
" \n " \
2015-04-08 10:49:31 +00:00
" No file operations available (MBEDTLS_FS_IO not defined) \n " \
2013-04-18 20:46:23 +00:00
" \n "
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_FS_IO */
2013-04-18 20:46:23 +00:00
# else
# define USAGE_IO ""
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_X509_CRT_PARSE_C */
2013-04-18 20:46:23 +00:00
2018-04-24 11:09:22 +00:00
# if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
2018-01-05 20:15:57 +00:00
# define USAGE_SSL_ASYNC \
2018-01-12 12:47:48 +00:00
" async_operations=%%c... d=decrypt, s=sign (default: -=off) \n " \
2018-01-05 20:15:57 +00:00
" async_private_delay1=%%d Asynchronous delay for key_file or preloaded key \n " \
2018-04-30 08:30:49 +00:00
" async_private_delay2=%%d Asynchronous delay for key_file2 and sni \n " \
2018-01-05 20:15:57 +00:00
" default: -1 (not asynchronous) \n " \
2018-01-08 10:28:05 +00:00
" async_private_error=%%d Async callback error injection (default=0=none, \n " \
2018-04-26 05:15:40 +00:00
" 1=start, 2=cancel, 3=resume, negative=first time only) "
2018-01-05 20:15:57 +00:00
# else
# define USAGE_SSL_ASYNC ""
2018-04-24 11:09:22 +00:00
# endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
2018-01-05 20:15:57 +00:00
2019-05-15 13:03:01 +00:00
# if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
2019-04-09 16:28:10 +00:00
# define USAGE_CID \
" cid=%%d Disable (0) or enable (1) the use of the DTLS Connection ID extension. \n " \
" default: 0 (disabled) \n " \
2019-05-03 16:30:59 +00:00
" cid_renego=%%d Disable (0) or enable (1) the use of the DTLS Connection ID extension during renegotiation. \n " \
2019-05-23 16:01:06 +00:00
" default: same as 'cid' parameter \n " \
2019-04-09 16:28:10 +00:00
" cid_val=%%s The CID to use for incoming messages (in hex, without 0x). \n " \
2019-05-03 16:30:59 +00:00
" default: \" \" \n " \
" cid_val_renego=%%s The CID to use for incoming messages (in hex, without 0x) after renegotiation. \n " \
2019-05-23 16:01:06 +00:00
" default: same as 'cid_val' parameter \n "
2019-05-15 13:03:01 +00:00
# else /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
2019-04-09 16:28:10 +00:00
# define USAGE_CID ""
2019-05-15 13:03:01 +00:00
# endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
2019-04-09 16:28:10 +00:00
2020-03-10 11:19:08 +00:00
# if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
2018-10-26 10:28:08 +00:00
# define USAGE_PSK_RAW \
2019-11-20 13:54:36 +00:00
" psk=%%s default: \" \" (disabled) \n " \
" The PSK values are in hex, without 0x. \n " \
2018-10-26 10:28:08 +00:00
" psk_list=%%s default: \" \" \n " \
2019-02-05 10:06:35 +00:00
" A list of (PSK identity, PSK value) pairs. \n " \
" The PSK values are in hex, without 0x. \n " \
" id1,psk1[,id2,psk2[,...]] \n " \
" psk_identity=%%s default: \" Client_identity \" \n "
2018-10-26 10:28:08 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
# define USAGE_PSK_SLOT \
2018-11-15 13:06:09 +00:00
" psk_opaque=%%d default: 0 (don't use opaque static PSK) \n " \
" Enable this to store the PSK configured through command line \n " \
" parameter `psk` in a PSA-based key slot. \n " \
2018-10-26 10:28:08 +00:00
" Note: Currently only supported in conjunction with \n " \
" the use of min_version to force TLS 1.2 and force_ciphersuite \n " \
" to force a particular PSK-only ciphersuite. \n " \
" Note: This is to test integration of PSA-based opaque PSKs with \n " \
" Mbed TLS only. Production systems are likely to configure Mbed TLS \n " \
" with prepopulated key slots instead of importing raw key material. \n " \
2018-11-15 13:06:09 +00:00
" psk_list_opaque=%%d default: 0 (don't use opaque dynamic PSKs) \n " \
" Enable this to store the list of dynamically chosen PSKs configured \n " \
" through the command line parameter `psk_list` in PSA-based key slots. \n " \
2018-10-26 10:28:08 +00:00
" Note: Currently only supported in conjunction with \n " \
" the use of min_version to force TLS 1.2 and force_ciphersuite \n " \
" to force a particular PSK-only ciphersuite. \n " \
" Note: This is to test integration of PSA-based opaque PSKs with \n " \
" Mbed TLS only. Production systems are likely to configure Mbed TLS \n " \
" with prepopulated key slots instead of importing raw key material. \n "
# else
# define USAGE_PSK_SLOT ""
# endif /* MBEDTLS_USE_PSA_CRYPTO */
# define USAGE_PSK USAGE_PSK_RAW USAGE_PSK_SLOT
2013-04-18 20:46:23 +00:00
# else
# define USAGE_PSK ""
2020-03-10 11:19:08 +00:00
# endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */
2019-03-27 15:55:27 +00:00
# if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
# define USAGE_CA_CALLBACK \
" ca_callback=%%d default: 0 (disabled) \n " \
" Enable this to use the trusted certificate callback function \n "
# else
# define USAGE_CA_CALLBACK ""
# endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_SESSION_TICKETS)
2013-08-14 11:48:06 +00:00
# define USAGE_TICKETS \
2014-02-21 08:18:13 +00:00
" tickets=%%d default: 1 (enabled) \n " \
2015-05-19 13:28:00 +00:00
" ticket_timeout=%%d default: 86400 (one day) \n "
2013-08-14 11:48:06 +00:00
# else
# define USAGE_TICKETS ""
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_SSL_SESSION_TICKETS */
2013-08-14 11:48:06 +00:00
2019-05-12 08:03:32 +00:00
# if defined(MBEDTLS_SSL_EXPORT_KEYS)
# define USAGE_EAP_TLS \
" eap_tls=%%d default: 0 (disabled) \n "
2019-08-29 05:31:22 +00:00
# define USAGE_NSS_KEYLOG \
2019-09-09 10:38:51 +00:00
" nss_keylog=%%d default: 0 (disabled) \n " \
" This cannot be used with eap_tls=1 \n "
2019-08-29 05:31:22 +00:00
# define USAGE_NSS_KEYLOG_FILE \
" nss_keylog_file=%%s \n "
2019-05-12 08:03:32 +00:00
# else
# define USAGE_EAP_TLS ""
2019-08-29 05:31:22 +00:00
# define USAGE_NSS_KEYLOG ""
# define USAGE_NSS_KEYLOG_FILE ""
2019-05-12 08:03:32 +00:00
# endif /* MBEDTLS_SSL_EXPORT_KEYS */
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_CACHE_C)
2014-02-20 20:32:41 +00:00
# define USAGE_CACHE \
2014-02-20 21:50:56 +00:00
" cache_max=%%d default: cache default (50) \n " \
" cache_timeout=%%d default: cache default (1d) \n "
2014-02-20 20:32:41 +00:00
# else
# define USAGE_CACHE ""
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_SSL_CACHE_C */
2014-02-20 20:32:41 +00:00
2015-04-03 14:41:52 +00:00
# if defined(SNI_OPTION)
2019-04-04 12:02:01 +00:00
# if defined(MBEDTLS_X509_CRL_PARSE_C)
# define SNI_CRL ",crl"
# else
# define SNI_CRL ""
# endif
2014-02-21 15:52:06 +00:00
# define USAGE_SNI \
2019-04-04 12:02:01 +00:00
" sni=%%s name1,cert1,key1,ca1 " SNI_CRL " ,auth1[,...] \n " \
2015-06-19 12:40:39 +00:00
" default: disabled \n "
2014-02-21 15:52:06 +00:00
# else
# define USAGE_SNI ""
2015-04-03 14:41:52 +00:00
# endif /* SNI_OPTION */
2014-02-21 15:52:06 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
2013-08-15 11:33:48 +00:00
# define USAGE_MAX_FRAG_LEN \
" max_frag_len=%%d default: 16384 (tls default) \n " \
" options: 512, 1024, 2048, 4096 \n "
# else
# define USAGE_MAX_FRAG_LEN ""
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
2013-08-15 11:33:48 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
2015-01-09 11:39:35 +00:00
# define USAGE_TRUNC_HMAC \
" trunc_hmac=%%d default: library default \n "
# else
# define USAGE_TRUNC_HMAC ""
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_ALPN)
2014-04-05 12:34:07 +00:00
# define USAGE_ALPN \
" alpn=%%s default: \" \" (disabled) \n " \
" example: spdy/1,http/1.1 \n "
# else
# define USAGE_ALPN ""
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_SSL_ALPN */
2014-04-05 12:34:07 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
2014-07-23 17:34:59 +00:00
# define USAGE_COOKIES \
" cookies=0/1/-1 default: 1 (enabled) \n " \
2014-09-24 12:41:11 +00:00
" 0: disabled, -1: library default (broken) \n "
2014-07-23 17:34:59 +00:00
# else
# define USAGE_COOKIES ""
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
2014-09-24 12:41:11 +00:00
# define USAGE_ANTI_REPLAY \
2014-10-14 17:36:36 +00:00
" anti_replay=0/1 default: (library default: enabled) \n "
2014-09-24 12:41:11 +00:00
# else
# define USAGE_ANTI_REPLAY ""
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_DTLS_BADMAC_LIMIT)
2014-10-14 17:36:36 +00:00
# define USAGE_BADMAC_LIMIT \
" badmac_limit=%%d default: (library default: disabled) \n "
# else
# define USAGE_BADMAC_LIMIT ""
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_PROTO_DTLS)
2014-10-01 12:40:56 +00:00
# define USAGE_DTLS \
" dtls=%%d default: 0 (TLS) \n " \
" hs_timeout=%%d-%%d default: (library default: 1000-60000) \n " \
2018-08-12 11:28:53 +00:00
" range of DTLS handshake timeouts in millisecs \n " \
2018-08-14 12:28:56 +00:00
" mtu=%%d default: (library default: unlimited) \n " \
" dgram_packing=%%d default: 1 (allowed) \n " \
" allow or forbid packing of multiple \n " \
" records within a single datgram. \n "
2014-10-01 12:40:56 +00:00
# else
# define USAGE_DTLS ""
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
2014-10-20 16:40:56 +00:00
# define USAGE_EMS \
" extended_ms=0/1 default: (library default: on) \n "
# else
# define USAGE_EMS ""
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
2014-10-27 12:57:03 +00:00
# define USAGE_ETM \
" etm=0/1 default: (library default: on) \n "
# else
# define USAGE_ETM ""
# endif
2019-06-18 18:16:43 +00:00
# define USAGE_REPRODUCIBLE \
" reproducible=0/1 default: 0 (disabled) \n "
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_RENEGOTIATION)
2014-11-03 07:23:14 +00:00
# define USAGE_RENEGO \
" renegotiation=%%d default: 0 (disabled) \n " \
" renegotiate=%%d default: 0 (disabled) \n " \
2014-11-05 13:23:03 +00:00
" renego_delay=%%d default: -2 (library default) \n " \
2017-01-19 16:30:57 +00:00
" renego_period=%%d default: (2^64 - 1 for TLS, 2^48 - 1 for DTLS) \n "
2014-11-03 07:23:14 +00:00
# else
# define USAGE_RENEGO ""
# endif
2015-09-16 09:08:34 +00:00
# if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
# define USAGE_ECJPAKE \
" ecjpake_pw=%%s default: none (disabled) \n "
# else
# define USAGE_ECJPAKE ""
# endif
2017-05-15 15:05:15 +00:00
# if defined(MBEDTLS_ECP_C)
# define USAGE_CURVES \
" curves=a,b,c,d default: \" default \" (library default) \n " \
" example: \" secp521r1,brainpoolP512r1 \" \n " \
" - use \" none \" for empty list \n " \
" - see mbedtls_ecp_curve_list() \n " \
" for acceptable curve names \n "
# else
# define USAGE_CURVES ""
# endif
2019-06-04 08:06:31 +00:00
# if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
# define USAGE_SERIALIZATION \
2019-06-06 07:40:52 +00:00
" serialize=%%d default: 0 (do not serialize/deserialize) \n " \
2019-06-07 05:39:24 +00:00
" options: 1 (serialize) \n " \
" 2 (serialize with re-initialization) \n "
2019-06-04 08:06:31 +00:00
# else
# define USAGE_SERIALIZATION ""
# endif
2012-09-25 09:05:17 +00:00
# define USAGE \
" \n usage: ssl_server2 param=<>... \n " \
" \n acceptable parameters: \n " \
2017-09-26 08:29:11 +00:00
" server_addr=%%s default: (all interfaces) \n " \
2012-09-25 09:05:17 +00:00
" server_port=%%d default: 4433 \n " \
" debug_level=%%d default: 0 (disabled) \n " \
2017-10-12 11:50:29 +00:00
" buffer_size=%%d default: 200 \n " \
" (minimum: 1, max: 16385) \n " \
" response_size=%%d default: about 152 (basic response) \n " \
" (minimum: 0, max: 16384) \n " \
" increases buffer_size if bigger \n " \
2014-02-26 12:47:08 +00:00
" nbio=%%d default: 0 (blocking I/O) \n " \
" options: 1 (non-blocking), 2 (added delays) \n " \
2017-10-10 14:56:37 +00:00
" event=%%d default: 0 (loop) \n " \
" options: 1 (level-triggered, implies nbio=1), \n " \
2015-09-09 09:22:58 +00:00
" read_timeout=%%d default: 0 ms (no timeout) \n " \
2014-02-19 17:22:59 +00:00
" \n " \
2014-10-01 12:40:56 +00:00
USAGE_DTLS \
USAGE_COOKIES \
USAGE_ANTI_REPLAY \
2014-10-14 17:36:36 +00:00
USAGE_BADMAC_LIMIT \
2014-10-01 12:40:56 +00:00
" \n " \
2015-05-07 09:18:26 +00:00
" auth_mode=%%s default: (library default: none) \n " \
2014-02-19 17:22:59 +00:00
" options: none, optional, required \n " \
2017-04-10 12:44:33 +00:00
" cert_req_ca_list=%%d default: 1 (send ca list) \n " \
" options: 1 (send ca list), 0 (don't send) \n " \
2012-09-25 09:05:17 +00:00
USAGE_IO \
2018-01-05 20:15:57 +00:00
USAGE_SSL_ASYNC \
2014-02-21 15:52:06 +00:00
USAGE_SNI \
2014-02-19 17:22:59 +00:00
" \n " \
USAGE_PSK \
2019-03-27 15:55:27 +00:00
USAGE_CA_CALLBACK \
2015-09-16 09:08:34 +00:00
USAGE_ECJPAKE \
2014-02-19 17:22:59 +00:00
" \n " \
2014-11-03 19:10:36 +00:00
" allow_legacy=%%d default: (library default: no) \n " \
2014-11-03 07:23:14 +00:00
USAGE_RENEGO \
2014-08-15 09:17:27 +00:00
" exchanges=%%d default: 1 \n " \
2014-10-01 12:40:56 +00:00
" \n " \
2014-02-19 17:22:59 +00:00
USAGE_TICKETS \
2019-05-12 08:03:32 +00:00
USAGE_EAP_TLS \
2019-06-18 18:16:43 +00:00
USAGE_REPRODUCIBLE \
2019-08-29 05:31:22 +00:00
USAGE_NSS_KEYLOG \
USAGE_NSS_KEYLOG_FILE \
2014-02-20 21:50:56 +00:00
USAGE_CACHE \
2014-02-19 17:22:59 +00:00
USAGE_MAX_FRAG_LEN \
2015-01-09 11:39:35 +00:00
USAGE_TRUNC_HMAC \
2014-04-05 12:34:07 +00:00
USAGE_ALPN \
2014-10-20 16:40:56 +00:00
USAGE_EMS \
2014-10-27 12:57:03 +00:00
USAGE_ETM \
2017-05-15 15:05:15 +00:00
USAGE_CURVES \
2014-02-19 17:22:59 +00:00
" \n " \
2015-03-27 16:52:25 +00:00
" arc4=%%d default: (library default: 0) \n " \
2017-05-09 13:59:24 +00:00
" allow_sha1=%%d default: 0 \n " \
2015-03-31 12:21:11 +00:00
" min_version=%%s default: (library default: tls1) \n " \
" max_version=%%s default: (library default: tls1_2) \n " \
2013-06-29 14:01:32 +00:00
" force_version=%%s default: \" \" (none) \n " \
2014-02-12 10:11:12 +00:00
" options: ssl3, tls1, tls1_1, tls1_2, dtls1, dtls1_2 \n " \
2014-06-11 11:50:34 +00:00
" \n " \
" version_suites=a,b,c,d per-version ciphersuites \n " \
" in order from ssl3 to tls1_2 \n " \
" default: all enabled \n " \
" force_ciphersuite=<name> default: all enabled \n " \
2018-10-16 20:08:38 +00:00
" query_config=<name> return 0 if the specified \n " \
" configuration macro is defined and 1 \n " \
" otherwise. The expansion of the macro \n " \
" is printed if it is defined \n " \
2019-06-04 08:06:31 +00:00
USAGE_SERIALIZATION \
2012-09-25 09:05:17 +00:00
" acceptable ciphersuite names: \n "
2017-06-09 15:13:22 +00:00
# define ALPN_LIST_SIZE 10
# define CURVE_LIST_SIZE 20
2017-01-19 16:30:57 +00:00
# define PUT_UINT64_BE(out_be,in_le,i) \
{ \
( out_be ) [ ( i ) + 0 ] = ( unsigned char ) ( ( ( in_le ) > > 56 ) & 0xFF ) ; \
( out_be ) [ ( i ) + 1 ] = ( unsigned char ) ( ( ( in_le ) > > 48 ) & 0xFF ) ; \
( out_be ) [ ( i ) + 2 ] = ( unsigned char ) ( ( ( in_le ) > > 40 ) & 0xFF ) ; \
( out_be ) [ ( i ) + 3 ] = ( unsigned char ) ( ( ( in_le ) > > 32 ) & 0xFF ) ; \
( out_be ) [ ( i ) + 4 ] = ( unsigned char ) ( ( ( in_le ) > > 24 ) & 0xFF ) ; \
( out_be ) [ ( i ) + 5 ] = ( unsigned char ) ( ( ( in_le ) > > 16 ) & 0xFF ) ; \
( out_be ) [ ( i ) + 6 ] = ( unsigned char ) ( ( ( in_le ) > > 8 ) & 0xFF ) ; \
( out_be ) [ ( i ) + 7 ] = ( unsigned char ) ( ( ( in_le ) > > 0 ) & 0xFF ) ; \
}
2019-01-31 13:20:20 +00:00
2015-02-12 11:37:29 +00:00
/*
* global options
*/
struct options
{
const char * server_addr ; /* address on which the ssl service runs */
2015-06-23 10:30:57 +00:00
const char * server_port ; /* port on which the ssl service runs */
2015-02-12 11:37:29 +00:00
int debug_level ; /* level of debugging */
int nbio ; /* should I/O be blocking? */
2017-10-10 14:56:37 +00:00
int event ; /* loop or event-driven IO? level or edge triggered? */
2015-04-08 10:49:31 +00:00
uint32_t read_timeout ; /* timeout on mbedtls_ssl_read() in milliseconds */
2017-10-12 11:50:29 +00:00
int response_size ; /* pad response with header to requested size */
uint16_t buffer_size ; /* IO buffer size */
2015-02-12 11:37:29 +00:00
const char * ca_file ; /* the file with the CA certificate(s) */
const char * ca_path ; /* the path with the CA certificate(s) reside */
const char * crt_file ; /* the file with the server certificate */
const char * key_file ; /* the file with the server key */
const char * crt_file2 ; /* the file with the 2nd server certificate */
const char * key_file2 ; /* the file with the 2nd server key */
2018-01-12 12:47:48 +00:00
const char * async_operations ; /* supported SSL asynchronous operations */
2018-01-05 20:15:57 +00:00
int async_private_delay1 ; /* number of times f_async_resume needs to be called for key 1, or -1 for no async */
int async_private_delay2 ; /* number of times f_async_resume needs to be called for key 2, or -1 for no async */
int async_private_error ; /* inject error in async private callback */
2018-10-26 10:28:08 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
2018-11-15 13:06:09 +00:00
int psk_opaque ;
int psk_list_opaque ;
2019-03-27 15:55:27 +00:00
# endif
# if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
2019-03-28 14:14:22 +00:00
int ca_callback ; /* Use callback for trusted certificate list */
2018-10-26 10:28:08 +00:00
# endif
2015-02-12 11:37:29 +00:00
const char * psk ; /* the pre-shared key */
const char * psk_identity ; /* the pre-shared key identity */
char * psk_list ; /* list of PSK id/key pairs for callback */
2015-09-16 09:08:34 +00:00
const char * ecjpake_pw ; /* the EC J-PAKE password */
2015-02-12 11:37:29 +00:00
int force_ciphersuite [ 2 ] ; /* protocol/ciphersuite to use, or all */
const char * version_suites ; /* per-version ciphersuites */
int renegotiation ; /* enable / disable renegotiation */
int allow_legacy ; /* allow legacy renegotiation */
int renegotiate ; /* attempt renegotiation? */
int renego_delay ; /* delay before enforcing renegotiation */
2017-01-19 16:30:57 +00:00
uint64_t renego_period ; /* period for automatic renegotiation */
2015-02-12 11:37:29 +00:00
int exchanges ; /* number of data exchanges */
int min_version ; /* minimum protocol version accepted */
int max_version ; /* maximum protocol version accepted */
int arc4 ; /* flag for arc4 suites support */
2017-05-09 13:59:24 +00:00
int allow_sha1 ; /* flag for SHA-1 support */
2015-02-12 11:37:29 +00:00
int auth_mode ; /* verify mode for connection */
2017-04-10 12:44:33 +00:00
int cert_req_ca_list ; /* should we send the CA list? */
2015-02-12 11:37:29 +00:00
unsigned char mfl_code ; /* code for maximum fragment length */
int trunc_hmac ; /* accept truncated hmac? */
int tickets ; /* enable / disable session tickets */
int ticket_timeout ; /* session ticket lifetime */
int cache_max ; /* max number of session cache entries */
int cache_timeout ; /* expiration delay of session cache entries */
char * sni ; /* string describing sni information */
2017-05-15 15:05:15 +00:00
const char * curves ; /* list of supported elliptic curves */
2015-02-12 11:37:29 +00:00
const char * alpn_string ; /* ALPN supported protocols */
const char * dhm_file ; /* the file with the DH parameters */
int extended_ms ; /* allow negotiation of extended MS? */
int etm ; /* allow negotiation of encrypt-then-MAC? */
2015-02-16 18:37:53 +00:00
int transport ; /* TLS or DTLS? */
int cookies ; /* Use cookies for DTLS? -1 to break them */
int anti_replay ; /* Use anti-replay for DTLS? -1 for default */
uint32_t hs_to_min ; /* Initial value of DTLS handshake timer */
uint32_t hs_to_max ; /* Max value of DTLS handshake timer */
2018-08-12 11:28:53 +00:00
int dtls_mtu ; /* UDP Maximum tranport unit for DTLS */
2018-08-14 12:28:56 +00:00
int dgram_packing ; /* allow/forbid datagram packing */
2015-02-16 18:37:53 +00:00
int badmac_limit ; /* Limit of records with bad MAC */
2019-05-12 08:03:32 +00:00
int eap_tls ; /* derive EAP-TLS keying material? */
2019-08-29 05:31:22 +00:00
int nss_keylog ; /* export NSS key log material */
const char * nss_keylog_file ; /* NSS key log file */
2019-04-09 16:28:10 +00:00
int cid_enabled ; /* whether to use the CID extension or not */
2019-05-03 16:30:59 +00:00
int cid_enabled_renego ; /* whether to use the CID extension or not
* during renegotiation */
2019-04-09 16:28:10 +00:00
const char * cid_val ; /* the CID to use for incoming messages */
2019-05-29 10:33:32 +00:00
int serialize ; /* serialize/deserialize connection */
2019-05-03 16:30:59 +00:00
const char * cid_val_renego ; /* the CID to use for incoming messages
* after renegotiation */
2019-06-11 15:50:23 +00:00
int reproducible ; /* make communication reproducible */
2015-02-12 11:37:29 +00:00
} opt ;
2018-10-16 20:08:38 +00:00
int query_config ( const char * config ) ;
2019-05-12 08:03:32 +00:00
# if defined(MBEDTLS_SSL_EXPORT_KEYS)
typedef struct eap_tls_keys
{
unsigned char master_secret [ 48 ] ;
unsigned char randbytes [ 64 ] ;
2019-05-12 11:54:30 +00:00
mbedtls_tls_prf_types tls_prf_type ;
2019-05-12 08:03:32 +00:00
} eap_tls_keys ;
static int eap_tls_key_derivation ( void * p_expkey ,
const unsigned char * ms ,
const unsigned char * kb ,
size_t maclen ,
size_t keylen ,
size_t ivlen ,
2019-09-12 09:09:57 +00:00
const unsigned char client_random [ 32 ] ,
const unsigned char server_random [ 32 ] ,
2019-05-12 11:54:30 +00:00
mbedtls_tls_prf_types tls_prf_type )
2019-05-12 08:03:32 +00:00
{
eap_tls_keys * keys = ( eap_tls_keys * ) p_expkey ;
( ( void ) kb ) ;
memcpy ( keys - > master_secret , ms , sizeof ( keys - > master_secret ) ) ;
memcpy ( keys - > randbytes , client_random , 32 ) ;
memcpy ( keys - > randbytes + 32 , server_random , 32 ) ;
2019-05-12 11:54:30 +00:00
keys - > tls_prf_type = tls_prf_type ;
2019-05-12 08:03:32 +00:00
2019-05-14 17:38:49 +00:00
if ( opt . debug_level > 2 )
{
2019-05-15 14:45:24 +00:00
mbedtls_printf ( " exported maclen is %u \n " , ( unsigned ) maclen ) ;
mbedtls_printf ( " exported keylen is %u \n " , ( unsigned ) keylen ) ;
mbedtls_printf ( " exported ivlen is %u \n " , ( unsigned ) ivlen ) ;
2019-05-14 17:38:49 +00:00
}
2019-05-12 08:03:32 +00:00
return ( 0 ) ;
}
2019-08-29 05:31:22 +00:00
static int nss_keylog_export ( void * p_expkey ,
const unsigned char * ms ,
const unsigned char * kb ,
size_t maclen ,
size_t keylen ,
size_t ivlen ,
2019-09-12 09:09:57 +00:00
const unsigned char client_random [ 32 ] ,
const unsigned char server_random [ 32 ] ,
2019-08-29 05:31:22 +00:00
mbedtls_tls_prf_types tls_prf_type )
{
char nss_keylog_line [ 200 ] ;
size_t const client_random_len = 32 ;
size_t const master_secret_len = 48 ;
size_t len = 0 ;
size_t j ;
int ret = 0 ;
( ( void ) p_expkey ) ;
( ( void ) kb ) ;
( ( void ) maclen ) ;
( ( void ) keylen ) ;
( ( void ) ivlen ) ;
( ( void ) server_random ) ;
( ( void ) tls_prf_type ) ;
len + = sprintf ( nss_keylog_line + len ,
" %s " , " CLIENT_RANDOM " ) ;
for ( j = 0 ; j < client_random_len ; j + + )
{
len + = sprintf ( nss_keylog_line + len ,
" %02x " , client_random [ j ] ) ;
}
len + = sprintf ( nss_keylog_line + len , " " ) ;
for ( j = 0 ; j < master_secret_len ; j + + )
{
len + = sprintf ( nss_keylog_line + len ,
" %02x " , ms [ j ] ) ;
}
len + = sprintf ( nss_keylog_line + len , " \n " ) ;
nss_keylog_line [ len ] = ' \0 ' ;
mbedtls_printf ( " \n " ) ;
mbedtls_printf ( " ---------------- NSS KEYLOG ----------------- \n " ) ;
mbedtls_printf ( " %s " , nss_keylog_line ) ;
mbedtls_printf ( " --------------------------------------------- \n " ) ;
if ( opt . nss_keylog_file ! = NULL )
{
FILE * f ;
if ( ( f = fopen ( opt . nss_keylog_file , " a " ) ) = = NULL )
{
ret = - 1 ;
goto exit ;
}
if ( fwrite ( nss_keylog_line , 1 , len , f ) ! = len )
{
ret = - 1 ;
2019-09-26 11:36:54 +00:00
fclose ( f ) ;
2019-08-29 05:31:22 +00:00
goto exit ;
}
fclose ( f ) ;
}
exit :
mbedtls_platform_zeroize ( nss_keylog_line ,
sizeof ( nss_keylog_line ) ) ;
return ( ret ) ;
}
2019-05-12 08:03:32 +00:00
# endif
2015-06-23 15:35:03 +00:00
static void my_debug ( void * ctx , int level ,
const char * file , int line ,
const char * str )
2015-02-12 11:37:29 +00:00
{
2015-07-01 09:50:23 +00:00
const char * p , * basename ;
2015-02-12 11:37:29 +00:00
2015-07-01 09:50:23 +00:00
/* Extract basename from file */
for ( p = basename = file ; * p ! = ' \0 ' ; p + + )
if ( * p = = ' / ' | | * p = = ' \\ ' )
basename = p + 1 ;
mbedtls_fprintf ( ( FILE * ) ctx , " %s:%04d: |%d| %s " , basename , line , level , str ) ;
2015-02-12 11:37:29 +00:00
fflush ( ( FILE * ) ctx ) ;
}
2019-06-06 19:24:31 +00:00
mbedtls_time_t dummy_constant_time ( mbedtls_time_t * time )
{
( void ) time ;
return 0x5af2a056 ;
}
int dummy_entropy ( void * data , unsigned char * output , size_t len )
{
size_t i ;
2019-06-11 14:07:53 +00:00
int ret ;
2019-06-11 14:29:28 +00:00
( void ) data ;
2019-06-06 19:24:31 +00:00
2019-06-07 20:31:59 +00:00
ret = mbedtls_entropy_func ( data , output , len ) ;
2019-06-07 13:04:32 +00:00
for ( i = 0 ; i < len ; i + + ) {
2019-06-06 19:24:31 +00:00
//replace result with pseudo random
output [ i ] = ( unsigned char ) rand ( ) ;
}
2019-06-07 20:31:59 +00:00
return ( ret ) ;
2019-06-06 19:24:31 +00:00
}
2019-03-27 15:55:27 +00:00
# if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
2019-03-28 14:14:22 +00:00
int ca_callback ( void * data , mbedtls_x509_crt const * child ,
mbedtls_x509_crt * * candidates )
2019-03-27 15:55:27 +00:00
{
2019-03-28 14:14:22 +00:00
int ret = 0 ;
2019-03-27 15:55:27 +00:00
mbedtls_x509_crt * ca = ( mbedtls_x509_crt * ) data ;
2019-03-28 14:14:22 +00:00
mbedtls_x509_crt * first ;
/* This is a test-only implementation of the CA callback
* which always returns the entire list of trusted certificates .
* Production implementations managing a large number of CAs
* should use an efficient presentation and lookup for the
* set of trusted certificates ( such as a hashtable ) and only
* return those trusted certificates which satisfy basic
* parental checks , such as the matching of child ` Issuer `
* and parent ` Subject ` field . */
( ( void ) child ) ;
first = mbedtls_calloc ( 1 , sizeof ( mbedtls_x509_crt ) ) ;
if ( first = = NULL )
{
ret = - 1 ;
goto exit ;
}
mbedtls_x509_crt_init ( first ) ;
if ( mbedtls_x509_crt_parse_der ( first , ca - > raw . p , ca - > raw . len ) ! = 0 )
{
ret = - 1 ;
goto exit ;
}
2019-03-27 15:55:27 +00:00
while ( ca - > next ! = NULL )
{
ca = ca - > next ;
2019-03-28 14:14:22 +00:00
if ( mbedtls_x509_crt_parse_der ( first , ca - > raw . p , ca - > raw . len ) ! = 0 )
{
ret = - 1 ;
goto exit ;
}
2019-03-27 15:55:27 +00:00
}
2019-03-28 14:14:22 +00:00
exit :
if ( ret ! = 0 )
{
mbedtls_x509_crt_free ( first ) ;
mbedtls_free ( first ) ;
first = NULL ;
}
2019-03-27 15:55:27 +00:00
* candidates = first ;
2019-03-28 14:14:22 +00:00
return ( ret ) ;
2019-03-27 15:55:27 +00:00
}
# endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
2015-02-12 11:37:29 +00:00
/*
* Test recv / send functions that make sure each try returns
* WANT_READ / WANT_WRITE at least once before sucesseding
*/
2019-07-03 16:05:43 +00:00
static int delayed_recv ( void * ctx , unsigned char * buf , size_t len )
2015-02-12 11:37:29 +00:00
{
static int first_try = 1 ;
int ret ;
if ( first_try )
{
first_try = 0 ;
2015-05-06 15:19:31 +00:00
return ( MBEDTLS_ERR_SSL_WANT_READ ) ;
2015-02-12 11:37:29 +00:00
}
2015-04-08 10:49:31 +00:00
ret = mbedtls_net_recv ( ctx , buf , len ) ;
2015-05-06 15:19:31 +00:00
if ( ret ! = MBEDTLS_ERR_SSL_WANT_READ )
2015-02-12 11:37:29 +00:00
first_try = 1 ; /* Next call will be a new operation */
return ( ret ) ;
}
2019-07-03 16:05:43 +00:00
static int delayed_send ( void * ctx , const unsigned char * buf , size_t len )
2015-02-12 11:37:29 +00:00
{
static int first_try = 1 ;
int ret ;
if ( first_try )
{
first_try = 0 ;
2015-05-06 15:19:31 +00:00
return ( MBEDTLS_ERR_SSL_WANT_WRITE ) ;
2015-02-12 11:37:29 +00:00
}
2015-04-08 10:49:31 +00:00
ret = mbedtls_net_send ( ctx , buf , len ) ;
2015-05-06 15:19:31 +00:00
if ( ret ! = MBEDTLS_ERR_SSL_WANT_WRITE )
2015-02-12 11:37:29 +00:00
first_try = 1 ; /* Next call will be a new operation */
return ( ret ) ;
}
2019-07-03 16:05:43 +00:00
typedef struct
{
mbedtls_ssl_context * ssl ;
mbedtls_net_context * net ;
} io_ctx_t ;
2019-07-03 16:14:41 +00:00
# if defined(MBEDTLS_SSL_RECORD_CHECKING)
static int ssl_check_record ( mbedtls_ssl_context const * ssl ,
unsigned char const * buf , size_t len )
{
int ret ;
unsigned char * tmp_buf ;
/* Record checking may modify the input buffer,
* so make a copy . */
tmp_buf = mbedtls_calloc ( 1 , len ) ;
if ( tmp_buf = = NULL )
return ( MBEDTLS_ERR_SSL_ALLOC_FAILED ) ;
memcpy ( tmp_buf , buf , len ) ;
ret = mbedtls_ssl_check_record ( ssl , tmp_buf , len ) ;
if ( ret ! = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE )
{
int ret_repeated ;
/* Test-only: Make sure that mbedtls_ssl_check_record()
* doesn ' t alter state . */
memcpy ( tmp_buf , buf , len ) ; /* Restore buffer */
ret_repeated = mbedtls_ssl_check_record ( ssl , tmp_buf , len ) ;
if ( ret ! = ret_repeated )
{
2019-07-24 12:59:07 +00:00
mbedtls_printf ( " mbedtls_ssl_check_record() returned inconsistent results. \n " ) ;
return ( - 1 ) ;
2019-07-03 16:14:41 +00:00
}
switch ( ret )
{
case 0 :
break ;
case MBEDTLS_ERR_SSL_INVALID_RECORD :
if ( opt . debug_level > 1 )
mbedtls_printf ( " mbedtls_ssl_check_record() detected invalid record. \n " ) ;
break ;
case MBEDTLS_ERR_SSL_INVALID_MAC :
if ( opt . debug_level > 1 )
mbedtls_printf ( " mbedtls_ssl_check_record() detected unauthentic record. \n " ) ;
break ;
case MBEDTLS_ERR_SSL_UNEXPECTED_RECORD :
if ( opt . debug_level > 1 )
mbedtls_printf ( " mbedtls_ssl_check_record() detected unexpected record. \n " ) ;
break ;
default :
mbedtls_printf ( " mbedtls_ssl_check_record() failed fatally with -%#04x. \n " , - ret ) ;
return ( - 1 ) ;
}
/* Regardless of the outcome, forward the record to the stack. */
}
mbedtls_free ( tmp_buf ) ;
return ( 0 ) ;
}
# endif /* MBEDTLS_SSL_RECORD_CHECKING */
2019-07-03 16:05:43 +00:00
static int recv_cb ( void * ctx , unsigned char * buf , size_t len )
{
io_ctx_t * io_ctx = ( io_ctx_t * ) ctx ;
size_t recv_len ;
int ret ;
if ( opt . nbio = = 2 )
ret = delayed_recv ( io_ctx - > net , buf , len ) ;
else
ret = mbedtls_net_recv ( io_ctx - > net , buf , len ) ;
if ( ret < 0 )
return ( ret ) ;
recv_len = ( size_t ) ret ;
if ( opt . transport = = MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
/* Here's the place to do any datagram/record checking
* in between receiving the packet from the underlying
* transport and passing it on to the TLS stack . */
2019-07-03 16:14:41 +00:00
# if defined(MBEDTLS_SSL_RECORD_CHECKING)
if ( ssl_check_record ( io_ctx - > ssl , buf , recv_len ) ! = 0 )
return ( - 1 ) ;
# endif /* MBEDTLS_SSL_RECORD_CHECKING */
2019-07-03 16:05:43 +00:00
}
return ( ( int ) recv_len ) ;
}
static int recv_timeout_cb ( void * ctx , unsigned char * buf , size_t len ,
uint32_t timeout )
{
io_ctx_t * io_ctx = ( io_ctx_t * ) ctx ;
int ret ;
size_t recv_len ;
ret = mbedtls_net_recv_timeout ( io_ctx - > net , buf , len , timeout ) ;
if ( ret < 0 )
return ( ret ) ;
recv_len = ( size_t ) ret ;
if ( opt . transport = = MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
/* Here's the place to do any datagram/record checking
* in between receiving the packet from the underlying
* transport and passing it on to the TLS stack . */
2019-07-03 16:14:41 +00:00
# if defined(MBEDTLS_SSL_RECORD_CHECKING)
if ( ssl_check_record ( io_ctx - > ssl , buf , recv_len ) ! = 0 )
return ( - 1 ) ;
# endif /* MBEDTLS_SSL_RECORD_CHECKING */
2019-07-03 16:05:43 +00:00
}
return ( ( int ) recv_len ) ;
}
static int send_cb ( void * ctx , unsigned char const * buf , size_t len )
{
io_ctx_t * io_ctx = ( io_ctx_t * ) ctx ;
if ( opt . nbio = = 2 )
return ( delayed_send ( io_ctx - > net , buf , len ) ) ;
return ( mbedtls_net_send ( io_ctx - > net , buf , len ) ) ;
}
2015-06-19 12:40:39 +00:00
/*
* Return authmode from string , or - 1 on error
*/
static int get_auth_mode ( const char * s )
{
if ( strcmp ( s , " none " ) = = 0 )
return ( MBEDTLS_SSL_VERIFY_NONE ) ;
if ( strcmp ( s , " optional " ) = = 0 )
return ( MBEDTLS_SSL_VERIFY_OPTIONAL ) ;
if ( strcmp ( s , " required " ) = = 0 )
return ( MBEDTLS_SSL_VERIFY_REQUIRED ) ;
return ( - 1 ) ;
}
2014-06-10 13:15:06 +00:00
/*
* Used by sni_parse and psk_parse to handle coma - separated lists
*/
# define GET_ITEM( dst ) \
2018-10-15 11:01:35 +00:00
do \
{ \
( dst ) = p ; \
while ( * p ! = ' , ' ) \
if ( + + p > end ) \
goto error ; \
* p + + = ' \0 ' ; \
} while ( 0 )
2014-06-10 13:15:06 +00:00
2015-04-03 14:41:52 +00:00
# if defined(SNI_OPTION)
2014-02-21 15:52:06 +00:00
typedef struct _sni_entry sni_entry ;
struct _sni_entry {
const char * name ;
2015-04-08 10:49:31 +00:00
mbedtls_x509_crt * cert ;
mbedtls_pk_context * key ;
2015-06-19 12:40:39 +00:00
mbedtls_x509_crt * ca ;
mbedtls_x509_crl * crl ;
int authmode ;
2014-02-21 15:52:06 +00:00
sni_entry * next ;
} ;
2015-02-14 13:56:39 +00:00
void sni_free ( sni_entry * head )
{
sni_entry * cur = head , * next ;
while ( cur ! = NULL )
{
2015-04-08 10:49:31 +00:00
mbedtls_x509_crt_free ( cur - > cert ) ;
mbedtls_free ( cur - > cert ) ;
2015-02-14 13:56:39 +00:00
2015-04-08 10:49:31 +00:00
mbedtls_pk_free ( cur - > key ) ;
mbedtls_free ( cur - > key ) ;
2015-02-14 13:56:39 +00:00
2015-06-19 12:40:39 +00:00
mbedtls_x509_crt_free ( cur - > ca ) ;
mbedtls_free ( cur - > ca ) ;
2019-04-04 12:02:01 +00:00
# if defined(MBEDTLS_X509_CRL_PARSE_C)
2015-06-19 12:40:39 +00:00
mbedtls_x509_crl_free ( cur - > crl ) ;
mbedtls_free ( cur - > crl ) ;
2019-04-04 12:02:01 +00:00
# endif
2015-02-14 13:56:39 +00:00
next = cur - > next ;
2015-04-08 10:49:31 +00:00
mbedtls_free ( cur ) ;
2015-02-14 13:56:39 +00:00
cur = next ;
}
}
2014-02-21 15:52:06 +00:00
/*
2015-06-19 12:40:39 +00:00
* Parse a string of sextuples name1 , crt1 , key1 , ca1 , crl1 , auth1 [ , . . . ]
* into a usable sni_entry list . For ca1 , crl1 , auth1 , the special value
* ' - ' means unset . If ca1 is unset , then crl1 is ignored too .
2014-02-21 15:52:06 +00:00
*
2014-06-10 13:15:06 +00:00
* Modifies the input string ! This is not production quality !
2014-02-21 15:52:06 +00:00
*/
sni_entry * sni_parse ( char * sni_string )
{
sni_entry * cur = NULL , * new = NULL ;
char * p = sni_string ;
char * end = p ;
2019-04-04 12:02:01 +00:00
char * crt_file , * key_file , * ca_file , * auth_str ;
# if defined(MBEDTLS_X509_CRL_PARSE_C)
char * crl_file ;
# endif
2014-02-21 15:52:06 +00:00
while ( * end ! = ' \0 ' )
+ + end ;
* end = ' , ' ;
while ( p < = end )
{
2015-05-26 14:04:06 +00:00
if ( ( new = mbedtls_calloc ( 1 , sizeof ( sni_entry ) ) ) = = NULL )
2015-02-14 13:56:39 +00:00
{
sni_free ( cur ) ;
2014-02-21 15:52:06 +00:00
return ( NULL ) ;
2015-02-14 13:56:39 +00:00
}
2014-02-21 15:52:06 +00:00
2015-06-19 12:40:39 +00:00
GET_ITEM ( new - > name ) ;
GET_ITEM ( crt_file ) ;
GET_ITEM ( key_file ) ;
GET_ITEM ( ca_file ) ;
2019-04-04 12:02:01 +00:00
# if defined(MBEDTLS_X509_CRL_PARSE_C)
2015-06-19 12:40:39 +00:00
GET_ITEM ( crl_file ) ;
2019-04-04 12:02:01 +00:00
# endif
2015-06-19 12:40:39 +00:00
GET_ITEM ( auth_str ) ;
2014-02-21 15:52:06 +00:00
2015-05-26 14:04:06 +00:00
if ( ( new - > cert = mbedtls_calloc ( 1 , sizeof ( mbedtls_x509_crt ) ) ) = = NULL | |
( new - > key = mbedtls_calloc ( 1 , sizeof ( mbedtls_pk_context ) ) ) = = NULL )
2015-06-19 12:40:39 +00:00
goto error ;
2014-02-21 15:52:06 +00:00
2015-04-08 10:49:31 +00:00
mbedtls_x509_crt_init ( new - > cert ) ;
mbedtls_pk_init ( new - > key ) ;
2014-02-21 15:52:06 +00:00
2015-04-08 10:49:31 +00:00
if ( mbedtls_x509_crt_parse_file ( new - > cert , crt_file ) ! = 0 | |
mbedtls_pk_parse_keyfile ( new - > key , key_file , " " ) ! = 0 )
2015-02-14 13:56:39 +00:00
goto error ;
2015-06-19 12:40:39 +00:00
if ( strcmp ( ca_file , " - " ) ! = 0 )
{
if ( ( new - > ca = mbedtls_calloc ( 1 , sizeof ( mbedtls_x509_crt ) ) ) = = NULL )
goto error ;
mbedtls_x509_crt_init ( new - > ca ) ;
if ( mbedtls_x509_crt_parse_file ( new - > ca , ca_file ) ! = 0 )
goto error ;
}
2019-04-04 12:02:01 +00:00
# if defined(MBEDTLS_X509_CRL_PARSE_C)
2015-06-19 12:40:39 +00:00
if ( strcmp ( crl_file , " - " ) ! = 0 )
{
if ( ( new - > crl = mbedtls_calloc ( 1 , sizeof ( mbedtls_x509_crl ) ) ) = = NULL )
goto error ;
mbedtls_x509_crl_init ( new - > crl ) ;
if ( mbedtls_x509_crl_parse_file ( new - > crl , crl_file ) ! = 0 )
goto error ;
2015-02-14 13:56:39 +00:00
}
2019-04-04 12:02:01 +00:00
# endif
2014-02-21 15:52:06 +00:00
2015-06-19 12:40:39 +00:00
if ( strcmp ( auth_str , " - " ) ! = 0 )
{
if ( ( new - > authmode = get_auth_mode ( auth_str ) ) < 0 )
goto error ;
}
else
new - > authmode = DFL_AUTH_MODE ;
2014-02-21 15:52:06 +00:00
new - > next = cur ;
cur = new ;
}
return ( cur ) ;
2015-02-14 13:56:39 +00:00
error :
sni_free ( new ) ;
sni_free ( cur ) ;
return ( NULL ) ;
2014-02-21 15:52:06 +00:00
}
/*
* SNI callback .
*/
2015-04-08 10:49:31 +00:00
int sni_callback ( void * p_info , mbedtls_ssl_context * ssl ,
2014-02-21 15:52:06 +00:00
const unsigned char * name , size_t name_len )
{
2015-06-19 12:40:39 +00:00
const sni_entry * cur = ( const sni_entry * ) p_info ;
2014-02-21 15:52:06 +00:00
while ( cur ! = NULL )
{
if ( name_len = = strlen ( cur - > name ) & &
memcmp ( name , cur - > name , name_len ) = = 0 )
{
2015-06-19 12:40:39 +00:00
if ( cur - > ca ! = NULL )
mbedtls_ssl_set_hs_ca_chain ( ssl , cur - > ca , cur - > crl ) ;
if ( cur - > authmode ! = DFL_AUTH_MODE )
mbedtls_ssl_set_hs_authmode ( ssl , cur - > authmode ) ;
2015-05-10 21:10:37 +00:00
return ( mbedtls_ssl_set_hs_own_cert ( ssl , cur - > cert , cur - > key ) ) ;
2014-02-21 15:52:06 +00:00
}
cur = cur - > next ;
}
return ( - 1 ) ;
}
2015-04-03 14:41:52 +00:00
# endif /* SNI_OPTION */
2014-02-21 15:52:06 +00:00
2020-03-10 11:19:08 +00:00
# if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED) || \
2019-05-15 13:03:01 +00:00
defined ( MBEDTLS_SSL_DTLS_CONNECTION_ID )
2014-06-09 17:06:00 +00:00
2018-10-15 11:01:35 +00:00
# define HEX2NUM( c ) \
do \
{ \
if ( ( c ) > = ' 0 ' & & ( c ) < = ' 9 ' ) \
( c ) - = ' 0 ' ; \
else if ( ( c ) > = ' a ' & & ( c ) < = ' f ' ) \
( c ) - = ' a ' - 10 ; \
else if ( ( c ) > = ' A ' & & ( c ) < = ' F ' ) \
( c ) - = ' A ' - 10 ; \
else \
return ( - 1 ) ; \
} while ( 0 )
2014-06-09 17:06:00 +00:00
/*
* Convert a hex string to bytes .
* Return 0 on success , - 1 on error .
*/
int unhexify ( unsigned char * output , const char * input , size_t * olen )
{
unsigned char c ;
size_t j ;
* olen = strlen ( input ) ;
2015-04-08 10:49:31 +00:00
if ( * olen % 2 ! = 0 | | * olen / 2 > MBEDTLS_PSK_MAX_LEN )
2014-06-09 17:06:00 +00:00
return ( - 1 ) ;
* olen / = 2 ;
for ( j = 0 ; j < * olen * 2 ; j + = 2 )
{
c = input [ j ] ;
HEX2NUM ( c ) ;
output [ j / 2 ] = c < < 4 ;
c = input [ j + 1 ] ;
HEX2NUM ( c ) ;
output [ j / 2 ] | = c ;
}
return ( 0 ) ;
}
2014-06-10 12:01:52 +00:00
2019-04-30 13:18:06 +00:00
# endif
2020-03-10 11:19:08 +00:00
# if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
2019-04-30 13:18:06 +00:00
2014-06-10 12:01:52 +00:00
typedef struct _psk_entry psk_entry ;
struct _psk_entry
{
const char * name ;
size_t key_len ;
2015-04-08 10:49:31 +00:00
unsigned char key [ MBEDTLS_PSK_MAX_LEN ] ;
2018-10-26 10:28:08 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
2019-01-08 14:36:01 +00:00
psa_key_handle_t slot ;
2018-10-26 10:28:08 +00:00
# endif /* MBEDTLS_USE_PSA_CRYPTO */
2014-06-10 12:01:52 +00:00
psk_entry * next ;
} ;
2015-02-14 13:56:39 +00:00
/*
* Free a list of psk_entry ' s
*/
2018-11-05 13:48:43 +00:00
int psk_free ( psk_entry * head )
2015-02-14 13:56:39 +00:00
{
psk_entry * next ;
while ( head ! = NULL )
{
2018-11-05 13:48:43 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
psa_status_t status ;
2019-01-08 14:36:01 +00:00
psa_key_handle_t const slot = head - > slot ;
2018-11-05 13:48:43 +00:00
if ( slot ! = 0 )
{
status = psa_destroy_key ( slot ) ;
if ( status ! = PSA_SUCCESS )
return ( status ) ;
}
# endif /* MBEDTLS_USE_PSA_CRYPTO */
2015-02-14 13:56:39 +00:00
next = head - > next ;
2015-04-08 10:49:31 +00:00
mbedtls_free ( head ) ;
2015-02-14 13:56:39 +00:00
head = next ;
}
2018-11-05 13:48:43 +00:00
return ( 0 ) ;
2015-02-14 13:56:39 +00:00
}
2014-06-10 12:01:52 +00:00
/*
* Parse a string of pairs name1 , key1 [ , name2 , key2 [ , . . . ] ]
* into a usable psk_entry list .
*
* Modifies the input string ! This is not production quality !
*/
psk_entry * psk_parse ( char * psk_string )
{
psk_entry * cur = NULL , * new = NULL ;
char * p = psk_string ;
char * end = p ;
char * key_hex ;
while ( * end ! = ' \0 ' )
+ + end ;
* end = ' , ' ;
while ( p < = end )
{
2015-05-26 14:04:06 +00:00
if ( ( new = mbedtls_calloc ( 1 , sizeof ( psk_entry ) ) ) = = NULL )
2015-02-18 09:32:06 +00:00
goto error ;
2014-06-10 12:01:52 +00:00
memset ( new , 0 , sizeof ( psk_entry ) ) ;
2014-06-10 13:15:06 +00:00
GET_ITEM ( new - > name ) ;
GET_ITEM ( key_hex ) ;
2014-06-10 12:01:52 +00:00
if ( unhexify ( new - > key , key_hex , & new - > key_len ) ! = 0 )
2015-02-14 13:56:39 +00:00
goto error ;
2014-06-10 12:01:52 +00:00
new - > next = cur ;
cur = new ;
}
return ( cur ) ;
2015-02-14 13:56:39 +00:00
error :
psk_free ( new ) ;
psk_free ( cur ) ;
return ( 0 ) ;
2014-06-10 12:01:52 +00:00
}
/*
* PSK callback
*/
2015-04-08 10:49:31 +00:00
int psk_callback ( void * p_info , mbedtls_ssl_context * ssl ,
2014-06-10 12:01:52 +00:00
const unsigned char * name , size_t name_len )
{
psk_entry * cur = ( psk_entry * ) p_info ;
while ( cur ! = NULL )
{
if ( name_len = = strlen ( cur - > name ) & &
memcmp ( name , cur - > name , name_len ) = = 0 )
{
2018-10-26 10:28:08 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
if ( cur - > slot ! = 0 )
return ( mbedtls_ssl_set_hs_psk_opaque ( ssl , cur - > slot ) ) ;
else
# endif
2015-05-07 14:59:54 +00:00
return ( mbedtls_ssl_set_hs_psk ( ssl , cur - > key , cur - > key_len ) ) ;
2014-06-10 12:01:52 +00:00
}
cur = cur - > next ;
}
return ( - 1 ) ;
}
2020-03-10 11:19:08 +00:00
# endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */
2014-06-09 17:06:00 +00:00
2015-06-30 13:40:39 +00:00
static mbedtls_net_context listen_fd , client_fd ;
2014-08-18 12:36:17 +00:00
/* Interruption handler to ensure clean exit (for valgrind testing) */
# if !defined(_WIN32)
2014-08-14 13:36:12 +00:00
static int received_sigterm = 0 ;
void term_handler ( int sig )
{
( ( void ) sig ) ;
received_sigterm = 1 ;
2015-06-30 13:55:03 +00:00
mbedtls_net_free ( & listen_fd ) ; /* causes mbedtls_net_accept() to abort */
mbedtls_net_free ( & client_fd ) ; /* causes net_read() to abort */
2014-08-14 13:36:12 +00:00
}
2014-08-18 09:05:51 +00:00
# endif
2014-08-14 13:36:12 +00:00
2017-05-11 17:01:11 +00:00
# if defined(MBEDTLS_X509_CRT_PARSE_C)
static int ssl_sig_hashes_for_test [ ] = {
# if defined(MBEDTLS_SHA512_C)
MBEDTLS_MD_SHA512 ,
MBEDTLS_MD_SHA384 ,
# endif
# if defined(MBEDTLS_SHA256_C)
MBEDTLS_MD_SHA256 ,
MBEDTLS_MD_SHA224 ,
# endif
# if defined(MBEDTLS_SHA1_C)
/* Allow SHA-1 as we use it extensively in tests. */
MBEDTLS_MD_SHA1 ,
# endif
MBEDTLS_MD_NONE
} ;
# endif /* MBEDTLS_X509_CRT_PARSE_C */
2018-04-26 06:05:02 +00:00
/** Return true if \p ret is a status code indicating that there is an
* operation in progress on an SSL connection , and false if it indicates
* success or a fatal error .
*
* The possible operations in progress are :
*
* - A read , when the SSL input buffer does not contain a full message .
* - A write , when the SSL output buffer contains some data that has not
* been sent over the network yet .
* - An asynchronous callback that has not completed yet . */
static int mbedtls_status_is_ssl_in_progress ( int ret )
{
return ( ret = = MBEDTLS_ERR_SSL_WANT_READ | |
ret = = MBEDTLS_ERR_SSL_WANT_WRITE | |
ret = = MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS ) ;
}
2018-04-24 11:09:22 +00:00
# if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
2018-01-05 20:15:57 +00:00
typedef struct
{
2018-06-13 16:09:28 +00:00
mbedtls_x509_crt * cert ; /*!< Certificate corresponding to the key */
mbedtls_pk_context * pk ; /*!< Private key */
unsigned delay ; /*!< Number of resume steps to go through */
unsigned pk_owned : 1 ; /*!< Whether to free the pk object on exit */
2018-01-05 20:15:57 +00:00
} ssl_async_key_slot_t ;
typedef enum {
2018-04-25 22:19:16 +00:00
SSL_ASYNC_INJECT_ERROR_NONE = 0 , /*!< Let the callbacks succeed */
SSL_ASYNC_INJECT_ERROR_START , /*!< Inject error during start */
SSL_ASYNC_INJECT_ERROR_CANCEL , /*!< Close the connection after async start */
SSL_ASYNC_INJECT_ERROR_RESUME , /*!< Inject error during resume */
2018-04-26 05:15:40 +00:00
# define SSL_ASYNC_INJECT_ERROR_MAX SSL_ASYNC_INJECT_ERROR_RESUME
2018-01-05 20:15:57 +00:00
} ssl_async_inject_error_t ;
typedef struct
{
2018-06-13 16:06:51 +00:00
ssl_async_key_slot_t slots [ 4 ] ; /* key, key2, sni1, sni2 */
2018-01-05 20:15:57 +00:00
size_t slots_used ;
ssl_async_inject_error_t inject_error ;
int ( * f_rng ) ( void * , unsigned char * , size_t ) ;
void * p_rng ;
} ssl_async_key_context_t ;
2018-04-30 08:23:56 +00:00
int ssl_async_set_key ( ssl_async_key_context_t * ctx ,
2018-06-13 16:09:28 +00:00
mbedtls_x509_crt * cert ,
mbedtls_pk_context * pk ,
int pk_take_ownership ,
unsigned delay )
2018-01-05 20:15:57 +00:00
{
2018-04-30 08:23:56 +00:00
if ( ctx - > slots_used > = sizeof ( ctx - > slots ) / sizeof ( * ctx - > slots ) )
return ( - 1 ) ;
2018-01-05 20:15:57 +00:00
ctx - > slots [ ctx - > slots_used ] . cert = cert ;
ctx - > slots [ ctx - > slots_used ] . pk = pk ;
ctx - > slots [ ctx - > slots_used ] . delay = delay ;
2018-06-13 16:09:28 +00:00
ctx - > slots [ ctx - > slots_used ] . pk_owned = pk_take_ownership ;
2018-01-05 20:15:57 +00:00
+ + ctx - > slots_used ;
2018-04-30 08:23:56 +00:00
return ( 0 ) ;
2018-01-05 20:15:57 +00:00
}
2018-01-12 12:47:48 +00:00
# define SSL_ASYNC_INPUT_MAX_SIZE 512
2018-04-26 04:23:59 +00:00
typedef enum
{
ASYNC_OP_SIGN ,
ASYNC_OP_DECRYPT ,
} ssl_async_operation_type_t ;
/* Note that the enum above and the array below need to be kept in sync!
* ` ssl_async_operation_names [ op ] ` is the name of op for each value ` op `
* of type ` ssl_async_operation_type_t ` . */
static const char * const ssl_async_operation_names [ ] =
{
" sign " ,
" decrypt " ,
} ;
2018-01-05 20:15:57 +00:00
typedef struct
{
2018-04-26 11:27:43 +00:00
unsigned slot ;
2018-04-26 04:23:59 +00:00
ssl_async_operation_type_t operation_type ;
2018-01-05 20:15:57 +00:00
mbedtls_md_type_t md_alg ;
2018-01-12 12:47:48 +00:00
unsigned char input [ SSL_ASYNC_INPUT_MAX_SIZE ] ;
size_t input_len ;
2018-04-26 04:30:45 +00:00
unsigned remaining_delay ;
2018-01-05 20:15:57 +00:00
} ssl_async_operation_context_t ;
2018-04-26 09:46:10 +00:00
static int ssl_async_start ( mbedtls_ssl_context * ssl ,
2018-01-12 12:47:48 +00:00
mbedtls_x509_crt * cert ,
2018-04-26 04:23:59 +00:00
ssl_async_operation_type_t op_type ,
2018-01-12 12:47:48 +00:00
mbedtls_md_type_t md_alg ,
const unsigned char * input ,
size_t input_len )
2018-01-05 20:15:57 +00:00
{
2018-04-26 09:46:10 +00:00
ssl_async_key_context_t * config_data =
mbedtls_ssl_conf_get_async_config_data ( ssl - > conf ) ;
2018-04-26 11:27:43 +00:00
unsigned slot ;
2018-01-05 20:15:57 +00:00
ssl_async_operation_context_t * ctx = NULL ;
2018-04-26 04:23:59 +00:00
const char * op_name = ssl_async_operation_names [ op_type ] ;
2018-04-24 11:05:39 +00:00
2018-01-05 20:15:57 +00:00
{
char dn [ 100 ] ;
2018-06-15 12:05:10 +00:00
if ( mbedtls_x509_dn_gets ( dn , sizeof ( dn ) , & cert - > subject ) > 0 )
mbedtls_printf ( " Async %s callback: looking for DN=%s \n " ,
op_name , dn ) ;
2018-01-05 20:15:57 +00:00
}
2018-04-24 11:05:39 +00:00
2018-04-30 10:07:56 +00:00
/* Look for a private key that matches the public key in cert.
* Since this test code has the private key inside Mbed TLS ,
* we call mbedtls_pk_check_pair to match a private key with the
* public key . */
2018-04-25 18:39:48 +00:00
for ( slot = 0 ; slot < config_data - > slots_used ; slot + + )
2018-01-05 20:15:57 +00:00
{
2018-04-30 10:07:56 +00:00
if ( mbedtls_pk_check_pair ( & cert - > pk ,
config_data - > slots [ slot ] . pk ) = = 0 )
2018-01-05 20:15:57 +00:00
break ;
}
2018-04-25 18:39:48 +00:00
if ( slot = = config_data - > slots_used )
2018-01-05 20:15:57 +00:00
{
2018-01-12 12:47:48 +00:00
mbedtls_printf ( " Async %s callback: no key matches this certificate. \n " ,
op_name ) ;
2018-01-05 20:15:57 +00:00
return ( MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH ) ;
}
2018-04-26 11:27:43 +00:00
mbedtls_printf ( " Async %s callback: using key slot %u, delay=%u. \n " ,
2018-04-25 18:39:48 +00:00
op_name , slot , config_data - > slots [ slot ] . delay ) ;
2018-04-24 11:05:39 +00:00
2018-04-25 18:39:48 +00:00
if ( config_data - > inject_error = = SSL_ASYNC_INJECT_ERROR_START )
2018-01-05 20:15:57 +00:00
{
2018-01-12 12:47:48 +00:00
mbedtls_printf ( " Async %s callback: injected error \n " , op_name ) ;
2018-01-05 20:15:57 +00:00
return ( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE ) ;
}
2018-04-24 11:05:39 +00:00
2018-01-12 12:47:48 +00:00
if ( input_len > SSL_ASYNC_INPUT_MAX_SIZE )
2018-01-05 20:15:57 +00:00
return ( MBEDTLS_ERR_SSL_BAD_INPUT_DATA ) ;
2018-04-24 11:05:39 +00:00
2018-01-05 20:15:57 +00:00
ctx = mbedtls_calloc ( 1 , sizeof ( * ctx ) ) ;
if ( ctx = = NULL )
return ( MBEDTLS_ERR_SSL_ALLOC_FAILED ) ;
ctx - > slot = slot ;
2018-04-26 04:23:59 +00:00
ctx - > operation_type = op_type ;
2018-01-05 20:15:57 +00:00
ctx - > md_alg = md_alg ;
2018-01-12 12:47:48 +00:00
memcpy ( ctx - > input , input , input_len ) ;
ctx - > input_len = input_len ;
2018-04-26 04:30:45 +00:00
ctx - > remaining_delay = config_data - > slots [ slot ] . delay ;
2018-04-30 09:54:39 +00:00
mbedtls_ssl_set_async_operation_data ( ssl , ctx ) ;
2018-04-24 11:05:39 +00:00
2018-04-26 04:30:45 +00:00
if ( ctx - > remaining_delay = = 0 )
2018-01-05 20:15:57 +00:00
return ( 0 ) ;
else
return ( MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS ) ;
}
2018-04-26 09:46:10 +00:00
static int ssl_async_sign ( mbedtls_ssl_context * ssl ,
2018-01-12 12:47:48 +00:00
mbedtls_x509_crt * cert ,
mbedtls_md_type_t md_alg ,
const unsigned char * hash ,
size_t hash_len )
{
2018-04-26 09:46:10 +00:00
return ( ssl_async_start ( ssl , cert ,
2018-04-26 04:23:59 +00:00
ASYNC_OP_SIGN , md_alg ,
2018-01-12 12:47:48 +00:00
hash , hash_len ) ) ;
}
2018-04-26 09:46:10 +00:00
static int ssl_async_decrypt ( mbedtls_ssl_context * ssl ,
2018-01-12 12:47:48 +00:00
mbedtls_x509_crt * cert ,
const unsigned char * input ,
size_t input_len )
{
2018-04-26 09:46:10 +00:00
return ( ssl_async_start ( ssl , cert ,
2018-04-26 04:23:59 +00:00
ASYNC_OP_DECRYPT , MBEDTLS_MD_NONE ,
2018-01-12 12:47:48 +00:00
input , input_len ) ) ;
}
2018-04-26 09:46:10 +00:00
static int ssl_async_resume ( mbedtls_ssl_context * ssl ,
2018-01-12 12:47:48 +00:00
unsigned char * output ,
size_t * output_len ,
size_t output_size )
2018-01-05 20:15:57 +00:00
{
2018-04-30 09:54:39 +00:00
ssl_async_operation_context_t * ctx = mbedtls_ssl_get_async_operation_data ( ssl ) ;
2018-04-26 09:46:10 +00:00
ssl_async_key_context_t * config_data =
mbedtls_ssl_conf_get_async_config_data ( ssl - > conf ) ;
2018-04-25 18:39:48 +00:00
ssl_async_key_slot_t * key_slot = & config_data - > slots [ ctx - > slot ] ;
2018-01-05 20:15:57 +00:00
int ret ;
2018-04-30 14:37:23 +00:00
const char * op_name ;
2018-04-24 11:05:39 +00:00
2018-04-26 04:30:45 +00:00
if ( ctx - > remaining_delay > 0 )
2018-01-05 20:15:57 +00:00
{
2018-04-26 04:30:45 +00:00
- - ctx - > remaining_delay ;
2018-04-26 11:27:43 +00:00
mbedtls_printf ( " Async resume (slot %u): call %u more times. \n " ,
2018-04-26 04:30:45 +00:00
ctx - > slot , ctx - > remaining_delay ) ;
2018-01-05 20:15:57 +00:00
return ( MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS ) ;
}
2018-04-24 11:05:39 +00:00
2018-04-26 04:23:59 +00:00
switch ( ctx - > operation_type )
2018-01-12 12:47:48 +00:00
{
2018-04-26 04:23:59 +00:00
case ASYNC_OP_DECRYPT :
ret = mbedtls_pk_decrypt ( key_slot - > pk ,
ctx - > input , ctx - > input_len ,
output , output_len , output_size ,
config_data - > f_rng , config_data - > p_rng ) ;
break ;
case ASYNC_OP_SIGN :
ret = mbedtls_pk_sign ( key_slot - > pk ,
ctx - > md_alg ,
ctx - > input , ctx - > input_len ,
output , output_len ,
config_data - > f_rng , config_data - > p_rng ) ;
break ;
default :
2018-04-26 11:27:43 +00:00
mbedtls_printf ( " Async resume (slot %u): unknown operation type %ld. This shouldn't happen. \n " ,
2018-04-26 04:23:59 +00:00
ctx - > slot , ( long ) ctx - > operation_type ) ;
2018-06-13 16:09:28 +00:00
mbedtls_free ( ctx ) ;
2018-04-26 04:23:59 +00:00
return ( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE ) ;
break ;
2018-01-12 12:47:48 +00:00
}
2018-04-24 11:05:39 +00:00
2018-04-30 14:37:23 +00:00
op_name = ssl_async_operation_names [ ctx - > operation_type ] ;
2018-04-26 05:15:40 +00:00
if ( config_data - > inject_error = = SSL_ASYNC_INJECT_ERROR_RESUME )
2018-01-05 20:15:57 +00:00
{
2018-01-12 12:47:48 +00:00
mbedtls_printf ( " Async resume callback: %s done but injected error \n " ,
op_name ) ;
2018-06-12 12:17:39 +00:00
mbedtls_free ( ctx ) ;
2018-01-05 20:15:57 +00:00
return ( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE ) ;
}
2018-04-24 11:05:39 +00:00
2018-04-26 11:27:43 +00:00
mbedtls_printf ( " Async resume (slot %u): %s done, status=%d. \n " ,
2018-01-12 12:47:48 +00:00
ctx - > slot , op_name , ret ) ;
2018-01-05 20:15:57 +00:00
mbedtls_free ( ctx ) ;
return ( ret ) ;
}
2018-04-26 09:46:10 +00:00
static void ssl_async_cancel ( mbedtls_ssl_context * ssl )
2018-01-05 20:15:57 +00:00
{
2018-04-30 09:54:39 +00:00
ssl_async_operation_context_t * ctx = mbedtls_ssl_get_async_operation_data ( ssl ) ;
2018-01-05 20:15:57 +00:00
mbedtls_printf ( " Async cancel callback. \n " ) ;
mbedtls_free ( ctx ) ;
}
2018-04-24 11:09:22 +00:00
# endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
2018-01-05 20:15:57 +00:00
2017-10-10 14:56:37 +00:00
/*
* Wait for an event from the underlying transport or the timer
* ( Used in event - driven IO mode ) .
*/
# if !defined(MBEDTLS_TIMING_C)
2018-03-15 11:35:07 +00:00
int idle ( mbedtls_net_context * fd ,
2018-03-15 12:21:15 +00:00
int idle_reason )
2017-10-10 14:56:37 +00:00
# else
2018-03-15 11:35:07 +00:00
int idle ( mbedtls_net_context * fd ,
2018-03-15 12:21:15 +00:00
mbedtls_timing_delay_context * timer ,
int idle_reason )
2017-10-10 14:56:37 +00:00
# endif
2018-03-15 12:21:15 +00:00
{
2018-03-15 11:35:07 +00:00
int ret ;
2017-10-10 14:56:37 +00:00
int poll_type = 0 ;
if ( idle_reason = = MBEDTLS_ERR_SSL_WANT_WRITE )
poll_type = MBEDTLS_NET_POLL_WRITE ;
else if ( idle_reason = = MBEDTLS_ERR_SSL_WANT_READ )
poll_type = MBEDTLS_NET_POLL_READ ;
# if !defined(MBEDTLS_TIMING_C)
else
2018-03-15 15:49:24 +00:00
return ( 0 ) ;
2017-10-10 14:56:37 +00:00
# endif
while ( 1 )
{
2017-10-31 10:58:53 +00:00
/* Check if timer has expired */
2017-10-10 14:56:37 +00:00
# if defined(MBEDTLS_TIMING_C)
2017-10-31 10:58:53 +00:00
if ( timer ! = NULL & &
mbedtls_timing_get_delay ( timer ) = = 2 )
2017-10-10 14:56:37 +00:00
{
break ;
}
2017-10-31 10:58:53 +00:00
# endif /* MBEDTLS_TIMING_C */
2017-10-10 14:56:37 +00:00
2017-10-31 10:58:53 +00:00
/* Check if underlying transport became available */
2018-03-15 11:35:07 +00:00
if ( poll_type ! = 0 )
2017-10-10 14:56:37 +00:00
{
2018-03-15 11:35:07 +00:00
ret = mbedtls_net_poll ( fd , poll_type , 0 ) ;
if ( ret < 0 )
return ( ret ) ;
if ( ret = = poll_type )
break ;
2017-10-10 14:56:37 +00:00
}
}
2018-03-15 11:35:07 +00:00
return ( 0 ) ;
2017-10-10 14:56:37 +00:00
}
2018-10-26 10:28:08 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
2019-08-08 10:38:18 +00:00
static psa_status_t psa_setup_psk_key_slot ( psa_key_handle_t * slot ,
2018-10-26 10:28:08 +00:00
psa_algorithm_t alg ,
unsigned char * psk ,
size_t psk_len )
{
psa_status_t status ;
2019-08-08 10:38:18 +00:00
psa_key_attributes_t key_attributes ;
2018-10-26 10:28:08 +00:00
2019-08-08 10:38:18 +00:00
key_attributes = psa_key_attributes_init ( ) ;
psa_set_key_usage_flags ( & key_attributes , PSA_KEY_USAGE_DERIVE ) ;
psa_set_key_algorithm ( & key_attributes , alg ) ;
psa_set_key_type ( & key_attributes , PSA_KEY_TYPE_DERIVE ) ;
2018-10-26 10:28:08 +00:00
2019-08-08 10:38:18 +00:00
status = psa_import_key ( & key_attributes , psk , psk_len , slot ) ;
2018-10-26 10:28:08 +00:00
if ( status ! = PSA_SUCCESS )
2018-11-15 13:06:09 +00:00
{
fprintf ( stderr , " IMPORT \n " ) ;
2018-10-26 10:28:08 +00:00
return ( status ) ;
2018-11-15 13:06:09 +00:00
}
2018-10-26 10:28:08 +00:00
return ( PSA_SUCCESS ) ;
}
# endif /* MBEDTLS_USE_PSA_CRYPTO */
2019-05-15 13:03:01 +00:00
# if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
2019-05-03 16:30:59 +00:00
int report_cid_usage ( mbedtls_ssl_context * ssl ,
const char * additional_description )
{
int ret ;
unsigned char peer_cid [ MBEDTLS_SSL_CID_OUT_LEN_MAX ] ;
size_t peer_cid_len ;
int cid_negotiated ;
if ( opt . transport ! = MBEDTLS_SSL_TRANSPORT_DATAGRAM )
return ( 0 ) ;
/* Check if the use of a CID has been negotiated */
ret = mbedtls_ssl_get_peer_cid ( ssl , & cid_negotiated ,
peer_cid , & peer_cid_len ) ;
if ( ret ! = 0 )
{
mbedtls_printf ( " failed \n ! mbedtls_ssl_get_peer_cid returned -0x%x \n \n " ,
- ret ) ;
return ( ret ) ;
}
if ( cid_negotiated = = MBEDTLS_SSL_CID_DISABLED )
{
if ( opt . cid_enabled = = MBEDTLS_SSL_CID_ENABLED )
{
mbedtls_printf ( " (%s) Use of Connection ID was not offered by client. \n " ,
additional_description ) ;
}
}
else
{
size_t idx = 0 ;
mbedtls_printf ( " (%s) Use of Connection ID has been negotiated. \n " ,
additional_description ) ;
mbedtls_printf ( " (%s) Peer CID (length %u Bytes): " ,
additional_description ,
( unsigned ) peer_cid_len ) ;
while ( idx < peer_cid_len )
{
mbedtls_printf ( " %02x " , peer_cid [ idx ] ) ;
idx + + ;
}
mbedtls_printf ( " \n " ) ;
}
return ( 0 ) ;
}
2019-05-15 13:03:01 +00:00
# endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
2019-05-03 16:30:59 +00:00
2012-09-25 09:05:17 +00:00
int main ( int argc , char * argv [ ] )
{
2015-01-22 10:33:29 +00:00
int ret = 0 , len , written , frags , exchanges_left ;
2014-06-11 11:50:34 +00:00
int version_suites [ 4 ] [ 2 ] ;
2019-07-03 16:05:43 +00:00
io_ctx_t io_ctx ;
2017-10-12 11:50:29 +00:00
unsigned char * buf = 0 ;
2020-03-10 11:19:08 +00:00
# if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
2018-10-26 10:28:08 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
psa_algorithm_t alg = 0 ;
2019-01-08 14:36:01 +00:00
psa_key_handle_t psk_slot = 0 ;
2018-10-26 10:28:08 +00:00
# endif /* MBEDTLS_USE_PSA_CRYPTO */
2015-04-08 10:49:31 +00:00
unsigned char psk [ MBEDTLS_PSK_MAX_LEN ] ;
2013-04-17 17:10:21 +00:00
size_t psk_len = 0 ;
2014-06-12 21:01:43 +00:00
psk_entry * psk_info = NULL ;
2013-04-18 20:46:23 +00:00
# endif
2013-06-24 11:01:08 +00:00
const char * pers = " ssl_server2 " ;
2014-07-22 15:57:43 +00:00
unsigned char client_ip [ 16 ] = { 0 } ;
2015-05-14 19:52:40 +00:00
size_t cliip_len ;
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_COOKIE_C)
mbedtls_ssl_cookie_ctx cookie_ctx ;
2014-07-23 12:56:15 +00:00
# endif
2012-09-25 09:05:17 +00:00
2017-05-05 16:59:02 +00:00
# if defined(MBEDTLS_X509_CRT_PARSE_C)
mbedtls_x509_crt_profile crt_profile_for_test = mbedtls_x509_crt_profile_default ;
# endif
2015-04-08 10:49:31 +00:00
mbedtls_entropy_context entropy ;
mbedtls_ctr_drbg_context ctr_drbg ;
mbedtls_ssl_context ssl ;
2015-05-04 12:56:36 +00:00
mbedtls_ssl_config conf ;
2015-05-13 11:58:56 +00:00
# if defined(MBEDTLS_TIMING_C)
2015-05-13 08:04:32 +00:00
mbedtls_timing_delay_context timer ;
2015-05-13 11:58:56 +00:00
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_RENEGOTIATION)
2014-11-05 13:23:03 +00:00
unsigned char renego_period [ 8 ] = { 0 } ;
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_X509_CRT_PARSE_C)
2015-05-12 09:27:25 +00:00
uint32_t flags ;
2015-04-08 10:49:31 +00:00
mbedtls_x509_crt cacert ;
mbedtls_x509_crt srvcert ;
mbedtls_pk_context pkey ;
mbedtls_x509_crt srvcert2 ;
mbedtls_pk_context pkey2 ;
2013-09-25 12:05:49 +00:00
int key_cert_init = 0 , key_cert_init2 = 0 ;
2018-04-24 11:09:22 +00:00
# if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
2018-01-05 20:15:57 +00:00
ssl_async_key_context_t ssl_async_keys ;
2018-04-24 11:09:22 +00:00
# endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
2018-01-05 20:15:57 +00:00
# endif /* MBEDTLS_X509_CRT_PARSE_C */
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_FS_IO)
mbedtls_dhm_context dhm ;
2014-06-09 09:29:50 +00:00
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_CACHE_C)
mbedtls_ssl_cache_context cache ;
2012-09-25 21:55:46 +00:00
# endif
2015-05-19 13:28:00 +00:00
# if defined(MBEDTLS_SSL_SESSION_TICKETS)
mbedtls_ssl_ticket_context ticket_ctx ;
# endif
2015-04-03 14:41:52 +00:00
# if defined(SNI_OPTION)
2014-02-21 15:52:06 +00:00
sni_entry * sni_info = NULL ;
# endif
2017-05-15 15:05:15 +00:00
# if defined(MBEDTLS_ECP_C)
2017-06-09 15:13:22 +00:00
mbedtls_ecp_group_id curve_list [ CURVE_LIST_SIZE ] ;
2017-05-15 15:05:15 +00:00
const mbedtls_ecp_curve_info * curve_cur ;
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_ALPN)
2017-06-09 15:13:22 +00:00
const char * alpn_list [ ALPN_LIST_SIZE ] ;
2014-04-05 12:34:07 +00:00
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
2018-07-23 13:26:09 +00:00
unsigned char alloc_buf [ MEMORY_HEAP_SIZE ] ;
2013-07-04 09:52:32 +00:00
# endif
2012-09-25 09:05:17 +00:00
2019-05-15 13:03:01 +00:00
# if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
2019-04-09 16:28:10 +00:00
unsigned char cid [ MBEDTLS_SSL_CID_IN_LEN_MAX ] ;
2019-05-03 16:30:59 +00:00
unsigned char cid_renego [ MBEDTLS_SSL_CID_IN_LEN_MAX ] ;
2019-04-09 16:28:10 +00:00
size_t cid_len = 0 ;
2019-05-03 16:30:59 +00:00
size_t cid_renego_len = 0 ;
2019-04-09 16:28:10 +00:00
# endif
2019-07-15 08:31:11 +00:00
# if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
unsigned char * context_buf = NULL ;
2019-09-20 17:12:31 +00:00
size_t context_buf_len = 0 ;
2019-07-15 08:31:11 +00:00
# endif
2019-04-09 16:28:10 +00:00
2012-09-25 09:05:17 +00:00
int i ;
char * p , * q ;
const int * list ;
2018-11-12 17:47:48 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
psa_status_t status ;
# endif
2019-05-12 08:03:32 +00:00
# if defined(MBEDTLS_SSL_EXPORT_KEYS)
unsigned char eap_tls_keymaterial [ 16 ] ;
unsigned char eap_tls_iv [ 8 ] ;
const char * eap_tls_label = " client EAP encryption " ;
eap_tls_keys eap_tls_keying ;
# endif
2012-09-25 09:05:17 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
mbedtls_memory_buffer_alloc_init ( alloc_buf , sizeof ( alloc_buf ) ) ;
2019-11-26 15:32:40 +00:00
# if defined(MBEDTLS_MEMORY_DEBUG)
size_t current_heap_memory , peak_heap_memory , heap_blocks ;
# endif /* MBEDTLS_MEMORY_DEBUG */
# endif /* MBEDTLS_MEMORY_BUFFER_ALLOC_C */
2013-07-04 09:52:32 +00:00
2012-09-25 09:05:17 +00:00
/*
2013-09-20 11:10:13 +00:00
* Make sure memory references are valid in case we exit early .
2012-09-25 09:05:17 +00:00
*/
2015-06-30 13:40:39 +00:00
mbedtls_net_init ( & client_fd ) ;
mbedtls_net_init ( & listen_fd ) ;
2015-04-28 22:48:22 +00:00
mbedtls_ssl_init ( & ssl ) ;
2015-05-04 12:56:36 +00:00
mbedtls_ssl_config_init ( & conf ) ;
2015-04-28 20:52:30 +00:00
mbedtls_ctr_drbg_init ( & ctr_drbg ) ;
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_X509_CRT_PARSE_C)
mbedtls_x509_crt_init ( & cacert ) ;
mbedtls_x509_crt_init ( & srvcert ) ;
mbedtls_pk_init ( & pkey ) ;
mbedtls_x509_crt_init ( & srvcert2 ) ;
mbedtls_pk_init ( & pkey2 ) ;
2018-04-26 12:33:43 +00:00
# if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
memset ( & ssl_async_keys , 0 , sizeof ( ssl_async_keys ) ) ;
# endif
2013-04-18 20:46:23 +00:00
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_FS_IO)
mbedtls_dhm_init ( & dhm ) ;
2014-06-09 09:29:50 +00:00
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_CACHE_C)
mbedtls_ssl_cache_init ( & cache ) ;
2012-09-25 21:55:46 +00:00
# endif
2015-05-19 13:28:00 +00:00
# if defined(MBEDTLS_SSL_SESSION_TICKETS)
mbedtls_ssl_ticket_init ( & ticket_ctx ) ;
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_ALPN)
2014-05-01 08:58:57 +00:00
memset ( ( void * ) alpn_list , 0 , sizeof ( alpn_list ) ) ;
2014-04-05 12:34:07 +00:00
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_COOKIE_C)
mbedtls_ssl_cookie_init ( & cookie_ctx ) ;
2014-07-23 12:56:15 +00:00
# endif
2012-09-25 09:05:17 +00:00
2018-11-12 17:47:48 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
status = psa_crypto_init ( ) ;
if ( status ! = PSA_SUCCESS )
{
mbedtls_fprintf ( stderr , " Failed to initialize PSA Crypto implementation: %d \n " ,
( int ) status ) ;
ret = MBEDTLS_ERR_SSL_HW_ACCEL_FAILED ;
goto exit ;
}
# endif
2014-08-18 09:05:51 +00:00
# if !defined(_WIN32)
2014-11-17 11:46:49 +00:00
/* Abort cleanly on SIGTERM and SIGINT */
2014-08-14 13:36:12 +00:00
signal ( SIGTERM , term_handler ) ;
2014-11-17 11:46:49 +00:00
signal ( SIGINT , term_handler ) ;
2014-08-18 09:05:51 +00:00
# endif
2014-08-14 13:36:12 +00:00
2012-09-25 09:05:17 +00:00
if ( argc = = 0 )
{
usage :
if ( ret = = 0 )
ret = 1 ;
2015-04-08 10:49:31 +00:00
mbedtls_printf ( USAGE ) ;
2012-09-25 09:05:17 +00:00
2015-04-08 10:49:31 +00:00
list = mbedtls_ssl_list_ciphersuites ( ) ;
2012-09-25 09:05:17 +00:00
while ( * list )
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " %-42s " , mbedtls_ssl_get_ciphersuite_name ( * list ) ) ;
2013-04-18 20:46:23 +00:00
list + + ;
if ( ! * list )
break ;
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " %s \n " , mbedtls_ssl_get_ciphersuite_name ( * list ) ) ;
2012-09-25 09:05:17 +00:00
list + + ;
}
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " \n " ) ;
2012-09-25 09:05:17 +00:00
goto exit ;
}
2017-10-12 11:50:29 +00:00
opt . buffer_size = DFL_IO_BUF_LEN ;
2013-12-13 15:21:41 +00:00
opt . server_addr = DFL_SERVER_ADDR ;
2012-09-25 09:05:17 +00:00
opt . server_port = DFL_SERVER_PORT ;
opt . debug_level = DFL_DEBUG_LEVEL ;
2017-10-10 14:56:37 +00:00
opt . event = DFL_EVENT ;
2017-10-12 11:50:29 +00:00
opt . response_size = DFL_RESPONSE_SIZE ;
2014-02-26 12:47:08 +00:00
opt . nbio = DFL_NBIO ;
2019-04-09 16:28:10 +00:00
opt . cid_enabled = DFL_CID_ENABLED ;
2019-05-03 16:30:59 +00:00
opt . cid_enabled_renego = DFL_CID_ENABLED_RENEGO ;
2019-04-09 16:28:10 +00:00
opt . cid_val = DFL_CID_VALUE ;
2019-05-03 16:30:59 +00:00
opt . cid_val_renego = DFL_CID_VALUE_RENEGO ;
2014-10-01 16:29:03 +00:00
opt . read_timeout = DFL_READ_TIMEOUT ;
2012-09-25 09:05:17 +00:00
opt . ca_file = DFL_CA_FILE ;
opt . ca_path = DFL_CA_PATH ;
opt . crt_file = DFL_CRT_FILE ;
opt . key_file = DFL_KEY_FILE ;
2013-09-23 15:00:18 +00:00
opt . crt_file2 = DFL_CRT_FILE2 ;
opt . key_file2 = DFL_KEY_FILE2 ;
2018-01-12 12:47:48 +00:00
opt . async_operations = DFL_ASYNC_OPERATIONS ;
2018-01-05 20:15:57 +00:00
opt . async_private_delay1 = DFL_ASYNC_PRIVATE_DELAY1 ;
opt . async_private_delay2 = DFL_ASYNC_PRIVATE_DELAY2 ;
opt . async_private_error = DFL_ASYNC_PRIVATE_ERROR ;
2013-04-17 17:10:21 +00:00
opt . psk = DFL_PSK ;
2018-10-26 10:28:08 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
2018-11-15 13:06:09 +00:00
opt . psk_opaque = DFL_PSK_OPAQUE ;
opt . psk_list_opaque = DFL_PSK_LIST_OPAQUE ;
2019-03-27 15:55:27 +00:00
# endif
# if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
opt . ca_callback = DFL_CA_CALLBACK ;
2018-10-26 10:28:08 +00:00
# endif
2013-04-17 17:10:21 +00:00
opt . psk_identity = DFL_PSK_IDENTITY ;
2014-06-10 12:01:52 +00:00
opt . psk_list = DFL_PSK_LIST ;
2015-09-16 09:08:34 +00:00
opt . ecjpake_pw = DFL_ECJPAKE_PW ;
2012-09-25 09:05:17 +00:00
opt . force_ciphersuite [ 0 ] = DFL_FORCE_CIPHER ;
2014-06-11 11:50:34 +00:00
opt . version_suites = DFL_VERSION_SUITES ;
2012-09-25 09:05:17 +00:00
opt . renegotiation = DFL_RENEGOTIATION ;
opt . allow_legacy = DFL_ALLOW_LEGACY ;
2014-02-20 16:19:59 +00:00
opt . renegotiate = DFL_RENEGOTIATE ;
2014-07-04 12:32:27 +00:00
opt . renego_delay = DFL_RENEGO_DELAY ;
2014-11-05 13:23:03 +00:00
opt . renego_period = DFL_RENEGO_PERIOD ;
2014-08-15 09:17:27 +00:00
opt . exchanges = DFL_EXCHANGES ;
2012-09-28 13:28:45 +00:00
opt . min_version = DFL_MIN_VERSION ;
2013-06-29 14:01:32 +00:00
opt . max_version = DFL_MAX_VERSION ;
2015-01-12 12:43:29 +00:00
opt . arc4 = DFL_ARC4 ;
2017-05-09 13:59:24 +00:00
opt . allow_sha1 = DFL_SHA1 ;
2012-11-23 13:04:08 +00:00
opt . auth_mode = DFL_AUTH_MODE ;
2017-04-10 12:44:33 +00:00
opt . cert_req_ca_list = DFL_CERT_REQ_CA_LIST ;
2013-07-18 12:07:36 +00:00
opt . mfl_code = DFL_MFL_CODE ;
2015-01-09 11:39:35 +00:00
opt . trunc_hmac = DFL_TRUNC_HMAC ;
2013-08-03 11:02:31 +00:00
opt . tickets = DFL_TICKETS ;
2014-02-21 08:18:13 +00:00
opt . ticket_timeout = DFL_TICKET_TIMEOUT ;
2014-02-20 20:32:41 +00:00
opt . cache_max = DFL_CACHE_MAX ;
2014-02-20 21:50:56 +00:00
opt . cache_timeout = DFL_CACHE_TIMEOUT ;
2014-02-21 15:52:06 +00:00
opt . sni = DFL_SNI ;
2014-04-05 12:34:07 +00:00
opt . alpn_string = DFL_ALPN_STRING ;
2017-05-15 15:05:15 +00:00
opt . curves = DFL_CURVES ;
2014-06-09 09:29:50 +00:00
opt . dhm_file = DFL_DHM_FILE ;
2014-02-06 13:02:55 +00:00
opt . transport = DFL_TRANSPORT ;
2014-07-23 17:34:59 +00:00
opt . cookies = DFL_COOKIES ;
2014-09-24 12:41:11 +00:00
opt . anti_replay = DFL_ANTI_REPLAY ;
2014-10-01 12:40:56 +00:00
opt . hs_to_min = DFL_HS_TO_MIN ;
opt . hs_to_max = DFL_HS_TO_MAX ;
2018-08-12 11:28:53 +00:00
opt . dtls_mtu = DFL_DTLS_MTU ;
2018-08-14 12:28:56 +00:00
opt . dgram_packing = DFL_DGRAM_PACKING ;
2014-10-14 17:36:36 +00:00
opt . badmac_limit = DFL_BADMAC_LIMIT ;
2014-10-20 16:40:56 +00:00
opt . extended_ms = DFL_EXTENDED_MS ;
2014-10-27 12:57:03 +00:00
opt . etm = DFL_ETM ;
2019-05-29 10:33:32 +00:00
opt . serialize = DFL_SERIALIZE ;
2019-05-12 08:03:32 +00:00
opt . eap_tls = DFL_EAP_TLS ;
2019-06-06 19:24:31 +00:00
opt . reproducible = DFL_REPRODUCIBLE ;
2019-08-29 05:31:22 +00:00
opt . nss_keylog = DFL_NSS_KEYLOG ;
opt . nss_keylog_file = DFL_NSS_KEYLOG_FILE ;
2012-09-25 09:05:17 +00:00
for ( i = 1 ; i < argc ; i + + )
{
p = argv [ i ] ;
if ( ( q = strchr ( p , ' = ' ) ) = = NULL )
goto usage ;
* q + + = ' \0 ' ;
if ( strcmp ( p , " server_port " ) = = 0 )
2015-06-23 10:30:57 +00:00
opt . server_port = q ;
2013-12-13 15:21:41 +00:00
else if ( strcmp ( p , " server_addr " ) = = 0 )
opt . server_addr = q ;
2014-02-06 13:02:55 +00:00
else if ( strcmp ( p , " dtls " ) = = 0 )
{
int t = atoi ( q ) ;
if ( t = = 0 )
2015-04-08 10:49:31 +00:00
opt . transport = MBEDTLS_SSL_TRANSPORT_STREAM ;
2014-02-06 13:02:55 +00:00
else if ( t = = 1 )
2015-04-08 10:49:31 +00:00
opt . transport = MBEDTLS_SSL_TRANSPORT_DATAGRAM ;
2014-02-06 13:02:55 +00:00
else
goto usage ;
}
2012-09-25 09:05:17 +00:00
else if ( strcmp ( p , " debug_level " ) = = 0 )
{
opt . debug_level = atoi ( q ) ;
if ( opt . debug_level < 0 | | opt . debug_level > 65535 )
goto usage ;
}
2014-02-26 12:47:08 +00:00
else if ( strcmp ( p , " nbio " ) = = 0 )
{
opt . nbio = atoi ( q ) ;
if ( opt . nbio < 0 | | opt . nbio > 2 )
goto usage ;
}
2017-10-10 14:56:37 +00:00
else if ( strcmp ( p , " event " ) = = 0 )
{
opt . event = atoi ( q ) ;
if ( opt . event < 0 | | opt . event > 2 )
goto usage ;
}
2014-10-01 16:29:03 +00:00
else if ( strcmp ( p , " read_timeout " ) = = 0 )
opt . read_timeout = atoi ( q ) ;
2017-10-12 11:50:29 +00:00
else if ( strcmp ( p , " buffer_size " ) = = 0 )
{
opt . buffer_size = atoi ( q ) ;
if ( opt . buffer_size < 1 | | opt . buffer_size > MBEDTLS_SSL_MAX_CONTENT_LEN + 1 )
goto usage ;
}
else if ( strcmp ( p , " response_size " ) = = 0 )
{
opt . response_size = atoi ( q ) ;
if ( opt . response_size < 0 | | opt . response_size > MBEDTLS_SSL_MAX_CONTENT_LEN )
goto usage ;
if ( opt . buffer_size < opt . response_size )
opt . buffer_size = opt . response_size ;
}
2012-09-25 09:05:17 +00:00
else if ( strcmp ( p , " ca_file " ) = = 0 )
opt . ca_file = q ;
else if ( strcmp ( p , " ca_path " ) = = 0 )
opt . ca_path = q ;
else if ( strcmp ( p , " crt_file " ) = = 0 )
opt . crt_file = q ;
else if ( strcmp ( p , " key_file " ) = = 0 )
opt . key_file = q ;
2013-09-23 15:00:18 +00:00
else if ( strcmp ( p , " crt_file2 " ) = = 0 )
opt . crt_file2 = q ;
else if ( strcmp ( p , " key_file2 " ) = = 0 )
opt . key_file2 = q ;
2014-06-09 09:29:50 +00:00
else if ( strcmp ( p , " dhm_file " ) = = 0 )
opt . dhm_file = q ;
2018-04-24 11:09:22 +00:00
# if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
2018-01-12 12:47:48 +00:00
else if ( strcmp ( p , " async_operations " ) = = 0 )
opt . async_operations = q ;
2018-01-05 20:15:57 +00:00
else if ( strcmp ( p , " async_private_delay1 " ) = = 0 )
opt . async_private_delay1 = atoi ( q ) ;
else if ( strcmp ( p , " async_private_delay2 " ) = = 0 )
opt . async_private_delay2 = atoi ( q ) ;
else if ( strcmp ( p , " async_private_error " ) = = 0 )
{
int n = atoi ( q ) ;
2018-01-08 10:28:05 +00:00
if ( n < - SSL_ASYNC_INJECT_ERROR_MAX | |
n > SSL_ASYNC_INJECT_ERROR_MAX )
2018-01-05 20:15:57 +00:00
{
ret = 2 ;
goto usage ;
}
opt . async_private_error = n ;
}
2018-04-24 11:09:22 +00:00
# endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
2019-05-15 13:03:01 +00:00
# if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
2019-04-09 16:28:10 +00:00
else if ( strcmp ( p , " cid " ) = = 0 )
{
opt . cid_enabled = atoi ( q ) ;
if ( opt . cid_enabled ! = 0 & & opt . cid_enabled ! = 1 )
goto usage ;
}
2019-05-03 16:30:59 +00:00
else if ( strcmp ( p , " cid_renego " ) = = 0 )
{
opt . cid_enabled_renego = atoi ( q ) ;
if ( opt . cid_enabled_renego ! = 0 & & opt . cid_enabled_renego ! = 1 )
goto usage ;
}
2019-04-09 16:28:10 +00:00
else if ( strcmp ( p , " cid_val " ) = = 0 )
{
opt . cid_val = q ;
}
2019-05-03 16:30:59 +00:00
else if ( strcmp ( p , " cid_val_renego " ) = = 0 )
{
opt . cid_val_renego = q ;
}
2019-05-15 13:03:01 +00:00
# endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
2013-04-17 17:10:21 +00:00
else if ( strcmp ( p , " psk " ) = = 0 )
opt . psk = q ;
2018-10-26 10:28:08 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
2018-11-15 13:06:09 +00:00
else if ( strcmp ( p , " psk_opaque " ) = = 0 )
opt . psk_opaque = atoi ( q ) ;
else if ( strcmp ( p , " psk_list_opaque " ) = = 0 )
opt . psk_list_opaque = atoi ( q ) ;
2019-03-27 15:55:27 +00:00
# endif
# if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
else if ( strcmp ( p , " ca_callback " ) = = 0 )
opt . ca_callback = atoi ( q ) ;
2018-10-26 10:28:08 +00:00
# endif
2013-04-17 17:10:21 +00:00
else if ( strcmp ( p , " psk_identity " ) = = 0 )
opt . psk_identity = q ;
2014-06-10 12:01:52 +00:00
else if ( strcmp ( p , " psk_list " ) = = 0 )
opt . psk_list = q ;
2015-09-16 09:08:34 +00:00
else if ( strcmp ( p , " ecjpake_pw " ) = = 0 )
opt . ecjpake_pw = q ;
2012-09-25 09:05:17 +00:00
else if ( strcmp ( p , " force_ciphersuite " ) = = 0 )
{
2015-04-08 10:49:31 +00:00
opt . force_ciphersuite [ 0 ] = mbedtls_ssl_get_ciphersuite_id ( q ) ;
2012-09-25 09:05:17 +00:00
2014-06-11 12:19:06 +00:00
if ( opt . force_ciphersuite [ 0 ] = = 0 )
2012-09-25 09:05:17 +00:00
{
ret = 2 ;
goto usage ;
}
opt . force_ciphersuite [ 1 ] = 0 ;
}
2017-05-15 15:05:15 +00:00
else if ( strcmp ( p , " curves " ) = = 0 )
opt . curves = q ;
2014-06-11 11:50:34 +00:00
else if ( strcmp ( p , " version_suites " ) = = 0 )
opt . version_suites = q ;
2012-09-25 09:05:17 +00:00
else if ( strcmp ( p , " renegotiation " ) = = 0 )
{
2017-10-10 14:59:57 +00:00
opt . renegotiation = ( atoi ( q ) ) ?
MBEDTLS_SSL_RENEGOTIATION_ENABLED :
MBEDTLS_SSL_RENEGOTIATION_DISABLED ;
2012-09-25 09:05:17 +00:00
}
else if ( strcmp ( p , " allow_legacy " ) = = 0 )
{
2014-11-03 19:10:36 +00:00
switch ( atoi ( q ) )
{
2017-10-10 14:59:57 +00:00
case - 1 :
opt . allow_legacy = MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE ;
break ;
case 0 :
opt . allow_legacy = MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION ;
break ;
case 1 :
opt . allow_legacy = MBEDTLS_SSL_LEGACY_ALLOW_RENEGOTIATION ;
break ;
2014-11-03 19:10:36 +00:00
default : goto usage ;
}
2012-09-25 09:05:17 +00:00
}
2014-02-20 16:19:59 +00:00
else if ( strcmp ( p , " renegotiate " ) = = 0 )
{
opt . renegotiate = atoi ( q ) ;
if ( opt . renegotiate < 0 | | opt . renegotiate > 1 )
goto usage ;
}
2014-07-04 12:32:27 +00:00
else if ( strcmp ( p , " renego_delay " ) = = 0 )
{
opt . renego_delay = atoi ( q ) ;
}
2014-11-05 13:23:03 +00:00
else if ( strcmp ( p , " renego_period " ) = = 0 )
{
2017-02-08 14:05:57 +00:00
# if defined(_MSC_VER)
opt . renego_period = _strtoui64 ( q , NULL , 10 ) ;
# else
if ( sscanf ( q , " % " SCNu64 , & opt . renego_period ) ! = 1 )
goto usage ;
# endif /* _MSC_VER */
if ( opt . renego_period < 2 )
2014-11-05 13:23:03 +00:00
goto usage ;
}
2014-08-15 09:17:27 +00:00
else if ( strcmp ( p , " exchanges " ) = = 0 )
{
opt . exchanges = atoi ( q ) ;
2014-10-09 13:33:13 +00:00
if ( opt . exchanges < 0 )
2014-08-15 09:17:27 +00:00
goto usage ;
}
2012-09-28 13:28:45 +00:00
else if ( strcmp ( p , " min_version " ) = = 0 )
{
if ( strcmp ( q , " ssl3 " ) = = 0 )
2015-04-08 10:49:31 +00:00
opt . min_version = MBEDTLS_SSL_MINOR_VERSION_0 ;
2012-09-28 13:28:45 +00:00
else if ( strcmp ( q , " tls1 " ) = = 0 )
2015-04-08 10:49:31 +00:00
opt . min_version = MBEDTLS_SSL_MINOR_VERSION_1 ;
2014-02-12 10:11:12 +00:00
else if ( strcmp ( q , " tls1_1 " ) = = 0 | |
strcmp ( q , " dtls1 " ) = = 0 )
2015-04-08 10:49:31 +00:00
opt . min_version = MBEDTLS_SSL_MINOR_VERSION_2 ;
2014-02-12 10:11:12 +00:00
else if ( strcmp ( q , " tls1_2 " ) = = 0 | |
strcmp ( q , " dtls1_2 " ) = = 0 )
2015-04-08 10:49:31 +00:00
opt . min_version = MBEDTLS_SSL_MINOR_VERSION_3 ;
2012-09-28 13:28:45 +00:00
else
goto usage ;
}
2013-06-29 14:01:32 +00:00
else if ( strcmp ( p , " max_version " ) = = 0 )
{
if ( strcmp ( q , " ssl3 " ) = = 0 )
2015-04-08 10:49:31 +00:00
opt . max_version = MBEDTLS_SSL_MINOR_VERSION_0 ;
2013-06-29 14:01:32 +00:00
else if ( strcmp ( q , " tls1 " ) = = 0 )
2015-04-08 10:49:31 +00:00
opt . max_version = MBEDTLS_SSL_MINOR_VERSION_1 ;
2014-02-12 10:11:12 +00:00
else if ( strcmp ( q , " tls1_1 " ) = = 0 | |
strcmp ( q , " dtls1 " ) = = 0 )
2015-04-08 10:49:31 +00:00
opt . max_version = MBEDTLS_SSL_MINOR_VERSION_2 ;
2014-02-12 10:11:12 +00:00
else if ( strcmp ( q , " tls1_2 " ) = = 0 | |
strcmp ( q , " dtls1_2 " ) = = 0 )
2015-04-08 10:49:31 +00:00
opt . max_version = MBEDTLS_SSL_MINOR_VERSION_3 ;
2013-06-29 14:01:32 +00:00
else
goto usage ;
}
2015-01-12 12:43:29 +00:00
else if ( strcmp ( p , " arc4 " ) = = 0 )
{
switch ( atoi ( q ) )
{
2015-04-08 10:49:31 +00:00
case 0 : opt . arc4 = MBEDTLS_SSL_ARC4_DISABLED ; break ;
case 1 : opt . arc4 = MBEDTLS_SSL_ARC4_ENABLED ; break ;
2015-01-12 12:43:29 +00:00
default : goto usage ;
}
}
2017-05-09 13:59:24 +00:00
else if ( strcmp ( p , " allow_sha1 " ) = = 0 )
{
switch ( atoi ( q ) )
{
case 0 : opt . allow_sha1 = 0 ; break ;
case 1 : opt . allow_sha1 = 1 ; break ;
default : goto usage ;
}
}
2013-06-29 14:01:32 +00:00
else if ( strcmp ( p , " force_version " ) = = 0 )
{
if ( strcmp ( q , " ssl3 " ) = = 0 )
{
2015-04-08 10:49:31 +00:00
opt . min_version = MBEDTLS_SSL_MINOR_VERSION_0 ;
opt . max_version = MBEDTLS_SSL_MINOR_VERSION_0 ;
2013-06-29 14:01:32 +00:00
}
else if ( strcmp ( q , " tls1 " ) = = 0 )
{
2015-04-08 10:49:31 +00:00
opt . min_version = MBEDTLS_SSL_MINOR_VERSION_1 ;
opt . max_version = MBEDTLS_SSL_MINOR_VERSION_1 ;
2013-06-29 14:01:32 +00:00
}
2014-03-26 11:16:44 +00:00
else if ( strcmp ( q , " tls1_1 " ) = = 0 )
2013-06-29 14:01:32 +00:00
{
2015-04-08 10:49:31 +00:00
opt . min_version = MBEDTLS_SSL_MINOR_VERSION_2 ;
opt . max_version = MBEDTLS_SSL_MINOR_VERSION_2 ;
2013-06-29 14:01:32 +00:00
}
2014-03-26 11:16:44 +00:00
else if ( strcmp ( q , " tls1_2 " ) = = 0 )
{
2015-04-08 10:49:31 +00:00
opt . min_version = MBEDTLS_SSL_MINOR_VERSION_3 ;
opt . max_version = MBEDTLS_SSL_MINOR_VERSION_3 ;
2014-03-26 11:16:44 +00:00
}
else if ( strcmp ( q , " dtls1 " ) = = 0 )
{
2015-04-08 10:49:31 +00:00
opt . min_version = MBEDTLS_SSL_MINOR_VERSION_2 ;
opt . max_version = MBEDTLS_SSL_MINOR_VERSION_2 ;
opt . transport = MBEDTLS_SSL_TRANSPORT_DATAGRAM ;
2014-03-26 11:16:44 +00:00
}
else if ( strcmp ( q , " dtls1_2 " ) = = 0 )
2013-06-29 14:01:32 +00:00
{
2015-04-08 10:49:31 +00:00
opt . min_version = MBEDTLS_SSL_MINOR_VERSION_3 ;
opt . max_version = MBEDTLS_SSL_MINOR_VERSION_3 ;
opt . transport = MBEDTLS_SSL_TRANSPORT_DATAGRAM ;
2013-06-29 14:01:32 +00:00
}
else
goto usage ;
}
2012-11-23 13:04:08 +00:00
else if ( strcmp ( p , " auth_mode " ) = = 0 )
{
2015-06-19 12:40:39 +00:00
if ( ( opt . auth_mode = get_auth_mode ( q ) ) < 0 )
2012-11-23 13:04:08 +00:00
goto usage ;
}
2017-04-10 12:44:33 +00:00
else if ( strcmp ( p , " cert_req_ca_list " ) = = 0 )
{
opt . cert_req_ca_list = atoi ( q ) ;
if ( opt . cert_req_ca_list < 0 | | opt . cert_req_ca_list > 1 )
goto usage ;
}
2013-07-18 12:07:36 +00:00
else if ( strcmp ( p , " max_frag_len " ) = = 0 )
{
if ( strcmp ( q , " 512 " ) = = 0 )
2015-04-08 10:49:31 +00:00
opt . mfl_code = MBEDTLS_SSL_MAX_FRAG_LEN_512 ;
2013-07-18 12:07:36 +00:00
else if ( strcmp ( q , " 1024 " ) = = 0 )
2015-04-08 10:49:31 +00:00
opt . mfl_code = MBEDTLS_SSL_MAX_FRAG_LEN_1024 ;
2013-07-18 12:07:36 +00:00
else if ( strcmp ( q , " 2048 " ) = = 0 )
2015-04-08 10:49:31 +00:00
opt . mfl_code = MBEDTLS_SSL_MAX_FRAG_LEN_2048 ;
2013-07-18 12:07:36 +00:00
else if ( strcmp ( q , " 4096 " ) = = 0 )
2015-04-08 10:49:31 +00:00
opt . mfl_code = MBEDTLS_SSL_MAX_FRAG_LEN_4096 ;
2013-07-18 12:07:36 +00:00
else
goto usage ;
}
2014-04-05 12:34:07 +00:00
else if ( strcmp ( p , " alpn " ) = = 0 )
{
opt . alpn_string = q ;
}
2015-01-09 11:39:35 +00:00
else if ( strcmp ( p , " trunc_hmac " ) = = 0 )
{
switch ( atoi ( q ) )
{
2015-04-08 10:49:31 +00:00
case 0 : opt . trunc_hmac = MBEDTLS_SSL_TRUNC_HMAC_DISABLED ; break ;
case 1 : opt . trunc_hmac = MBEDTLS_SSL_TRUNC_HMAC_ENABLED ; break ;
2015-01-09 11:39:35 +00:00
default : goto usage ;
}
}
2014-10-20 16:40:56 +00:00
else if ( strcmp ( p , " extended_ms " ) = = 0 )
{
switch ( atoi ( q ) )
{
2017-10-10 14:59:57 +00:00
case 0 :
opt . extended_ms = MBEDTLS_SSL_EXTENDED_MS_DISABLED ;
break ;
case 1 :
opt . extended_ms = MBEDTLS_SSL_EXTENDED_MS_ENABLED ;
break ;
2014-10-20 16:40:56 +00:00
default : goto usage ;
}
}
2014-10-27 12:57:03 +00:00
else if ( strcmp ( p , " etm " ) = = 0 )
{
switch ( atoi ( q ) )
{
2015-04-08 10:49:31 +00:00
case 0 : opt . etm = MBEDTLS_SSL_ETM_DISABLED ; break ;
case 1 : opt . etm = MBEDTLS_SSL_ETM_ENABLED ; break ;
2014-10-27 12:57:03 +00:00
default : goto usage ;
}
}
2013-08-03 11:02:31 +00:00
else if ( strcmp ( p , " tickets " ) = = 0 )
{
opt . tickets = atoi ( q ) ;
if ( opt . tickets < 0 | | opt . tickets > 1 )
goto usage ;
}
2014-02-21 08:18:13 +00:00
else if ( strcmp ( p , " ticket_timeout " ) = = 0 )
{
opt . ticket_timeout = atoi ( q ) ;
if ( opt . ticket_timeout < 0 )
goto usage ;
}
2014-02-20 20:32:41 +00:00
else if ( strcmp ( p , " cache_max " ) = = 0 )
{
opt . cache_max = atoi ( q ) ;
if ( opt . cache_max < 0 )
goto usage ;
}
2014-02-20 21:50:56 +00:00
else if ( strcmp ( p , " cache_timeout " ) = = 0 )
{
opt . cache_timeout = atoi ( q ) ;
if ( opt . cache_timeout < 0 )
goto usage ;
}
2014-07-23 17:34:59 +00:00
else if ( strcmp ( p , " cookies " ) = = 0 )
{
opt . cookies = atoi ( q ) ;
if ( opt . cookies < - 1 | | opt . cookies > 1 )
goto usage ;
}
2014-09-24 12:41:11 +00:00
else if ( strcmp ( p , " anti_replay " ) = = 0 )
{
opt . anti_replay = atoi ( q ) ;
if ( opt . anti_replay < 0 | | opt . anti_replay > 1 )
goto usage ;
}
2014-10-14 17:36:36 +00:00
else if ( strcmp ( p , " badmac_limit " ) = = 0 )
{
opt . badmac_limit = atoi ( q ) ;
if ( opt . badmac_limit < 0 )
goto usage ;
}
2014-10-01 12:40:56 +00:00
else if ( strcmp ( p , " hs_timeout " ) = = 0 )
{
if ( ( p = strchr ( q , ' - ' ) ) = = NULL )
goto usage ;
* p + + = ' \0 ' ;
opt . hs_to_min = atoi ( q ) ;
opt . hs_to_max = atoi ( p ) ;
if ( opt . hs_to_min = = 0 | | opt . hs_to_max < opt . hs_to_min )
goto usage ;
}
2018-08-12 11:28:53 +00:00
else if ( strcmp ( p , " mtu " ) = = 0 )
{
opt . dtls_mtu = atoi ( q ) ;
if ( opt . dtls_mtu < 0 )
goto usage ;
}
2018-08-14 12:28:56 +00:00
else if ( strcmp ( p , " dgram_packing " ) = = 0 )
{
opt . dgram_packing = atoi ( q ) ;
if ( opt . dgram_packing ! = 0 & &
opt . dgram_packing ! = 1 )
{
goto usage ;
}
}
2014-02-21 15:52:06 +00:00
else if ( strcmp ( p , " sni " ) = = 0 )
{
opt . sni = q ;
}
2018-10-16 20:08:38 +00:00
else if ( strcmp ( p , " query_config " ) = = 0 )
{
return query_config ( q ) ;
}
2019-05-29 10:33:32 +00:00
else if ( strcmp ( p , " serialize " ) = = 0 )
{
opt . serialize = atoi ( q ) ;
2019-06-06 07:40:52 +00:00
if ( opt . serialize < 0 | | opt . serialize > 2 )
2019-05-29 10:33:32 +00:00
goto usage ;
}
2019-05-12 08:03:32 +00:00
else if ( strcmp ( p , " eap_tls " ) = = 0 )
{
opt . eap_tls = atoi ( q ) ;
if ( opt . eap_tls < 0 | | opt . eap_tls > 1 )
goto usage ;
}
2019-06-06 19:24:31 +00:00
else if ( strcmp ( p , " reproducible " ) = = 0 )
{
opt . reproducible = 1 ;
}
2019-08-29 05:31:22 +00:00
else if ( strcmp ( p , " nss_keylog " ) = = 0 )
{
opt . nss_keylog = atoi ( q ) ;
if ( opt . nss_keylog < 0 | | opt . nss_keylog > 1 )
goto usage ;
}
else if ( strcmp ( p , " nss_keylog_file " ) = = 0 )
{
opt . nss_keylog_file = q ;
}
2012-09-25 09:05:17 +00:00
else
goto usage ;
}
2019-09-09 10:38:51 +00:00
if ( opt . nss_keylog ! = 0 & & opt . eap_tls ! = 0 )
{
mbedtls_printf ( " Error: eap_tls and nss_keylog options cannot be used together. \n " ) ;
goto usage ;
}
2017-10-10 14:56:37 +00:00
/* Event-driven IO is incompatible with the above custom
* receive and send functions , as the polling builds on
* refers to the underlying net_context . */
if ( opt . event = = 1 & & opt . nbio ! = 1 )
{
2017-10-27 12:43:58 +00:00
mbedtls_printf ( " Warning: event-driven IO mandates nbio=1 - overwrite \n " ) ;
2017-10-10 14:56:37 +00:00
opt . nbio = 1 ;
}
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_DEBUG_C)
mbedtls_debug_set_threshold ( opt . debug_level ) ;
2014-04-25 14:34:30 +00:00
# endif
2018-06-20 11:07:55 +00:00
buf = mbedtls_calloc ( 1 , opt . buffer_size + 1 ) ;
2017-10-12 11:50:29 +00:00
if ( buf = = NULL )
{
2018-06-20 12:17:04 +00:00
mbedtls_printf ( " Could not allocate %u bytes \n " , opt . buffer_size ) ;
2017-10-12 11:50:29 +00:00
ret = 3 ;
goto exit ;
}
2014-04-25 14:34:30 +00:00
2018-10-26 10:28:08 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
2018-11-15 13:06:09 +00:00
if ( opt . psk_opaque ! = 0 )
2018-10-26 10:28:08 +00:00
{
if ( strlen ( opt . psk ) = = 0 )
{
2018-11-15 13:06:09 +00:00
mbedtls_printf ( " psk_opaque set but no psk to be imported specified. \n " ) ;
2018-10-26 10:28:08 +00:00
ret = 2 ;
goto usage ;
}
if ( opt . force_ciphersuite [ 0 ] < = 0 )
{
mbedtls_printf ( " opaque PSKs are only supported in conjunction with forcing TLS 1.2 and a PSK-only ciphersuite through the 'force_ciphersuite' option. \n " ) ;
ret = 2 ;
goto usage ;
}
}
2018-11-15 13:06:09 +00:00
if ( opt . psk_list_opaque ! = 0 )
2018-10-26 10:28:08 +00:00
{
if ( opt . psk_list = = NULL )
{
mbedtls_printf ( " psk_slot set but no psk to be imported specified. \n " ) ;
ret = 2 ;
goto usage ;
}
if ( opt . force_ciphersuite [ 0 ] < = 0 )
{
mbedtls_printf ( " opaque PSKs are only supported in conjunction with forcing TLS 1.2 and a PSK-only ciphersuite through the 'force_ciphersuite' option. \n " ) ;
ret = 2 ;
goto usage ;
}
}
# endif /* MBEDTLS_USE_PSA_CRYPTO */
2013-06-29 14:01:32 +00:00
if ( opt . force_ciphersuite [ 0 ] > 0 )
{
2015-04-08 10:49:31 +00:00
const mbedtls_ssl_ciphersuite_t * ciphersuite_info ;
2017-10-10 14:59:57 +00:00
ciphersuite_info =
mbedtls_ssl_ciphersuite_from_id ( opt . force_ciphersuite [ 0 ] ) ;
2013-06-29 14:01:32 +00:00
2013-07-19 11:43:43 +00:00
if ( opt . max_version ! = - 1 & &
ciphersuite_info - > min_minor_ver > opt . max_version )
{
2017-10-10 14:59:57 +00:00
mbedtls_printf ( " forced ciphersuite not allowed with this protocol version \n " ) ;
2013-07-19 11:43:43 +00:00
ret = 2 ;
goto usage ;
}
if ( opt . min_version ! = - 1 & &
2013-06-29 14:01:32 +00:00
ciphersuite_info - > max_minor_ver < opt . min_version )
{
2017-10-10 14:59:57 +00:00
mbedtls_printf ( " forced ciphersuite not allowed with this protocol version \n " ) ;
2013-06-29 14:01:32 +00:00
ret = 2 ;
goto usage ;
}
2014-03-26 17:12:04 +00:00
/* If we select a version that's not supported by
* this suite , then there will be no common ciphersuite . . . */
if ( opt . max_version = = - 1 | |
opt . max_version > ciphersuite_info - > max_minor_ver )
{
2013-07-19 11:43:43 +00:00
opt . max_version = ciphersuite_info - > max_minor_ver ;
2014-03-26 17:12:04 +00:00
}
2013-07-19 11:43:43 +00:00
if ( opt . min_version < ciphersuite_info - > min_minor_ver )
2014-03-26 17:12:04 +00:00
{
2013-07-19 11:43:43 +00:00
opt . min_version = ciphersuite_info - > min_minor_ver ;
2014-03-26 17:12:04 +00:00
/* DTLS starts with TLS 1.1 */
2015-04-08 10:49:31 +00:00
if ( opt . transport = = MBEDTLS_SSL_TRANSPORT_DATAGRAM & &
opt . min_version < MBEDTLS_SSL_MINOR_VERSION_2 )
opt . min_version = MBEDTLS_SSL_MINOR_VERSION_2 ;
2014-03-26 17:12:04 +00:00
}
2015-03-20 19:44:04 +00:00
/* Enable RC4 if needed and not explicitly disabled */
2015-04-08 10:49:31 +00:00
if ( ciphersuite_info - > cipher = = MBEDTLS_CIPHER_ARC4_128 )
2015-03-20 19:44:04 +00:00
{
2015-04-08 10:49:31 +00:00
if ( opt . arc4 = = MBEDTLS_SSL_ARC4_DISABLED )
2015-03-20 19:44:04 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " forced RC4 ciphersuite with RC4 disabled \n " ) ;
2015-03-20 19:44:04 +00:00
ret = 2 ;
goto usage ;
}
2015-04-08 10:49:31 +00:00
opt . arc4 = MBEDTLS_SSL_ARC4_ENABLED ;
2015-03-20 19:44:04 +00:00
}
2018-10-26 10:28:08 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
2018-11-15 13:06:09 +00:00
if ( opt . psk_opaque ! = 0 | | opt . psk_list_opaque ! = 0 )
2018-10-26 10:28:08 +00:00
{
/* Ensure that the chosen ciphersuite is PSK-only; we must know
* the ciphersuite in advance to set the correct policy for the
* PSK key slot . This limitation might go away in the future . */
if ( ciphersuite_info - > key_exchange ! = MBEDTLS_KEY_EXCHANGE_PSK | |
opt . min_version ! = MBEDTLS_SSL_MINOR_VERSION_3 )
{
mbedtls_printf ( " opaque PSKs are only supported in conjunction with forcing TLS 1.2 and a PSK-only ciphersuite through the 'force_ciphersuite' option. \n " ) ;
ret = 2 ;
goto usage ;
}
/* Determine KDF algorithm the opaque PSK will be used in. */
# if defined(MBEDTLS_SHA512_C)
if ( ciphersuite_info - > mac = = MBEDTLS_MD_SHA384 )
alg = PSA_ALG_TLS12_PSK_TO_MS ( PSA_ALG_SHA_384 ) ;
else
# endif /* MBEDTLS_SHA512_C */
alg = PSA_ALG_TLS12_PSK_TO_MS ( PSA_ALG_SHA_256 ) ;
}
# endif /* MBEDTLS_USE_PSA_CRYPTO */
2013-06-29 14:01:32 +00:00
}
2014-06-11 11:50:34 +00:00
if ( opt . version_suites ! = NULL )
{
const char * name [ 4 ] = { 0 } ;
/* Parse 4-element coma-separated list */
for ( i = 0 , p = ( char * ) opt . version_suites ;
i < 4 & & * p ! = ' \0 ' ;
i + + )
{
name [ i ] = p ;
/* Terminate the current string and move on to next one */
while ( * p ! = ' , ' & & * p ! = ' \0 ' )
p + + ;
if ( * p = = ' , ' )
* p + + = ' \0 ' ;
}
if ( i ! = 4 )
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " too few values for version_suites \n " ) ;
2014-06-11 11:50:34 +00:00
ret = 1 ;
goto exit ;
}
memset ( version_suites , 0 , sizeof ( version_suites ) ) ;
/* Get the suites identifiers from their name */
for ( i = 0 ; i < 4 ; i + + )
{
2015-04-08 10:49:31 +00:00
version_suites [ i ] [ 0 ] = mbedtls_ssl_get_ciphersuite_id ( name [ i ] ) ;
2014-06-11 11:50:34 +00:00
if ( version_suites [ i ] [ 0 ] = = 0 )
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " unknown ciphersuite: '%s' \n " , name [ i ] ) ;
2014-06-11 11:50:34 +00:00
ret = 2 ;
goto usage ;
}
}
}
2019-05-15 13:03:01 +00:00
# if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
2019-05-03 16:30:59 +00:00
if ( unhexify ( cid , opt . cid_val , & cid_len ) ! = 0 )
{
mbedtls_printf ( " CID not valid hex \n " ) ;
goto exit ;
}
/* Keep CID settings for renegotiation unless
* specified otherwise . */
if ( opt . cid_enabled_renego = = DFL_CID_ENABLED_RENEGO )
opt . cid_enabled_renego = opt . cid_enabled ;
if ( opt . cid_val_renego = = DFL_CID_VALUE_RENEGO )
opt . cid_val_renego = opt . cid_val ;
if ( unhexify ( cid_renego , opt . cid_val_renego , & cid_renego_len ) ! = 0 )
{
mbedtls_printf ( " CID not valid hex \n " ) ;
goto exit ;
}
2019-05-15 13:03:01 +00:00
# endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
2019-04-09 16:28:10 +00:00
2020-03-10 11:19:08 +00:00
# if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
2013-04-17 17:10:21 +00:00
/*
2014-06-10 12:01:52 +00:00
* Unhexify the pre - shared key and parse the list if any given
2013-04-17 17:10:21 +00:00
*/
2014-06-10 12:01:52 +00:00
if ( unhexify ( psk , opt . psk , & psk_len ) ! = 0 )
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " pre-shared key not valid hex \n " ) ;
2014-06-10 12:01:52 +00:00
goto exit ;
}
if ( opt . psk_list ! = NULL )
2013-04-17 17:10:21 +00:00
{
2014-06-10 12:01:52 +00:00
if ( ( psk_info = psk_parse ( opt . psk_list ) ) = = NULL )
2013-04-17 17:10:21 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " psk_list invalid " ) ;
2013-04-17 17:10:21 +00:00
goto exit ;
}
}
2020-03-10 11:19:08 +00:00
# endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */
2013-04-17 17:10:21 +00:00
2017-05-15 15:05:15 +00:00
# if defined(MBEDTLS_ECP_C)
if ( opt . curves ! = NULL )
{
p = ( char * ) opt . curves ;
i = 0 ;
if ( strcmp ( p , " none " ) = = 0 )
{
curve_list [ 0 ] = MBEDTLS_ECP_DP_NONE ;
}
else if ( strcmp ( p , " default " ) ! = 0 )
{
/* Leave room for a final NULL in curve list */
2017-06-09 15:13:22 +00:00
while ( i < CURVE_LIST_SIZE - 1 & & * p ! = ' \0 ' )
2017-05-15 15:05:15 +00:00
{
q = p ;
/* Terminate the current string */
while ( * p ! = ' , ' & & * p ! = ' \0 ' )
p + + ;
if ( * p = = ' , ' )
* p + + = ' \0 ' ;
if ( ( curve_cur = mbedtls_ecp_curve_info_from_name ( q ) ) ! = NULL )
{
curve_list [ i + + ] = curve_cur - > grp_id ;
}
else
{
mbedtls_printf ( " unknown curve %s \n " , q ) ;
mbedtls_printf ( " supported curves: " ) ;
for ( curve_cur = mbedtls_ecp_curve_list ( ) ;
curve_cur - > grp_id ! = MBEDTLS_ECP_DP_NONE ;
curve_cur + + )
{
mbedtls_printf ( " %s " , curve_cur - > name ) ;
}
mbedtls_printf ( " \n " ) ;
goto exit ;
}
}
mbedtls_printf ( " Number of curves: %d \n " , i ) ;
2017-06-09 15:13:22 +00:00
if ( i = = CURVE_LIST_SIZE - 1 & & * p ! = ' \0 ' )
2017-05-15 15:05:15 +00:00
{
2017-06-09 15:13:22 +00:00
mbedtls_printf ( " curves list too long, maximum %d " ,
CURVE_LIST_SIZE - 1 ) ;
2017-05-15 15:05:15 +00:00
goto exit ;
}
curve_list [ i ] = MBEDTLS_ECP_DP_NONE ;
}
}
# endif /* MBEDTLS_ECP_C */
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_ALPN)
2014-04-05 12:34:07 +00:00
if ( opt . alpn_string ! = NULL )
{
p = ( char * ) opt . alpn_string ;
i = 0 ;
/* Leave room for a final NULL in alpn_list */
2017-06-09 15:13:22 +00:00
while ( i < ALPN_LIST_SIZE - 1 & & * p ! = ' \0 ' )
2014-04-05 12:34:07 +00:00
{
alpn_list [ i + + ] = p ;
/* Terminate the current string and move on to next one */
while ( * p ! = ' , ' & & * p ! = ' \0 ' )
p + + ;
if ( * p = = ' , ' )
* p + + = ' \0 ' ;
}
}
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_SSL_ALPN */
2014-04-05 12:34:07 +00:00
2012-09-25 09:05:17 +00:00
/*
* 0. Initialize the RNG and the session data
*/
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " \n . Seeding the random number generator... " ) ;
2012-09-25 09:05:17 +00:00
fflush ( stdout ) ;
2015-04-08 10:49:31 +00:00
mbedtls_entropy_init ( & entropy ) ;
2019-06-07 13:04:32 +00:00
if ( opt . reproducible )
2012-09-25 09:05:17 +00:00
{
2019-06-18 18:16:43 +00:00
srand ( 1 ) ;
2019-06-06 19:24:31 +00:00
if ( ( ret = mbedtls_ctr_drbg_seed ( & ctr_drbg , dummy_entropy ,
2019-06-07 13:04:32 +00:00
& entropy , ( const unsigned char * ) pers ,
strlen ( pers ) ) ) ! = 0 )
2019-06-06 19:24:31 +00:00
{
mbedtls_printf ( " failed \n ! mbedtls_ctr_drbg_seed returned -0x%x \n " ,
2019-06-07 13:04:32 +00:00
- ret ) ;
2019-06-06 19:24:31 +00:00
goto exit ;
}
2019-06-07 13:04:32 +00:00
}
else
{
2019-06-06 19:24:31 +00:00
if ( ( ret = mbedtls_ctr_drbg_seed ( & ctr_drbg , mbedtls_entropy_func ,
2019-06-07 13:04:32 +00:00
& entropy , ( const unsigned char * ) pers ,
strlen ( pers ) ) ) ! = 0 )
2019-06-06 19:24:31 +00:00
{
mbedtls_printf ( " failed \n ! mbedtls_ctr_drbg_seed returned -0x%x \n " ,
2019-06-07 13:04:32 +00:00
- ret ) ;
2019-06-06 19:24:31 +00:00
goto exit ;
}
2012-09-25 09:05:17 +00:00
}
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " ok \n " ) ;
2012-09-25 09:05:17 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_X509_CRT_PARSE_C)
2012-09-25 09:05:17 +00:00
/*
* 1.1 . Load the trusted CA
*/
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " . Loading the CA root certificate ... " ) ;
2012-09-25 09:05:17 +00:00
fflush ( stdout ) ;
2019-03-05 16:22:07 +00:00
if ( strcmp ( opt . ca_path , " none " ) = = 0 | |
strcmp ( opt . ca_file , " none " ) = = 0 )
{
ret = 0 ;
}
else
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_FS_IO)
2012-09-25 09:05:17 +00:00
if ( strlen ( opt . ca_path ) )
2019-03-05 16:22:07 +00:00
ret = mbedtls_x509_crt_parse_path ( & cacert , opt . ca_path ) ;
2012-09-25 09:05:17 +00:00
else if ( strlen ( opt . ca_file ) )
2019-03-05 16:22:07 +00:00
ret = mbedtls_x509_crt_parse_file ( & cacert , opt . ca_file ) ;
2013-09-18 11:46:23 +00:00
else
2012-09-25 09:05:17 +00:00
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_CERTS_C)
2019-02-01 08:13:19 +00:00
{
# if defined(MBEDTLS_PEM_PARSE_C)
2015-04-08 10:49:31 +00:00
for ( i = 0 ; mbedtls_test_cas [ i ] ! = NULL ; i + + )
2015-03-27 09:20:26 +00:00
{
2015-04-08 10:49:31 +00:00
ret = mbedtls_x509_crt_parse ( & cacert ,
( const unsigned char * ) mbedtls_test_cas [ i ] ,
mbedtls_test_cas_len [ i ] ) ;
2015-03-27 09:20:26 +00:00
if ( ret ! = 0 )
break ;
}
2019-02-01 08:13:19 +00:00
if ( ret = = 0 )
# endif /* MBEDTLS_PEM_PARSE_C */
for ( i = 0 ; mbedtls_test_cas_der [ i ] ! = NULL ; i + + )
{
ret = mbedtls_x509_crt_parse_der ( & cacert ,
( const unsigned char * ) mbedtls_test_cas_der [ i ] ,
mbedtls_test_cas_der_len [ i ] ) ;
if ( ret ! = 0 )
break ;
}
}
2012-09-25 09:05:17 +00:00
# else
{
ret = 1 ;
2018-12-05 16:49:42 +00:00
mbedtls_printf ( " MBEDTLS_CERTS_C not defined. " ) ;
2012-09-25 09:05:17 +00:00
}
2019-02-01 08:13:19 +00:00
# endif /* MBEDTLS_CERTS_C */
2012-09-25 09:05:17 +00:00
if ( ret < 0 )
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! mbedtls_x509_crt_parse returned -0x%x \n \n " , - ret ) ;
2012-09-25 09:05:17 +00:00
goto exit ;
}
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " ok (%d skipped) \n " , ret ) ;
2012-09-25 09:05:17 +00:00
/*
* 1.2 . Load own certificate and private key
*/
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " . Loading the server cert. and key... " ) ;
2012-09-25 09:05:17 +00:00
fflush ( stdout ) ;
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_FS_IO)
2014-02-27 12:35:00 +00:00
if ( strlen ( opt . crt_file ) & & strcmp ( opt . crt_file , " none " ) ! = 0 )
2013-09-24 19:14:51 +00:00
{
2013-09-25 12:05:49 +00:00
key_cert_init + + ;
2015-04-08 10:49:31 +00:00
if ( ( ret = mbedtls_x509_crt_parse_file ( & srvcert , opt . crt_file ) ) ! = 0 )
2013-09-25 09:35:15 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! mbedtls_x509_crt_parse_file returned -0x%x \n \n " ,
2013-09-25 09:35:15 +00:00
- ret ) ;
goto exit ;
}
2013-09-24 19:14:51 +00:00
}
2014-02-27 12:35:00 +00:00
if ( strlen ( opt . key_file ) & & strcmp ( opt . key_file , " none " ) ! = 0 )
2013-09-24 19:14:51 +00:00
{
2013-09-25 12:05:49 +00:00
key_cert_init + + ;
2015-04-08 10:49:31 +00:00
if ( ( ret = mbedtls_pk_parse_keyfile ( & pkey , opt . key_file , " " ) ) ! = 0 )
2013-09-25 09:35:15 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! mbedtls_pk_parse_keyfile returned -0x%x \n \n " , - ret ) ;
2013-09-25 09:35:15 +00:00
goto exit ;
}
2013-09-24 19:14:51 +00:00
}
2013-09-25 12:05:49 +00:00
if ( key_cert_init = = 1 )
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! crt_file without key_file or vice-versa \n \n " ) ;
2013-09-25 12:05:49 +00:00
goto exit ;
}
2014-02-27 12:35:00 +00:00
if ( strlen ( opt . crt_file2 ) & & strcmp ( opt . crt_file2 , " none " ) ! = 0 )
2013-09-24 19:14:51 +00:00
{
2013-09-25 12:05:49 +00:00
key_cert_init2 + + ;
2015-04-08 10:49:31 +00:00
if ( ( ret = mbedtls_x509_crt_parse_file ( & srvcert2 , opt . crt_file2 ) ) ! = 0 )
2013-09-25 09:35:15 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! mbedtls_x509_crt_parse_file(2) returned -0x%x \n \n " ,
2013-09-25 09:35:15 +00:00
- ret ) ;
goto exit ;
}
2013-09-24 19:14:51 +00:00
}
2014-02-27 12:35:00 +00:00
if ( strlen ( opt . key_file2 ) & & strcmp ( opt . key_file2 , " none " ) ! = 0 )
2013-09-24 19:14:51 +00:00
{
2013-09-25 12:05:49 +00:00
key_cert_init2 + + ;
2015-04-08 10:49:31 +00:00
if ( ( ret = mbedtls_pk_parse_keyfile ( & pkey2 , opt . key_file2 , " " ) ) ! = 0 )
2013-09-25 09:35:15 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! mbedtls_pk_parse_keyfile(2) returned -0x%x \n \n " ,
2017-10-27 12:43:58 +00:00
- ret ) ;
2013-09-25 09:35:15 +00:00
goto exit ;
}
2013-09-24 19:14:51 +00:00
}
2013-09-25 12:05:49 +00:00
if ( key_cert_init2 = = 1 )
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! crt_file2 without key_file2 or vice-versa \n \n " ) ;
2013-09-25 12:05:49 +00:00
goto exit ;
}
2013-09-24 19:14:51 +00:00
# endif
2014-02-27 12:35:00 +00:00
if ( key_cert_init = = 0 & &
strcmp ( opt . crt_file , " none " ) ! = 0 & &
strcmp ( opt . key_file , " none " ) ! = 0 & &
key_cert_init2 = = 0 & &
strcmp ( opt . crt_file2 , " none " ) ! = 0 & &
strcmp ( opt . key_file2 , " none " ) ! = 0 )
2013-09-24 19:14:51 +00:00
{
2015-04-08 10:49:31 +00:00
# if !defined(MBEDTLS_CERTS_C)
2017-10-27 12:43:58 +00:00
mbedtls_printf ( " Not certificated or key provided, and \n MBEDTLS_CERTS_C not defined! \n " ) ;
2013-09-24 19:14:51 +00:00
goto exit ;
2013-09-25 09:35:15 +00:00
# else
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_RSA_C)
if ( ( ret = mbedtls_x509_crt_parse ( & srvcert ,
( const unsigned char * ) mbedtls_test_srv_crt_rsa ,
mbedtls_test_srv_crt_rsa_len ) ) ! = 0 )
2013-09-25 09:35:15 +00:00
{
2017-10-27 12:43:58 +00:00
mbedtls_printf ( " failed \n ! mbedtls_x509_crt_parse returned -0x%x \n \n " ,
- ret ) ;
2013-09-25 09:35:15 +00:00
goto exit ;
}
2015-04-08 10:49:31 +00:00
if ( ( ret = mbedtls_pk_parse_key ( & pkey ,
( const unsigned char * ) mbedtls_test_srv_key_rsa ,
mbedtls_test_srv_key_rsa_len , NULL , 0 ) ) ! = 0 )
2013-09-25 09:35:15 +00:00
{
2017-10-27 12:43:58 +00:00
mbedtls_printf ( " failed \n ! mbedtls_pk_parse_key returned -0x%x \n \n " ,
- ret ) ;
2013-09-25 09:35:15 +00:00
goto exit ;
}
2013-09-25 12:05:49 +00:00
key_cert_init = 2 ;
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_RSA_C */
# if defined(MBEDTLS_ECDSA_C)
if ( ( ret = mbedtls_x509_crt_parse ( & srvcert2 ,
( const unsigned char * ) mbedtls_test_srv_crt_ec ,
mbedtls_test_srv_crt_ec_len ) ) ! = 0 )
2013-09-25 09:35:15 +00:00
{
2017-10-27 12:43:58 +00:00
mbedtls_printf ( " failed \n ! x509_crt_parse2 returned -0x%x \n \n " ,
- ret ) ;
2013-09-25 09:35:15 +00:00
goto exit ;
}
2015-04-08 10:49:31 +00:00
if ( ( ret = mbedtls_pk_parse_key ( & pkey2 ,
( const unsigned char * ) mbedtls_test_srv_key_ec ,
mbedtls_test_srv_key_ec_len , NULL , 0 ) ) ! = 0 )
2013-09-25 09:35:15 +00:00
{
2017-10-27 12:43:58 +00:00
mbedtls_printf ( " failed \n ! pk_parse_key2 returned -0x%x \n \n " ,
- ret ) ;
2013-09-25 09:35:15 +00:00
goto exit ;
}
2013-09-25 12:05:49 +00:00
key_cert_init2 = 2 ;
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_ECDSA_C */
# endif /* MBEDTLS_CERTS_C */
2013-09-25 09:35:15 +00:00
}
2012-09-25 09:05:17 +00:00
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " ok \n " ) ;
# endif /* MBEDTLS_X509_CRT_PARSE_C */
2012-09-25 09:05:17 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_FS_IO)
2014-06-09 09:29:50 +00:00
if ( opt . dhm_file ! = NULL )
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " . Loading DHM parameters... " ) ;
2014-06-09 09:29:50 +00:00
fflush ( stdout ) ;
2015-04-08 10:49:31 +00:00
if ( ( ret = mbedtls_dhm_parse_dhmfile ( & dhm , opt . dhm_file ) ) ! = 0 )
2014-06-09 09:29:50 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! mbedtls_dhm_parse_dhmfile returned -0x%04X \n \n " ,
2014-06-09 09:29:50 +00:00
- ret ) ;
goto exit ;
}
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " ok \n " ) ;
2014-06-09 09:29:50 +00:00
}
# endif
2015-04-03 14:41:52 +00:00
# if defined(SNI_OPTION)
2014-02-21 15:52:06 +00:00
if ( opt . sni ! = NULL )
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " . Setting up SNI information... " ) ;
2014-02-21 15:52:06 +00:00
fflush ( stdout ) ;
if ( ( sni_info = sni_parse ( opt . sni ) ) = = NULL )
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n " ) ;
2014-02-21 15:52:06 +00:00
goto exit ;
}
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " ok \n " ) ;
2014-02-21 15:52:06 +00:00
}
2015-04-03 14:41:52 +00:00
# endif /* SNI_OPTION */
2014-02-21 15:52:06 +00:00
2012-09-25 09:05:17 +00:00
/*
* 2. Setup the listening TCP socket
*/
2015-06-23 10:30:57 +00:00
mbedtls_printf ( " . Bind on %s://%s:%s/ ... " ,
2015-04-08 10:49:31 +00:00
opt . transport = = MBEDTLS_SSL_TRANSPORT_STREAM ? " tcp " : " udp " ,
2014-03-23 17:23:41 +00:00
opt . server_addr ? opt . server_addr : " * " ,
opt . server_port ) ;
2012-09-25 09:05:17 +00:00
fflush ( stdout ) ;
2015-04-08 10:49:31 +00:00
if ( ( ret = mbedtls_net_bind ( & listen_fd , opt . server_addr , opt . server_port ,
opt . transport = = MBEDTLS_SSL_TRANSPORT_STREAM ?
MBEDTLS_NET_PROTO_TCP : MBEDTLS_NET_PROTO_UDP ) ) ! = 0 )
2012-09-25 09:05:17 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! mbedtls_net_bind returned -0x%x \n \n " , - ret ) ;
2012-09-25 09:05:17 +00:00
goto exit ;
}
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " ok \n " ) ;
2012-09-25 09:05:17 +00:00
/*
* 3. Setup stuff
*/
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " . Setting up the SSL/TLS structure... " ) ;
2012-09-25 09:05:17 +00:00
fflush ( stdout ) ;
2015-05-04 17:32:36 +00:00
if ( ( ret = mbedtls_ssl_config_defaults ( & conf ,
MBEDTLS_SSL_IS_SERVER ,
2015-06-17 11:53:47 +00:00
opt . transport ,
MBEDTLS_SSL_PRESET_DEFAULT ) ) ! = 0 )
2015-05-04 12:56:36 +00:00
{
mbedtls_printf ( " failed \n ! mbedtls_ssl_config_defaults returned -0x%x \n \n " , - ret ) ;
goto exit ;
}
2017-05-05 16:59:02 +00:00
# if defined(MBEDTLS_X509_CRT_PARSE_C)
/* The default algorithms profile disables SHA-1, but our tests still
rely on it heavily . Hence we allow it here . A real - world server
should use the default profile unless there is a good reason not to . */
2017-05-09 13:59:24 +00:00
if ( opt . allow_sha1 > 0 )
{
crt_profile_for_test . allowed_mds | = MBEDTLS_X509_ID_FLAG ( MBEDTLS_MD_SHA1 ) ;
mbedtls_ssl_conf_cert_profile ( & conf , & crt_profile_for_test ) ;
2017-05-11 17:01:11 +00:00
mbedtls_ssl_conf_sig_hashes ( & conf , ssl_sig_hashes_for_test ) ;
2017-05-09 13:59:24 +00:00
}
2017-05-05 16:59:02 +00:00
# endif /* MBEDTLS_X509_CRT_PARSE_C */
2015-03-27 16:52:25 +00:00
if ( opt . auth_mode ! = DFL_AUTH_MODE )
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_authmode ( & conf , opt . auth_mode ) ;
2012-09-25 09:05:17 +00:00
2017-04-10 12:44:33 +00:00
if ( opt . cert_req_ca_list ! = DFL_CERT_REQ_CA_LIST )
mbedtls_ssl_conf_cert_req_ca_list ( & conf , opt . cert_req_ca_list ) ;
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_PROTO_DTLS)
2014-10-01 12:40:56 +00:00
if ( opt . hs_to_min ! = DFL_HS_TO_MIN | | opt . hs_to_max ! = DFL_HS_TO_MAX )
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_handshake_timeout ( & conf , opt . hs_to_min , opt . hs_to_max ) ;
2018-08-12 11:28:53 +00:00
2018-08-14 12:28:56 +00:00
if ( opt . dgram_packing ! = DFL_DGRAM_PACKING )
2018-08-24 10:13:57 +00:00
mbedtls_ssl_set_datagram_packing ( & ssl , opt . dgram_packing ) ;
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_SSL_PROTO_DTLS */
2014-10-01 12:40:56 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
2015-05-11 07:50:24 +00:00
if ( ( ret = mbedtls_ssl_conf_max_frag_len ( & conf , opt . mfl_code ) ) ! = 0 )
2014-07-08 12:05:52 +00:00
{
2015-05-11 07:50:24 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_conf_max_frag_len returned %d \n \n " , ret ) ;
2014-07-08 12:05:52 +00:00
goto exit ;
} ;
2013-08-15 11:33:48 +00:00
# endif
2013-07-18 12:07:36 +00:00
2019-05-15 13:03:01 +00:00
# if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
2019-05-03 16:30:59 +00:00
if ( opt . cid_enabled = = 1 | | opt . cid_enabled_renego = = 1 )
Add CID configuration API
Context:
The CID draft does not require that the length of CIDs used for incoming
records must not change in the course of a connection. Since the record
header does not contain a length field for the CID, this means that if
CIDs of varying lengths are used, the CID length must be inferred from
other aspects of the record header (such as the epoch) and/or by means
outside of the protocol, e.g. by coding its length in the CID itself.
Inferring the CID length from the record's epoch is theoretically possible
in DTLS 1.2, but it requires the information about the epoch to be present
even if the epoch is no longer used: That's because one should silently drop
records from old epochs, but not the entire datagrams to which they belong
(there might be entire flights in a single datagram, including a change of
epoch); however, in order to do so, one needs to parse the record's content
length, the position of which is only known once the CID length for the epoch
is known. In conclusion, it puts a significant burden on the implementation
to infer the CID length from the record epoch, which moreover mangles record
processing with the high-level logic of the protocol (determining which epochs
are in use in which flights, when they are changed, etc. -- this would normally
determine when we drop epochs).
Moreover, with DTLS 1.3, CIDs are no longer uniquely associated to epochs,
but every epoch may use a set of CIDs of varying lengths -- in that case,
it's even theoretically impossible to do record header parsing based on
the epoch configuration only.
We must therefore seek a way for standalone record header parsing, which
means that we must either (a) fix the CID lengths for incoming records,
or (b) allow the application-code to configure a callback to implement
an application-specific CID parsing which would somehow infer the length
of the CID from the CID itself.
Supporting multiple lengths for incoming CIDs significantly increases
complexity while, on the other hand, the restriction to a fixed CID length
for incoming CIDs (which the application controls - in contrast to the
lengths of the CIDs used when writing messages to the peer) doesn't
appear to severely limit the usefulness of the CID extension.
Therefore, the initial implementation of the CID feature will require
a fixed length for incoming CIDs, which is what this commit enforces,
in the following way:
In order to avoid a change of API in case support for variable lengths
CIDs shall be added at some point, we keep mbedtls_ssl_set_cid(), which
includes a CID length parameter, but add a new API mbedtls_ssl_conf_cid_len()
which applies to an SSL configuration, and which fixes the CID length that
any call to mbetls_ssl_set_cid() which applies to an SSL context that is bound
to the given SSL configuration must use.
While this creates a slight redundancy of parameters, it allows to
potentially add an API like mbedtls_ssl_conf_cid_len_cb() later which
could allow users to register a callback which dynamically infers the
length of a CID at record header parsing time, without changing the
rest of the API.
2019-05-03 12:06:44 +00:00
{
2019-05-03 16:30:59 +00:00
if ( opt . cid_enabled = = 1 & &
opt . cid_enabled_renego = = 1 & &
cid_len ! = cid_renego_len )
{
mbedtls_printf ( " CID length must not change during renegotiation \n " ) ;
goto usage ;
}
if ( opt . cid_enabled = = 1 )
2019-05-14 10:30:10 +00:00
ret = mbedtls_ssl_conf_cid ( & conf , cid_len ,
MBEDTLS_SSL_UNEXPECTED_CID_IGNORE ) ;
2019-05-03 16:30:59 +00:00
else
2019-05-14 10:30:10 +00:00
ret = mbedtls_ssl_conf_cid ( & conf , cid_renego_len ,
MBEDTLS_SSL_UNEXPECTED_CID_IGNORE ) ;
2019-05-03 16:30:59 +00:00
Add CID configuration API
Context:
The CID draft does not require that the length of CIDs used for incoming
records must not change in the course of a connection. Since the record
header does not contain a length field for the CID, this means that if
CIDs of varying lengths are used, the CID length must be inferred from
other aspects of the record header (such as the epoch) and/or by means
outside of the protocol, e.g. by coding its length in the CID itself.
Inferring the CID length from the record's epoch is theoretically possible
in DTLS 1.2, but it requires the information about the epoch to be present
even if the epoch is no longer used: That's because one should silently drop
records from old epochs, but not the entire datagrams to which they belong
(there might be entire flights in a single datagram, including a change of
epoch); however, in order to do so, one needs to parse the record's content
length, the position of which is only known once the CID length for the epoch
is known. In conclusion, it puts a significant burden on the implementation
to infer the CID length from the record epoch, which moreover mangles record
processing with the high-level logic of the protocol (determining which epochs
are in use in which flights, when they are changed, etc. -- this would normally
determine when we drop epochs).
Moreover, with DTLS 1.3, CIDs are no longer uniquely associated to epochs,
but every epoch may use a set of CIDs of varying lengths -- in that case,
it's even theoretically impossible to do record header parsing based on
the epoch configuration only.
We must therefore seek a way for standalone record header parsing, which
means that we must either (a) fix the CID lengths for incoming records,
or (b) allow the application-code to configure a callback to implement
an application-specific CID parsing which would somehow infer the length
of the CID from the CID itself.
Supporting multiple lengths for incoming CIDs significantly increases
complexity while, on the other hand, the restriction to a fixed CID length
for incoming CIDs (which the application controls - in contrast to the
lengths of the CIDs used when writing messages to the peer) doesn't
appear to severely limit the usefulness of the CID extension.
Therefore, the initial implementation of the CID feature will require
a fixed length for incoming CIDs, which is what this commit enforces,
in the following way:
In order to avoid a change of API in case support for variable lengths
CIDs shall be added at some point, we keep mbedtls_ssl_set_cid(), which
includes a CID length parameter, but add a new API mbedtls_ssl_conf_cid_len()
which applies to an SSL configuration, and which fixes the CID length that
any call to mbetls_ssl_set_cid() which applies to an SSL context that is bound
to the given SSL configuration must use.
While this creates a slight redundancy of parameters, it allows to
potentially add an API like mbedtls_ssl_conf_cid_len_cb() later which
could allow users to register a callback which dynamically infers the
length of a CID at record header parsing time, without changing the
rest of the API.
2019-05-03 12:06:44 +00:00
if ( ret ! = 0 )
{
2019-05-23 15:58:22 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_conf_cid_len returned -%#04x \n \n " ,
- ret ) ;
Add CID configuration API
Context:
The CID draft does not require that the length of CIDs used for incoming
records must not change in the course of a connection. Since the record
header does not contain a length field for the CID, this means that if
CIDs of varying lengths are used, the CID length must be inferred from
other aspects of the record header (such as the epoch) and/or by means
outside of the protocol, e.g. by coding its length in the CID itself.
Inferring the CID length from the record's epoch is theoretically possible
in DTLS 1.2, but it requires the information about the epoch to be present
even if the epoch is no longer used: That's because one should silently drop
records from old epochs, but not the entire datagrams to which they belong
(there might be entire flights in a single datagram, including a change of
epoch); however, in order to do so, one needs to parse the record's content
length, the position of which is only known once the CID length for the epoch
is known. In conclusion, it puts a significant burden on the implementation
to infer the CID length from the record epoch, which moreover mangles record
processing with the high-level logic of the protocol (determining which epochs
are in use in which flights, when they are changed, etc. -- this would normally
determine when we drop epochs).
Moreover, with DTLS 1.3, CIDs are no longer uniquely associated to epochs,
but every epoch may use a set of CIDs of varying lengths -- in that case,
it's even theoretically impossible to do record header parsing based on
the epoch configuration only.
We must therefore seek a way for standalone record header parsing, which
means that we must either (a) fix the CID lengths for incoming records,
or (b) allow the application-code to configure a callback to implement
an application-specific CID parsing which would somehow infer the length
of the CID from the CID itself.
Supporting multiple lengths for incoming CIDs significantly increases
complexity while, on the other hand, the restriction to a fixed CID length
for incoming CIDs (which the application controls - in contrast to the
lengths of the CIDs used when writing messages to the peer) doesn't
appear to severely limit the usefulness of the CID extension.
Therefore, the initial implementation of the CID feature will require
a fixed length for incoming CIDs, which is what this commit enforces,
in the following way:
In order to avoid a change of API in case support for variable lengths
CIDs shall be added at some point, we keep mbedtls_ssl_set_cid(), which
includes a CID length parameter, but add a new API mbedtls_ssl_conf_cid_len()
which applies to an SSL configuration, and which fixes the CID length that
any call to mbetls_ssl_set_cid() which applies to an SSL context that is bound
to the given SSL configuration must use.
While this creates a slight redundancy of parameters, it allows to
potentially add an API like mbedtls_ssl_conf_cid_len_cb() later which
could allow users to register a callback which dynamically infers the
length of a CID at record header parsing time, without changing the
rest of the API.
2019-05-03 12:06:44 +00:00
goto exit ;
}
}
2019-05-15 13:03:01 +00:00
# endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Add CID configuration API
Context:
The CID draft does not require that the length of CIDs used for incoming
records must not change in the course of a connection. Since the record
header does not contain a length field for the CID, this means that if
CIDs of varying lengths are used, the CID length must be inferred from
other aspects of the record header (such as the epoch) and/or by means
outside of the protocol, e.g. by coding its length in the CID itself.
Inferring the CID length from the record's epoch is theoretically possible
in DTLS 1.2, but it requires the information about the epoch to be present
even if the epoch is no longer used: That's because one should silently drop
records from old epochs, but not the entire datagrams to which they belong
(there might be entire flights in a single datagram, including a change of
epoch); however, in order to do so, one needs to parse the record's content
length, the position of which is only known once the CID length for the epoch
is known. In conclusion, it puts a significant burden on the implementation
to infer the CID length from the record epoch, which moreover mangles record
processing with the high-level logic of the protocol (determining which epochs
are in use in which flights, when they are changed, etc. -- this would normally
determine when we drop epochs).
Moreover, with DTLS 1.3, CIDs are no longer uniquely associated to epochs,
but every epoch may use a set of CIDs of varying lengths -- in that case,
it's even theoretically impossible to do record header parsing based on
the epoch configuration only.
We must therefore seek a way for standalone record header parsing, which
means that we must either (a) fix the CID lengths for incoming records,
or (b) allow the application-code to configure a callback to implement
an application-specific CID parsing which would somehow infer the length
of the CID from the CID itself.
Supporting multiple lengths for incoming CIDs significantly increases
complexity while, on the other hand, the restriction to a fixed CID length
for incoming CIDs (which the application controls - in contrast to the
lengths of the CIDs used when writing messages to the peer) doesn't
appear to severely limit the usefulness of the CID extension.
Therefore, the initial implementation of the CID feature will require
a fixed length for incoming CIDs, which is what this commit enforces,
in the following way:
In order to avoid a change of API in case support for variable lengths
CIDs shall be added at some point, we keep mbedtls_ssl_set_cid(), which
includes a CID length parameter, but add a new API mbedtls_ssl_conf_cid_len()
which applies to an SSL configuration, and which fixes the CID length that
any call to mbetls_ssl_set_cid() which applies to an SSL context that is bound
to the given SSL configuration must use.
While this creates a slight redundancy of parameters, it allows to
potentially add an API like mbedtls_ssl_conf_cid_len_cb() later which
could allow users to register a callback which dynamically infers the
length of a CID at record header parsing time, without changing the
rest of the API.
2019-05-03 12:06:44 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
2015-01-09 11:39:35 +00:00
if ( opt . trunc_hmac ! = DFL_TRUNC_HMAC )
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_truncated_hmac ( & conf , opt . trunc_hmac ) ;
2015-01-09 11:39:35 +00:00
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
2014-10-20 16:40:56 +00:00
if ( opt . extended_ms ! = DFL_EXTENDED_MS )
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_extended_master_secret ( & conf , opt . extended_ms ) ;
2014-10-20 16:40:56 +00:00
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
2014-10-27 12:57:03 +00:00
if ( opt . etm ! = DFL_ETM )
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_encrypt_then_mac ( & conf , opt . etm ) ;
2014-10-27 12:57:03 +00:00
# endif
2019-05-12 08:03:32 +00:00
# if defined(MBEDTLS_SSL_EXPORT_KEYS)
if ( opt . eap_tls ! = 0 )
2019-08-29 05:31:22 +00:00
{
2019-05-12 08:03:32 +00:00
mbedtls_ssl_conf_export_keys_ext_cb ( & conf , eap_tls_key_derivation ,
& eap_tls_keying ) ;
2019-08-29 05:31:22 +00:00
}
else if ( opt . nss_keylog ! = 0 )
{
mbedtls_ssl_conf_export_keys_ext_cb ( & conf ,
nss_keylog_export ,
NULL ) ;
}
2019-05-12 08:03:32 +00:00
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_ALPN)
2014-04-05 12:34:07 +00:00
if ( opt . alpn_string ! = NULL )
2015-05-11 07:50:24 +00:00
if ( ( ret = mbedtls_ssl_conf_alpn_protocols ( & conf , alpn_list ) ) ! = 0 )
2014-07-08 12:05:52 +00:00
{
2015-05-11 07:50:24 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_conf_alpn_protocols returned %d \n \n " , ret ) ;
2014-07-08 12:05:52 +00:00
goto exit ;
}
2014-04-05 12:34:07 +00:00
# endif
2019-06-07 13:04:32 +00:00
if ( opt . reproducible )
{
2019-06-11 14:02:43 +00:00
# if defined(MBEDTLS_HAVE_TIME)
2019-06-06 19:24:31 +00:00
# if defined(MBEDTLS_PLATFORM_TIME_ALT)
mbedtls_platform_set_time ( dummy_constant_time ) ;
# else
2019-06-11 10:11:36 +00:00
fprintf ( stderr , " Warning: reproducible option used without constant time \n " ) ;
2019-06-11 10:15:17 +00:00
# endif
2019-06-06 19:24:31 +00:00
# endif
2019-06-07 13:04:32 +00:00
}
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_rng ( & conf , mbedtls_ctr_drbg_random , & ctr_drbg ) ;
mbedtls_ssl_conf_dbg ( & conf , my_debug , stdout ) ;
2012-09-25 09:05:17 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_CACHE_C)
2014-02-20 20:32:41 +00:00
if ( opt . cache_max ! = - 1 )
2015-04-08 10:49:31 +00:00
mbedtls_ssl_cache_set_max_entries ( & cache , opt . cache_max ) ;
2014-02-20 20:32:41 +00:00
2014-02-20 21:50:56 +00:00
if ( opt . cache_timeout ! = - 1 )
2015-04-08 10:49:31 +00:00
mbedtls_ssl_cache_set_timeout ( & cache , opt . cache_timeout ) ;
2014-02-20 21:50:56 +00:00
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_session_cache ( & conf , & cache ,
2015-05-06 17:06:26 +00:00
mbedtls_ssl_cache_get ,
mbedtls_ssl_cache_set ) ;
2012-09-25 21:55:46 +00:00
# endif
2012-09-25 09:05:17 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_SESSION_TICKETS)
2015-05-19 13:28:00 +00:00
if ( opt . tickets = = MBEDTLS_SSL_SESSION_TICKETS_ENABLED )
2014-07-08 12:05:52 +00:00
{
2015-05-19 13:28:00 +00:00
if ( ( ret = mbedtls_ssl_ticket_setup ( & ticket_ctx ,
mbedtls_ctr_drbg_random , & ctr_drbg ,
2015-05-25 08:35:16 +00:00
MBEDTLS_CIPHER_AES_256_GCM ,
2015-05-19 13:28:00 +00:00
opt . ticket_timeout ) ) ! = 0 )
{
mbedtls_printf ( " failed \n ! mbedtls_ssl_ticket_setup returned %d \n \n " , ret ) ;
goto exit ;
}
2014-02-21 08:18:13 +00:00
2015-05-19 13:28:00 +00:00
mbedtls_ssl_conf_session_tickets_cb ( & conf ,
mbedtls_ssl_ticket_write ,
mbedtls_ssl_ticket_parse ,
& ticket_ctx ) ;
}
2013-08-14 11:48:06 +00:00
# endif
2013-08-03 11:02:31 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_PROTO_DTLS)
if ( opt . transport = = MBEDTLS_SSL_TRANSPORT_DATAGRAM )
2014-07-22 20:10:43 +00:00
{
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_COOKIE_C)
2014-07-23 17:34:59 +00:00
if ( opt . cookies > 0 )
2014-07-23 12:56:15 +00:00
{
2015-04-08 10:49:31 +00:00
if ( ( ret = mbedtls_ssl_cookie_setup ( & cookie_ctx ,
mbedtls_ctr_drbg_random , & ctr_drbg ) ) ! = 0 )
2014-07-23 17:34:59 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_cookie_setup returned %d \n \n " , ret ) ;
2014-07-23 17:34:59 +00:00
goto exit ;
}
2014-07-23 12:56:15 +00:00
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_dtls_cookies ( & conf , mbedtls_ssl_cookie_write , mbedtls_ssl_cookie_check ,
2014-07-23 17:34:59 +00:00
& cookie_ctx ) ;
}
else
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_SSL_COOKIE_C */
# if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
2014-07-23 17:34:59 +00:00
if ( opt . cookies = = 0 )
{
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_dtls_cookies ( & conf , NULL , NULL , NULL ) ;
2014-07-23 17:34:59 +00:00
}
else
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
2014-07-23 17:34:59 +00:00
{
; /* Nothing to do */
}
2014-09-24 12:41:11 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
2014-09-24 12:41:11 +00:00
if ( opt . anti_replay ! = DFL_ANTI_REPLAY )
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_dtls_anti_replay ( & conf , opt . anti_replay ) ;
2014-10-14 17:36:36 +00:00
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_DTLS_BADMAC_LIMIT)
2014-10-14 17:36:36 +00:00
if ( opt . badmac_limit ! = DFL_BADMAC_LIMIT )
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_dtls_badmac_limit ( & conf , opt . badmac_limit ) ;
2014-09-24 12:41:11 +00:00
# endif
2014-07-22 20:10:43 +00:00
}
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_SSL_PROTO_DTLS */
2014-07-22 20:10:43 +00:00
2013-03-20 13:39:14 +00:00
if ( opt . force_ciphersuite [ 0 ] ! = DFL_FORCE_CIPHER )
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_ciphersuites ( & conf , opt . force_ciphersuite ) ;
2015-03-20 19:44:04 +00:00
2015-05-14 10:28:21 +00:00
# if defined(MBEDTLS_ARC4_C)
2015-03-20 19:44:04 +00:00
if ( opt . arc4 ! = DFL_ARC4 )
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_arc4_support ( & conf , opt . arc4 ) ;
2015-05-14 10:28:21 +00:00
# endif
2012-09-25 09:05:17 +00:00
2014-06-11 11:50:34 +00:00
if ( opt . version_suites ! = NULL )
{
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_ciphersuites_for_version ( & conf , version_suites [ 0 ] ,
2015-04-08 10:49:31 +00:00
MBEDTLS_SSL_MAJOR_VERSION_3 ,
MBEDTLS_SSL_MINOR_VERSION_0 ) ;
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_ciphersuites_for_version ( & conf , version_suites [ 1 ] ,
2015-04-08 10:49:31 +00:00
MBEDTLS_SSL_MAJOR_VERSION_3 ,
MBEDTLS_SSL_MINOR_VERSION_1 ) ;
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_ciphersuites_for_version ( & conf , version_suites [ 2 ] ,
2015-04-08 10:49:31 +00:00
MBEDTLS_SSL_MAJOR_VERSION_3 ,
MBEDTLS_SSL_MINOR_VERSION_2 ) ;
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_ciphersuites_for_version ( & conf , version_suites [ 3 ] ,
2015-04-08 10:49:31 +00:00
MBEDTLS_SSL_MAJOR_VERSION_3 ,
MBEDTLS_SSL_MINOR_VERSION_3 ) ;
2014-06-11 11:50:34 +00:00
}
2014-11-03 19:10:36 +00:00
if ( opt . allow_legacy ! = DFL_ALLOW_LEGACY )
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_legacy_renegotiation ( & conf , opt . allow_legacy ) ;
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_RENEGOTIATION)
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_renegotiation ( & conf , opt . renegotiation ) ;
2014-11-05 13:23:03 +00:00
2014-07-04 12:32:27 +00:00
if ( opt . renego_delay ! = DFL_RENEGO_DELAY )
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_renegotiation_enforced ( & conf , opt . renego_delay ) ;
2012-09-25 09:05:17 +00:00
2014-11-05 13:23:03 +00:00
if ( opt . renego_period ! = DFL_RENEGO_PERIOD )
{
2017-01-19 16:30:57 +00:00
PUT_UINT64_BE ( renego_period , opt . renego_period , 0 ) ;
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_renegotiation_period ( & conf , renego_period ) ;
2014-11-05 13:23:03 +00:00
}
2014-11-03 07:23:14 +00:00
# endif
2012-09-25 09:05:17 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_X509_CRT_PARSE_C)
2014-02-27 12:35:00 +00:00
if ( strcmp ( opt . ca_path , " none " ) ! = 0 & &
strcmp ( opt . ca_file , " none " ) ! = 0 )
{
2019-03-27 15:55:27 +00:00
# if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
if ( opt . ca_callback ! = 0 )
mbedtls_ssl_conf_ca_cb ( & conf , ca_callback , & cacert ) ;
else
# endif
mbedtls_ssl_conf_ca_chain ( & conf , & cacert , NULL ) ;
2014-02-27 12:35:00 +00:00
}
2013-09-25 12:05:49 +00:00
if ( key_cert_init )
2018-01-05 20:15:57 +00:00
{
mbedtls_pk_context * pk = & pkey ;
2018-04-24 11:09:22 +00:00
# if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
2018-01-05 20:15:57 +00:00
if ( opt . async_private_delay1 > = 0 )
{
2018-06-13 16:09:28 +00:00
ret = ssl_async_set_key ( & ssl_async_keys , & srvcert , pk , 0 ,
2018-04-30 08:23:56 +00:00
opt . async_private_delay1 ) ;
if ( ret < 0 )
{
mbedtls_printf ( " Test error: ssl_async_set_key failed (%d) \n " ,
ret ) ;
goto exit ;
}
2018-01-05 20:15:57 +00:00
pk = NULL ;
}
2018-04-24 11:09:22 +00:00
# endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
2018-01-05 20:15:57 +00:00
if ( ( ret = mbedtls_ssl_conf_own_cert ( & conf , & srvcert , pk ) ) ! = 0 )
2014-07-08 12:05:52 +00:00
{
2015-05-11 07:50:24 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_conf_own_cert returned %d \n \n " , ret ) ;
2014-07-08 12:05:52 +00:00
goto exit ;
}
2018-01-05 20:15:57 +00:00
}
2013-09-25 12:05:49 +00:00
if ( key_cert_init2 )
2018-01-05 20:15:57 +00:00
{
mbedtls_pk_context * pk = & pkey2 ;
2018-04-24 11:09:22 +00:00
# if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
2018-01-05 20:15:57 +00:00
if ( opt . async_private_delay2 > = 0 )
{
2018-06-13 16:09:28 +00:00
ret = ssl_async_set_key ( & ssl_async_keys , & srvcert2 , pk , 0 ,
2018-04-30 08:23:56 +00:00
opt . async_private_delay2 ) ;
if ( ret < 0 )
{
mbedtls_printf ( " Test error: ssl_async_set_key failed (%d) \n " ,
ret ) ;
goto exit ;
}
2018-01-05 20:15:57 +00:00
pk = NULL ;
}
2018-04-24 11:09:22 +00:00
# endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
2018-01-05 20:15:57 +00:00
if ( ( ret = mbedtls_ssl_conf_own_cert ( & conf , & srvcert2 , pk ) ) ! = 0 )
2014-07-08 12:05:52 +00:00
{
2015-05-11 07:50:24 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_conf_own_cert returned %d \n \n " , ret ) ;
2014-07-08 12:05:52 +00:00
goto exit ;
}
2018-01-05 20:15:57 +00:00
}
2018-04-24 11:09:22 +00:00
# if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
2018-01-12 12:47:48 +00:00
if ( opt . async_operations [ 0 ] ! = ' - ' )
2018-01-05 20:15:57 +00:00
{
2018-01-12 12:47:48 +00:00
mbedtls_ssl_async_sign_t * sign = NULL ;
mbedtls_ssl_async_decrypt_t * decrypt = NULL ;
2018-04-24 10:32:04 +00:00
const char * r ;
for ( r = opt . async_operations ; * r ; r + + )
2018-01-12 12:47:48 +00:00
{
2018-04-24 10:32:04 +00:00
switch ( * r )
2018-01-12 12:47:48 +00:00
{
case ' d ' :
decrypt = ssl_async_decrypt ;
break ;
case ' s ' :
sign = ssl_async_sign ;
break ;
}
}
2018-01-08 10:28:05 +00:00
ssl_async_keys . inject_error = ( opt . async_private_error < 0 ?
- opt . async_private_error :
opt . async_private_error ) ;
2018-01-05 20:15:57 +00:00
ssl_async_keys . f_rng = mbedtls_ctr_drbg_random ;
ssl_async_keys . p_rng = & ctr_drbg ;
mbedtls_ssl_conf_async_private_cb ( & conf ,
2018-01-12 12:47:48 +00:00
sign ,
decrypt ,
2018-01-05 20:15:57 +00:00
ssl_async_resume ,
ssl_async_cancel ,
& ssl_async_keys ) ;
}
2018-04-24 11:09:22 +00:00
# endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
2018-01-05 20:15:57 +00:00
# endif /* MBEDTLS_X509_CRT_PARSE_C */
2013-04-18 20:46:23 +00:00
2015-04-03 14:41:52 +00:00
# if defined(SNI_OPTION)
2014-02-21 15:52:06 +00:00
if ( opt . sni ! = NULL )
2018-04-30 08:30:49 +00:00
{
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_sni ( & conf , sni_callback , sni_info ) ;
2018-04-30 08:30:49 +00:00
# if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
if ( opt . async_private_delay2 > = 0 )
{
2018-06-13 16:06:51 +00:00
sni_entry * cur ;
for ( cur = sni_info ; cur ! = NULL ; cur = cur - > next )
2018-04-30 08:30:49 +00:00
{
2018-06-13 16:06:51 +00:00
ret = ssl_async_set_key ( & ssl_async_keys ,
2018-06-13 16:09:28 +00:00
cur - > cert , cur - > key , 1 ,
2018-06-13 16:06:51 +00:00
opt . async_private_delay2 ) ;
if ( ret < 0 )
{
mbedtls_printf ( " Test error: ssl_async_set_key failed (%d) \n " ,
ret ) ;
goto exit ;
}
cur - > key = NULL ;
2018-04-30 08:30:49 +00:00
}
}
# endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
}
2014-02-21 15:52:06 +00:00
# endif
2017-05-15 15:05:15 +00:00
# if defined(MBEDTLS_ECP_C)
if ( opt . curves ! = NULL & &
strcmp ( opt . curves , " default " ) ! = 0 )
{
mbedtls_ssl_conf_curves ( & conf , curve_list ) ;
}
# endif
2020-03-10 11:19:08 +00:00
# if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
2018-10-26 10:28:08 +00:00
2014-06-10 13:24:51 +00:00
if ( strlen ( opt . psk ) ! = 0 & & strlen ( opt . psk_identity ) ! = 0 )
{
2018-10-26 10:28:08 +00:00
# if defined(MBEDTLS_USE_PSA_CRYPTO)
2018-11-15 13:06:09 +00:00
if ( opt . psk_opaque ! = 0 )
2018-10-26 10:28:08 +00:00
{
2018-11-15 13:06:09 +00:00
/* The algorithm has already been determined earlier. */
2019-08-08 10:38:18 +00:00
status = psa_setup_psk_key_slot ( & psk_slot , alg , psk , psk_len ) ;
2018-11-15 13:06:09 +00:00
if ( status ! = PSA_SUCCESS )
{
fprintf ( stderr , " SETUP FAIL \n " ) ;
ret = MBEDTLS_ERR_SSL_HW_ACCEL_FAILED ;
goto exit ;
}
if ( ( ret = mbedtls_ssl_conf_psk_opaque ( & conf , psk_slot ,
( const unsigned char * ) opt . psk_identity ,
strlen ( opt . psk_identity ) ) ) ! = 0 )
2018-10-26 10:28:08 +00:00
{
mbedtls_printf ( " failed \n ! mbedtls_ssl_conf_psk_opaque returned %d \n \n " ,
ret ) ;
goto exit ;
}
}
else
# endif /* MBEDTLS_USE_PSA_CRYPTO */
2019-11-20 13:54:36 +00:00
if ( psk_len > 0 )
2014-06-10 13:24:51 +00:00
{
2019-11-20 13:54:36 +00:00
ret = mbedtls_ssl_conf_psk ( & conf , psk , psk_len ,
( const unsigned char * ) opt . psk_identity ,
strlen ( opt . psk_identity ) ) ;
if ( ret ! = 0 )
{
mbedtls_printf ( " failed \n mbedtls_ssl_conf_psk returned -0x%04X \n \n " , - ret ) ;
goto exit ;
}
2014-06-10 13:24:51 +00:00
}
}
2014-06-10 12:01:52 +00:00
if ( opt . psk_list ! = NULL )
2018-10-26 10:28:08 +00:00
{
# if defined(MBEDTLS_USE_PSA_CRYPTO)
2018-11-15 13:06:09 +00:00
if ( opt . psk_list_opaque ! = 0 )
2018-10-26 10:28:08 +00:00
{
psk_entry * cur_psk ;
for ( cur_psk = psk_info ; cur_psk ! = NULL ; cur_psk = cur_psk - > next )
{
2018-11-15 13:06:09 +00:00
2019-08-08 10:38:18 +00:00
status = psa_setup_psk_key_slot ( & cur_psk - > slot , alg ,
2018-10-26 10:28:08 +00:00
cur_psk - > key ,
cur_psk - > key_len ) ;
if ( status ! = PSA_SUCCESS )
{
ret = MBEDTLS_ERR_SSL_HW_ACCEL_FAILED ;
goto exit ;
}
}
}
# endif /* MBEDTLS_USE_PSA_CRYPTO */
2018-11-15 13:06:09 +00:00
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_psk_cb ( & conf , psk_callback , psk_info ) ;
2018-10-26 10:28:08 +00:00
}
2013-04-18 20:46:23 +00:00
# endif
2012-09-25 09:05:17 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_DHM_C)
2012-09-28 07:33:00 +00:00
/*
* Use different group than default DHM group
*/
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_FS_IO)
2014-06-09 09:29:50 +00:00
if ( opt . dhm_file ! = NULL )
2015-05-11 07:50:24 +00:00
ret = mbedtls_ssl_conf_dh_param_ctx ( & conf , & dhm ) ;
2014-06-09 09:29:50 +00:00
# endif
if ( ret ! = 0 )
{
2015-05-11 07:50:24 +00:00
mbedtls_printf ( " failed \n mbedtls_ssl_conf_dh_param returned -0x%04X \n \n " , - ret ) ;
2014-06-09 09:29:50 +00:00
goto exit ;
}
2012-09-25 09:05:17 +00:00
# endif
2015-03-31 12:21:11 +00:00
if ( opt . min_version ! = DFL_MIN_VERSION )
2015-05-11 08:11:56 +00:00
mbedtls_ssl_conf_min_version ( & conf , MBEDTLS_SSL_MAJOR_VERSION_3 , opt . min_version ) ;
2012-09-28 13:28:45 +00:00
2015-03-31 12:21:11 +00:00
if ( opt . max_version ! = DFL_MIN_VERSION )
2015-05-11 08:11:56 +00:00
mbedtls_ssl_conf_max_version ( & conf , MBEDTLS_SSL_MAJOR_VERSION_3 , opt . max_version ) ;
2013-06-29 14:01:32 +00:00
2015-05-11 09:25:46 +00:00
if ( ( ret = mbedtls_ssl_setup ( & ssl , & conf ) ) ! = 0 )
{
mbedtls_printf ( " failed \n ! mbedtls_ssl_setup returned -0x%x \n \n " , - ret ) ;
goto exit ;
}
2019-07-03 16:05:43 +00:00
io_ctx . ssl = & ssl ;
io_ctx . net = & client_fd ;
mbedtls_ssl_set_bio ( & ssl , & io_ctx , send_cb , recv_cb ,
opt . nbio = = 0 ? recv_timeout_cb : NULL ) ;
2015-05-11 09:25:46 +00:00
2019-05-15 13:03:01 +00:00
# if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
2019-04-09 16:28:10 +00:00
if ( opt . transport = = MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
if ( ( ret = mbedtls_ssl_set_cid ( & ssl , opt . cid_enabled ,
cid , cid_len ) ) ! = 0 )
{
mbedtls_printf ( " failed \n ! mbedtls_ssl_set_cid returned %d \n \n " ,
ret ) ;
goto exit ;
}
}
2019-05-15 13:03:01 +00:00
# endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
2019-04-09 16:28:10 +00:00
2018-08-20 08:37:23 +00:00
# if defined(MBEDTLS_SSL_PROTO_DTLS)
if ( opt . dtls_mtu ! = DFL_DTLS_MTU )
mbedtls_ssl_set_mtu ( & ssl , opt . dtls_mtu ) ;
# endif
2015-05-13 11:58:56 +00:00
# if defined(MBEDTLS_TIMING_C)
2015-05-13 08:04:32 +00:00
mbedtls_ssl_set_timer_cb ( & ssl , & timer , mbedtls_timing_set_delay ,
mbedtls_timing_get_delay ) ;
2015-05-13 11:58:56 +00:00
# endif
2015-05-13 08:04:32 +00:00
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " ok \n " ) ;
2012-09-25 09:05:17 +00:00
reset :
2014-09-20 10:03:00 +00:00
# if !defined(_WIN32)
if ( received_sigterm )
{
2018-01-22 09:55:10 +00:00
mbedtls_printf ( " interrupted by SIGTERM (not in net_accept()) \n " ) ;
if ( ret = = MBEDTLS_ERR_NET_INVALID_CONTEXT )
ret = 0 ;
2014-09-20 10:03:00 +00:00
goto exit ;
}
# endif
2015-09-08 09:58:14 +00:00
if ( ret = = MBEDTLS_ERR_SSL_CLIENT_RECONNECT )
{
mbedtls_printf ( " ! Client initiated reconnection from same port \n " ) ;
goto handshake ;
}
2015-04-08 10:49:31 +00:00
# ifdef MBEDTLS_ERROR_C
2012-09-25 09:05:17 +00:00
if ( ret ! = 0 )
{
char error_buf [ 100 ] ;
2015-04-08 10:49:31 +00:00
mbedtls_strerror ( ret , error_buf , 100 ) ;
mbedtls_printf ( " Last error was: %d - %s \n \n " , ret , error_buf ) ;
2012-09-25 09:05:17 +00:00
}
# endif
2015-06-30 13:55:03 +00:00
mbedtls_net_free ( & client_fd ) ;
2014-03-23 17:23:41 +00:00
2015-04-08 10:49:31 +00:00
mbedtls_ssl_session_reset ( & ssl ) ;
2012-09-25 09:05:17 +00:00
/*
* 3. Wait until a client connects
*/
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " . Waiting for a remote connection ... " ) ;
2012-09-25 09:05:17 +00:00
fflush ( stdout ) ;
2015-06-30 13:40:39 +00:00
if ( ( ret = mbedtls_net_accept ( & listen_fd , & client_fd ,
2015-05-14 19:52:40 +00:00
client_ip , sizeof ( client_ip ) , & cliip_len ) ) ! = 0 )
2012-09-25 09:05:17 +00:00
{
2014-08-18 09:05:51 +00:00
# if !defined(_WIN32)
2014-08-14 13:36:12 +00:00
if ( received_sigterm )
{
2018-01-22 09:55:10 +00:00
mbedtls_printf ( " interrupted by SIGTERM (in net_accept()) \n " ) ;
if ( ret = = MBEDTLS_ERR_NET_ACCEPT_FAILED )
ret = 0 ;
2014-08-14 13:36:12 +00:00
goto exit ;
}
2014-08-18 09:05:51 +00:00
# endif
2014-08-14 13:36:12 +00:00
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! mbedtls_net_accept returned -0x%x \n \n " , - ret ) ;
2012-09-25 09:05:17 +00:00
goto exit ;
}
2014-02-26 12:47:08 +00:00
if ( opt . nbio > 0 )
2015-06-30 13:40:39 +00:00
ret = mbedtls_net_set_nonblock ( & client_fd ) ;
2014-02-26 12:47:08 +00:00
else
2015-06-30 13:40:39 +00:00
ret = mbedtls_net_set_block ( & client_fd ) ;
2014-02-26 12:47:08 +00:00
if ( ret ! = 0 )
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! net_set_(non)block() returned -0x%x \n \n " , - ret ) ;
2014-02-26 12:47:08 +00:00
goto exit ;
}
2015-05-11 07:50:24 +00:00
mbedtls_ssl_conf_read_timeout ( & conf , opt . read_timeout ) ;
2012-09-25 09:05:17 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
if ( opt . transport = = MBEDTLS_SSL_TRANSPORT_DATAGRAM )
2014-07-22 15:57:43 +00:00
{
2015-05-14 19:52:40 +00:00
if ( ( ret = mbedtls_ssl_set_client_transport_id ( & ssl ,
client_ip , cliip_len ) ) ! = 0 )
2014-07-22 15:57:43 +00:00
{
2017-10-27 12:43:58 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_set_client_transport_id() returned -0x%x \n \n " ,
- ret ) ;
2014-07-22 15:57:43 +00:00
goto exit ;
}
}
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
2014-07-22 15:57:43 +00:00
2015-09-16 09:08:34 +00:00
# if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
if ( opt . ecjpake_pw ! = DFL_ECJPAKE_PW )
{
if ( ( ret = mbedtls_ssl_set_hs_ecjpake_password ( & ssl ,
( const unsigned char * ) opt . ecjpake_pw ,
strlen ( opt . ecjpake_pw ) ) ) ! = 0 )
{
mbedtls_printf ( " failed \n ! mbedtls_ssl_set_hs_ecjpake_password returned %d \n \n " , ret ) ;
goto exit ;
}
}
# endif
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " ok \n " ) ;
2012-09-25 09:05:17 +00:00
/*
* 4. Handshake
*/
2015-09-08 09:58:14 +00:00
handshake :
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " . Performing the SSL/TLS handshake... " ) ;
2012-09-25 09:05:17 +00:00
fflush ( stdout ) ;
2017-10-10 14:56:37 +00:00
while ( ( ret = mbedtls_ssl_handshake ( & ssl ) ) ! = 0 )
2018-01-05 20:15:57 +00:00
{
2018-04-24 11:09:22 +00:00
# if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
2018-01-05 20:15:57 +00:00
if ( ret = = MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS & &
2018-01-08 10:28:05 +00:00
ssl_async_keys . inject_error = = SSL_ASYNC_INJECT_ERROR_CANCEL )
2018-01-05 20:15:57 +00:00
{
mbedtls_printf ( " cancelling on injected error \n " ) ;
2018-01-08 10:28:05 +00:00
break ;
2018-01-05 20:15:57 +00:00
}
2018-04-24 11:09:22 +00:00
# endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
Merge branch 'mbedtls_ssl_get_key_exchange_md_ssl_tls-return_hashlen' into tls_async_server-2.9
Conflict resolution:
* ChangeLog: put the new entry from my branch in the proper place.
* include/mbedtls/error.h: counted high-level module error codes again.
* include/mbedtls/ssl.h: picked different numeric codes for the
concurrently added errors; made the new error a full sentence per
current standards.
* library/error.c: ran scripts/generate_errors.pl.
* library/ssl_srv.c:
* ssl_prepare_server_key_exchange "DHE key exchanges": the conflict
was due to style corrections in development
(4cb1f4d49cff999d0c853bc696ad7eea68888c35) which I merged with
my refactoring.
* ssl_prepare_server_key_exchange "For key exchanges involving the
server signing", first case, variable declarations: merged line
by line:
* dig_signed_len: added in async
* signature_len: removed in async
* hashlen: type changed to size_t in development
* hash: size changed to MBEDTLS_MD_MAX_SIZE in async
* ret: added in async
* ssl_prepare_server_key_exchange "For key exchanges involving the
server signing", first cae comment: the conflict was due to style
corrections in development (4cb1f4d49cff999d0c853bc696ad7eea68888c35)
which I merged with my comment changes made as part of refactoring
the function.
* ssl_prepare_server_key_exchange "Compute the hash to be signed" if
`md_alg != MBEDTLS_MD_NONE`: conflict between
ebd652fe2dfc2c82d774bfd334398279d9027492
"ssl_write_server_key_exchange: calculate hashlen explicitly" and
46f5a3e9b4d5db3cacfe2ba33480a27317c62d46 "Check return codes from
MD in ssl code". I took the code from commit
ca1d74290439ec9e2723a911657fd96aa320e219 made on top of development
which makes mbedtls_ssl_get_key_exchange_md_ssl_tls return the
hash length.
* programs/ssl/ssl_server2.c: multiple conflicts between the introduction
of MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS and new auxiliary functions and
definitions for async support, and the introduction of idle().
* definitions before main: concurrent additions, kept both.
* main, just after `handshake:`: in the loop around
mbedtls_ssl_handshake(), merge the addition of support for
MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS and SSL_ASYNC_INJECT_ERROR_CANCEL
with the addition of the idle() call.
* main, if `opt.transport == MBEDTLS_SSL_TRANSPORT_STREAM`: take the
code from development and add a check for
MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS.
* main, loop around mbedtls_ssl_read() in the datagram case:
take the code from development and add a check for
MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS; revert to a do...while loop.
* main, loop around mbedtls_ssl_write() in the datagram case:
take the code from development and add a check for
MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS; revert to a do...while loop.
2018-04-24 10:18:19 +00:00
2018-04-26 06:05:02 +00:00
if ( ! mbedtls_status_is_ssl_in_progress ( ret ) )
2017-10-10 14:56:37 +00:00
break ;
/* For event-driven IO, wait for socket to become available */
if ( opt . event = = 1 /* level triggered IO */ )
{
# if defined(MBEDTLS_TIMING_C)
2018-03-15 11:35:07 +00:00
ret = idle ( & client_fd , & timer , ret ) ;
2017-10-10 14:56:37 +00:00
# else
2018-03-15 11:35:07 +00:00
ret = idle ( & client_fd , ret ) ;
2017-10-10 14:56:37 +00:00
# endif
2018-03-15 11:35:07 +00:00
if ( ret ! = 0 )
goto reset ;
2017-10-10 14:56:37 +00:00
}
2018-01-05 20:15:57 +00:00
}
2014-10-13 17:04:37 +00:00
2015-04-08 10:49:31 +00:00
if ( ret = = MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED )
2012-09-25 09:05:17 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " hello verification requested \n " ) ;
2014-10-13 17:04:37 +00:00
ret = 0 ;
goto reset ;
}
else if ( ret ! = 0 )
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_handshake returned -0x%x \n \n " , - ret ) ;
2015-06-22 14:50:52 +00:00
# if defined(MBEDTLS_X509_CRT_PARSE_C)
if ( ret = = MBEDTLS_ERR_X509_CERT_VERIFY_FAILED )
{
char vrfy_buf [ 512 ] ;
2015-08-27 10:02:40 +00:00
flags = mbedtls_ssl_get_verify_result ( & ssl ) ;
2015-06-22 14:50:52 +00:00
mbedtls_x509_crt_verify_info ( vrfy_buf , sizeof ( vrfy_buf ) , " ! " , flags ) ;
mbedtls_printf ( " %s \n " , vrfy_buf ) ;
}
# endif
2018-04-24 11:09:22 +00:00
# if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
2018-01-08 10:28:05 +00:00
if ( opt . async_private_error < 0 )
/* Injected error only the first time round, to test reset */
ssl_async_keys . inject_error = SSL_ASYNC_INJECT_ERROR_NONE ;
# endif
2014-10-13 17:04:37 +00:00
goto reset ;
}
else /* ret == 0 */
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " ok \n [ Protocol is %s ] \n [ Ciphersuite is %s ] \n " ,
mbedtls_ssl_get_version ( & ssl ) , mbedtls_ssl_get_ciphersuite ( & ssl ) ) ;
2012-09-25 09:05:17 +00:00
}
2015-04-08 10:49:31 +00:00
if ( ( ret = mbedtls_ssl_get_record_expansion ( & ssl ) ) > = 0 )
mbedtls_printf ( " [ Record expansion is %d ] \n " , ret ) ;
2014-10-14 15:47:31 +00:00
else
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " [ Record expansion is unknown (compression) ] \n " ) ;
2014-10-14 15:47:31 +00:00
2015-08-31 16:30:52 +00:00
# if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
mbedtls_printf ( " [ Maximum fragment length is %u ] \n " ,
( unsigned int ) mbedtls_ssl_get_max_frag_len ( & ssl ) ) ;
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_ALPN)
2014-04-05 12:34:07 +00:00
if ( opt . alpn_string ! = NULL )
{
2015-04-08 10:49:31 +00:00
const char * alp = mbedtls_ssl_get_alpn_protocol ( & ssl ) ;
mbedtls_printf ( " [ Application Layer Protocol is %s ] \n " ,
2014-04-05 12:34:07 +00:00
alp ? alp : " (none) " ) ;
}
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_X509_CRT_PARSE_C)
2012-09-25 09:05:17 +00:00
/*
2017-06-20 12:23:23 +00:00
* 5. Verify the client certificate
2012-09-25 09:05:17 +00:00
*/
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " . Verifying peer X.509 certificate... " ) ;
2012-09-25 09:05:17 +00:00
2015-05-11 17:54:43 +00:00
if ( ( flags = mbedtls_ssl_get_verify_result ( & ssl ) ) ! = 0 )
2012-09-25 09:05:17 +00:00
{
2015-04-20 09:56:18 +00:00
char vrfy_buf [ 512 ] ;
2012-09-25 09:05:17 +00:00
2015-04-20 09:56:18 +00:00
mbedtls_printf ( " failed \n " ) ;
2012-09-25 09:05:17 +00:00
2015-05-11 17:54:43 +00:00
mbedtls_x509_crt_verify_info ( vrfy_buf , sizeof ( vrfy_buf ) , " ! " , flags ) ;
2012-09-25 09:05:17 +00:00
2015-04-20 09:56:18 +00:00
mbedtls_printf ( " %s \n " , vrfy_buf ) ;
2012-09-25 09:05:17 +00:00
}
else
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " ok \n " ) ;
2012-09-25 09:05:17 +00:00
2015-06-27 12:38:51 +00:00
if ( mbedtls_ssl_get_peer_cert ( & ssl ) ! = NULL )
2012-09-25 09:05:17 +00:00
{
2015-06-27 12:38:51 +00:00
char crt_buf [ 512 ] ;
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " . Peer certificate information ... \n " ) ;
2015-06-27 12:38:51 +00:00
mbedtls_x509_crt_info ( crt_buf , sizeof ( crt_buf ) , " " ,
2015-04-08 10:49:31 +00:00
mbedtls_ssl_get_peer_cert ( & ssl ) ) ;
2015-07-02 09:15:48 +00:00
mbedtls_printf ( " %s \n " , crt_buf ) ;
2012-09-25 09:05:17 +00:00
}
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_X509_CRT_PARSE_C */
2012-09-25 09:05:17 +00:00
2019-05-12 08:03:32 +00:00
# if defined(MBEDTLS_SSL_EXPORT_KEYS)
2019-05-12 11:54:30 +00:00
if ( opt . eap_tls ! = 0 )
2019-05-12 08:03:32 +00:00
{
size_t j = 0 ;
2019-05-12 11:54:30 +00:00
if ( ( ret = mbedtls_ssl_tls_prf ( eap_tls_keying . tls_prf_type ,
eap_tls_keying . master_secret ,
sizeof ( eap_tls_keying . master_secret ) ,
eap_tls_label ,
eap_tls_keying . randbytes ,
sizeof ( eap_tls_keying . randbytes ) ,
eap_tls_keymaterial ,
sizeof ( eap_tls_keymaterial ) ) )
! = 0 )
{
mbedtls_printf ( " failed \n ! mbedtls_ssl_tls_prf returned -0x%x \n \n " ,
- ret ) ;
goto exit ;
}
2019-05-12 08:03:32 +00:00
mbedtls_printf ( " EAP-TLS key material is: " ) ;
for ( j = 0 ; j < sizeof ( eap_tls_keymaterial ) ; j + + )
{
if ( j % 8 = = 0 )
mbedtls_printf ( " \n " ) ;
mbedtls_printf ( " %02x " , eap_tls_keymaterial [ j ] ) ;
}
mbedtls_printf ( " \n " ) ;
2019-05-12 11:54:30 +00:00
if ( ( ret = mbedtls_ssl_tls_prf ( eap_tls_keying . tls_prf_type , NULL , 0 ,
2019-05-15 14:49:54 +00:00
eap_tls_label ,
eap_tls_keying . randbytes ,
sizeof ( eap_tls_keying . randbytes ) ,
eap_tls_iv ,
sizeof ( eap_tls_iv ) ) ) ! = 0 )
2019-05-12 11:54:30 +00:00
{
mbedtls_printf ( " failed \n ! mbedtls_ssl_tls_prf returned -0x%x \n \n " ,
- ret ) ;
goto exit ;
}
2019-05-12 08:03:32 +00:00
mbedtls_printf ( " EAP-TLS IV is: " ) ;
for ( j = 0 ; j < sizeof ( eap_tls_iv ) ; j + + )
{
if ( j % 8 = = 0 )
mbedtls_printf ( " \n " ) ;
mbedtls_printf ( " %02x " , eap_tls_iv [ j ] ) ;
}
mbedtls_printf ( " \n " ) ;
}
# endif
2019-04-09 16:28:10 +00:00
2019-05-15 13:03:01 +00:00
# if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
2019-05-03 16:30:59 +00:00
ret = report_cid_usage ( & ssl , " initial handshake " ) ;
if ( ret ! = 0 )
goto exit ;
2019-04-09 16:28:10 +00:00
if ( opt . transport = = MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
2019-05-03 16:30:59 +00:00
if ( ( ret = mbedtls_ssl_set_cid ( & ssl , opt . cid_enabled_renego ,
cid_renego , cid_renego_len ) ) ! = 0 )
2019-04-09 16:28:10 +00:00
{
2019-05-03 16:30:59 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_set_cid returned %d \n \n " ,
ret ) ;
2019-04-09 16:28:10 +00:00
goto exit ;
}
}
2019-05-15 13:03:01 +00:00
# endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
2019-04-09 16:28:10 +00:00
2019-11-26 15:32:40 +00:00
# if defined(MBEDTLS_MEMORY_DEBUG)
mbedtls_memory_buffer_alloc_cur_get ( & current_heap_memory , & heap_blocks ) ;
mbedtls_memory_buffer_alloc_max_get ( & peak_heap_memory , & heap_blocks ) ;
mbedtls_printf ( " Heap memory usage after handshake: %lu bytes. Peak memory usage was %lu \n " ,
( unsigned long ) current_heap_memory , ( unsigned long ) peak_heap_memory ) ;
# endif /* MBEDTLS_MEMORY_DEBUG */
2014-10-09 13:33:13 +00:00
if ( opt . exchanges = = 0 )
goto close_notify ;
2015-01-22 10:33:29 +00:00
exchanges_left = opt . exchanges ;
2014-08-15 10:07:38 +00:00
data_exchange :
2012-09-25 09:05:17 +00:00
/*
* 6. Read the HTTP Request
*/
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " < Read from client: " ) ;
2012-09-25 09:05:17 +00:00
fflush ( stdout ) ;
2014-10-06 16:11:43 +00:00
/*
* TLS and DTLS need different reading styles ( stream vs datagram )
*/
2015-04-08 10:49:31 +00:00
if ( opt . transport = = MBEDTLS_SSL_TRANSPORT_STREAM )
2014-10-06 16:11:43 +00:00
{
do
{
int terminated = 0 ;
2017-10-12 11:50:29 +00:00
len = opt . buffer_size - 1 ;
memset ( buf , 0 , opt . buffer_size ) ;
2015-04-08 10:49:31 +00:00
ret = mbedtls_ssl_read ( & ssl , buf , len ) ;
2014-10-06 16:11:43 +00:00
2018-04-26 06:05:02 +00:00
if ( mbedtls_status_is_ssl_in_progress ( ret ) )
2017-10-10 14:56:37 +00:00
{
if ( opt . event = = 1 /* level triggered IO */ )
{
# if defined(MBEDTLS_TIMING_C)
2017-10-31 10:58:53 +00:00
idle ( & client_fd , & timer , ret ) ;
2017-10-10 14:56:37 +00:00
# else
2017-10-31 10:58:53 +00:00
idle ( & client_fd , ret ) ;
2017-10-10 14:56:37 +00:00
# endif
}
2014-10-06 16:11:43 +00:00
continue ;
2017-10-10 14:56:37 +00:00
}
2014-10-06 16:11:43 +00:00
if ( ret < = 0 )
{
switch ( ret )
{
2015-04-08 10:49:31 +00:00
case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY :
mbedtls_printf ( " connection was closed gracefully \n " ) ;
2014-10-06 16:11:43 +00:00
goto close_notify ;
case 0 :
2015-04-08 10:49:31 +00:00
case MBEDTLS_ERR_NET_CONN_RESET :
mbedtls_printf ( " connection was reset by peer \n " ) ;
ret = MBEDTLS_ERR_NET_CONN_RESET ;
2014-10-06 16:11:43 +00:00
goto reset ;
default :
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " mbedtls_ssl_read returned -0x%x \n " , - ret ) ;
2014-10-06 16:11:43 +00:00
goto reset ;
}
}
2015-04-08 10:49:31 +00:00
if ( mbedtls_ssl_get_bytes_avail ( & ssl ) = = 0 )
2014-10-06 16:11:43 +00:00
{
len = ret ;
buf [ len ] = ' \0 ' ;
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " %d bytes read \n \n %s \n " , len , ( char * ) buf ) ;
2014-10-06 16:11:43 +00:00
/* End of message should be detected according to the syntax of the
* application protocol ( eg HTTP ) , just use a dummy test here . */
if ( buf [ len - 1 ] = = ' \n ' )
terminated = 1 ;
}
else
{
int extra_len , ori_len ;
unsigned char * larger_buf ;
ori_len = ret ;
2015-07-01 13:51:43 +00:00
extra_len = ( int ) mbedtls_ssl_get_bytes_avail ( & ssl ) ;
2014-10-06 16:11:43 +00:00
2015-05-26 14:04:06 +00:00
larger_buf = mbedtls_calloc ( 1 , ori_len + extra_len + 1 ) ;
2014-10-06 16:11:43 +00:00
if ( larger_buf = = NULL )
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " ! memory allocation failed \n " ) ;
2014-10-06 16:11:43 +00:00
ret = 1 ;
goto reset ;
}
memset ( larger_buf , 0 , ori_len + extra_len ) ;
memcpy ( larger_buf , buf , ori_len ) ;
/* This read should never fail and get the whole cached data */
2015-04-08 10:49:31 +00:00
ret = mbedtls_ssl_read ( & ssl , larger_buf + ori_len , extra_len ) ;
2014-10-06 16:11:43 +00:00
if ( ret ! = extra_len | |
2015-04-08 10:49:31 +00:00
mbedtls_ssl_get_bytes_avail ( & ssl ) ! = 0 )
2014-10-06 16:11:43 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " ! mbedtls_ssl_read failed on cached data \n " ) ;
2014-10-06 16:11:43 +00:00
ret = 1 ;
goto reset ;
}
larger_buf [ ori_len + extra_len ] = ' \0 ' ;
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " %u bytes read (%u + %u) \n \n %s \n " ,
2014-10-06 16:11:43 +00:00
ori_len + extra_len , ori_len , extra_len ,
( char * ) larger_buf ) ;
/* End of message should be detected according to the syntax of the
* application protocol ( eg HTTP ) , just use a dummy test here . */
if ( larger_buf [ ori_len + extra_len - 1 ] = = ' \n ' )
terminated = 1 ;
2015-04-08 10:49:31 +00:00
mbedtls_free ( larger_buf ) ;
2014-10-06 16:11:43 +00:00
}
if ( terminated )
{
ret = 0 ;
break ;
}
}
while ( 1 ) ;
}
else /* Not stream, so datagram */
2012-09-25 09:05:17 +00:00
{
2017-10-12 11:50:29 +00:00
len = opt . buffer_size - 1 ;
memset ( buf , 0 , opt . buffer_size ) ;
2012-09-25 09:05:17 +00:00
Merge branch 'mbedtls_ssl_get_key_exchange_md_ssl_tls-return_hashlen' into tls_async_server-2.9
Conflict resolution:
* ChangeLog: put the new entry from my branch in the proper place.
* include/mbedtls/error.h: counted high-level module error codes again.
* include/mbedtls/ssl.h: picked different numeric codes for the
concurrently added errors; made the new error a full sentence per
current standards.
* library/error.c: ran scripts/generate_errors.pl.
* library/ssl_srv.c:
* ssl_prepare_server_key_exchange "DHE key exchanges": the conflict
was due to style corrections in development
(4cb1f4d49cff999d0c853bc696ad7eea68888c35) which I merged with
my refactoring.
* ssl_prepare_server_key_exchange "For key exchanges involving the
server signing", first case, variable declarations: merged line
by line:
* dig_signed_len: added in async
* signature_len: removed in async
* hashlen: type changed to size_t in development
* hash: size changed to MBEDTLS_MD_MAX_SIZE in async
* ret: added in async
* ssl_prepare_server_key_exchange "For key exchanges involving the
server signing", first cae comment: the conflict was due to style
corrections in development (4cb1f4d49cff999d0c853bc696ad7eea68888c35)
which I merged with my comment changes made as part of refactoring
the function.
* ssl_prepare_server_key_exchange "Compute the hash to be signed" if
`md_alg != MBEDTLS_MD_NONE`: conflict between
ebd652fe2dfc2c82d774bfd334398279d9027492
"ssl_write_server_key_exchange: calculate hashlen explicitly" and
46f5a3e9b4d5db3cacfe2ba33480a27317c62d46 "Check return codes from
MD in ssl code". I took the code from commit
ca1d74290439ec9e2723a911657fd96aa320e219 made on top of development
which makes mbedtls_ssl_get_key_exchange_md_ssl_tls return the
hash length.
* programs/ssl/ssl_server2.c: multiple conflicts between the introduction
of MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS and new auxiliary functions and
definitions for async support, and the introduction of idle().
* definitions before main: concurrent additions, kept both.
* main, just after `handshake:`: in the loop around
mbedtls_ssl_handshake(), merge the addition of support for
MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS and SSL_ASYNC_INJECT_ERROR_CANCEL
with the addition of the idle() call.
* main, if `opt.transport == MBEDTLS_SSL_TRANSPORT_STREAM`: take the
code from development and add a check for
MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS.
* main, loop around mbedtls_ssl_read() in the datagram case:
take the code from development and add a check for
MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS; revert to a do...while loop.
* main, loop around mbedtls_ssl_write() in the datagram case:
take the code from development and add a check for
MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS; revert to a do...while loop.
2018-04-24 10:18:19 +00:00
do
2017-10-10 14:56:37 +00:00
{
2018-03-13 11:39:09 +00:00
/* Without the call to `mbedtls_ssl_check_pending`, it might
* happen that the client sends application data in the same
* datagram as the Finished message concluding the handshake .
* In this case , the application data would be ready to be
* processed while the underlying transport wouldn ' t signal
* any further incoming data .
*
* See the test ' Event - driven I / O : session - id resume , UDP packing '
* in tests / ssl - opt . sh .
*/
2017-10-10 14:56:37 +00:00
/* For event-driven IO, wait for socket to become available */
2018-03-13 11:39:09 +00:00
if ( mbedtls_ssl_check_pending ( & ssl ) = = 0 & &
opt . event = = 1 /* level triggered IO */ )
2017-10-10 14:56:37 +00:00
{
# if defined(MBEDTLS_TIMING_C)
2018-03-13 11:39:09 +00:00
idle ( & client_fd , & timer , MBEDTLS_ERR_SSL_WANT_READ ) ;
2017-10-10 14:56:37 +00:00
# else
2018-03-13 11:39:09 +00:00
idle ( & client_fd , MBEDTLS_ERR_SSL_WANT_READ ) ;
2017-10-10 14:56:37 +00:00
# endif
}
2018-03-13 11:39:09 +00:00
ret = mbedtls_ssl_read ( & ssl , buf , len ) ;
/* Note that even if `mbedtls_ssl_check_pending` returns true,
* it can happen that the subsequent call to ` mbedtls_ssl_read `
* returns ` MBEDTLS_ERR_SSL_WANT_READ ` , because the pending messages
* might be discarded ( e . g . because they are retransmissions ) . */
2017-10-10 14:56:37 +00:00
}
2018-04-26 06:05:02 +00:00
while ( mbedtls_status_is_ssl_in_progress ( ret ) ) ;
2012-09-25 09:05:17 +00:00
if ( ret < = 0 )
{
switch ( ret )
{
2015-04-08 10:49:31 +00:00
case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY :
mbedtls_printf ( " connection was closed gracefully \n " ) ;
2014-10-06 16:11:43 +00:00
ret = 0 ;
2014-08-16 09:28:40 +00:00
goto close_notify ;
2012-09-25 09:05:17 +00:00
default :
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " mbedtls_ssl_read returned -0x%x \n " , - ret ) ;
2014-08-15 10:07:38 +00:00
goto reset ;
2012-09-25 09:05:17 +00:00
}
}
2014-10-06 16:11:43 +00:00
len = ret ;
buf [ len ] = ' \0 ' ;
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " %d bytes read \n \n %s " , len , ( char * ) buf ) ;
2014-10-06 16:11:43 +00:00
ret = 0 ;
2012-09-25 09:05:17 +00:00
}
/*
2014-08-15 10:07:38 +00:00
* 7 a . Request renegotiation while client is waiting for input from us .
2014-10-15 10:44:41 +00:00
* ( only on the first exchange , to be able to test retransmission )
2012-09-25 09:05:17 +00:00
*/
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_RENEGOTIATION)
2015-01-22 13:30:33 +00:00
if ( opt . renegotiate & & exchanges_left = = opt . exchanges )
2014-08-19 10:59:03 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " . Requestion renegotiation... " ) ;
2014-08-19 10:59:03 +00:00
fflush ( stdout ) ;
2014-08-15 10:07:38 +00:00
2015-04-08 10:49:31 +00:00
while ( ( ret = mbedtls_ssl_renegotiate ( & ssl ) ) ! = 0 )
2014-08-19 10:59:03 +00:00
{
2018-04-26 06:05:02 +00:00
if ( ! mbedtls_status_is_ssl_in_progress ( ret ) )
2014-08-19 10:59:03 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_renegotiate returned %d \n \n " , ret ) ;
2014-08-19 10:59:03 +00:00
goto reset ;
}
2017-10-10 14:56:37 +00:00
/* For event-driven IO, wait for socket to become available */
if ( opt . event = = 1 /* level triggered IO */ )
{
# if defined(MBEDTLS_TIMING_C)
2017-10-31 10:58:53 +00:00
idle ( & client_fd , & timer , ret ) ;
2017-10-10 14:56:37 +00:00
# else
2017-10-31 10:58:53 +00:00
idle ( & client_fd , ret ) ;
2017-10-10 14:56:37 +00:00
# endif
}
2014-08-19 10:59:03 +00:00
}
2014-08-15 10:07:38 +00:00
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " ok \n " ) ;
2014-08-19 10:59:03 +00:00
}
2015-04-08 10:49:31 +00:00
# endif /* MBEDTLS_SSL_RENEGOTIATION */
2014-08-19 10:59:03 +00:00
2019-05-15 13:03:01 +00:00
# if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
2019-05-03 16:30:59 +00:00
ret = report_cid_usage ( & ssl , " after renegotiation " ) ;
if ( ret ! = 0 )
goto exit ;
2019-05-15 13:03:01 +00:00
# endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
2019-05-03 16:30:59 +00:00
2014-08-15 10:07:38 +00:00
/*
* 7. Write the 200 Response
*/
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " > Write to client: " ) ;
2012-09-25 09:05:17 +00:00
fflush ( stdout ) ;
len = sprintf ( ( char * ) buf , HTTP_RESPONSE ,
2015-04-08 10:49:31 +00:00
mbedtls_ssl_get_ciphersuite ( & ssl ) ) ;
2012-09-25 09:05:17 +00:00
2017-10-12 11:50:29 +00:00
/* Add padding to the response to reach opt.response_size in length */
if ( opt . response_size ! = DFL_RESPONSE_SIZE & &
len < opt . response_size )
{
memset ( buf + len , ' B ' , opt . response_size - len ) ;
len + = opt . response_size - len ;
}
/* Truncate if response size is smaller than the "natural" size */
if ( opt . response_size ! = DFL_RESPONSE_SIZE & &
len > opt . response_size )
{
len = opt . response_size ;
/* Still end with \r\n unless that's really not possible */
if ( len > = 2 ) buf [ len - 2 ] = ' \r ' ;
if ( len > = 1 ) buf [ len - 1 ] = ' \n ' ;
}
2015-04-08 10:49:31 +00:00
if ( opt . transport = = MBEDTLS_SSL_TRANSPORT_STREAM )
2012-09-25 09:05:17 +00:00
{
2014-10-13 16:38:36 +00:00
for ( written = 0 , frags = 0 ; written < len ; written + = ret , frags + + )
2012-09-25 09:05:17 +00:00
{
2015-04-08 10:49:31 +00:00
while ( ( ret = mbedtls_ssl_write ( & ssl , buf + written , len - written ) )
2014-10-13 16:38:36 +00:00
< = 0 )
2013-07-17 13:34:17 +00:00
{
2015-04-08 10:49:31 +00:00
if ( ret = = MBEDTLS_ERR_NET_CONN_RESET )
2014-10-13 16:38:36 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! peer closed the connection \n \n " ) ;
2014-10-13 16:38:36 +00:00
goto reset ;
}
2012-09-25 09:05:17 +00:00
2018-04-26 06:05:02 +00:00
if ( ! mbedtls_status_is_ssl_in_progress ( ret ) )
2014-10-13 16:38:36 +00:00
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_write returned %d \n \n " , ret ) ;
2014-10-13 16:38:36 +00:00
goto reset ;
}
2017-10-10 14:56:37 +00:00
/* For event-driven IO, wait for socket to become available */
if ( opt . event = = 1 /* level triggered IO */ )
{
# if defined(MBEDTLS_TIMING_C)
2017-10-31 10:58:53 +00:00
idle ( & client_fd , & timer , ret ) ;
2017-10-10 14:56:37 +00:00
# else
2017-10-31 10:58:53 +00:00
idle ( & client_fd , ret ) ;
2017-10-10 14:56:37 +00:00
# endif
}
2013-07-17 13:34:17 +00:00
}
2012-09-25 09:05:17 +00:00
}
}
2014-10-13 16:38:36 +00:00
else /* Not stream, so datagram */
{
2017-10-10 14:56:37 +00:00
while ( 1 )
{
ret = mbedtls_ssl_write ( & ssl , buf , len ) ;
2018-04-26 06:05:02 +00:00
if ( ! mbedtls_status_is_ssl_in_progress ( ret ) )
2017-10-10 14:56:37 +00:00
break ;
/* For event-driven IO, wait for socket to become available */
if ( opt . event = = 1 /* level triggered IO */ )
{
# if defined(MBEDTLS_TIMING_C)
2017-10-31 10:58:53 +00:00
idle ( & client_fd , & timer , ret ) ;
2017-10-10 14:56:37 +00:00
# else
2017-10-31 10:58:53 +00:00
idle ( & client_fd , ret ) ;
2017-10-10 14:56:37 +00:00
# endif
}
}
2014-10-13 16:38:36 +00:00
if ( ret < 0 )
{
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_write returned %d \n \n " , ret ) ;
2014-10-13 16:38:36 +00:00
goto reset ;
}
frags = 1 ;
written = ret ;
}
2012-09-25 09:05:17 +00:00
2013-07-17 13:34:17 +00:00
buf [ written ] = ' \0 ' ;
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " %d bytes written in %d fragments \n \n %s \n " , written , frags , ( char * ) buf ) ;
2015-01-14 09:46:08 +00:00
ret = 0 ;
2014-02-20 16:19:59 +00:00
2014-08-15 10:07:38 +00:00
/*
2019-05-29 12:41:21 +00:00
* 7 b . Simulate serialize / deserialize and go back to data exchange
*/
2019-06-04 08:06:31 +00:00
# if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
2019-06-06 07:40:52 +00:00
if ( opt . serialize ! = 0 )
2019-05-29 12:41:21 +00:00
{
2019-06-06 12:10:07 +00:00
size_t buf_len ;
2019-05-29 12:41:21 +00:00
2019-07-12 08:41:55 +00:00
mbedtls_printf ( " . Serializing live connection... " ) ;
2019-05-29 12:41:21 +00:00
2019-06-06 12:10:07 +00:00
ret = mbedtls_ssl_context_save ( & ssl , NULL , 0 , & buf_len ) ;
2019-07-12 08:41:55 +00:00
if ( ret ! = MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL )
2019-05-29 12:41:21 +00:00
{
2019-06-04 12:36:18 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_context_save returned "
" -0x%x \n \n " , - ret ) ;
2019-05-29 12:41:21 +00:00
goto exit ;
}
2019-06-06 12:10:07 +00:00
if ( ( context_buf = mbedtls_calloc ( 1 , buf_len ) ) = = NULL )
2019-05-29 12:41:21 +00:00
{
2019-06-04 12:36:18 +00:00
mbedtls_printf ( " failed \n ! Couldn't allocate buffer for "
" serialized context " ) ;
2019-05-29 12:41:21 +00:00
goto exit ;
}
2019-07-15 08:31:11 +00:00
context_buf_len = buf_len ;
2019-05-29 12:41:21 +00:00
2019-06-13 09:22:50 +00:00
if ( ( ret = mbedtls_ssl_context_save ( & ssl , context_buf ,
buf_len , & buf_len ) ) ! = 0 )
2019-05-29 12:41:21 +00:00
{
2019-07-12 08:41:55 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_context_save returned "
2019-06-04 12:36:18 +00:00
" -0x%x \n \n " , - ret ) ;
2019-05-29 12:41:21 +00:00
goto exit ;
}
2019-07-12 08:41:55 +00:00
mbedtls_printf ( " ok \n " ) ;
/*
* This simulates a workflow where you have a long - lived server
* instance , potentially with a pool of ssl_context objects , and you
* just want to re - use one while the connection is inactive : in that
* case you can just reset ( ) it , and then it ' s ready to receive
* serialized data from another connection ( or the same here ) .
*/
if ( opt . serialize = = 1 )
{
2019-07-23 12:51:09 +00:00
/* nothing to do here, done by context_save() already */
mbedtls_printf ( " . Context has been reset... ok " ) ;
2019-07-12 08:41:55 +00:00
}
/*
* This simulates a workflow where you have one server instance per
* connection , and want to release it entire when the connection is
* inactive , and spawn it again when needed again - this would happen
* between ssl_free ( ) and ssl_init ( ) below , together with any other
* teardown / startup code needed - for example , preparing the
* ssl_config again ( see section 3 " setup stuff " in this file ) .
*/
2019-06-06 07:40:52 +00:00
if ( opt . serialize = = 2 )
{
2019-07-12 08:41:55 +00:00
mbedtls_printf ( " . Freeing and reinitializing context... " ) ;
2019-06-06 07:40:52 +00:00
mbedtls_ssl_free ( & ssl ) ;
mbedtls_ssl_init ( & ssl ) ;
if ( ( ret = mbedtls_ssl_setup ( & ssl , & conf ) ) ! = 0 )
{
2019-06-13 09:22:50 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_setup returned "
" -0x%x \n \n " , - ret ) ;
2019-06-06 07:40:52 +00:00
goto exit ;
}
2019-07-12 08:41:55 +00:00
/*
* This illustrates the minimum amount of things you need to set
* up , however you could set up much more if desired , for example
* if you want to share your set up code between the case of
* establishing a new connection and this case .
*/
2019-06-06 07:40:52 +00:00
if ( opt . nbio = = 2 )
2019-06-13 09:22:50 +00:00
mbedtls_ssl_set_bio ( & ssl , & client_fd , delayed_send ,
delayed_recv , NULL ) ;
2019-06-06 07:40:52 +00:00
else
2019-06-13 09:22:50 +00:00
mbedtls_ssl_set_bio ( & ssl , & client_fd , mbedtls_net_send ,
mbedtls_net_recv ,
opt . nbio = = 0 ? mbedtls_net_recv_timeout : NULL ) ;
2019-06-06 07:40:52 +00:00
2019-06-13 08:45:06 +00:00
# if defined(MBEDTLS_TIMING_C)
2019-06-13 09:22:50 +00:00
mbedtls_ssl_set_timer_cb ( & ssl , & timer ,
mbedtls_timing_set_delay ,
mbedtls_timing_get_delay ) ;
2019-06-13 08:45:06 +00:00
# endif /* MBEDTLS_TIMING_C */
2019-07-12 08:41:55 +00:00
mbedtls_printf ( " ok \n " ) ;
2019-06-06 07:40:52 +00:00
}
2019-07-12 08:41:55 +00:00
mbedtls_printf ( " . Deserializing connection... " ) ;
2019-05-29 12:41:21 +00:00
2019-06-13 09:22:50 +00:00
if ( ( ret = mbedtls_ssl_context_load ( & ssl , context_buf ,
buf_len ) ) ! = 0 )
2019-05-29 12:41:21 +00:00
{
2019-06-04 12:36:18 +00:00
mbedtls_printf ( " failed \n ! mbedtls_ssl_context_load returned "
" -0x%x \n \n " , - ret ) ;
2019-05-29 12:41:21 +00:00
goto exit ;
}
2019-07-12 08:41:55 +00:00
2019-07-15 08:31:11 +00:00
mbedtls_free ( context_buf ) ;
context_buf = NULL ;
context_buf_len = 0 ;
2019-07-12 08:41:55 +00:00
mbedtls_printf ( " ok \n " ) ;
2019-05-29 12:41:21 +00:00
}
2019-06-04 12:36:18 +00:00
# endif /* MBEDTLS_SSL_CONTEXT_SERIALIZATION */
2019-05-29 12:41:21 +00:00
/*
* 7 c . Continue doing data exchanges ?
2014-08-15 10:07:38 +00:00
*/
2015-01-22 10:33:29 +00:00
if ( - - exchanges_left > 0 )
2014-08-15 10:07:38 +00:00
goto data_exchange ;
2013-10-29 17:17:41 +00:00
2014-08-16 09:28:40 +00:00
/*
2014-08-15 10:07:38 +00:00
* 8. Done , cleanly close the connection
2014-08-16 09:28:40 +00:00
*/
close_notify :
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " . Closing the connection... " ) ;
2014-03-25 10:24:43 +00:00
2014-10-09 17:56:44 +00:00
/* No error checking, the connection might be closed already */
2015-04-08 10:49:31 +00:00
do ret = mbedtls_ssl_close_notify ( & ssl ) ;
2015-05-06 15:19:31 +00:00
while ( ret = = MBEDTLS_ERR_SSL_WANT_WRITE ) ;
2014-10-09 17:56:44 +00:00
ret = 0 ;
2014-08-16 09:28:40 +00:00
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " done \n " ) ;
2015-01-19 14:26:37 +00:00
2012-09-25 09:05:17 +00:00
goto reset ;
2014-08-16 09:28:40 +00:00
/*
* Cleanup and exit
*/
2012-09-25 09:05:17 +00:00
exit :
2015-04-08 10:49:31 +00:00
# ifdef MBEDTLS_ERROR_C
2012-09-25 09:05:17 +00:00
if ( ret ! = 0 )
{
char error_buf [ 100 ] ;
2015-04-08 10:49:31 +00:00
mbedtls_strerror ( ret , error_buf , 100 ) ;
mbedtls_printf ( " Last error was: -0x%X - %s \n \n " , - ret , error_buf ) ;
2012-09-25 09:05:17 +00:00
}
# endif
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " . Cleaning up... " ) ;
2014-11-21 10:54:41 +00:00
fflush ( stdout ) ;
2015-06-30 13:55:03 +00:00
mbedtls_net_free ( & client_fd ) ;
mbedtls_net_free ( & listen_fd ) ;
2014-04-17 14:02:36 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_FS_IO)
mbedtls_dhm_free ( & dhm ) ;
2014-06-18 14:44:11 +00:00
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_X509_CRT_PARSE_C)
mbedtls_x509_crt_free ( & cacert ) ;
mbedtls_x509_crt_free ( & srvcert ) ;
mbedtls_pk_free ( & pkey ) ;
mbedtls_x509_crt_free ( & srvcert2 ) ;
mbedtls_pk_free ( & pkey2 ) ;
2013-04-18 20:46:23 +00:00
# endif
2018-06-13 16:09:28 +00:00
# if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
for ( i = 0 ; ( size_t ) i < ssl_async_keys . slots_used ; i + + )
{
if ( ssl_async_keys . slots [ i ] . pk_owned )
{
mbedtls_pk_free ( ssl_async_keys . slots [ i ] . pk ) ;
mbedtls_free ( ssl_async_keys . slots [ i ] . pk ) ;
ssl_async_keys . slots [ i ] . pk = NULL ;
}
}
# endif
2015-04-03 14:41:52 +00:00
# if defined(SNI_OPTION)
2014-02-21 15:52:06 +00:00
sni_free ( sni_info ) ;
# endif
2020-03-10 11:19:08 +00:00
# if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
2018-11-05 13:48:43 +00:00
if ( ( ret = psk_free ( psk_info ) ) ! = 0 )
mbedtls_printf ( " Failed to list of opaque PSKs - error was %d \n " , ret ) ;
2014-06-19 18:56:52 +00:00
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_FS_IO)
mbedtls_dhm_free ( & dhm ) ;
2014-06-19 18:56:52 +00:00
# endif
2013-04-18 20:46:23 +00:00
2020-03-10 11:19:08 +00:00
# if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED) && \
2018-11-05 13:48:43 +00:00
defined ( MBEDTLS_USE_PSA_CRYPTO )
2018-11-15 13:06:09 +00:00
if ( opt . psk_opaque ! = 0 )
2018-11-05 13:48:43 +00:00
{
/* This is ok even if the slot hasn't been
* initialized ( we might have jumed here
* immediately because of bad cmd line params ,
* for example ) . */
2018-11-15 13:06:09 +00:00
status = psa_destroy_key ( psk_slot ) ;
2018-11-05 13:48:43 +00:00
if ( status ! = PSA_SUCCESS )
{
mbedtls_printf ( " Failed to destroy key slot %u - error was %d " ,
2018-11-15 13:06:09 +00:00
( unsigned ) psk_slot , ( int ) status ) ;
2018-11-05 13:48:43 +00:00
}
}
2020-03-10 11:19:08 +00:00
# endif / * MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED &&
2018-11-05 13:48:43 +00:00
MBEDTLS_USE_PSA_CRYPTO */
2015-04-08 10:49:31 +00:00
mbedtls_ssl_free ( & ssl ) ;
2015-05-04 12:56:36 +00:00
mbedtls_ssl_config_free ( & conf ) ;
2015-04-08 10:49:31 +00:00
mbedtls_ctr_drbg_free ( & ctr_drbg ) ;
mbedtls_entropy_free ( & entropy ) ;
2012-09-25 09:05:17 +00:00
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_CACHE_C)
mbedtls_ssl_cache_free ( & cache ) ;
2012-09-25 21:55:46 +00:00
# endif
2015-05-19 13:28:00 +00:00
# if defined(MBEDTLS_SSL_SESSION_TICKETS)
mbedtls_ssl_ticket_free ( & ticket_ctx ) ;
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_SSL_COOKIE_C)
mbedtls_ssl_cookie_free ( & cookie_ctx ) ;
2014-07-23 12:56:15 +00:00
# endif
2012-09-25 21:55:46 +00:00
2018-10-09 11:39:13 +00:00
mbedtls_free ( buf ) ;
2019-07-15 08:31:11 +00:00
# if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
if ( context_buf ! = NULL )
mbedtls_platform_zeroize ( context_buf , context_buf_len ) ;
mbedtls_free ( context_buf ) ;
# endif
2015-04-08 10:49:31 +00:00
# if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
# if defined(MBEDTLS_MEMORY_DEBUG)
mbedtls_memory_buffer_alloc_status ( ) ;
2013-07-04 09:52:32 +00:00
# endif
2015-04-08 10:49:31 +00:00
mbedtls_memory_buffer_alloc_free ( ) ;
2013-09-29 12:45:34 +00:00
# endif
2013-07-04 09:52:32 +00:00
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " done. \n " ) ;
2014-11-21 10:54:41 +00:00
2012-09-25 09:05:17 +00:00
# if defined(_WIN32)
2015-04-08 10:49:31 +00:00
mbedtls_printf ( " + Press Enter to exit this program. \n " ) ;
2012-09-25 09:05:17 +00:00
fflush ( stdout ) ; getchar ( ) ;
# endif
2013-07-24 14:28:35 +00:00
// Shell can not handle large exit numbers -> 1 for errors
if ( ret < 0 )
ret = 1 ;
2012-09-25 09:05:17 +00:00
return ( ret ) ;
}
2015-04-08 10:49:31 +00:00
# endif / * MBEDTLS_BIGNUM_C && MBEDTLS_ENTROPY_C && MBEDTLS_SSL_TLS_C &&
MBEDTLS_SSL_SRV_C & & MBEDTLS_NET_C & & MBEDTLS_RSA_C & &
2015-05-13 11:58:56 +00:00
MBEDTLS_CTR_DRBG_C */