From e63582a166162b095f350089a0f4b90304ba915e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Manuel=20P=C3=A9gouri=C3=A9-Gonnard?= Date: Tue, 14 Oct 2014 11:47:21 +0200 Subject: [PATCH] Add dlts_client.c and dtls_server.c --- programs/.gitignore | 2 + programs/Makefile | 9 + programs/ssl/CMakeLists.txt | 8 + programs/ssl/dtls_client.c | 343 ++++++++++++++++++++++++++++++ programs/ssl/dtls_server.c | 410 ++++++++++++++++++++++++++++++++++++ programs/ssl/ssl_client2.c | 5 +- programs/ssl/ssl_server2.c | 2 +- 7 files changed, 776 insertions(+), 3 deletions(-) create mode 100644 programs/ssl/dtls_client.c create mode 100644 programs/ssl/dtls_server.c diff --git a/programs/.gitignore b/programs/.gitignore index 4dc2c18533..233947a235 100644 --- a/programs/.gitignore +++ b/programs/.gitignore @@ -28,6 +28,8 @@ pkey/rsa_verify_pss random/gen_entropy random/gen_random_ctr_drbg random/gen_random_havege +ssl/dtls_client +ssl/dtls_server ssl/ssl_client1 ssl/ssl_client2 ssl/ssl_fork_server diff --git a/programs/Makefile b/programs/Makefile index b3d8dbf777..a0b8c8caf4 100644 --- a/programs/Makefile +++ b/programs/Makefile @@ -33,6 +33,7 @@ APPS = aes/aescrypt2 aes/crypt_and_hash \ pkey/rsa_decrypt pkey/rsa_encrypt \ pkey/rsa_sign pkey/rsa_verify \ pkey/rsa_sign_pss pkey/rsa_verify_pss \ + ssl/dtls_client ssl/dtls_server \ ssl/ssl_client1 ssl/ssl_client2 \ ssl/ssl_server ssl/ssl_server2 \ ssl/ssl_fork_server \ @@ -174,6 +175,14 @@ random/gen_random_ctr_drbg: random/gen_random_ctr_drbg.c ../library/libpolarssl. echo " CC random/gen_random_ctr_drbg.c" $(CC) $(CFLAGS) $(OFLAGS) random/gen_random_ctr_drbg.c $(LDFLAGS) -o $@ +ssl/dtls_client: ssl/dtls_client.c ../library/libpolarssl.a + echo " CC ssl/dtls_client.c" + $(CC) $(CFLAGS) $(OFLAGS) ssl/dtls_client.c $(LDFLAGS) -o $@ + +ssl/dtls_server: ssl/dtls_server.c ../library/libpolarssl.a + echo " CC ssl/dtls_server.c" + $(CC) $(CFLAGS) $(OFLAGS) ssl/dtls_server.c $(LDFLAGS) -o $@ + ssl/ssl_client1: ssl/ssl_client1.c ../library/libpolarssl.a echo " CC ssl/ssl_client1.c" $(CC) $(CFLAGS) $(OFLAGS) ssl/ssl_client1.c $(LDFLAGS) -o $@ diff --git a/programs/ssl/CMakeLists.txt b/programs/ssl/CMakeLists.txt index e0cfba0509..9872869abe 100644 --- a/programs/ssl/CMakeLists.txt +++ b/programs/ssl/CMakeLists.txt @@ -6,6 +6,8 @@ set(libs ) set(targets + dtls_client + dtls_server ssl_client1 ssl_client2 ssl_server @@ -21,6 +23,12 @@ if(ENABLE_ZLIB_SUPPORT) set(libs ${libs} ${ZLIB_LIBRARIES}) endif(ENABLE_ZLIB_SUPPORT) +add_executable(dtls_client dtls_client.c) +target_link_libraries(dtls_client ${libs}) + +add_executable(dtls_server dtls_server.c) +target_link_libraries(dtls_server ${libs}) + add_executable(ssl_client1 ssl_client1.c) target_link_libraries(ssl_client1 ${libs}) diff --git a/programs/ssl/dtls_client.c b/programs/ssl/dtls_client.c new file mode 100644 index 0000000000..7c95c4417f --- /dev/null +++ b/programs/ssl/dtls_client.c @@ -0,0 +1,343 @@ +/* + * Simple DTLS client demonstration program + * + * Copyright (C) 2014, Brainspark B.V. + * + * This file is part of PolarSSL (http://www.polarssl.org) + * Lead Maintainer: Paul Bakker + * + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#if !defined(POLARSSL_CONFIG_FILE) +#include "polarssl/config.h" +#else +#include POLARSSL_CONFIG_FILE +#endif + +#if !defined(POLARSSL_SSL_CLI_C) || !defined(POLARSSL_SSL_PROTO_DTLS) || \ + !defined(POLARSSL_NET_C) || \ + !defined(POLARSSL_ENTROPY_C) || !defined(POLARSSL_CTR_DRBG_C) || \ + !defined(POLARSSL_X509_CRT_PARSE_C) || !defined(POLARSSL_RSA_C) || \ + !defined(POLARSSL_CERTS_C) + +#include +int main( int argc, char *argv[] ) +{ + ((void) argc); + ((void) argv); + + printf( "POLARSSL_SSL_CLI_C and/or POLARSSL_SSL_PROTO_DTLS and/or " + "POLARSSL_NET_C and/or " + "POLARSSL_ENTROPY_C and/or POLARSSL_CTR_DRBG_C and/or " + "POLARSSL_X509_CRT_PARSE_C and/or POLARSSL_RSA_C and/or " + "POLARSSL_CERTS_C not defined.\n" ); + return( 0 ); +} +#else + +#include +#include + +#include "polarssl/net.h" +#include "polarssl/debug.h" +#include "polarssl/ssl.h" +#include "polarssl/entropy.h" +#include "polarssl/ctr_drbg.h" +#include "polarssl/error.h" +#include "polarssl/certs.h" + +#define SERVER_PORT 4433 +#define SERVER_NAME "localhost" +#define SERVER_ADDR "127.0.0.1" /* forces IPv4 */ +#define MESSAGE "Echo this" + +#define READ_TIMEOUT_MS 1000 +#define MAX_RETRY 5 + +#define DEBUG_LEVEL 0 + +static void my_debug( void *ctx, int level, const char *str ) +{ + ((void) level); + + fprintf( (FILE *) ctx, "%s", str ); + fflush( (FILE *) ctx ); +} + +int main( int argc, char *argv[] ) +{ + int ret, len, server_fd = -1; + unsigned char buf[1024]; + const char *pers = "dtls_client"; + int retry_left = MAX_RETRY; + + entropy_context entropy; + ctr_drbg_context ctr_drbg; + ssl_context ssl; + x509_crt cacert; + + ((void) argc); + ((void) argv); + +#if defined(POLARSSL_DEBUG_C) + debug_set_threshold( DEBUG_LEVEL ); +#endif + + /* + * 0. Initialize the RNG and the session data + */ + memset( &ssl, 0, sizeof( ssl_context ) ); + x509_crt_init( &cacert ); + + printf( "\n . Seeding the random number generator..." ); + fflush( stdout ); + + entropy_init( &entropy ); + if( ( ret = ctr_drbg_init( &ctr_drbg, entropy_func, &entropy, + (const unsigned char *) pers, + strlen( pers ) ) ) != 0 ) + { + printf( " failed\n ! ctr_drbg_init returned %d\n", ret ); + goto exit; + } + + printf( " ok\n" ); + + /* + * 0. Initialize certificates + */ + printf( " . Loading the CA root certificate ..." ); + fflush( stdout ); + +#if defined(POLARSSL_CERTS_C) + ret = x509_crt_parse( &cacert, (const unsigned char *) test_ca_list, + strlen( test_ca_list ) ); +#else + ret = 1; + printf("POLARSSL_CERTS_C not defined."); +#endif + + if( ret < 0 ) + { + printf( " failed\n ! x509_crt_parse returned -0x%x\n\n", -ret ); + goto exit; + } + + printf( " ok (%d skipped)\n", ret ); + + /* + * 1. Start the connection + */ + printf( " . Connecting to udp/%s/%4d...", SERVER_NAME, + SERVER_PORT ); + fflush( stdout ); + + if( ( ret = net_connect( &server_fd, SERVER_ADDR, + SERVER_PORT, NET_PROTO_UDP ) ) != 0 ) + { + printf( " failed\n ! net_connect returned %d\n\n", ret ); + goto exit; + } + + printf( " ok\n" ); + + /* + * 2. Setup stuff + */ + printf( " . Setting up the DTLS structure..." ); + fflush( stdout ); + + if( ( ret = ssl_init( &ssl ) ) != 0 ) + { + printf( " failed\n ! ssl_init returned %d\n\n", ret ); + goto exit; + } + + printf( " ok\n" ); + + ssl_set_endpoint( &ssl, SSL_IS_CLIENT ); + ssl_set_transport( &ssl, SSL_TRANSPORT_DATAGRAM ); + + /* OPTIONAL is usually a bad choice for security, but makes interop easier + * in this simplified example, in which the ca chain is hardcoded. + * Production code should set a proper ca chain and use REQUIRED. */ + ssl_set_authmode( &ssl, SSL_VERIFY_OPTIONAL ); + ssl_set_ca_chain( &ssl, &cacert, NULL, SERVER_NAME ); + + ssl_set_rng( &ssl, ctr_drbg_random, &ctr_drbg ); + ssl_set_dbg( &ssl, my_debug, stdout ); + + ssl_set_bio_timeout( &ssl, &server_fd, + net_send, net_recv, net_recv_timeout, + READ_TIMEOUT_MS ); + + /* + * 4. Handshake + */ + printf( " . Performing the SSL/TLS handshake..." ); + fflush( stdout ); + + do ret = ssl_handshake( &ssl ); + while( ret == POLARSSL_ERR_NET_WANT_READ || + ret == POLARSSL_ERR_NET_WANT_WRITE ); + + if( ret != 0 ) + { + printf( " failed\n ! ssl_handshake returned -0x%x\n\n", -ret ); + goto exit; + } + + printf( " ok\n" ); + + /* + * 5. Verify the server certificate + */ + printf( " . Verifying peer X.509 certificate..." ); + + /* In real life, we would have used SSL_VERIFY_REQUIRED so that the + * handshake would not succeed if the peer's cert is bad. Even if we used + * SSL_VERIFY_OPTIONAL, we would bail out here if ret != 0 */ + if( ( ret = ssl_get_verify_result( &ssl ) ) != 0 ) + { + printf( " failed\n" ); + + if( ( ret & BADCERT_EXPIRED ) != 0 ) + printf( " ! server certificate has expired\n" ); + + if( ( ret & BADCERT_REVOKED ) != 0 ) + printf( " ! server certificate has been revoked\n" ); + + if( ( ret & BADCERT_CN_MISMATCH ) != 0 ) + printf( " ! CN mismatch (expected CN=%s)\n", SERVER_NAME ); + + if( ( ret & BADCERT_NOT_TRUSTED ) != 0 ) + printf( " ! self-signed or not signed by a trusted CA\n" ); + + printf( "\n" ); + } + else + printf( " ok\n" ); + + /* + * 6. Write the echo request + */ +send_request: + printf( " > Write to server:" ); + fflush( stdout ); + + len = sizeof( MESSAGE ) - 1; + + do ret = ssl_write( &ssl, (unsigned char *) MESSAGE, len ); + while( ret == POLARSSL_ERR_NET_WANT_READ || + ret == POLARSSL_ERR_NET_WANT_WRITE ); + + if( ret < 0 ) + { + printf( " failed\n ! ssl_write returned %d\n\n", ret ); + goto exit; + } + + len = ret; + printf( " %d bytes written\n\n%s\n\n", len, MESSAGE ); + + /* + * 7. Read the echo response + */ + printf( " < Read from server:" ); + fflush( stdout ); + + len = sizeof( buf ) - 1; + memset( buf, 0, sizeof( buf ) ); + + do ret = ssl_read( &ssl, buf, len ); + while( ret == POLARSSL_ERR_NET_WANT_READ || + ret == POLARSSL_ERR_NET_WANT_WRITE ); + + if( ret <= 0 ) + { + switch( ret ) + { + case POLARSSL_ERR_NET_TIMEOUT: + printf( " timeout\n\n" ); + if( retry_left-- > 0 ) + goto send_request; + goto exit; + + case POLARSSL_ERR_SSL_PEER_CLOSE_NOTIFY: + printf( " connection was closed gracefully\n" ); + ret = 0; + goto close_notify; + + default: + printf( " ssl_read returned -0x%x\n\n", -ret ); + goto exit; + } + } + + len = ret; + printf( " %d bytes read\n\n%s\n\n", len, buf ); + + /* + * 8. Done, cleanly close the connection + */ +close_notify: + printf( " . Closing the connection..." ); + + /* No error checking, the connection might be closed already */ + do ret = ssl_close_notify( &ssl ); + while( ret == POLARSSL_ERR_NET_WANT_WRITE ); + ret = 0; + + printf( " done\n" ); + + /* + * 9. Final clean-ups and exit + */ +exit: + +#ifdef POLARSSL_ERROR_C + if( ret != 0 ) + { + char error_buf[100]; + polarssl_strerror( ret, error_buf, 100 ); + printf( "Last error was: %d - %s\n\n", ret, error_buf ); + } +#endif + + if( server_fd != -1 ) + net_close( server_fd ); + + x509_crt_free( &cacert ); + ssl_free( &ssl ); + ctr_drbg_free( &ctr_drbg ); + entropy_free( &entropy ); + +#if defined(_WIN32) + printf( " + Press Enter to exit this program.\n" ); + fflush( stdout ); getchar(); +#endif + + /* Shell can not handle large exit numbers -> 1 for errors */ + if( ret < 0 ) + ret = 1; + + return( ret ); +} +#endif /* POLARSSL_SSL_CLI_C && POLARSSL_SSL_PROTO_DTLS && POLARSSL_NET_C && + POLARSSL_ENTROPY_C && POLARSSL_CTR_DRBG_C && + POLARSSL_X509_CRT_PARSE_C && POLARSSL_RSA_C && POLARSSL_CERTS_C */ diff --git a/programs/ssl/dtls_server.c b/programs/ssl/dtls_server.c new file mode 100644 index 0000000000..2f1f2c45f3 --- /dev/null +++ b/programs/ssl/dtls_server.c @@ -0,0 +1,410 @@ +/* + * Simple DTLS server demonstration program + * + * Copyright (C) 2014, Brainspark B.V. + * + * This file is part of PolarSSL (http://www.polarssl.org) + * Lead Maintainer: Paul Bakker + * + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#if !defined(POLARSSL_CONFIG_FILE) +#include "polarssl/config.h" +#else +#include POLARSSL_CONFIG_FILE +#endif + +#if !defined(POLARSSL_SSL_SRV_C) || !defined(POLARSSL_SSL_PROTO_DTLS) || \ + !defined(POLARSSL_SSL_COOKIE_C) || !defined(POLARSSL_NET_C) || \ + !defined(POLARSSL_ENTROPY_C) || !defined(POLARSSL_CTR_DRBG_C) || \ + !defined(POLARSSL_X509_CRT_PARSE_C) || !defined(POLARSSL_RSA_C) || \ + !defined(POLARSSL_CERTS_C) + +#include +int main( void ) +{ + printf( "POLARSSL_SSL_SRV_C and/or POLARSSL_SSL_PROTO_DTLS and/or " + "POLARSSL_SSL_COOKIE_C and/or POLARSSL_NET_C and/or " + "POLARSSL_ENTROPY_C and/or POLARSSL_CTR_DRBG_C and/or " + "POLARSSL_X509_CRT_PARSE_C and/or POLARSSL_RSA_C and/or " + "POLARSSL_CERTS_C not defined.\n" ); + return( 0 ); +} +#else + +#if defined(_WIN32) +#include +#endif + +#include +#include +#include + +#include "polarssl/entropy.h" +#include "polarssl/ctr_drbg.h" +#include "polarssl/certs.h" +#include "polarssl/x509.h" +#include "polarssl/ssl.h" +#include "polarssl/ssl_cookie.h" +#include "polarssl/net.h" +#include "polarssl/error.h" +#include "polarssl/debug.h" + +#if defined(POLARSSL_SSL_CACHE_C) +#include "polarssl/ssl_cache.h" +#endif + +#define READ_TIMEOUT_MS 10000 /* 5 seconds */ +#define DEBUG_LEVEL 0 + +static void my_debug( void *ctx, int level, const char *str ) +{ + ((void) level); + + fprintf( (FILE *) ctx, "%s", str ); + fflush( (FILE *) ctx ); +} + +int main( void ) +{ + int ret, len; + int listen_fd; + int client_fd = -1; + unsigned char buf[1024]; + const char *pers = "dtls_server"; + unsigned char client_ip[16] = { 0 }; + ssl_cookie_ctx cookie_ctx; + + entropy_context entropy; + ctr_drbg_context ctr_drbg; + ssl_context ssl; + x509_crt srvcert; + pk_context pkey; +#if defined(POLARSSL_SSL_CACHE_C) + ssl_cache_context cache; +#endif + + memset( &ssl, 0, sizeof(ssl_context) ); + ssl_cookie_init( &cookie_ctx ); +#if defined(POLARSSL_SSL_CACHE_C) + ssl_cache_init( &cache ); +#endif + x509_crt_init( &srvcert ); + pk_init( &pkey ); + entropy_init( &entropy ); + +#if defined(POLARSSL_DEBUG_C) + debug_set_threshold( DEBUG_LEVEL ); +#endif + + /* + * 1. Load the certificates and private RSA key + */ + printf( "\n . Loading the server cert. and key..." ); + fflush( stdout ); + + /* + * This demonstration program uses embedded test certificates. + * Instead, you may want to use x509_crt_parse_file() to read the + * server and CA certificates, as well as pk_parse_keyfile(). + */ + ret = x509_crt_parse( &srvcert, (const unsigned char *) test_srv_crt, + strlen( test_srv_crt ) ); + if( ret != 0 ) + { + printf( " failed\n ! x509_crt_parse returned %d\n\n", ret ); + goto exit; + } + + ret = x509_crt_parse( &srvcert, (const unsigned char *) test_ca_list, + strlen( test_ca_list ) ); + if( ret != 0 ) + { + printf( " failed\n ! x509_crt_parse returned %d\n\n", ret ); + goto exit; + } + + ret = pk_parse_key( &pkey, (const unsigned char *) test_srv_key, + strlen( test_srv_key ), NULL, 0 ); + if( ret != 0 ) + { + printf( " failed\n ! pk_parse_key returned %d\n\n", ret ); + goto exit; + } + + printf( " ok\n" ); + + /* + * 2. Setup the "listening" UDP socket + */ + printf( " . Bind on udp/*/4433 ..." ); + fflush( stdout ); + + if( ( ret = net_bind( &listen_fd, NULL, 4433, NET_PROTO_UDP ) ) != 0 ) + { + printf( " failed\n ! net_bind returned %d\n\n", ret ); + goto exit; + } + + printf( " ok\n" ); + + /* + * 3. Seed the RNG + */ + printf( " . Seeding the random number generator..." ); + fflush( stdout ); + + if( ( ret = ctr_drbg_init( &ctr_drbg, entropy_func, &entropy, + (const unsigned char *) pers, + strlen( pers ) ) ) != 0 ) + { + printf( " failed\n ! ctr_drbg_init returned %d\n", ret ); + goto exit; + } + + printf( " ok\n" ); + + /* + * 4. Setup stuff + */ + printf( " . Setting up the DTLS data..." ); + fflush( stdout ); + + if( ( ret = ssl_init( &ssl ) ) != 0 ) + { + printf( " failed\n ! ssl_init returned %d\n\n", ret ); + goto exit; + } + + ssl_set_endpoint( &ssl, SSL_IS_SERVER ); + ssl_set_transport( &ssl, SSL_TRANSPORT_DATAGRAM ); + ssl_set_authmode( &ssl, SSL_VERIFY_NONE ); + + ssl_set_rng( &ssl, ctr_drbg_random, &ctr_drbg ); + ssl_set_dbg( &ssl, my_debug, stdout ); + +#if defined(POLARSSL_SSL_CACHE_C) + ssl_set_session_cache( &ssl, ssl_cache_get, &cache, + ssl_cache_set, &cache ); +#endif + + ssl_set_ca_chain( &ssl, srvcert.next, NULL, NULL ); + if( ( ret = ssl_set_own_cert( &ssl, &srvcert, &pkey ) ) != 0 ) + { + printf( " failed\n ! ssl_set_own_cert returned %d\n\n", ret ); + goto exit; + } + + if( ( ret = ssl_cookie_setup( &cookie_ctx, + ctr_drbg_random, &ctr_drbg ) ) != 0 ) + { + printf( " failed\n ! ssl_cookie_setup returned %d\n\n", ret ); + goto exit; + } + + ssl_set_dtls_cookies( &ssl, ssl_cookie_write, ssl_cookie_check, + &cookie_ctx ); + + printf( " ok\n" ); + +reset: +#ifdef POLARSSL_ERROR_C + if( ret != 0 ) + { + char error_buf[100]; + polarssl_strerror( ret, error_buf, 100 ); + printf("Last error was: %d - %s\n\n", ret, error_buf ); + } +#endif + + if( client_fd != -1 ) + net_close( client_fd ); + + ssl_session_reset( &ssl ); + + /* + * 3. Wait until a client connects + */ + client_fd = -1; + + printf( " . Waiting for a remote connection ..." ); + fflush( stdout ); + + if( ( ret = net_accept( listen_fd, &client_fd, client_ip ) ) != 0 ) + { + printf( " failed\n ! net_accept returned %d\n\n", ret ); + goto exit; + } + + /* With UDP, bind_fd is hijacked by client_fd, so bind a new one */ + if( ( ret = net_bind( &listen_fd, NULL, 4433, NET_PROTO_UDP ) ) != 0 ) + { + printf( " failed\n ! net_bind returned -0x%x\n\n", -ret ); + goto exit; + } + + /* For HelloVerifyRequest cookies */ + if( ( ret = ssl_set_client_transport_id( &ssl, client_ip, + sizeof( client_ip ) ) ) != 0 ) + { + printf( " failed\n ! " + "ssl_set_client_tranport_id() returned -0x%x\n\n", -ret ); + goto exit; + } + + ssl_set_bio_timeout( &ssl, &client_fd, + net_send, net_recv, net_recv_timeout, + READ_TIMEOUT_MS ); + + printf( " ok\n" ); + + /* + * 5. Handshake + */ + printf( " . Performing the DTLS handshake..." ); + fflush( stdout ); + + do ret = ssl_handshake( &ssl ); + while( ret == POLARSSL_ERR_NET_WANT_READ || + ret == POLARSSL_ERR_NET_WANT_WRITE ); + + if( ret == POLARSSL_ERR_SSL_HELLO_VERIFY_REQUIRED ) + { + printf( " hello verification requested\n" ); + ret = 0; + goto reset; + } + else if( ret != 0 ) + { + printf( " failed\n ! ssl_handshake returned -0x%x\n\n", -ret ); + goto reset; + } + + printf( " ok\n" ); + + /* + * 6. Read the echo Request + */ + printf( " < Read from client:" ); + fflush( stdout ); + + len = sizeof( buf ) - 1; + memset( buf, 0, sizeof( buf ) ); + + do ret = ssl_read( &ssl, buf, len ); + while( ret == POLARSSL_ERR_NET_WANT_READ || + ret == POLARSSL_ERR_NET_WANT_WRITE ); + + if( ret <= 0 ) + { + switch( ret ) + { + case POLARSSL_ERR_NET_TIMEOUT: + printf( " timeout\n\n" ); + goto reset; + + case POLARSSL_ERR_SSL_PEER_CLOSE_NOTIFY: + printf( " connection was closed gracefully\n" ); + ret = 0; + goto close_notify; + + default: + printf( " ssl_read returned -0x%x\n\n", -ret ); + goto reset; + } + } + + len = ret; + printf( " %d bytes read\n\n%s\n\n", len, buf ); + + /* + * 7. Write the 200 Response + */ + printf( " > Write to client:" ); + fflush( stdout ); + + do ret = ssl_write( &ssl, buf, len ); + while( ret == POLARSSL_ERR_NET_WANT_READ || + ret == POLARSSL_ERR_NET_WANT_WRITE ); + + if( ret < 0 ) + { + printf( " failed\n ! ssl_write returned %d\n\n", ret ); + goto exit; + } + + len = ret; + printf( " %d bytes written\n\n%s\n\n", len, buf ); + + /* + * 8. Done, cleanly close the connection + */ +close_notify: + printf( " . Closing the connection..." ); + + /* No error checking, the connection might be closed already */ + do ret = ssl_close_notify( &ssl ); + while( ret == POLARSSL_ERR_NET_WANT_WRITE ); + ret = 0; + + printf( " done\n" ); + + goto reset; + + /* + * Final clean-ups and exit + */ +exit: + +#ifdef POLARSSL_ERROR_C + if( ret != 0 ) + { + char error_buf[100]; + polarssl_strerror( ret, error_buf, 100 ); + printf( "Last error was: %d - %s\n\n", ret, error_buf ); + } +#endif + + if( client_fd != -1 ) + net_close( client_fd ); + + x509_crt_free( &srvcert ); + pk_free( &pkey ); + ssl_free( &ssl ); + ssl_cookie_free( &cookie_ctx ); +#if defined(POLARSSL_SSL_CACHE_C) + ssl_cache_free( &cache ); +#endif + ctr_drbg_free( &ctr_drbg ); + entropy_free( &entropy ); + +#if defined(_WIN32) + printf( " Press Enter to exit this program.\n" ); + fflush( stdout ); getchar(); +#endif + + /* Shell can not handle large exit numbers -> 1 for errors */ + if( ret < 0 ) + ret = 1; + + return( ret ); +} +#endif /* POLARSSL_SSL_SRV_C && POLARSSL_SSL_PROTO_DTLS && + POLARSSL_SSL_COOKIE_C && POLARSSL_NET_C && POLARSSL_ENTROPY_C && + POLARSSL_CTR_DRBG_C && POLARSSL_X509_CRT_PARSE_C && POLARSSL_RSA_C + && POLARSSL_CERTS_C */ diff --git a/programs/ssl/ssl_client2.c b/programs/ssl/ssl_client2.c index a574a2c12e..53b0645677 100644 --- a/programs/ssl/ssl_client2.c +++ b/programs/ssl/ssl_client2.c @@ -349,7 +349,7 @@ static int my_verify( void *data, x509_crt *crt, int depth, int *flags ) int main( int argc, char *argv[] ) { - int ret = 0, len, tail_len, server_fd, i, written, frags; + int ret = 0, len, tail_len, server_fd, i, written, frags, retry_left; unsigned char buf[SSL_MAX_CONTENT_LEN + 1]; #if defined(POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED) unsigned char psk[POLARSSL_PSK_MAX_LEN]; @@ -1181,6 +1181,7 @@ int main( int argc, char *argv[] ) /* * 6. Write the GET request */ + retry_left = opt.max_resend; send_request: printf( " > Write to server:" ); fflush( stdout ); @@ -1317,7 +1318,7 @@ send_request: { case POLARSSL_ERR_NET_TIMEOUT: printf( " timeout\n" ); - if( opt.max_resend-- > 0 ) + if( retry_left-- > 0 ) goto send_request; goto exit; diff --git a/programs/ssl/ssl_server2.c b/programs/ssl/ssl_server2.c index 13922646a2..d5c57a4643 100644 --- a/programs/ssl/ssl_server2.c +++ b/programs/ssl/ssl_server2.c @@ -1436,7 +1436,7 @@ int main( int argc, char *argv[] ) if( ( ret = ssl_cookie_setup( &cookie_ctx, ctr_drbg_random, &ctr_drbg ) ) != 0 ) { - printf( " failed\n ! ssl_setup_hvr_key returned %d\n\n", ret ); + printf( " failed\n ! ssl_cookie_setup returned %d\n\n", ret ); goto exit; }