aboutsummaryrefslogtreecommitdiffstats
path: root/roms/skiboot/libstb/crypto/mbedtls/programs/test
diff options
context:
space:
mode:
authorAngelos Mouzakitis <a.mouzakitis@virtualopensystems.com>2023-10-10 14:33:42 +0000
committerAngelos Mouzakitis <a.mouzakitis@virtualopensystems.com>2023-10-10 14:33:42 +0000
commitaf1a266670d040d2f4083ff309d732d648afba2a (patch)
tree2fc46203448ddcc6f81546d379abfaeb323575e9 /roms/skiboot/libstb/crypto/mbedtls/programs/test
parente02cda008591317b1625707ff8e115a4841aa889 (diff)
Add submodule dependency filesHEADmaster
Change-Id: Iaf8d18082d3991dec7c0ebbea540f092188eb4ec
Diffstat (limited to 'roms/skiboot/libstb/crypto/mbedtls/programs/test')
-rw-r--r--roms/skiboot/libstb/crypto/mbedtls/programs/test/CMakeLists.txt36
-rw-r--r--roms/skiboot/libstb/crypto/mbedtls/programs/test/benchmark.c1016
-rw-r--r--roms/skiboot/libstb/crypto/mbedtls/programs/test/cpp_dummy_build.cpp119
-rw-r--r--roms/skiboot/libstb/crypto/mbedtls/programs/test/query_compile_time_config.c56
-rw-r--r--roms/skiboot/libstb/crypto/mbedtls/programs/test/selftest.c434
-rw-r--r--roms/skiboot/libstb/crypto/mbedtls/programs/test/udp_proxy.c929
-rwxr-xr-xroms/skiboot/libstb/crypto/mbedtls/programs/test/udp_proxy_wrapper.sh117
-rw-r--r--roms/skiboot/libstb/crypto/mbedtls/programs/test/zeroize.c101
8 files changed, 2808 insertions, 0 deletions
diff --git a/roms/skiboot/libstb/crypto/mbedtls/programs/test/CMakeLists.txt b/roms/skiboot/libstb/crypto/mbedtls/programs/test/CMakeLists.txt
new file mode 100644
index 000000000..282ef58aa
--- /dev/null
+++ b/roms/skiboot/libstb/crypto/mbedtls/programs/test/CMakeLists.txt
@@ -0,0 +1,36 @@
+set(libs
+ mbedtls
+)
+
+if(USE_PKCS11_HELPER_LIBRARY)
+ set(libs ${libs} pkcs11-helper)
+endif(USE_PKCS11_HELPER_LIBRARY)
+
+if(ENABLE_ZLIB_SUPPORT)
+ set(libs ${libs} ${ZLIB_LIBRARIES})
+endif(ENABLE_ZLIB_SUPPORT)
+
+add_executable(selftest selftest.c)
+target_link_libraries(selftest ${libs})
+
+add_executable(benchmark benchmark.c)
+target_link_libraries(benchmark ${libs})
+
+if(TEST_CPP)
+ add_executable(cpp_dummy_build cpp_dummy_build.cpp)
+ target_link_libraries(cpp_dummy_build ${libs})
+endif()
+
+add_executable(udp_proxy udp_proxy.c)
+target_link_libraries(udp_proxy ${libs})
+
+add_executable(zeroize zeroize.c)
+target_link_libraries(zeroize ${libs})
+
+add_executable(query_compile_time_config query_compile_time_config.c)
+target_sources(query_compile_time_config PUBLIC ../ssl/query_config.c)
+target_link_libraries(query_compile_time_config ${libs})
+
+install(TARGETS selftest benchmark udp_proxy query_compile_time_config
+ DESTINATION "bin"
+ PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
diff --git a/roms/skiboot/libstb/crypto/mbedtls/programs/test/benchmark.c b/roms/skiboot/libstb/crypto/mbedtls/programs/test/benchmark.c
new file mode 100644
index 000000000..e31faafeb
--- /dev/null
+++ b/roms/skiboot/libstb/crypto/mbedtls/programs/test/benchmark.c
@@ -0,0 +1,1016 @@
+/*
+ * Benchmark demonstration program
+ *
+ * Copyright (C) 2006-2016, ARM Limited, All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ *
+ * This file is part of mbed TLS (https://tls.mbed.org)
+ */
+
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+
+#if defined(MBEDTLS_PLATFORM_C)
+#include "mbedtls/platform.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#define mbedtls_exit exit
+#define mbedtls_printf printf
+#define mbedtls_snprintf snprintf
+#define mbedtls_free free
+#define mbedtls_exit exit
+#define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS
+#define MBEDTLS_EXIT_FAILURE EXIT_FAILURE
+#endif
+
+#if !defined(MBEDTLS_TIMING_C)
+int main( void )
+{
+ mbedtls_printf("MBEDTLS_TIMING_C not defined.\n");
+ return( 0 );
+}
+#else
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "mbedtls/timing.h"
+
+#include "mbedtls/md4.h"
+#include "mbedtls/md5.h"
+#include "mbedtls/ripemd160.h"
+#include "mbedtls/sha1.h"
+#include "mbedtls/sha256.h"
+#include "mbedtls/sha512.h"
+
+#include "mbedtls/arc4.h"
+#include "mbedtls/des.h"
+#include "mbedtls/aes.h"
+#include "mbedtls/aria.h"
+#include "mbedtls/blowfish.h"
+#include "mbedtls/camellia.h"
+#include "mbedtls/chacha20.h"
+#include "mbedtls/gcm.h"
+#include "mbedtls/ccm.h"
+#include "mbedtls/chachapoly.h"
+#include "mbedtls/cmac.h"
+#include "mbedtls/poly1305.h"
+
+#include "mbedtls/havege.h"
+#include "mbedtls/ctr_drbg.h"
+#include "mbedtls/hmac_drbg.h"
+
+#include "mbedtls/rsa.h"
+#include "mbedtls/dhm.h"
+#include "mbedtls/ecdsa.h"
+#include "mbedtls/ecdh.h"
+
+#include "mbedtls/error.h"
+
+#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
+#include "mbedtls/memory_buffer_alloc.h"
+#endif
+
+/*
+ * For heap usage estimates, we need an estimate of the overhead per allocated
+ * block. ptmalloc2/3 (used in gnu libc for instance) uses 2 size_t per block,
+ * so use that as our baseline.
+ */
+#define MEM_BLOCK_OVERHEAD ( 2 * sizeof( size_t ) )
+
+/*
+ * Size to use for the alloc buffer if MEMORY_BUFFER_ALLOC_C is defined.
+ */
+#define HEAP_SIZE (1u << 16) // 64k
+
+#define BUFSIZE 1024
+#define HEADER_FORMAT " %-24s : "
+#define TITLE_LEN 25
+
+#define OPTIONS \
+ "md4, md5, ripemd160, sha1, sha256, sha512,\n" \
+ "arc4, des3, des, camellia, blowfish, chacha20,\n" \
+ "aes_cbc, aes_gcm, aes_ccm, aes_ctx, chachapoly,\n" \
+ "aes_cmac, des3_cmac, poly1305\n" \
+ "havege, ctr_drbg, hmac_drbg\n" \
+ "rsa, dhm, ecdsa, ecdh.\n"
+
+#if defined(MBEDTLS_ERROR_C)
+#define PRINT_ERROR \
+ mbedtls_strerror( ret, ( char * )tmp, sizeof( tmp ) ); \
+ mbedtls_printf( "FAILED: %s\n", tmp );
+#else
+#define PRINT_ERROR \
+ mbedtls_printf( "FAILED: -0x%04x\n", -ret );
+#endif
+
+#define TIME_AND_TSC( TITLE, CODE ) \
+do { \
+ unsigned long ii, jj, tsc; \
+ int ret = 0; \
+ \
+ mbedtls_printf( HEADER_FORMAT, TITLE ); \
+ fflush( stdout ); \
+ \
+ mbedtls_set_alarm( 1 ); \
+ for( ii = 1; ret == 0 && ! mbedtls_timing_alarmed; ii++ ) \
+ { \
+ ret = CODE; \
+ } \
+ \
+ tsc = mbedtls_timing_hardclock(); \
+ for( jj = 0; ret == 0 && jj < 1024; jj++ ) \
+ { \
+ ret = CODE; \
+ } \
+ \
+ if( ret != 0 ) \
+ { \
+ PRINT_ERROR; \
+ } \
+ else \
+ { \
+ mbedtls_printf( "%9lu KiB/s, %9lu cycles/byte\n", \
+ ii * BUFSIZE / 1024, \
+ ( mbedtls_timing_hardclock() - tsc ) \
+ / ( jj * BUFSIZE ) ); \
+ } \
+} while( 0 )
+
+#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && defined(MBEDTLS_MEMORY_DEBUG)
+
+#define MEMORY_MEASURE_INIT \
+ size_t max_used, max_blocks, max_bytes; \
+ size_t prv_used, prv_blocks; \
+ mbedtls_memory_buffer_alloc_cur_get( &prv_used, &prv_blocks ); \
+ mbedtls_memory_buffer_alloc_max_reset( );
+
+#define MEMORY_MEASURE_PRINT( title_len ) \
+ mbedtls_memory_buffer_alloc_max_get( &max_used, &max_blocks ); \
+ for( ii = 12 - (title_len); ii != 0; ii-- ) mbedtls_printf( " " ); \
+ max_used -= prv_used; \
+ max_blocks -= prv_blocks; \
+ max_bytes = max_used + MEM_BLOCK_OVERHEAD * max_blocks; \
+ mbedtls_printf( "%6u heap bytes", (unsigned) max_bytes );
+
+#else
+#define MEMORY_MEASURE_INIT
+#define MEMORY_MEASURE_PRINT( title_len )
+#endif
+
+#define TIME_PUBLIC( TITLE, TYPE, CODE ) \
+do { \
+ unsigned long ii; \
+ int ret; \
+ MEMORY_MEASURE_INIT; \
+ \
+ mbedtls_printf( HEADER_FORMAT, TITLE ); \
+ fflush( stdout ); \
+ mbedtls_set_alarm( 3 ); \
+ \
+ ret = 0; \
+ for( ii = 1; ! mbedtls_timing_alarmed && ! ret ; ii++ ) \
+ { \
+ CODE; \
+ } \
+ \
+ if( ret != 0 ) \
+ { \
+ PRINT_ERROR; \
+ } \
+ else \
+ { \
+ mbedtls_printf( "%6lu " TYPE "/s", ii / 3 ); \
+ MEMORY_MEASURE_PRINT( sizeof( TYPE ) + 1 ); \
+ mbedtls_printf( "\n" ); \
+ } \
+} while( 0 )
+
+static int myrand( void *rng_state, unsigned char *output, size_t len )
+{
+ size_t use_len;
+ int rnd;
+
+ if( rng_state != NULL )
+ rng_state = NULL;
+
+ while( len > 0 )
+ {
+ use_len = len;
+ if( use_len > sizeof(int) )
+ use_len = sizeof(int);
+
+ rnd = rand();
+ memcpy( output, &rnd, use_len );
+ output += use_len;
+ len -= use_len;
+ }
+
+ return( 0 );
+}
+
+/*
+ * Clear some memory that was used to prepare the context
+ */
+#if defined(MBEDTLS_ECP_C)
+void ecp_clear_precomputed( mbedtls_ecp_group *grp )
+{
+ if( grp->T != NULL )
+ {
+ size_t i;
+ for( i = 0; i < grp->T_size; i++ )
+ mbedtls_ecp_point_free( &grp->T[i] );
+ mbedtls_free( grp->T );
+ }
+ grp->T = NULL;
+ grp->T_size = 0;
+}
+#else
+#define ecp_clear_precomputed( g )
+#endif
+
+unsigned char buf[BUFSIZE];
+
+typedef struct {
+ char md4, md5, ripemd160, sha1, sha256, sha512,
+ arc4, des3, des,
+ aes_cbc, aes_gcm, aes_ccm, aes_xts, chachapoly,
+ aes_cmac, des3_cmac,
+ aria, camellia, blowfish, chacha20,
+ poly1305,
+ havege, ctr_drbg, hmac_drbg,
+ rsa, dhm, ecdsa, ecdh;
+} todo_list;
+
+#if defined(MBEDTLS_CHECK_PARAMS)
+#include "mbedtls/platform_util.h"
+void mbedtls_param_failed( const char *failure_condition,
+ const char *file,
+ int line )
+{
+ mbedtls_printf( "%s:%i: Input param failed - %s\n",
+ file, line, failure_condition );
+ mbedtls_exit( MBEDTLS_EXIT_FAILURE );
+}
+#endif
+
+int main( int argc, char *argv[] )
+{
+ int i;
+ unsigned char tmp[200];
+ char title[TITLE_LEN];
+ todo_list todo;
+#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
+ unsigned char alloc_buf[HEAP_SIZE] = { 0 };
+#endif
+
+ if( argc <= 1 )
+ {
+ memset( &todo, 1, sizeof( todo ) );
+ }
+ else
+ {
+ memset( &todo, 0, sizeof( todo ) );
+
+ for( i = 1; i < argc; i++ )
+ {
+ if( strcmp( argv[i], "md4" ) == 0 )
+ todo.md4 = 1;
+ else if( strcmp( argv[i], "md5" ) == 0 )
+ todo.md5 = 1;
+ else if( strcmp( argv[i], "ripemd160" ) == 0 )
+ todo.ripemd160 = 1;
+ else if( strcmp( argv[i], "sha1" ) == 0 )
+ todo.sha1 = 1;
+ else if( strcmp( argv[i], "sha256" ) == 0 )
+ todo.sha256 = 1;
+ else if( strcmp( argv[i], "sha512" ) == 0 )
+ todo.sha512 = 1;
+ else if( strcmp( argv[i], "arc4" ) == 0 )
+ todo.arc4 = 1;
+ else if( strcmp( argv[i], "des3" ) == 0 )
+ todo.des3 = 1;
+ else if( strcmp( argv[i], "des" ) == 0 )
+ todo.des = 1;
+ else if( strcmp( argv[i], "aes_cbc" ) == 0 )
+ todo.aes_cbc = 1;
+ else if( strcmp( argv[i], "aes_xts" ) == 0 )
+ todo.aes_xts = 1;
+ else if( strcmp( argv[i], "aes_gcm" ) == 0 )
+ todo.aes_gcm = 1;
+ else if( strcmp( argv[i], "aes_ccm" ) == 0 )
+ todo.aes_ccm = 1;
+ else if( strcmp( argv[i], "chachapoly" ) == 0 )
+ todo.chachapoly = 1;
+ else if( strcmp( argv[i], "aes_cmac" ) == 0 )
+ todo.aes_cmac = 1;
+ else if( strcmp( argv[i], "des3_cmac" ) == 0 )
+ todo.des3_cmac = 1;
+ else if( strcmp( argv[i], "aria" ) == 0 )
+ todo.aria = 1;
+ else if( strcmp( argv[i], "camellia" ) == 0 )
+ todo.camellia = 1;
+ else if( strcmp( argv[i], "blowfish" ) == 0 )
+ todo.blowfish = 1;
+ else if( strcmp( argv[i], "chacha20" ) == 0 )
+ todo.chacha20 = 1;
+ else if( strcmp( argv[i], "poly1305" ) == 0 )
+ todo.poly1305 = 1;
+ else if( strcmp( argv[i], "havege" ) == 0 )
+ todo.havege = 1;
+ else if( strcmp( argv[i], "ctr_drbg" ) == 0 )
+ todo.ctr_drbg = 1;
+ else if( strcmp( argv[i], "hmac_drbg" ) == 0 )
+ todo.hmac_drbg = 1;
+ else if( strcmp( argv[i], "rsa" ) == 0 )
+ todo.rsa = 1;
+ else if( strcmp( argv[i], "dhm" ) == 0 )
+ todo.dhm = 1;
+ else if( strcmp( argv[i], "ecdsa" ) == 0 )
+ todo.ecdsa = 1;
+ else if( strcmp( argv[i], "ecdh" ) == 0 )
+ todo.ecdh = 1;
+ else
+ {
+ mbedtls_printf( "Unrecognized option: %s\n", argv[i] );
+ mbedtls_printf( "Available options: " OPTIONS );
+ }
+ }
+ }
+
+ mbedtls_printf( "\n" );
+
+#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
+ mbedtls_memory_buffer_alloc_init( alloc_buf, sizeof( alloc_buf ) );
+#endif
+ memset( buf, 0xAA, sizeof( buf ) );
+ memset( tmp, 0xBB, sizeof( tmp ) );
+
+#if defined(MBEDTLS_MD4_C)
+ if( todo.md4 )
+ TIME_AND_TSC( "MD4", mbedtls_md4_ret( buf, BUFSIZE, tmp ) );
+#endif
+
+#if defined(MBEDTLS_MD5_C)
+ if( todo.md5 )
+ TIME_AND_TSC( "MD5", mbedtls_md5_ret( buf, BUFSIZE, tmp ) );
+#endif
+
+#if defined(MBEDTLS_RIPEMD160_C)
+ if( todo.ripemd160 )
+ TIME_AND_TSC( "RIPEMD160", mbedtls_ripemd160_ret( buf, BUFSIZE, tmp ) );
+#endif
+
+#if defined(MBEDTLS_SHA1_C)
+ if( todo.sha1 )
+ TIME_AND_TSC( "SHA-1", mbedtls_sha1_ret( buf, BUFSIZE, tmp ) );
+#endif
+
+#if defined(MBEDTLS_SHA256_C)
+ if( todo.sha256 )
+ TIME_AND_TSC( "SHA-256", mbedtls_sha256_ret( buf, BUFSIZE, tmp, 0 ) );
+#endif
+
+#if defined(MBEDTLS_SHA512_C)
+ if( todo.sha512 )
+ TIME_AND_TSC( "SHA-512", mbedtls_sha512_ret( buf, BUFSIZE, tmp, 0 ) );
+#endif
+
+#if defined(MBEDTLS_ARC4_C)
+ if( todo.arc4 )
+ {
+ mbedtls_arc4_context arc4;
+ mbedtls_arc4_init( &arc4 );
+ mbedtls_arc4_setup( &arc4, tmp, 32 );
+ TIME_AND_TSC( "ARC4", mbedtls_arc4_crypt( &arc4, BUFSIZE, buf, buf ) );
+ mbedtls_arc4_free( &arc4 );
+ }
+#endif
+
+#if defined(MBEDTLS_DES_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ if( todo.des3 )
+ {
+ mbedtls_des3_context des3;
+ mbedtls_des3_init( &des3 );
+ mbedtls_des3_set3key_enc( &des3, tmp );
+ TIME_AND_TSC( "3DES",
+ mbedtls_des3_crypt_cbc( &des3, MBEDTLS_DES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
+ mbedtls_des3_free( &des3 );
+ }
+
+ if( todo.des )
+ {
+ mbedtls_des_context des;
+ mbedtls_des_init( &des );
+ mbedtls_des_setkey_enc( &des, tmp );
+ TIME_AND_TSC( "DES",
+ mbedtls_des_crypt_cbc( &des, MBEDTLS_DES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
+ mbedtls_des_free( &des );
+ }
+
+#endif /* MBEDTLS_CIPHER_MODE_CBC */
+#if defined(MBEDTLS_CMAC_C)
+ if( todo.des3_cmac )
+ {
+ unsigned char output[8];
+ const mbedtls_cipher_info_t *cipher_info;
+
+ memset( buf, 0, sizeof( buf ) );
+ memset( tmp, 0, sizeof( tmp ) );
+
+ cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_DES_EDE3_ECB );
+
+ TIME_AND_TSC( "3DES-CMAC",
+ mbedtls_cipher_cmac( cipher_info, tmp, 192, buf,
+ BUFSIZE, output ) );
+ }
+#endif /* MBEDTLS_CMAC_C */
+#endif /* MBEDTLS_DES_C */
+
+#if defined(MBEDTLS_AES_C)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
+ if( todo.aes_cbc )
+ {
+ int keysize;
+ mbedtls_aes_context aes;
+ mbedtls_aes_init( &aes );
+ for( keysize = 128; keysize <= 256; keysize += 64 )
+ {
+ mbedtls_snprintf( title, sizeof( title ), "AES-CBC-%d", keysize );
+
+ memset( buf, 0, sizeof( buf ) );
+ memset( tmp, 0, sizeof( tmp ) );
+ mbedtls_aes_setkey_enc( &aes, tmp, keysize );
+
+ TIME_AND_TSC( title,
+ mbedtls_aes_crypt_cbc( &aes, MBEDTLS_AES_ENCRYPT, BUFSIZE, tmp, buf, buf ) );
+ }
+ mbedtls_aes_free( &aes );
+ }
+#endif
+#if defined(MBEDTLS_CIPHER_MODE_XTS)
+ if( todo.aes_xts )
+ {
+ int keysize;
+ mbedtls_aes_xts_context ctx;
+
+ mbedtls_aes_xts_init( &ctx );
+ for( keysize = 128; keysize <= 256; keysize += 128 )
+ {
+ mbedtls_snprintf( title, sizeof( title ), "AES-XTS-%d", keysize );
+
+ memset( buf, 0, sizeof( buf ) );
+ memset( tmp, 0, sizeof( tmp ) );
+ mbedtls_aes_xts_setkey_enc( &ctx, tmp, keysize * 2 );
+
+ TIME_AND_TSC( title,
+ mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_ENCRYPT, BUFSIZE,
+ tmp, buf, buf ) );
+
+ mbedtls_aes_xts_free( &ctx );
+ }
+ }
+#endif
+#if defined(MBEDTLS_GCM_C)
+ if( todo.aes_gcm )
+ {
+ int keysize;
+ mbedtls_gcm_context gcm;
+
+ mbedtls_gcm_init( &gcm );
+ for( keysize = 128; keysize <= 256; keysize += 64 )
+ {
+ mbedtls_snprintf( title, sizeof( title ), "AES-GCM-%d", keysize );
+
+ memset( buf, 0, sizeof( buf ) );
+ memset( tmp, 0, sizeof( tmp ) );
+ mbedtls_gcm_setkey( &gcm, MBEDTLS_CIPHER_ID_AES, tmp, keysize );
+
+ TIME_AND_TSC( title,
+ mbedtls_gcm_crypt_and_tag( &gcm, MBEDTLS_GCM_ENCRYPT, BUFSIZE, tmp,
+ 12, NULL, 0, buf, buf, 16, tmp ) );
+
+ mbedtls_gcm_free( &gcm );
+ }
+ }
+#endif
+#if defined(MBEDTLS_CCM_C)
+ if( todo.aes_ccm )
+ {
+ int keysize;
+ mbedtls_ccm_context ccm;
+
+ mbedtls_ccm_init( &ccm );
+ for( keysize = 128; keysize <= 256; keysize += 64 )
+ {
+ mbedtls_snprintf( title, sizeof( title ), "AES-CCM-%d", keysize );
+
+ memset( buf, 0, sizeof( buf ) );
+ memset( tmp, 0, sizeof( tmp ) );
+ mbedtls_ccm_setkey( &ccm, MBEDTLS_CIPHER_ID_AES, tmp, keysize );
+
+ TIME_AND_TSC( title,
+ mbedtls_ccm_encrypt_and_tag( &ccm, BUFSIZE, tmp,
+ 12, NULL, 0, buf, buf, tmp, 16 ) );
+
+ mbedtls_ccm_free( &ccm );
+ }
+ }
+#endif
+#if defined(MBEDTLS_CHACHAPOLY_C)
+ if( todo.chachapoly )
+ {
+ mbedtls_chachapoly_context chachapoly;
+
+ mbedtls_chachapoly_init( &chachapoly );
+ memset( buf, 0, sizeof( buf ) );
+ memset( tmp, 0, sizeof( tmp ) );
+
+ mbedtls_snprintf( title, sizeof( title ), "ChaCha20-Poly1305" );
+
+ mbedtls_chachapoly_setkey( &chachapoly, tmp );
+
+ TIME_AND_TSC( title,
+ mbedtls_chachapoly_encrypt_and_tag( &chachapoly,
+ BUFSIZE, tmp, NULL, 0, buf, buf, tmp ) );
+
+ mbedtls_chachapoly_free( &chachapoly );
+ }
+#endif
+#if defined(MBEDTLS_CMAC_C)
+ if( todo.aes_cmac )
+ {
+ unsigned char output[16];
+ const mbedtls_cipher_info_t *cipher_info;
+ mbedtls_cipher_type_t cipher_type;
+ int keysize;
+
+ for( keysize = 128, cipher_type = MBEDTLS_CIPHER_AES_128_ECB;
+ keysize <= 256;
+ keysize += 64, cipher_type++ )
+ {
+ mbedtls_snprintf( title, sizeof( title ), "AES-CMAC-%d", keysize );
+
+ memset( buf, 0, sizeof( buf ) );
+ memset( tmp, 0, sizeof( tmp ) );
+
+ cipher_info = mbedtls_cipher_info_from_type( cipher_type );
+
+ TIME_AND_TSC( title,
+ mbedtls_cipher_cmac( cipher_info, tmp, keysize,
+ buf, BUFSIZE, output ) );
+ }
+
+ memset( buf, 0, sizeof( buf ) );
+ memset( tmp, 0, sizeof( tmp ) );
+ TIME_AND_TSC( "AES-CMAC-PRF-128",
+ mbedtls_aes_cmac_prf_128( tmp, 16, buf, BUFSIZE,
+ output ) );
+ }
+#endif /* MBEDTLS_CMAC_C */
+#endif /* MBEDTLS_AES_C */
+
+#if defined(MBEDTLS_ARIA_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
+ if( todo.aria )
+ {
+ int keysize;
+ mbedtls_aria_context aria;
+ mbedtls_aria_init( &aria );
+ for( keysize = 128; keysize <= 256; keysize += 64 )
+ {
+ mbedtls_snprintf( title, sizeof( title ), "ARIA-CBC-%d", keysize );
+
+ memset( buf, 0, sizeof( buf ) );
+ memset( tmp, 0, sizeof( tmp ) );
+ mbedtls_aria_setkey_enc( &aria, tmp, keysize );
+
+ TIME_AND_TSC( title,
+ mbedtls_aria_crypt_cbc( &aria, MBEDTLS_ARIA_ENCRYPT,
+ BUFSIZE, tmp, buf, buf ) );
+ }
+ mbedtls_aria_free( &aria );
+ }
+#endif
+
+#if defined(MBEDTLS_CAMELLIA_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
+ if( todo.camellia )
+ {
+ int keysize;
+ mbedtls_camellia_context camellia;
+ mbedtls_camellia_init( &camellia );
+ for( keysize = 128; keysize <= 256; keysize += 64 )
+ {
+ mbedtls_snprintf( title, sizeof( title ), "CAMELLIA-CBC-%d", keysize );
+
+ memset( buf, 0, sizeof( buf ) );
+ memset( tmp, 0, sizeof( tmp ) );
+ mbedtls_camellia_setkey_enc( &camellia, tmp, keysize );
+
+ TIME_AND_TSC( title,
+ mbedtls_camellia_crypt_cbc( &camellia, MBEDTLS_CAMELLIA_ENCRYPT,
+ BUFSIZE, tmp, buf, buf ) );
+ }
+ mbedtls_camellia_free( &camellia );
+ }
+#endif
+
+#if defined(MBEDTLS_CHACHA20_C)
+ if ( todo.chacha20 )
+ {
+ TIME_AND_TSC( "ChaCha20", mbedtls_chacha20_crypt( buf, buf, 0U, BUFSIZE, buf, buf ) );
+ }
+#endif
+
+#if defined(MBEDTLS_POLY1305_C)
+ if ( todo.poly1305 )
+ {
+ TIME_AND_TSC( "Poly1305", mbedtls_poly1305_mac( buf, buf, BUFSIZE, buf ) );
+ }
+#endif
+
+#if defined(MBEDTLS_BLOWFISH_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
+ if( todo.blowfish )
+ {
+ int keysize;
+ mbedtls_blowfish_context blowfish;
+ mbedtls_blowfish_init( &blowfish );
+
+ for( keysize = 128; keysize <= 256; keysize += 64 )
+ {
+ mbedtls_snprintf( title, sizeof( title ), "BLOWFISH-CBC-%d", keysize );
+
+ memset( buf, 0, sizeof( buf ) );
+ memset( tmp, 0, sizeof( tmp ) );
+ mbedtls_blowfish_setkey( &blowfish, tmp, keysize );
+
+ TIME_AND_TSC( title,
+ mbedtls_blowfish_crypt_cbc( &blowfish, MBEDTLS_BLOWFISH_ENCRYPT, BUFSIZE,
+ tmp, buf, buf ) );
+ }
+
+ mbedtls_blowfish_free( &blowfish );
+ }
+#endif
+
+#if defined(MBEDTLS_HAVEGE_C)
+ if( todo.havege )
+ {
+ mbedtls_havege_state hs;
+ mbedtls_havege_init( &hs );
+ TIME_AND_TSC( "HAVEGE", mbedtls_havege_random( &hs, buf, BUFSIZE ) );
+ mbedtls_havege_free( &hs );
+ }
+#endif
+
+#if defined(MBEDTLS_CTR_DRBG_C)
+ if( todo.ctr_drbg )
+ {
+ mbedtls_ctr_drbg_context ctr_drbg;
+
+ mbedtls_ctr_drbg_init( &ctr_drbg );
+
+ if( mbedtls_ctr_drbg_seed( &ctr_drbg, myrand, NULL, NULL, 0 ) != 0 )
+ mbedtls_exit(1);
+ TIME_AND_TSC( "CTR_DRBG (NOPR)",
+ mbedtls_ctr_drbg_random( &ctr_drbg, buf, BUFSIZE ) );
+
+ if( mbedtls_ctr_drbg_seed( &ctr_drbg, myrand, NULL, NULL, 0 ) != 0 )
+ mbedtls_exit(1);
+ mbedtls_ctr_drbg_set_prediction_resistance( &ctr_drbg, MBEDTLS_CTR_DRBG_PR_ON );
+ TIME_AND_TSC( "CTR_DRBG (PR)",
+ mbedtls_ctr_drbg_random( &ctr_drbg, buf, BUFSIZE ) );
+ mbedtls_ctr_drbg_free( &ctr_drbg );
+ }
+#endif
+
+#if defined(MBEDTLS_HMAC_DRBG_C)
+ if( todo.hmac_drbg )
+ {
+ mbedtls_hmac_drbg_context hmac_drbg;
+ const mbedtls_md_info_t *md_info;
+
+ mbedtls_hmac_drbg_init( &hmac_drbg );
+
+#if defined(MBEDTLS_SHA1_C)
+ if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 ) ) == NULL )
+ mbedtls_exit(1);
+
+ if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
+ mbedtls_exit(1);
+ TIME_AND_TSC( "HMAC_DRBG SHA-1 (NOPR)",
+ mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) );
+
+ if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
+ mbedtls_exit(1);
+ mbedtls_hmac_drbg_set_prediction_resistance( &hmac_drbg,
+ MBEDTLS_HMAC_DRBG_PR_ON );
+ TIME_AND_TSC( "HMAC_DRBG SHA-1 (PR)",
+ mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) );
+#endif
+
+#if defined(MBEDTLS_SHA256_C)
+ if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 ) ) == NULL )
+ mbedtls_exit(1);
+
+ if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
+ mbedtls_exit(1);
+ TIME_AND_TSC( "HMAC_DRBG SHA-256 (NOPR)",
+ mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) );
+
+ if( mbedtls_hmac_drbg_seed( &hmac_drbg, md_info, myrand, NULL, NULL, 0 ) != 0 )
+ mbedtls_exit(1);
+ mbedtls_hmac_drbg_set_prediction_resistance( &hmac_drbg,
+ MBEDTLS_HMAC_DRBG_PR_ON );
+ TIME_AND_TSC( "HMAC_DRBG SHA-256 (PR)",
+ mbedtls_hmac_drbg_random( &hmac_drbg, buf, BUFSIZE ) );
+#endif
+ mbedtls_hmac_drbg_free( &hmac_drbg );
+ }
+#endif
+
+#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME)
+ if( todo.rsa )
+ {
+ int keysize;
+ mbedtls_rsa_context rsa;
+ for( keysize = 2048; keysize <= 4096; keysize *= 2 )
+ {
+ mbedtls_snprintf( title, sizeof( title ), "RSA-%d", keysize );
+
+ mbedtls_rsa_init( &rsa, MBEDTLS_RSA_PKCS_V15, 0 );
+ mbedtls_rsa_gen_key( &rsa, myrand, NULL, keysize, 65537 );
+
+ TIME_PUBLIC( title, " public",
+ buf[0] = 0;
+ ret = mbedtls_rsa_public( &rsa, buf, buf ) );
+
+ TIME_PUBLIC( title, "private",
+ buf[0] = 0;
+ ret = mbedtls_rsa_private( &rsa, myrand, NULL, buf, buf ) );
+
+ mbedtls_rsa_free( &rsa );
+ }
+ }
+#endif
+
+#if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_BIGNUM_C)
+ if( todo.dhm )
+ {
+ int dhm_sizes[] = { 2048, 3072 };
+ static const unsigned char dhm_P_2048[] =
+ MBEDTLS_DHM_RFC3526_MODP_2048_P_BIN;
+ static const unsigned char dhm_P_3072[] =
+ MBEDTLS_DHM_RFC3526_MODP_3072_P_BIN;
+ static const unsigned char dhm_G_2048[] =
+ MBEDTLS_DHM_RFC3526_MODP_2048_G_BIN;
+ static const unsigned char dhm_G_3072[] =
+ MBEDTLS_DHM_RFC3526_MODP_3072_G_BIN;
+
+ const unsigned char *dhm_P[] = { dhm_P_2048, dhm_P_3072 };
+ const size_t dhm_P_size[] = { sizeof( dhm_P_2048 ),
+ sizeof( dhm_P_3072 ) };
+
+ const unsigned char *dhm_G[] = { dhm_G_2048, dhm_G_3072 };
+ const size_t dhm_G_size[] = { sizeof( dhm_G_2048 ),
+ sizeof( dhm_G_3072 ) };
+
+ mbedtls_dhm_context dhm;
+ size_t olen;
+ for( i = 0; (size_t) i < sizeof( dhm_sizes ) / sizeof( dhm_sizes[0] ); i++ )
+ {
+ mbedtls_dhm_init( &dhm );
+
+ if( mbedtls_mpi_read_binary( &dhm.P, dhm_P[i],
+ dhm_P_size[i] ) != 0 ||
+ mbedtls_mpi_read_binary( &dhm.G, dhm_G[i],
+ dhm_G_size[i] ) != 0 )
+ {
+ mbedtls_exit( 1 );
+ }
+
+ dhm.len = mbedtls_mpi_size( &dhm.P );
+ mbedtls_dhm_make_public( &dhm, (int) dhm.len, buf, dhm.len, myrand, NULL );
+ if( mbedtls_mpi_copy( &dhm.GY, &dhm.GX ) != 0 )
+ mbedtls_exit( 1 );
+
+ mbedtls_snprintf( title, sizeof( title ), "DHE-%d", dhm_sizes[i] );
+ TIME_PUBLIC( title, "handshake",
+ ret |= mbedtls_dhm_make_public( &dhm, (int) dhm.len, buf, dhm.len,
+ myrand, NULL );
+ ret |= mbedtls_dhm_calc_secret( &dhm, buf, sizeof( buf ), &olen, myrand, NULL ) );
+
+ mbedtls_snprintf( title, sizeof( title ), "DH-%d", dhm_sizes[i] );
+ TIME_PUBLIC( title, "handshake",
+ ret |= mbedtls_dhm_calc_secret( &dhm, buf, sizeof( buf ), &olen, myrand, NULL ) );
+
+ mbedtls_dhm_free( &dhm );
+ }
+ }
+#endif
+
+#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_SHA256_C)
+ if( todo.ecdsa )
+ {
+ mbedtls_ecdsa_context ecdsa;
+ const mbedtls_ecp_curve_info *curve_info;
+ size_t sig_len;
+
+ memset( buf, 0x2A, sizeof( buf ) );
+
+ for( curve_info = mbedtls_ecp_curve_list();
+ curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
+ curve_info++ )
+ {
+ mbedtls_ecdsa_init( &ecdsa );
+
+ if( mbedtls_ecdsa_genkey( &ecdsa, curve_info->grp_id, myrand, NULL ) != 0 )
+ mbedtls_exit( 1 );
+ ecp_clear_precomputed( &ecdsa.grp );
+
+ mbedtls_snprintf( title, sizeof( title ), "ECDSA-%s",
+ curve_info->name );
+ TIME_PUBLIC( title, "sign",
+ ret = mbedtls_ecdsa_write_signature( &ecdsa, MBEDTLS_MD_SHA256, buf, curve_info->bit_size,
+ tmp, &sig_len, myrand, NULL ) );
+
+ mbedtls_ecdsa_free( &ecdsa );
+ }
+
+ for( curve_info = mbedtls_ecp_curve_list();
+ curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
+ curve_info++ )
+ {
+ mbedtls_ecdsa_init( &ecdsa );
+
+ if( mbedtls_ecdsa_genkey( &ecdsa, curve_info->grp_id, myrand, NULL ) != 0 ||
+ mbedtls_ecdsa_write_signature( &ecdsa, MBEDTLS_MD_SHA256, buf, curve_info->bit_size,
+ tmp, &sig_len, myrand, NULL ) != 0 )
+ {
+ mbedtls_exit( 1 );
+ }
+ ecp_clear_precomputed( &ecdsa.grp );
+
+ mbedtls_snprintf( title, sizeof( title ), "ECDSA-%s",
+ curve_info->name );
+ TIME_PUBLIC( title, "verify",
+ ret = mbedtls_ecdsa_read_signature( &ecdsa, buf, curve_info->bit_size,
+ tmp, sig_len ) );
+
+ mbedtls_ecdsa_free( &ecdsa );
+ }
+ }
+#endif
+
+#if defined(MBEDTLS_ECDH_C) && defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
+ if( todo.ecdh )
+ {
+ mbedtls_ecdh_context ecdh;
+ mbedtls_mpi z;
+ const mbedtls_ecp_curve_info montgomery_curve_list[] = {
+#if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
+ { MBEDTLS_ECP_DP_CURVE25519, 0, 0, "Curve25519" },
+#endif
+#if defined(MBEDTLS_ECP_DP_CURVE448_ENABLED)
+ { MBEDTLS_ECP_DP_CURVE448, 0, 0, "Curve448" },
+#endif
+ { MBEDTLS_ECP_DP_NONE, 0, 0, 0 }
+ };
+ const mbedtls_ecp_curve_info *curve_info;
+ size_t olen;
+
+ for( curve_info = mbedtls_ecp_curve_list();
+ curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
+ curve_info++ )
+ {
+ mbedtls_ecdh_init( &ecdh );
+
+ if( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) != 0 ||
+ mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
+ myrand, NULL ) != 0 ||
+ mbedtls_ecp_copy( &ecdh.Qp, &ecdh.Q ) != 0 )
+ {
+ mbedtls_exit( 1 );
+ }
+ ecp_clear_precomputed( &ecdh.grp );
+
+ mbedtls_snprintf( title, sizeof( title ), "ECDHE-%s",
+ curve_info->name );
+ TIME_PUBLIC( title, "handshake",
+ ret |= mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
+ myrand, NULL );
+ ret |= mbedtls_ecdh_calc_secret( &ecdh, &olen, buf, sizeof( buf ),
+ myrand, NULL ) );
+ mbedtls_ecdh_free( &ecdh );
+ }
+
+ /* Montgomery curves need to be handled separately */
+ for ( curve_info = montgomery_curve_list;
+ curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
+ curve_info++ )
+ {
+ mbedtls_ecdh_init( &ecdh );
+ mbedtls_mpi_init( &z );
+
+ if( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) != 0 ||
+ mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Qp, myrand, NULL ) != 0 )
+ {
+ mbedtls_exit( 1 );
+ }
+
+ mbedtls_snprintf( title, sizeof(title), "ECDHE-%s",
+ curve_info->name );
+ TIME_PUBLIC( title, "handshake",
+ ret |= mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Q,
+ myrand, NULL );
+ ret |= mbedtls_ecdh_compute_shared( &ecdh.grp, &z, &ecdh.Qp, &ecdh.d,
+ myrand, NULL ) );
+
+ mbedtls_ecdh_free( &ecdh );
+ mbedtls_mpi_free( &z );
+ }
+
+ for( curve_info = mbedtls_ecp_curve_list();
+ curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
+ curve_info++ )
+ {
+ mbedtls_ecdh_init( &ecdh );
+
+ if( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) != 0 ||
+ mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
+ myrand, NULL ) != 0 ||
+ mbedtls_ecp_copy( &ecdh.Qp, &ecdh.Q ) != 0 ||
+ mbedtls_ecdh_make_public( &ecdh, &olen, buf, sizeof( buf),
+ myrand, NULL ) != 0 )
+ {
+ mbedtls_exit( 1 );
+ }
+ ecp_clear_precomputed( &ecdh.grp );
+
+ mbedtls_snprintf( title, sizeof( title ), "ECDH-%s",
+ curve_info->name );
+ TIME_PUBLIC( title, "handshake",
+ ret |= mbedtls_ecdh_calc_secret( &ecdh, &olen, buf, sizeof( buf ),
+ myrand, NULL ) );
+ mbedtls_ecdh_free( &ecdh );
+ }
+
+ /* Montgomery curves need to be handled separately */
+ for ( curve_info = montgomery_curve_list;
+ curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
+ curve_info++)
+ {
+ mbedtls_ecdh_init( &ecdh );
+ mbedtls_mpi_init( &z );
+
+ if( mbedtls_ecp_group_load( &ecdh.grp, curve_info->grp_id ) != 0 ||
+ mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Qp,
+ myrand, NULL ) != 0 ||
+ mbedtls_ecdh_gen_public( &ecdh.grp, &ecdh.d, &ecdh.Q, myrand, NULL ) != 0 )
+ {
+ mbedtls_exit( 1 );
+ }
+
+ mbedtls_snprintf( title, sizeof(title), "ECDH-%s",
+ curve_info->name );
+ TIME_PUBLIC( title, "handshake",
+ ret |= mbedtls_ecdh_compute_shared( &ecdh.grp, &z, &ecdh.Qp, &ecdh.d,
+ myrand, NULL ) );
+
+ mbedtls_ecdh_free( &ecdh );
+ mbedtls_mpi_free( &z );
+ }
+ }
+#endif
+
+ mbedtls_printf( "\n" );
+
+#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
+ mbedtls_memory_buffer_alloc_free();
+#endif
+
+#if defined(_WIN32)
+ mbedtls_printf( " Press Enter to exit this program.\n" );
+ fflush( stdout ); getchar();
+#endif
+
+ return( 0 );
+}
+
+#endif /* MBEDTLS_TIMING_C */
diff --git a/roms/skiboot/libstb/crypto/mbedtls/programs/test/cpp_dummy_build.cpp b/roms/skiboot/libstb/crypto/mbedtls/programs/test/cpp_dummy_build.cpp
new file mode 100644
index 000000000..c65288404
--- /dev/null
+++ b/roms/skiboot/libstb/crypto/mbedtls/programs/test/cpp_dummy_build.cpp
@@ -0,0 +1,119 @@
+/*
+ * This program is a dummy C++ program to ensure Mbed TLS library header files
+ * can be included and built with a C++ compiler.
+ *
+ * Copyright (C) 2018, ARM Limited, All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ *
+ * This file is part of mbed TLS (https://tls.mbed.org)
+ */
+
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+
+#include "mbedtls/aes.h"
+#include "mbedtls/aesni.h"
+#include "mbedtls/arc4.h"
+#include "mbedtls/aria.h"
+#include "mbedtls/asn1.h"
+#include "mbedtls/asn1write.h"
+#include "mbedtls/base64.h"
+#include "mbedtls/bignum.h"
+#include "mbedtls/blowfish.h"
+#include "mbedtls/bn_mul.h"
+#include "mbedtls/camellia.h"
+#include "mbedtls/ccm.h"
+#include "mbedtls/certs.h"
+#include "mbedtls/chacha20.h"
+#include "mbedtls/chachapoly.h"
+#include "mbedtls/check_config.h"
+#include "mbedtls/cipher.h"
+#include "mbedtls/cipher_internal.h"
+#include "mbedtls/cmac.h"
+#include "mbedtls/compat-1.3.h"
+#include "mbedtls/ctr_drbg.h"
+#include "mbedtls/debug.h"
+#include "mbedtls/des.h"
+#include "mbedtls/dhm.h"
+#include "mbedtls/ecdh.h"
+#include "mbedtls/ecdsa.h"
+#include "mbedtls/ecjpake.h"
+#include "mbedtls/ecp.h"
+#include "mbedtls/ecp_internal.h"
+#include "mbedtls/entropy.h"
+#include "mbedtls/entropy_poll.h"
+#include "mbedtls/error.h"
+#include "mbedtls/gcm.h"
+#include "mbedtls/havege.h"
+#include "mbedtls/hkdf.h"
+#include "mbedtls/hmac_drbg.h"
+#include "mbedtls/md.h"
+#include "mbedtls/md2.h"
+#include "mbedtls/md4.h"
+#include "mbedtls/md5.h"
+#include "mbedtls/md_internal.h"
+#include "mbedtls/net.h"
+#include "mbedtls/net_sockets.h"
+#include "mbedtls/nist_kw.h"
+#include "mbedtls/oid.h"
+#include "mbedtls/padlock.h"
+#include "mbedtls/pem.h"
+#include "mbedtls/pk.h"
+#include "mbedtls/pk_internal.h"
+#include "mbedtls/pkcs11.h"
+#include "mbedtls/pkcs12.h"
+#include "mbedtls/pkcs5.h"
+#include "mbedtls/platform_time.h"
+#include "mbedtls/platform_util.h"
+#include "mbedtls/poly1305.h"
+#include "mbedtls/ripemd160.h"
+#include "mbedtls/rsa.h"
+#include "mbedtls/rsa_internal.h"
+#include "mbedtls/sha1.h"
+#include "mbedtls/sha256.h"
+#include "mbedtls/sha512.h"
+#include "mbedtls/ssl.h"
+#include "mbedtls/ssl_cache.h"
+#include "mbedtls/ssl_ciphersuites.h"
+#include "mbedtls/ssl_cookie.h"
+#include "mbedtls/ssl_internal.h"
+#include "mbedtls/ssl_ticket.h"
+#include "mbedtls/threading.h"
+#include "mbedtls/timing.h"
+#include "mbedtls/version.h"
+#include "mbedtls/x509.h"
+#include "mbedtls/x509_crl.h"
+#include "mbedtls/x509_crt.h"
+#include "mbedtls/x509_csr.h"
+#include "mbedtls/xtea.h"
+
+#if defined(MBEDTLS_PLATFORM_C)
+#include "mbedtls/platform.h"
+#endif
+
+#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
+#include "mbedtls/memory_buffer_alloc.h"
+#endif
+
+int main()
+{
+ mbedtls_platform_context *ctx = NULL;
+ mbedtls_platform_setup(ctx);
+ mbedtls_printf("CPP Build test\n");
+ mbedtls_platform_teardown(ctx);
+}
diff --git a/roms/skiboot/libstb/crypto/mbedtls/programs/test/query_compile_time_config.c b/roms/skiboot/libstb/crypto/mbedtls/programs/test/query_compile_time_config.c
new file mode 100644
index 000000000..17becf27f
--- /dev/null
+++ b/roms/skiboot/libstb/crypto/mbedtls/programs/test/query_compile_time_config.c
@@ -0,0 +1,56 @@
+/*
+ * Query the Mbed TLS compile time configuration
+ *
+ * Copyright (C) 2018, Arm Limited, All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ *
+ * This file is part of Mbed TLS (https://tls.mbed.org)
+ */
+
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+
+#if defined(MBEDTLS_PLATFORM_C)
+#include "mbedtls/platform.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#define mbedtls_printf printf
+#define MBEDTLS_EXIT_FAILURE EXIT_FAILURE
+#endif
+
+#define USAGE \
+ "usage: %s <MBEDTLS_CONFIG>\n\n" \
+ "This program takes one command line argument which corresponds to\n" \
+ "the string representation of a Mbed TLS compile time configuration.\n" \
+ "The value 0 will be returned if this configuration is defined in the\n" \
+ "Mbed TLS build and the macro expansion of that configuration will be\n" \
+ "printed (if any). Otherwise, 1 will be returned.\n"
+
+int query_config( const char *config );
+
+int main( int argc, char *argv[] )
+{
+ if ( argc != 2 )
+ {
+ mbedtls_printf( USAGE, argv[0] );
+ return( MBEDTLS_EXIT_FAILURE );
+ }
+
+ return( query_config( argv[1] ) );
+}
diff --git a/roms/skiboot/libstb/crypto/mbedtls/programs/test/selftest.c b/roms/skiboot/libstb/crypto/mbedtls/programs/test/selftest.c
new file mode 100644
index 000000000..9d3ea7ec0
--- /dev/null
+++ b/roms/skiboot/libstb/crypto/mbedtls/programs/test/selftest.c
@@ -0,0 +1,434 @@
+/*
+ * Self-test demonstration program
+ *
+ * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ *
+ * This file is part of mbed TLS (https://tls.mbed.org)
+ */
+
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+
+#include "mbedtls/entropy.h"
+#include "mbedtls/entropy_poll.h"
+#include "mbedtls/hmac_drbg.h"
+#include "mbedtls/ctr_drbg.h"
+#include "mbedtls/dhm.h"
+#include "mbedtls/gcm.h"
+#include "mbedtls/ccm.h"
+#include "mbedtls/cmac.h"
+#include "mbedtls/md2.h"
+#include "mbedtls/md4.h"
+#include "mbedtls/md5.h"
+#include "mbedtls/ripemd160.h"
+#include "mbedtls/sha1.h"
+#include "mbedtls/sha256.h"
+#include "mbedtls/sha512.h"
+#include "mbedtls/arc4.h"
+#include "mbedtls/des.h"
+#include "mbedtls/aes.h"
+#include "mbedtls/camellia.h"
+#include "mbedtls/aria.h"
+#include "mbedtls/chacha20.h"
+#include "mbedtls/poly1305.h"
+#include "mbedtls/chachapoly.h"
+#include "mbedtls/base64.h"
+#include "mbedtls/bignum.h"
+#include "mbedtls/rsa.h"
+#include "mbedtls/x509.h"
+#include "mbedtls/xtea.h"
+#include "mbedtls/pkcs5.h"
+#include "mbedtls/ecp.h"
+#include "mbedtls/ecjpake.h"
+#include "mbedtls/timing.h"
+#include "mbedtls/nist_kw.h"
+
+#include <string.h>
+
+#if defined(MBEDTLS_PLATFORM_C)
+#include "mbedtls/platform.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#define mbedtls_printf printf
+#define mbedtls_snprintf snprintf
+#define mbedtls_exit exit
+#define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS
+#define MBEDTLS_EXIT_FAILURE EXIT_FAILURE
+#endif
+
+#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
+#include "mbedtls/memory_buffer_alloc.h"
+#endif
+
+#if defined(MBEDTLS_CHECK_PARAMS)
+#include "mbedtls/platform_util.h"
+void mbedtls_param_failed( const char *failure_condition,
+ const char *file,
+ int line )
+{
+ mbedtls_printf( "%s:%i: Input param failed - %s\n",
+ file, line, failure_condition );
+ mbedtls_exit( MBEDTLS_EXIT_FAILURE );
+}
+#endif
+
+static int test_snprintf( size_t n, const char ref_buf[10], int ref_ret )
+{
+ int ret;
+ char buf[10] = "xxxxxxxxx";
+ const char ref[10] = "xxxxxxxxx";
+
+ ret = mbedtls_snprintf( buf, n, "%s", "123" );
+ if( ret < 0 || (size_t) ret >= n )
+ ret = -1;
+
+ if( strncmp( ref_buf, buf, sizeof( buf ) ) != 0 ||
+ ref_ret != ret ||
+ memcmp( buf + n, ref + n, sizeof( buf ) - n ) != 0 )
+ {
+ return( 1 );
+ }
+
+ return( 0 );
+}
+
+static int run_test_snprintf( void )
+{
+ return( test_snprintf( 0, "xxxxxxxxx", -1 ) != 0 ||
+ test_snprintf( 1, "", -1 ) != 0 ||
+ test_snprintf( 2, "1", -1 ) != 0 ||
+ test_snprintf( 3, "12", -1 ) != 0 ||
+ test_snprintf( 4, "123", 3 ) != 0 ||
+ test_snprintf( 5, "123", 3 ) != 0 );
+}
+
+/*
+ * Check if a seed file is present, and if not create one for the entropy
+ * self-test. If this fails, we attempt the test anyway, so no error is passed
+ * back.
+ */
+#if defined(MBEDTLS_SELF_TEST) && defined(MBEDTLS_ENTROPY_C)
+#if defined(MBEDTLS_ENTROPY_NV_SEED) && !defined(MBEDTLS_NO_PLATFORM_ENTROPY)
+static void create_entropy_seed_file( void )
+{
+ int result;
+ size_t output_len = 0;
+ unsigned char seed_value[MBEDTLS_ENTROPY_BLOCK_SIZE];
+
+ /* Attempt to read the entropy seed file. If this fails - attempt to write
+ * to the file to ensure one is present. */
+ result = mbedtls_platform_std_nv_seed_read( seed_value,
+ MBEDTLS_ENTROPY_BLOCK_SIZE );
+ if( 0 == result )
+ return;
+
+ result = mbedtls_platform_entropy_poll( NULL,
+ seed_value,
+ MBEDTLS_ENTROPY_BLOCK_SIZE,
+ &output_len );
+ if( 0 != result )
+ return;
+
+ if( MBEDTLS_ENTROPY_BLOCK_SIZE != output_len )
+ return;
+
+ mbedtls_platform_std_nv_seed_write( seed_value, MBEDTLS_ENTROPY_BLOCK_SIZE );
+}
+#endif
+
+int mbedtls_entropy_self_test_wrapper( int verbose )
+{
+#if defined(MBEDTLS_ENTROPY_NV_SEED) && !defined(MBEDTLS_NO_PLATFORM_ENTROPY)
+ create_entropy_seed_file( );
+#endif
+ return( mbedtls_entropy_self_test( verbose ) );
+}
+#endif
+
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
+int mbedtls_memory_buffer_alloc_free_and_self_test( int verbose )
+{
+ if( verbose != 0 )
+ {
+#if defined(MBEDTLS_MEMORY_DEBUG)
+ mbedtls_memory_buffer_alloc_status( );
+#endif
+ }
+ mbedtls_memory_buffer_alloc_free( );
+ return( mbedtls_memory_buffer_alloc_self_test( verbose ) );
+}
+#endif
+
+typedef struct
+{
+ const char *name;
+ int ( *function )( int );
+} selftest_t;
+
+const selftest_t selftests[] =
+{
+#if defined(MBEDTLS_MD2_C)
+ {"md2", mbedtls_md2_self_test},
+#endif
+#if defined(MBEDTLS_MD4_C)
+ {"md4", mbedtls_md4_self_test},
+#endif
+#if defined(MBEDTLS_MD5_C)
+ {"md5", mbedtls_md5_self_test},
+#endif
+#if defined(MBEDTLS_RIPEMD160_C)
+ {"ripemd160", mbedtls_ripemd160_self_test},
+#endif
+#if defined(MBEDTLS_SHA1_C)
+ {"sha1", mbedtls_sha1_self_test},
+#endif
+#if defined(MBEDTLS_SHA256_C)
+ {"sha256", mbedtls_sha256_self_test},
+#endif
+#if defined(MBEDTLS_SHA512_C)
+ {"sha512", mbedtls_sha512_self_test},
+#endif
+#if defined(MBEDTLS_ARC4_C)
+ {"arc4", mbedtls_arc4_self_test},
+#endif
+#if defined(MBEDTLS_DES_C)
+ {"des", mbedtls_des_self_test},
+#endif
+#if defined(MBEDTLS_AES_C)
+ {"aes", mbedtls_aes_self_test},
+#endif
+#if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_AES_C)
+ {"gcm", mbedtls_gcm_self_test},
+#endif
+#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_AES_C)
+ {"ccm", mbedtls_ccm_self_test},
+#endif
+#if defined(MBEDTLS_NIST_KW_C) && defined(MBEDTLS_AES_C)
+ {"nist_kw", mbedtls_nist_kw_self_test},
+#endif
+#if defined(MBEDTLS_CMAC_C)
+ {"cmac", mbedtls_cmac_self_test},
+#endif
+#if defined(MBEDTLS_CHACHA20_C)
+ {"chacha20", mbedtls_chacha20_self_test},
+#endif
+#if defined(MBEDTLS_POLY1305_C)
+ {"poly1305", mbedtls_poly1305_self_test},
+#endif
+#if defined(MBEDTLS_CHACHAPOLY_C)
+ {"chacha20-poly1305", mbedtls_chachapoly_self_test},
+#endif
+#if defined(MBEDTLS_BASE64_C)
+ {"base64", mbedtls_base64_self_test},
+#endif
+#if defined(MBEDTLS_BIGNUM_C)
+ {"mpi", mbedtls_mpi_self_test},
+#endif
+#if defined(MBEDTLS_RSA_C)
+ {"rsa", mbedtls_rsa_self_test},
+#endif
+#if defined(MBEDTLS_X509_USE_C)
+ {"x509", mbedtls_x509_self_test},
+#endif
+#if defined(MBEDTLS_XTEA_C)
+ {"xtea", mbedtls_xtea_self_test},
+#endif
+#if defined(MBEDTLS_CAMELLIA_C)
+ {"camellia", mbedtls_camellia_self_test},
+#endif
+#if defined(MBEDTLS_ARIA_C)
+ {"aria", mbedtls_aria_self_test},
+#endif
+#if defined(MBEDTLS_CTR_DRBG_C)
+ {"ctr_drbg", mbedtls_ctr_drbg_self_test},
+#endif
+#if defined(MBEDTLS_HMAC_DRBG_C)
+ {"hmac_drbg", mbedtls_hmac_drbg_self_test},
+#endif
+#if defined(MBEDTLS_ECP_C)
+ {"ecp", mbedtls_ecp_self_test},
+#endif
+#if defined(MBEDTLS_ECJPAKE_C)
+ {"ecjpake", mbedtls_ecjpake_self_test},
+#endif
+#if defined(MBEDTLS_DHM_C)
+ {"dhm", mbedtls_dhm_self_test},
+#endif
+#if defined(MBEDTLS_ENTROPY_C)
+ {"entropy", mbedtls_entropy_self_test_wrapper},
+#endif
+#if defined(MBEDTLS_PKCS5_C)
+ {"pkcs5", mbedtls_pkcs5_self_test},
+#endif
+/* Slower test after the faster ones */
+#if defined(MBEDTLS_TIMING_C)
+ {"timing", mbedtls_timing_self_test},
+#endif
+/* Heap test comes last */
+#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
+ {"memory_buffer_alloc", mbedtls_memory_buffer_alloc_free_and_self_test},
+#endif
+ {NULL, NULL}
+};
+#endif /* MBEDTLS_SELF_TEST */
+
+int main( int argc, char *argv[] )
+{
+#if defined(MBEDTLS_SELF_TEST)
+ const selftest_t *test;
+#endif /* MBEDTLS_SELF_TEST */
+ char **argp;
+ int v = 1; /* v=1 for verbose mode */
+ int exclude_mode = 0;
+ int suites_tested = 0, suites_failed = 0;
+#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && defined(MBEDTLS_SELF_TEST)
+ unsigned char buf[1000000];
+#endif
+ void *pointer;
+
+ /*
+ * The C standard doesn't guarantee that all-bits-0 is the representation
+ * of a NULL pointer. We do however use that in our code for initializing
+ * structures, which should work on every modern platform. Let's be sure.
+ */
+ memset( &pointer, 0, sizeof( void * ) );
+ if( pointer != NULL )
+ {
+ mbedtls_printf( "all-bits-zero is not a NULL pointer\n" );
+ mbedtls_exit( MBEDTLS_EXIT_FAILURE );
+ }
+
+ /*
+ * Make sure we have a snprintf that correctly zero-terminates
+ */
+ if( run_test_snprintf() != 0 )
+ {
+ mbedtls_printf( "the snprintf implementation is broken\n" );
+ mbedtls_exit( MBEDTLS_EXIT_FAILURE );
+ }
+
+ for( argp = argv + ( argc >= 1 ? 1 : argc ); *argp != NULL; ++argp )
+ {
+ if( strcmp( *argp, "--quiet" ) == 0 ||
+ strcmp( *argp, "-q" ) == 0 )
+ {
+ v = 0;
+ }
+ else if( strcmp( *argp, "--exclude" ) == 0 ||
+ strcmp( *argp, "-x" ) == 0 )
+ {
+ exclude_mode = 1;
+ }
+ else
+ break;
+ }
+
+ if( v != 0 )
+ mbedtls_printf( "\n" );
+
+#if defined(MBEDTLS_SELF_TEST)
+
+#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
+ mbedtls_memory_buffer_alloc_init( buf, sizeof(buf) );
+#endif
+
+ if( *argp != NULL && exclude_mode == 0 )
+ {
+ /* Run the specified tests */
+ for( ; *argp != NULL; argp++ )
+ {
+ for( test = selftests; test->name != NULL; test++ )
+ {
+ if( !strcmp( *argp, test->name ) )
+ {
+ if( test->function( v ) != 0 )
+ {
+ suites_failed++;
+ }
+ suites_tested++;
+ break;
+ }
+ }
+ if( test->name == NULL )
+ {
+ mbedtls_printf( " Test suite %s not available -> failed\n\n", *argp );
+ suites_failed++;
+ }
+ }
+ }
+ else
+ {
+ /* Run all the tests except excluded ones */
+ for( test = selftests; test->name != NULL; test++ )
+ {
+ if( exclude_mode )
+ {
+ char **excluded;
+ for( excluded = argp; *excluded != NULL; ++excluded )
+ {
+ if( !strcmp( *excluded, test->name ) )
+ break;
+ }
+ if( *excluded )
+ {
+ if( v )
+ mbedtls_printf( " Skip: %s\n", test->name );
+ continue;
+ }
+ }
+ if( test->function( v ) != 0 )
+ {
+ suites_failed++;
+ }
+ suites_tested++;
+ }
+ }
+
+#else
+ (void) exclude_mode;
+ mbedtls_printf( " MBEDTLS_SELF_TEST not defined.\n" );
+#endif
+
+ if( v != 0 )
+ {
+ mbedtls_printf( " Executed %d test suites\n\n", suites_tested );
+
+ if( suites_failed > 0)
+ {
+ mbedtls_printf( " [ %d tests FAIL ]\n\n", suites_failed );
+ }
+ else
+ {
+ mbedtls_printf( " [ All tests PASS ]\n\n" );
+ }
+#if defined(_WIN32)
+ mbedtls_printf( " Press Enter to exit this program.\n" );
+ fflush( stdout ); getchar();
+#endif
+ }
+
+ if( suites_failed > 0)
+ mbedtls_exit( MBEDTLS_EXIT_FAILURE );
+
+ /* return() is here to prevent compiler warnings */
+ return( MBEDTLS_EXIT_SUCCESS );
+}
+
diff --git a/roms/skiboot/libstb/crypto/mbedtls/programs/test/udp_proxy.c b/roms/skiboot/libstb/crypto/mbedtls/programs/test/udp_proxy.c
new file mode 100644
index 000000000..e96e91bf5
--- /dev/null
+++ b/roms/skiboot/libstb/crypto/mbedtls/programs/test/udp_proxy.c
@@ -0,0 +1,929 @@
+/*
+ * UDP proxy: emulate an unreliable UDP connexion for DTLS testing
+ *
+ * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ *
+ * This file is part of mbed TLS (https://tls.mbed.org)
+ */
+
+/*
+ * Warning: this is an internal utility program we use for tests.
+ * It does break some abstractions from the NET layer, and is thus NOT an
+ * example of good general usage.
+ */
+
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+
+#if defined(MBEDTLS_PLATFORM_C)
+#include "mbedtls/platform.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#define mbedtls_time time
+#define mbedtls_time_t time_t
+#define mbedtls_printf printf
+#define mbedtls_calloc calloc
+#define mbedtls_free free
+#define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS
+#define MBEDTLS_EXIT_FAILURE EXIT_FAILURE
+#endif /* MBEDTLS_PLATFORM_C */
+
+#if !defined(MBEDTLS_NET_C)
+int main( void )
+{
+ mbedtls_printf( "MBEDTLS_NET_C not defined.\n" );
+ return( 0 );
+}
+#else
+
+#include "mbedtls/net_sockets.h"
+#include "mbedtls/error.h"
+#include "mbedtls/ssl.h"
+#include "mbedtls/timing.h"
+
+#include <string.h>
+
+/* For select() */
+#if (defined(_WIN32) || defined(_WIN32_WCE)) && !defined(EFIX64) && \
+ !defined(EFI32)
+#include <winsock2.h>
+#include <windows.h>
+#if defined(_MSC_VER)
+#if defined(_WIN32_WCE)
+#pragma comment( lib, "ws2.lib" )
+#else
+#pragma comment( lib, "ws2_32.lib" )
+#endif
+#endif /* _MSC_VER */
+#else /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#endif /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */
+
+#define MAX_MSG_SIZE 16384 + 2048 /* max record/datagram size */
+
+#define DFL_SERVER_ADDR "localhost"
+#define DFL_SERVER_PORT "4433"
+#define DFL_LISTEN_ADDR "localhost"
+#define DFL_LISTEN_PORT "5556"
+#define DFL_PACK 0
+
+#if defined(MBEDTLS_TIMING_C)
+#define USAGE_PACK \
+ " pack=%%d default: 0 (don't pack)\n" \
+ " options: t > 0 (pack for t milliseconds)\n"
+#else
+#define USAGE_PACK
+#endif
+
+#define USAGE \
+ "\n usage: udp_proxy param=<>...\n" \
+ "\n acceptable parameters:\n" \
+ " server_addr=%%s default: localhost\n" \
+ " server_port=%%d default: 4433\n" \
+ " listen_addr=%%s default: localhost\n" \
+ " listen_port=%%d default: 4433\n" \
+ "\n" \
+ " duplicate=%%d default: 0 (no duplication)\n" \
+ " duplicate about 1:N packets randomly\n" \
+ " delay=%%d default: 0 (no delayed packets)\n" \
+ " delay about 1:N packets randomly\n" \
+ " delay_ccs=0/1 default: 0 (don't delay ChangeCipherSpec)\n" \
+ " delay_cli=%%s Handshake message from client that should be\n"\
+ " delayed. Possible values are 'ClientHello',\n" \
+ " 'Certificate', 'CertificateVerify', and\n" \
+ " 'ClientKeyExchange'.\n" \
+ " May be used multiple times, even for the same\n"\
+ " message, in which case the respective message\n"\
+ " gets delayed multiple times.\n" \
+ " delay_srv=%%s Handshake message from server that should be\n"\
+ " delayed. Possible values are 'HelloRequest',\n"\
+ " 'ServerHello', 'ServerHelloDone', 'Certificate'\n"\
+ " 'ServerKeyExchange', 'NewSessionTicket',\n"\
+ " 'HelloVerifyRequest' and ''CertificateRequest'.\n"\
+ " May be used multiple times, even for the same\n"\
+ " message, in which case the respective message\n"\
+ " gets delayed multiple times.\n" \
+ " drop=%%d default: 0 (no dropped packets)\n" \
+ " drop about 1:N packets randomly\n" \
+ " mtu=%%d default: 0 (unlimited)\n" \
+ " drop packets larger than N bytes\n" \
+ " bad_ad=0/1 default: 0 (don't add bad ApplicationData)\n" \
+ " protect_hvr=0/1 default: 0 (don't protect HelloVerifyRequest)\n" \
+ " protect_len=%%d default: (don't protect packets of this size)\n" \
+ "\n" \
+ " seed=%%d default: (use current time)\n" \
+ USAGE_PACK \
+ "\n"
+
+/*
+ * global options
+ */
+
+#define MAX_DELAYED_HS 10
+
+static struct options
+{
+ const char *server_addr; /* address to forward packets to */
+ const char *server_port; /* port to forward packets to */
+ const char *listen_addr; /* address for accepting client connections */
+ const char *listen_port; /* port for accepting client connections */
+
+ int duplicate; /* duplicate 1 in N packets (none if 0) */
+ int delay; /* delay 1 packet in N (none if 0) */
+ int delay_ccs; /* delay ChangeCipherSpec */
+ char* delay_cli[MAX_DELAYED_HS]; /* handshake types of messages from
+ * client that should be delayed. */
+ uint8_t delay_cli_cnt; /* Number of entries in delay_cli. */
+ char* delay_srv[MAX_DELAYED_HS]; /* handshake types of messages from
+ * server that should be delayed. */
+ uint8_t delay_srv_cnt; /* Number of entries in delay_srv. */
+ int drop; /* drop 1 packet in N (none if 0) */
+ int mtu; /* drop packets larger than this */
+ int bad_ad; /* inject corrupted ApplicationData record */
+ int protect_hvr; /* never drop or delay HelloVerifyRequest */
+ int protect_len; /* never drop/delay packet of the given size*/
+ unsigned pack; /* merge packets into single datagram for
+ * at most \c merge milliseconds if > 0 */
+ unsigned int seed; /* seed for "random" events */
+} opt;
+
+static void exit_usage( const char *name, const char *value )
+{
+ if( value == NULL )
+ mbedtls_printf( " unknown option or missing value: %s\n", name );
+ else
+ mbedtls_printf( " option %s: illegal value: %s\n", name, value );
+
+ mbedtls_printf( USAGE );
+ exit( 1 );
+}
+
+static void get_options( int argc, char *argv[] )
+{
+ int i;
+ char *p, *q;
+
+ opt.server_addr = DFL_SERVER_ADDR;
+ opt.server_port = DFL_SERVER_PORT;
+ opt.listen_addr = DFL_LISTEN_ADDR;
+ opt.listen_port = DFL_LISTEN_PORT;
+ opt.pack = DFL_PACK;
+ /* Other members default to 0 */
+
+ opt.delay_cli_cnt = 0;
+ opt.delay_srv_cnt = 0;
+ memset( opt.delay_cli, 0, sizeof( opt.delay_cli ) );
+ memset( opt.delay_srv, 0, sizeof( opt.delay_srv ) );
+
+ for( i = 1; i < argc; i++ )
+ {
+ p = argv[i];
+ if( ( q = strchr( p, '=' ) ) == NULL )
+ exit_usage( p, NULL );
+ *q++ = '\0';
+
+ if( strcmp( p, "server_addr" ) == 0 )
+ opt.server_addr = q;
+ else if( strcmp( p, "server_port" ) == 0 )
+ opt.server_port = q;
+ else if( strcmp( p, "listen_addr" ) == 0 )
+ opt.listen_addr = q;
+ else if( strcmp( p, "listen_port" ) == 0 )
+ opt.listen_port = q;
+ else if( strcmp( p, "duplicate" ) == 0 )
+ {
+ opt.duplicate = atoi( q );
+ if( opt.duplicate < 0 || opt.duplicate > 20 )
+ exit_usage( p, q );
+ }
+ else if( strcmp( p, "delay" ) == 0 )
+ {
+ opt.delay = atoi( q );
+ if( opt.delay < 0 || opt.delay > 20 || opt.delay == 1 )
+ exit_usage( p, q );
+ }
+ else if( strcmp( p, "delay_ccs" ) == 0 )
+ {
+ opt.delay_ccs = atoi( q );
+ if( opt.delay_ccs < 0 || opt.delay_ccs > 1 )
+ exit_usage( p, q );
+ }
+ else if( strcmp( p, "delay_cli" ) == 0 ||
+ strcmp( p, "delay_srv" ) == 0 )
+ {
+ uint8_t *delay_cnt;
+ char **delay_list;
+ size_t len;
+ char *buf;
+
+ if( strcmp( p, "delay_cli" ) == 0 )
+ {
+ delay_cnt = &opt.delay_cli_cnt;
+ delay_list = opt.delay_cli;
+ }
+ else
+ {
+ delay_cnt = &opt.delay_srv_cnt;
+ delay_list = opt.delay_srv;
+ }
+
+ if( *delay_cnt == MAX_DELAYED_HS )
+ {
+ mbedtls_printf( " too many uses of %s: only %d allowed\n",
+ p, MAX_DELAYED_HS );
+ exit_usage( p, NULL );
+ }
+
+ len = strlen( q );
+ buf = mbedtls_calloc( 1, len + 1 );
+ if( buf == NULL )
+ {
+ mbedtls_printf( " Allocation failure\n" );
+ exit( 1 );
+ }
+ memcpy( buf, q, len + 1 );
+
+ delay_list[ (*delay_cnt)++ ] = buf;
+ }
+ else if( strcmp( p, "drop" ) == 0 )
+ {
+ opt.drop = atoi( q );
+ if( opt.drop < 0 || opt.drop > 20 || opt.drop == 1 )
+ exit_usage( p, q );
+ }
+ else if( strcmp( p, "pack" ) == 0 )
+ {
+#if defined(MBEDTLS_TIMING_C)
+ opt.pack = (unsigned) atoi( q );
+#else
+ mbedtls_printf( " option pack only defined if MBEDTLS_TIMING_C is enabled\n" );
+ exit( 1 );
+#endif
+ }
+ else if( strcmp( p, "mtu" ) == 0 )
+ {
+ opt.mtu = atoi( q );
+ if( opt.mtu < 0 || opt.mtu > MAX_MSG_SIZE )
+ exit_usage( p, q );
+ }
+ else if( strcmp( p, "bad_ad" ) == 0 )
+ {
+ opt.bad_ad = atoi( q );
+ if( opt.bad_ad < 0 || opt.bad_ad > 1 )
+ exit_usage( p, q );
+ }
+ else if( strcmp( p, "protect_hvr" ) == 0 )
+ {
+ opt.protect_hvr = atoi( q );
+ if( opt.protect_hvr < 0 || opt.protect_hvr > 1 )
+ exit_usage( p, q );
+ }
+ else if( strcmp( p, "protect_len" ) == 0 )
+ {
+ opt.protect_len = atoi( q );
+ if( opt.protect_len < 0 )
+ exit_usage( p, q );
+ }
+ else if( strcmp( p, "seed" ) == 0 )
+ {
+ opt.seed = atoi( q );
+ if( opt.seed == 0 )
+ exit_usage( p, q );
+ }
+ else
+ exit_usage( p, NULL );
+ }
+}
+
+static const char *msg_type( unsigned char *msg, size_t len )
+{
+ if( len < 1 ) return( "Invalid" );
+ switch( msg[0] )
+ {
+ case MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC: return( "ChangeCipherSpec" );
+ case MBEDTLS_SSL_MSG_ALERT: return( "Alert" );
+ case MBEDTLS_SSL_MSG_APPLICATION_DATA: return( "ApplicationData" );
+ case MBEDTLS_SSL_MSG_HANDSHAKE: break; /* See below */
+ default: return( "Unknown" );
+ }
+
+ if( len < 13 + 12 ) return( "Invalid handshake" );
+
+ /*
+ * Our handshake message are less than 2^16 bytes long, so they should
+ * have 0 as the first byte of length, frag_offset and frag_length.
+ * Otherwise, assume they are encrypted.
+ */
+ if( msg[14] || msg[19] || msg[22] ) return( "Encrypted handshake" );
+
+ switch( msg[13] )
+ {
+ case MBEDTLS_SSL_HS_HELLO_REQUEST: return( "HelloRequest" );
+ case MBEDTLS_SSL_HS_CLIENT_HELLO: return( "ClientHello" );
+ case MBEDTLS_SSL_HS_SERVER_HELLO: return( "ServerHello" );
+ case MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST: return( "HelloVerifyRequest" );
+ case MBEDTLS_SSL_HS_NEW_SESSION_TICKET: return( "NewSessionTicket" );
+ case MBEDTLS_SSL_HS_CERTIFICATE: return( "Certificate" );
+ case MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE: return( "ServerKeyExchange" );
+ case MBEDTLS_SSL_HS_CERTIFICATE_REQUEST: return( "CertificateRequest" );
+ case MBEDTLS_SSL_HS_SERVER_HELLO_DONE: return( "ServerHelloDone" );
+ case MBEDTLS_SSL_HS_CERTIFICATE_VERIFY: return( "CertificateVerify" );
+ case MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE: return( "ClientKeyExchange" );
+ case MBEDTLS_SSL_HS_FINISHED: return( "Finished" );
+ default: return( "Unknown handshake" );
+ }
+}
+
+#if defined(MBEDTLS_TIMING_C)
+/* Return elapsed time in milliseconds since the first call */
+static unsigned ellapsed_time( void )
+{
+ static int initialized = 0;
+ static struct mbedtls_timing_hr_time hires;
+
+ if( initialized == 0 )
+ {
+ (void) mbedtls_timing_get_timer( &hires, 1 );
+ initialized = 1;
+ return( 0 );
+ }
+
+ return( mbedtls_timing_get_timer( &hires, 0 ) );
+}
+
+typedef struct
+{
+ mbedtls_net_context *ctx;
+
+ const char *description;
+
+ unsigned packet_lifetime;
+ unsigned num_datagrams;
+
+ unsigned char data[MAX_MSG_SIZE];
+ size_t len;
+
+} ctx_buffer;
+
+static ctx_buffer outbuf[2];
+
+static int ctx_buffer_flush( ctx_buffer *buf )
+{
+ int ret;
+
+ mbedtls_printf( " %05u flush %s: %u bytes, %u datagrams, last %u ms\n",
+ ellapsed_time(), buf->description,
+ (unsigned) buf->len, buf->num_datagrams,
+ ellapsed_time() - buf->packet_lifetime );
+
+ ret = mbedtls_net_send( buf->ctx, buf->data, buf->len );
+
+ buf->len = 0;
+ buf->num_datagrams = 0;
+
+ return( ret );
+}
+
+static unsigned ctx_buffer_time_remaining( ctx_buffer *buf )
+{
+ unsigned const cur_time = ellapsed_time();
+
+ if( buf->num_datagrams == 0 )
+ return( (unsigned) -1 );
+
+ if( cur_time - buf->packet_lifetime >= opt.pack )
+ return( 0 );
+
+ return( opt.pack - ( cur_time - buf->packet_lifetime ) );
+}
+
+static int ctx_buffer_append( ctx_buffer *buf,
+ const unsigned char * data,
+ size_t len )
+{
+ int ret;
+
+ if( len > (size_t) INT_MAX )
+ return( -1 );
+
+ if( len > sizeof( buf->data ) )
+ {
+ mbedtls_printf( " ! buffer size %u too large (max %u)\n",
+ (unsigned) len, (unsigned) sizeof( buf->data ) );
+ return( -1 );
+ }
+
+ if( sizeof( buf->data ) - buf->len < len )
+ {
+ if( ( ret = ctx_buffer_flush( buf ) ) <= 0 )
+ return( ret );
+ }
+
+ memcpy( buf->data + buf->len, data, len );
+
+ buf->len += len;
+ if( ++buf->num_datagrams == 1 )
+ buf->packet_lifetime = ellapsed_time();
+
+ return( (int) len );
+}
+#endif /* MBEDTLS_TIMING_C */
+
+static int dispatch_data( mbedtls_net_context *ctx,
+ const unsigned char * data,
+ size_t len )
+{
+#if defined(MBEDTLS_TIMING_C)
+ ctx_buffer *buf = NULL;
+ if( opt.pack > 0 )
+ {
+ if( outbuf[0].ctx == ctx )
+ buf = &outbuf[0];
+ else if( outbuf[1].ctx == ctx )
+ buf = &outbuf[1];
+
+ if( buf == NULL )
+ return( -1 );
+
+ return( ctx_buffer_append( buf, data, len ) );
+ }
+#endif /* MBEDTLS_TIMING_C */
+
+ return( mbedtls_net_send( ctx, data, len ) );
+}
+
+typedef struct
+{
+ mbedtls_net_context *dst;
+ const char *way;
+ const char *type;
+ unsigned len;
+ unsigned char buf[MAX_MSG_SIZE];
+} packet;
+
+/* Print packet. Outgoing packets come with a reason (forward, dupl, etc.) */
+void print_packet( const packet *p, const char *why )
+{
+#if defined(MBEDTLS_TIMING_C)
+ if( why == NULL )
+ mbedtls_printf( " %05u dispatch %s %s (%u bytes)\n",
+ ellapsed_time(), p->way, p->type, p->len );
+ else
+ mbedtls_printf( " %05u dispatch %s %s (%u bytes): %s\n",
+ ellapsed_time(), p->way, p->type, p->len, why );
+#else
+ if( why == NULL )
+ mbedtls_printf( " dispatch %s %s (%u bytes)\n",
+ p->way, p->type, p->len );
+ else
+ mbedtls_printf( " dispatch %s %s (%u bytes): %s\n",
+ p->way, p->type, p->len, why );
+#endif
+
+ fflush( stdout );
+}
+
+int send_packet( const packet *p, const char *why )
+{
+ int ret;
+ mbedtls_net_context *dst = p->dst;
+
+ /* insert corrupted ApplicationData record? */
+ if( opt.bad_ad &&
+ strcmp( p->type, "ApplicationData" ) == 0 )
+ {
+ unsigned char buf[MAX_MSG_SIZE];
+ memcpy( buf, p->buf, p->len );
+
+ if( p->len <= 13 )
+ {
+ mbedtls_printf( " ! can't corrupt empty AD record" );
+ }
+ else
+ {
+ ++buf[13];
+ print_packet( p, "corrupted" );
+ }
+
+ if( ( ret = dispatch_data( dst, buf, p->len ) ) <= 0 )
+ {
+ mbedtls_printf( " ! dispatch returned %d\n", ret );
+ return( ret );
+ }
+ }
+
+ print_packet( p, why );
+ if( ( ret = dispatch_data( dst, p->buf, p->len ) ) <= 0 )
+ {
+ mbedtls_printf( " ! dispatch returned %d\n", ret );
+ return( ret );
+ }
+
+ /* Don't duplicate Application Data, only handshake covered */
+ if( opt.duplicate != 0 &&
+ strcmp( p->type, "ApplicationData" ) != 0 &&
+ rand() % opt.duplicate == 0 )
+ {
+ print_packet( p, "duplicated" );
+
+ if( ( ret = dispatch_data( dst, p->buf, p->len ) ) <= 0 )
+ {
+ mbedtls_printf( " ! dispatch returned %d\n", ret );
+ return( ret );
+ }
+ }
+
+ return( 0 );
+}
+
+#define MAX_DELAYED_MSG 5
+static size_t prev_len;
+static packet prev[MAX_DELAYED_MSG];
+
+void clear_pending( void )
+{
+ memset( &prev, 0, sizeof( prev ) );
+ prev_len = 0;
+}
+
+void delay_packet( packet *delay )
+{
+ if( prev_len == MAX_DELAYED_MSG )
+ return;
+
+ memcpy( &prev[prev_len++], delay, sizeof( packet ) );
+}
+
+int send_delayed()
+{
+ uint8_t offset;
+ int ret;
+ for( offset = 0; offset < prev_len; offset++ )
+ {
+ ret = send_packet( &prev[offset], "delayed" );
+ if( ret != 0 )
+ return( ret );
+ }
+
+ clear_pending();
+ return( 0 );
+}
+
+/*
+ * Avoid dropping or delaying a packet that was already dropped twice: this
+ * only results in uninteresting timeouts. We can't rely on type to identify
+ * packets, since during renegotiation they're all encrypted. So, rely on
+ * size mod 2048 (which is usually just size).
+ */
+static unsigned char dropped[2048] = { 0 };
+#define DROP_MAX 2
+
+/* We only drop packets at the level of entire datagrams, not at the level
+ * of records. In particular, if the peer changes the way it packs multiple
+ * records into a single datagram, we don't necessarily count the number of
+ * times a record has been dropped correctly. However, the only known reason
+ * why a peer would change datagram packing is disabling the latter on
+ * retransmission, in which case we'd drop involved records at most
+ * DROP_MAX + 1 times. */
+void update_dropped( const packet *p )
+{
+ size_t id = p->len % sizeof( dropped );
+ ++dropped[id];
+}
+
+int handle_message( const char *way,
+ mbedtls_net_context *dst,
+ mbedtls_net_context *src )
+{
+ int ret;
+ packet cur;
+ size_t id;
+
+ uint8_t delay_idx;
+ char ** delay_list;
+ uint8_t delay_list_len;
+
+ /* receive packet */
+ if( ( ret = mbedtls_net_recv( src, cur.buf, sizeof( cur.buf ) ) ) <= 0 )
+ {
+ mbedtls_printf( " ! mbedtls_net_recv returned %d\n", ret );
+ return( ret );
+ }
+
+ cur.len = ret;
+ cur.type = msg_type( cur.buf, cur.len );
+ cur.way = way;
+ cur.dst = dst;
+ print_packet( &cur, NULL );
+
+ id = cur.len % sizeof( dropped );
+
+ if( strcmp( way, "S <- C" ) == 0 )
+ {
+ delay_list = opt.delay_cli;
+ delay_list_len = opt.delay_cli_cnt;
+ }
+ else
+ {
+ delay_list = opt.delay_srv;
+ delay_list_len = opt.delay_srv_cnt;
+ }
+
+ /* Check if message type is in the list of messages
+ * that should be delayed */
+ for( delay_idx = 0; delay_idx < delay_list_len; delay_idx++ )
+ {
+ if( delay_list[ delay_idx ] == NULL )
+ continue;
+
+ if( strcmp( delay_list[ delay_idx ], cur.type ) == 0 )
+ {
+ /* Delay message */
+ delay_packet( &cur );
+
+ /* Remove entry from list */
+ mbedtls_free( delay_list[delay_idx] );
+ delay_list[delay_idx] = NULL;
+
+ return( 0 );
+ }
+ }
+
+ /* do we want to drop, delay, or forward it? */
+ if( ( opt.mtu != 0 &&
+ cur.len > (unsigned) opt.mtu ) ||
+ ( opt.drop != 0 &&
+ strcmp( cur.type, "ApplicationData" ) != 0 &&
+ ! ( opt.protect_hvr &&
+ strcmp( cur.type, "HelloVerifyRequest" ) == 0 ) &&
+ cur.len != (size_t) opt.protect_len &&
+ dropped[id] < DROP_MAX &&
+ rand() % opt.drop == 0 ) )
+ {
+ update_dropped( &cur );
+ }
+ else if( ( opt.delay_ccs == 1 &&
+ strcmp( cur.type, "ChangeCipherSpec" ) == 0 ) ||
+ ( opt.delay != 0 &&
+ strcmp( cur.type, "ApplicationData" ) != 0 &&
+ ! ( opt.protect_hvr &&
+ strcmp( cur.type, "HelloVerifyRequest" ) == 0 ) &&
+ cur.len != (size_t) opt.protect_len &&
+ dropped[id] < DROP_MAX &&
+ rand() % opt.delay == 0 ) )
+ {
+ delay_packet( &cur );
+ }
+ else
+ {
+ /* forward and possibly duplicate */
+ if( ( ret = send_packet( &cur, "forwarded" ) ) != 0 )
+ return( ret );
+
+ /* send previously delayed messages if any */
+ ret = send_delayed();
+ if( ret != 0 )
+ return( ret );
+ }
+
+ return( 0 );
+}
+
+int main( int argc, char *argv[] )
+{
+ int ret = 1;
+ int exit_code = MBEDTLS_EXIT_FAILURE;
+ uint8_t delay_idx;
+
+ mbedtls_net_context listen_fd, client_fd, server_fd;
+
+#if defined( MBEDTLS_TIMING_C )
+ struct timeval tm;
+#endif
+
+ struct timeval *tm_ptr = NULL;
+
+ int nb_fds;
+ fd_set read_fds;
+
+ mbedtls_net_init( &listen_fd );
+ mbedtls_net_init( &client_fd );
+ mbedtls_net_init( &server_fd );
+
+ get_options( argc, argv );
+
+ /*
+ * Decisions to drop/delay/duplicate packets are pseudo-random: dropping
+ * exactly 1 in N packets would lead to problems when a flight has exactly
+ * N packets: the same packet would be dropped on every resend.
+ *
+ * In order to be able to reproduce problems reliably, the seed may be
+ * specified explicitly.
+ */
+ if( opt.seed == 0 )
+ {
+ opt.seed = (unsigned int) time( NULL );
+ mbedtls_printf( " . Pseudo-random seed: %u\n", opt.seed );
+ }
+
+ srand( opt.seed );
+
+ /*
+ * 0. "Connect" to the server
+ */
+ mbedtls_printf( " . Connect to server on UDP/%s/%s ...",
+ opt.server_addr, opt.server_port );
+ fflush( stdout );
+
+ if( ( ret = mbedtls_net_connect( &server_fd, opt.server_addr, opt.server_port,
+ MBEDTLS_NET_PROTO_UDP ) ) != 0 )
+ {
+ mbedtls_printf( " failed\n ! mbedtls_net_connect returned %d\n\n", ret );
+ goto exit;
+ }
+
+ mbedtls_printf( " ok\n" );
+
+ /*
+ * 1. Setup the "listening" UDP socket
+ */
+ mbedtls_printf( " . Bind on UDP/%s/%s ...",
+ opt.listen_addr, opt.listen_port );
+ fflush( stdout );
+
+ if( ( ret = mbedtls_net_bind( &listen_fd, opt.listen_addr, opt.listen_port,
+ MBEDTLS_NET_PROTO_UDP ) ) != 0 )
+ {
+ mbedtls_printf( " failed\n ! mbedtls_net_bind returned %d\n\n", ret );
+ goto exit;
+ }
+
+ mbedtls_printf( " ok\n" );
+
+ /*
+ * 2. Wait until a client connects
+ */
+accept:
+ mbedtls_net_free( &client_fd );
+
+ mbedtls_printf( " . Waiting for a remote connection ..." );
+ fflush( stdout );
+
+ if( ( ret = mbedtls_net_accept( &listen_fd, &client_fd,
+ NULL, 0, NULL ) ) != 0 )
+ {
+ mbedtls_printf( " failed\n ! mbedtls_net_accept returned %d\n\n", ret );
+ goto exit;
+ }
+
+ mbedtls_printf( " ok\n" );
+
+ /*
+ * 3. Forward packets forever (kill the process to terminate it)
+ */
+ clear_pending();
+ memset( dropped, 0, sizeof( dropped ) );
+
+ nb_fds = client_fd.fd;
+ if( nb_fds < server_fd.fd )
+ nb_fds = server_fd.fd;
+ if( nb_fds < listen_fd.fd )
+ nb_fds = listen_fd.fd;
+ ++nb_fds;
+
+#if defined(MBEDTLS_TIMING_C)
+ if( opt.pack > 0 )
+ {
+ outbuf[0].ctx = &server_fd;
+ outbuf[0].description = "S <- C";
+ outbuf[0].num_datagrams = 0;
+ outbuf[0].len = 0;
+
+ outbuf[1].ctx = &client_fd;
+ outbuf[1].description = "S -> C";
+ outbuf[1].num_datagrams = 0;
+ outbuf[1].len = 0;
+ }
+#endif /* MBEDTLS_TIMING_C */
+
+ while( 1 )
+ {
+#if defined(MBEDTLS_TIMING_C)
+ if( opt.pack > 0 )
+ {
+ unsigned max_wait_server, max_wait_client, max_wait;
+ max_wait_server = ctx_buffer_time_remaining( &outbuf[0] );
+ max_wait_client = ctx_buffer_time_remaining( &outbuf[1] );
+
+ max_wait = (unsigned) -1;
+
+ if( max_wait_server == 0 )
+ ctx_buffer_flush( &outbuf[0] );
+ else
+ max_wait = max_wait_server;
+
+ if( max_wait_client == 0 )
+ ctx_buffer_flush( &outbuf[1] );
+ else
+ {
+ if( max_wait_client < max_wait )
+ max_wait = max_wait_client;
+ }
+
+ if( max_wait != (unsigned) -1 )
+ {
+ tm.tv_sec = max_wait / 1000;
+ tm.tv_usec = ( max_wait % 1000 ) * 1000;
+
+ tm_ptr = &tm;
+ }
+ else
+ {
+ tm_ptr = NULL;
+ }
+ }
+#endif /* MBEDTLS_TIMING_C */
+
+ FD_ZERO( &read_fds );
+ FD_SET( server_fd.fd, &read_fds );
+ FD_SET( client_fd.fd, &read_fds );
+ FD_SET( listen_fd.fd, &read_fds );
+
+ if( ( ret = select( nb_fds, &read_fds, NULL, NULL, tm_ptr ) ) < 0 )
+ {
+ perror( "select" );
+ goto exit;
+ }
+
+ if( FD_ISSET( listen_fd.fd, &read_fds ) )
+ goto accept;
+
+ if( FD_ISSET( client_fd.fd, &read_fds ) )
+ {
+ if( ( ret = handle_message( "S <- C",
+ &server_fd, &client_fd ) ) != 0 )
+ goto accept;
+ }
+
+ if( FD_ISSET( server_fd.fd, &read_fds ) )
+ {
+ if( ( ret = handle_message( "S -> C",
+ &client_fd, &server_fd ) ) != 0 )
+ goto accept;
+ }
+
+ }
+
+ exit_code = MBEDTLS_EXIT_SUCCESS;
+
+exit:
+
+#ifdef MBEDTLS_ERROR_C
+ if( exit_code != MBEDTLS_EXIT_SUCCESS )
+ {
+ char error_buf[100];
+ mbedtls_strerror( ret, error_buf, 100 );
+ mbedtls_printf( "Last error was: -0x%04X - %s\n\n", - ret, error_buf );
+ fflush( stdout );
+ }
+#endif
+
+ for( delay_idx = 0; delay_idx < MAX_DELAYED_HS; delay_idx++ )
+ {
+ mbedtls_free( opt.delay_cli + delay_idx );
+ mbedtls_free( opt.delay_srv + delay_idx );
+ }
+
+ mbedtls_net_free( &client_fd );
+ mbedtls_net_free( &server_fd );
+ mbedtls_net_free( &listen_fd );
+
+#if defined(_WIN32)
+ mbedtls_printf( " Press Enter to exit this program.\n" );
+ fflush( stdout ); getchar();
+#endif
+
+ return( exit_code );
+}
+
+#endif /* MBEDTLS_NET_C */
diff --git a/roms/skiboot/libstb/crypto/mbedtls/programs/test/udp_proxy_wrapper.sh b/roms/skiboot/libstb/crypto/mbedtls/programs/test/udp_proxy_wrapper.sh
new file mode 100755
index 000000000..29033d5d1
--- /dev/null
+++ b/roms/skiboot/libstb/crypto/mbedtls/programs/test/udp_proxy_wrapper.sh
@@ -0,0 +1,117 @@
+#!/bin/sh
+# -*-sh-basic-offset: 4-*-
+# Usage: udp_proxy_wrapper.sh [PROXY_PARAM...] -- [SERVER_PARAM...]
+
+set -u
+
+MBEDTLS_BASE="$(dirname -- "$0")/../.."
+TPXY_BIN="$MBEDTLS_BASE/programs/test/udp_proxy"
+SRV_BIN="$MBEDTLS_BASE/programs/ssl/ssl_server2"
+
+: ${VERBOSE:=0}
+
+stop_proxy() {
+ if [ -n "${tpxy_pid:-}" ]; then
+ echo
+ echo " * Killing proxy (pid $tpxy_pid) ..."
+ kill $tpxy_pid
+ fi
+}
+
+stop_server() {
+ if [ -n "${srv_pid:-}" ]; then
+ echo
+ echo " * Killing server (pid $srv_pid) ..."
+ kill $srv_pid >/dev/null 2>/dev/null
+ fi
+}
+
+cleanup() {
+ stop_server
+ stop_proxy
+ exit 129
+}
+
+trap cleanup INT TERM HUP
+
+# Extract the proxy parameters
+tpxy_cmd_snippet='"$TPXY_BIN"'
+while [ $# -ne 0 ] && [ "$1" != "--" ]; do
+ tail="$1" quoted=""
+ while [ -n "$tail" ]; do
+ case "$tail" in
+ *\'*) quoted="${quoted}${tail%%\'*}'\\''" tail="${tail#*\'}";;
+ *) quoted="${quoted}${tail}"; tail=; false;;
+ esac
+ done
+ tpxy_cmd_snippet="$tpxy_cmd_snippet '$quoted'"
+ shift
+done
+unset tail quoted
+if [ $# -eq 0 ]; then
+ echo " * No server arguments (must be preceded by \" -- \") - exit"
+ exit 3
+fi
+shift
+
+dtls_enabled=
+ipv6_in_use=
+server_port_orig=
+server_addr_orig=
+for param; do
+ case "$param" in
+ server_port=*) server_port_orig="${param#*=}";;
+ server_addr=*:*) server_addr_orig="${param#*=}"; ipv6_in_use=1;;
+ server_addr=*) server_addr_orig="${param#*=}";;
+ dtls=[!0]*) dtls_enabled=1;;
+ esac
+done
+
+if [ -z "$dtls_enabled" ] || [ -n "$ipv6_in_use" ]; then
+ echo >&2 "$0: Couldn't find DTLS enabling, or IPv6 is in use - immediate fallback to server application..."
+ if [ $VERBOSE -gt 0 ]; then
+ echo "[ $SRV_BIN $* ]"
+ fi
+ exec "$SRV_BIN" "$@"
+fi
+
+if [ -z "$server_port_orig" ]; then
+ server_port_orig=4433
+fi
+echo " * Server port: $server_port_orig"
+tpxy_cmd_snippet="$tpxy_cmd_snippet \"listen_port=\$server_port_orig\""
+tpxy_cmd_snippet="$tpxy_cmd_snippet \"server_port=\$server_port\""
+
+if [ -n "$server_addr_orig" ]; then
+ echo " * Server address: $server_addr_orig"
+ tpxy_cmd_snippet="$tpxy_cmd_snippet \"server_addr=\$server_addr_orig\""
+ tpxy_cmd_snippet="$tpxy_cmd_snippet \"listen_addr=\$server_addr_orig\""
+fi
+
+server_port=$(( server_port_orig + 1 ))
+set -- "$@" "server_port=$server_port"
+echo " * Intermediate port: $server_port"
+
+echo " * Start proxy in background ..."
+if [ $VERBOSE -gt 0 ]; then
+ echo "[ $tpxy_cmd_snippet ]"
+fi
+eval exec "$tpxy_cmd_snippet" >/dev/null 2>&1 &
+tpxy_pid=$!
+
+if [ $VERBOSE -gt 0 ]; then
+ echo " * Proxy ID: $TPXY_PID"
+fi
+
+echo " * Starting server ..."
+if [ $VERBOSE -gt 0 ]; then
+ echo "[ $SRV_BIN $* ]"
+fi
+
+exec "$SRV_BIN" "$@" >&2 &
+srv_pid=$!
+
+wait $srv_pid
+
+stop_proxy
+return 0
diff --git a/roms/skiboot/libstb/crypto/mbedtls/programs/test/zeroize.c b/roms/skiboot/libstb/crypto/mbedtls/programs/test/zeroize.c
new file mode 100644
index 000000000..29cc0ac3c
--- /dev/null
+++ b/roms/skiboot/libstb/crypto/mbedtls/programs/test/zeroize.c
@@ -0,0 +1,101 @@
+/*
+ * Zeroize application for debugger-driven testing
+ *
+ * This is a simple test application used for debugger-driven testing to check
+ * whether calls to mbedtls_platform_zeroize() are being eliminated by compiler
+ * optimizations. This application is used by the GDB script at
+ * tests/scripts/test_zeroize.gdb under the assumption that the code does not
+ * change often (as opposed to the library code) because the script sets a
+ * breakpoint at the last return statement in the main() function of this
+ * program. The debugger facilities are then used to manually inspect the
+ * memory and verify that the call to mbedtls_platform_zeroize() was not
+ * eliminated.
+ *
+ * Copyright (C) 2018, Arm Limited, All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ *
+ * This file is part of mbed TLS (https://tls.mbed.org)
+ */
+
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+
+#include <stdio.h>
+
+#if defined(MBEDTLS_PLATFORM_C)
+#include "mbedtls/platform.h"
+#else
+#include <stdlib.h>
+#define mbedtls_printf printf
+#define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS
+#define MBEDTLS_EXIT_FAILURE EXIT_FAILURE
+#endif
+
+#include "mbedtls/platform_util.h"
+
+#define BUFFER_LEN 1024
+
+void usage( void )
+{
+ mbedtls_printf( "Zeroize is a simple program to assist with testing\n" );
+ mbedtls_printf( "the mbedtls_platform_zeroize() function by using the\n" );
+ mbedtls_printf( "debugger. This program takes a file as input and\n" );
+ mbedtls_printf( "prints the first %d characters. Usage:\n\n", BUFFER_LEN );
+ mbedtls_printf( " zeroize <FILE>\n" );
+}
+
+int main( int argc, char** argv )
+{
+ int exit_code = MBEDTLS_EXIT_FAILURE;
+ FILE *fp;
+ char buf[BUFFER_LEN];
+ char *p = buf;
+ char *end = p + BUFFER_LEN;
+ int c;
+
+ if( argc != 2 )
+ {
+ mbedtls_printf( "This program takes exactly 1 agument\n" );
+ usage();
+ return( exit_code );
+ }
+
+ fp = fopen( argv[1], "r" );
+ if( fp == NULL )
+ {
+ mbedtls_printf( "Could not open file '%s'\n", argv[1] );
+ return( exit_code );
+ }
+
+ while( ( c = fgetc( fp ) ) != EOF && p < end - 1 )
+ *p++ = (char)c;
+ *p = '\0';
+
+ if( p - buf != 0 )
+ {
+ mbedtls_printf( "%s\n", buf );
+ exit_code = MBEDTLS_EXIT_SUCCESS;
+ }
+ else
+ mbedtls_printf( "The file is empty!\n" );
+
+ fclose( fp );
+ mbedtls_platform_zeroize( buf, sizeof( buf ) );
+
+ return( exit_code );
+}