static int verify_chain( void ) { memory_header *prv = heap.first, *cur; if( prv == NULL || verify_header( prv ) != 0 ) { #if defined(MBEDTLS_MEMORY_DEBUG) mbedtls_fprintf( stderr, "FATAL: verification of first header " "failed\n" ); #endif return( 1 ); } if( heap.first->prev != NULL ) { #if defined(MBEDTLS_MEMORY_DEBUG) mbedtls_fprintf( stderr, "FATAL: verification failed: " "first->prev != NULL\n" ); #endif return( 1 ); } cur = heap.first->next; while( cur != NULL ) { if( verify_header( cur ) != 0 ) { #if defined(MBEDTLS_MEMORY_DEBUG) mbedtls_fprintf( stderr, "FATAL: verification of header " "failed\n" ); #endif return( 1 ); } if( cur->prev != prv ) { #if defined(MBEDTLS_MEMORY_DEBUG) mbedtls_fprintf( stderr, "FATAL: verification failed: " "cur->prev != prv\n" ); #endif return( 1 ); } prv = cur; cur = cur->next; } return( 0 ); }
static void my_debug(void *ctx, int level, const char *file, int line, const char *str) { ((void)level); mbedtls_fprintf((FILE *)ctx, "%s:%04d: %s", file, line, str); fflush((FILE *)ctx); }
static int verify_header( memory_header *hdr ) { if( hdr->magic1 != MAGIC1 ) { #if defined(MBEDTLS_MEMORY_DEBUG) mbedtls_fprintf( stderr, "FATAL: MAGIC1 mismatch\n" ); #endif return( 1 ); } if( hdr->magic2 != MAGIC2 ) { #if defined(MBEDTLS_MEMORY_DEBUG) mbedtls_fprintf( stderr, "FATAL: MAGIC2 mismatch\n" ); #endif return( 1 ); } if( hdr->alloc > 1 ) { #if defined(MBEDTLS_MEMORY_DEBUG) mbedtls_fprintf( stderr, "FATAL: alloc has illegal value\n" ); #endif return( 1 ); } if( hdr->prev != NULL && hdr->prev == hdr->next ) { #if defined(MBEDTLS_MEMORY_DEBUG) mbedtls_fprintf( stderr, "FATAL: prev == next\n" ); #endif return( 1 ); } if( hdr->prev_free != NULL && hdr->prev_free == hdr->next_free ) { #if defined(MBEDTLS_MEMORY_DEBUG) mbedtls_fprintf( stderr, "FATAL: prev_free == next_free\n" ); #endif return( 1 ); } return( 0 ); }
static void debug_header( memory_header *hdr ) { #if defined(MBEDTLS_MEMORY_BACKTRACE) size_t i; #endif mbedtls_fprintf( stderr, "HDR: PTR(%10zu), PREV(%10zu), NEXT(%10zu), " "ALLOC(%zu), SIZE(%10zu)\n", (size_t) hdr, (size_t) hdr->prev, (size_t) hdr->next, hdr->alloc, hdr->size ); mbedtls_fprintf( stderr, " FPREV(%10zu), FNEXT(%10zu)\n", (size_t) hdr->prev_free, (size_t) hdr->next_free ); #if defined(MBEDTLS_MEMORY_BACKTRACE) mbedtls_fprintf( stderr, "TRACE: \n" ); for( i = 0; i < hdr->trace_count; i++ ) mbedtls_fprintf( stderr, "%s\n", hdr->trace[i] ); mbedtls_fprintf( stderr, "\n" ); #endif }
static void debug_chain() { memory_header *cur = heap.first; mbedtls_fprintf( stderr, "\nBlock list\n" ); while( cur != NULL ) { debug_header( cur ); cur = cur->next; } mbedtls_fprintf( stderr, "Free list\n" ); cur = heap.first_free; while( cur != NULL ) { debug_header( cur ); cur = cur->next_free; } }
static void my_debug( void *ctx, int level, const char *file, int line, const char *str ) { const char *p, *basename; /* Extract basename from file */ for( p = basename = file; *p != '\0'; p++ ) if( *p == '/' || *p == '\\' ) basename = p + 1; mbedtls_fprintf( (FILE *) ctx, "%s:%04d: |%d| %s", basename, line, level, str ); fflush( (FILE *) ctx ); }
int main( int argc, char *argv[] ) { FILE *f; int i, k, ret = 1; int exit_code = MBEDTLS_EXIT_FAILURE; mbedtls_entropy_context entropy; unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE]; if( argc < 2 ) { mbedtls_fprintf( stderr, "usage: %s <output filename>\n", argv[0] ); return( exit_code ); } if( ( f = fopen( argv[1], "wb+" ) ) == NULL ) { mbedtls_printf( "failed to open '%s' for writing.\n", argv[1] ); return( exit_code ); } mbedtls_entropy_init( &entropy ); for( i = 0, k = 768; i < k; i++ ) { ret = mbedtls_entropy_func( &entropy, buf, sizeof( buf ) ); if( ret != 0 ) { mbedtls_printf( " failed\n ! mbedtls_entropy_func returned -%04X\n", ret ); goto cleanup; } fwrite( buf, 1, sizeof( buf ), f ); mbedtls_printf( "Generating %ldkb of data in file '%s'... %04.1f" \ "%% done\r", (long)(sizeof(buf) * k / 1024), argv[1], (100 * (float) (i + 1)) / k ); fflush( stdout ); } exit_code = MBEDTLS_EXIT_SUCCESS; cleanup: mbedtls_printf( "\n" ); fclose( f ); mbedtls_entropy_free( &entropy ); return( exit_code ); }
static void my_mutexed_debug( void *ctx, int level, const char *file, int line, const char *str ) { long int thread_id = (long int) pthread_self(); mbedtls_mutex_lock( &debug_mutex ); ((void) level); mbedtls_fprintf( (FILE *) ctx, "%s:%04d: [ #%ld ] %s", file, line, thread_id, str ); fflush( (FILE *) ctx ); mbedtls_mutex_unlock( &debug_mutex ); }
/* * Write at most 'len' characters to shared buffer or file. * Multiple sends can occur before a receive; therefore, maintain an * offset. * Also, write content of file to shared buffer, if desired (determined * by command-line options). */ static int mbedtls_send_custom( void *ctx, const unsigned char *buf, size_t len ) { int ret; #if SOCKET_COMMUNICATION int fd = ((mbedtls_net_context *) ctx)->fd; if( fd < 0 ) return( MBEDTLS_ERR_NET_INVALID_CONTEXT ); #else ((void) ctx); #endif /* Read packet from file or write packet to file */ if( packet_count == packet_in_num ) { FILE *in_file; #if !SOCKET_COMMUNICATION size_t rlen; #endif if( !packet_in_file ) { mbedtls_fprintf( stderr, "Packet input file not specified!\n" ); exit(1); } /* Read packet from file, ignoring buf */ in_file = fopen( packet_in_file, "rb" ); if( !in_file ) { perror( "Unable to open packet input file" ); exit( 1 ); } /* Write packet to socket/buffer. */ #if SOCKET_COMMUNICATION ret = (int) write( fd, buf, len ); #else rlen = fread( shared_buf, sizeof(shared_buf[0]), BUF_SIZE, in_file ); #endif if ( ferror( in_file ) ) { perror( "Unable to read packet input file" ); exit( 1 ); } #if !SOCKET_COMMUNICATION else { *send_off += rlen; ret = rlen; } #endif fclose( in_file ); } else { /* Write packet to socket/buffer. */ #if SOCKET_COMMUNICATION ret = (int) write( fd, buf, len ); #else if ( (len <= BUF_SIZE) && memcpy( shared_buf, buf, len ) ) { *send_off += len; ret = len; } else { ret = -1; } #endif if( packet_in_num == 0 ) { char out_filename[100]; FILE *out_file; /* Write packet to file. */ snprintf( out_filename, sizeof(out_filename), "%s%zd", PACKET_FILE_PREFIX, packet_count ); out_file = fopen( out_filename, "wb" ); fwrite( buf, sizeof(char), len, out_file ); fclose( out_file ); } } packet_count++; #if SOCKET_COMMUNICATION if( ret < 0 ) { if( net_would_block( ctx ) != 0 ) return( MBEDTLS_ERR_SSL_WANT_WRITE ); #if( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \ !defined(EFI32) if( WSAGetLastError() == WSAECONNRESET ) return( MBEDTLS_ERR_NET_CONN_RESET ); #else if( errno == EPIPE || errno == ECONNRESET ) return( MBEDTLS_ERR_NET_CONN_RESET ); if( errno == EINTR ) return( MBEDTLS_ERR_SSL_WANT_WRITE ); #endif return( MBEDTLS_ERR_NET_SEND_FAILED ); } #endif return( ret ); }
int pkencrypt_main( int argc, char *argv[] ) { FILE *f; int ret; size_t i, olen = 0; mbedtls_pk_context pk; mbedtls_entropy_context entropy; mbedtls_ctr_drbg_context ctr_drbg; unsigned char input[1024]; unsigned char buf[512]; const char *pers = "mbedtls_pk_encrypt"; ret = 1; mbedtls_ctr_drbg_init( &ctr_drbg ); if( argc != 3 ) { mbedtls_printf( "usage: mbedtls_pk_encrypt <key_file> <string of max 100 characters>\n" ); #if defined(_WIN32) mbedtls_printf( "\n" ); #endif goto exit; } mbedtls_printf( "\n . Seeding the random number generator..." ); fflush( stdout ); mbedtls_entropy_init( &entropy ); if( ( ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func, &entropy, (const unsigned char *) pers, strlen( pers ) ) ) != 0 ) { mbedtls_printf( " failed\n ! mbedtls_ctr_drbg_seed returned -0x%04x\n", -ret ); goto exit; } mbedtls_printf( "\n . Reading public key from '%s'", argv[1] ); fflush( stdout ); mbedtls_pk_init( &pk ); if( ( ret = mbedtls_pk_parse_public_keyfile( &pk, argv[1] ) ) != 0 ) { mbedtls_printf( " failed\n ! mbedtls_pk_parse_public_keyfile returned -0x%04x\n", -ret ); goto exit; } if( strlen( argv[2] ) > 100 ) { mbedtls_printf( " Input data larger than 100 characters.\n\n" ); goto exit; } memcpy( input, argv[2], strlen( argv[2] ) ); /* * Calculate the RSA encryption of the hash. */ mbedtls_printf( "\n . Generating the encrypted value" ); fflush( stdout ); if( ( ret = mbedtls_pk_encrypt( &pk, input, strlen( argv[2] ), buf, &olen, sizeof(buf), mbedtls_ctr_drbg_random, &ctr_drbg ) ) != 0 ) { mbedtls_printf( " failed\n ! mbedtls_pk_encrypt returned -0x%04x\n", -ret ); goto exit; } /* * Write the signature into result-enc.txt */ if( ( f = fopen( "result-enc.txt", "wb+" ) ) == NULL ) { ret = 1; mbedtls_printf( " failed\n ! Could not create %s\n\n", "result-enc.txt" ); goto exit; } for( i = 0; i < olen; i++ ) mbedtls_fprintf( f, "%02X%s", buf[i], ( i + 1 ) % 16 == 0 ? "\r\n" : " " ); fclose( f ); mbedtls_printf( "\n . Done (created \"%s\")\n\n", "result-enc.txt" ); exit: mbedtls_ctr_drbg_free( &ctr_drbg ); mbedtls_entropy_free( &entropy ); #if defined(MBEDTLS_ERROR_C) if( ret != 0 ) { mbedtls_strerror( ret, (char *) buf, sizeof(buf) ); mbedtls_printf( " ! Last error was: %s\n", buf ); } #endif #if defined(_WIN32) mbedtls_printf( " + Press Enter to exit this program.\n" ); fflush( stdout ); getchar(); #endif return( ret ); }
int rsaencrypt_main( int argc, char *argv[] ) { FILE *f; int ret; size_t i; mbedtls_rsa_context rsa; mbedtls_entropy_context entropy; mbedtls_ctr_drbg_context ctr_drbg; unsigned char input[1024]; unsigned char buf[512]; const char *pers = "rsa_encrypt"; mbedtls_ctr_drbg_init( &ctr_drbg ); ret = 1; if( argc != 2 ) { mbedtls_printf( "usage: rsa_encrypt <string of max 100 characters>\n" ); #if defined(_WIN32) mbedtls_printf( "\n" ); #endif goto exit; } mbedtls_printf( "\n . Seeding the random number generator..." ); fflush( stdout ); mbedtls_entropy_init( &entropy ); if( ( ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func, &entropy, (const unsigned char *) pers, strlen( pers ) ) ) != 0 ) { mbedtls_printf( " failed\n ! mbedtls_ctr_drbg_seed returned %d\n", ret ); goto exit; } mbedtls_printf( "\n . Reading public key from rsa_pub.txt" ); fflush( stdout ); if( ( f = fopen( "rsa_pub.txt", "rb" ) ) == NULL ) { ret = 1; mbedtls_printf( " failed\n ! Could not open rsa_pub.txt\n" \ " ! Please run rsa_genkey first\n\n" ); goto exit; } mbedtls_rsa_init( &rsa, MBEDTLS_RSA_PKCS_V15, 0 ); if( ( ret = mbedtls_mpi_read_file( &rsa.N, 16, f ) ) != 0 || ( ret = mbedtls_mpi_read_file( &rsa.E, 16, f ) ) != 0 ) { mbedtls_printf( " failed\n ! mbedtls_mpi_read_file returned %d\n\n", ret ); goto exit; } rsa.len = ( mbedtls_mpi_bitlen( &rsa.N ) + 7 ) >> 3; fclose( f ); if( strlen( argv[1] ) > 100 ) { mbedtls_printf( " Input data larger than 100 characters.\n\n" ); goto exit; } memcpy( input, argv[1], strlen( argv[1] ) ); /* * Calculate the RSA encryption of the hash. */ mbedtls_printf( "\n . Generating the RSA encrypted value" ); fflush( stdout ); if( ( ret = mbedtls_rsa_pkcs1_encrypt( &rsa, mbedtls_ctr_drbg_random, &ctr_drbg, MBEDTLS_RSA_PUBLIC, strlen( argv[1] ), input, buf ) ) != 0 ) { mbedtls_printf( " failed\n ! mbedtls_rsa_pkcs1_encrypt returned %d\n\n", ret ); goto exit; } /* * Write the signature into result-enc.txt */ if( ( f = fopen( "result-enc.txt", "wb+" ) ) == NULL ) { ret = 1; mbedtls_printf( " failed\n ! Could not create %s\n\n", "result-enc.txt" ); goto exit; } for( i = 0; i < rsa.len; i++ ) mbedtls_fprintf( f, "%02X%s", buf[i], ( i + 1 ) % 16 == 0 ? "\r\n" : " " ); fclose( f ); mbedtls_printf( "\n . Done (created \"%s\")\n\n", "result-enc.txt" ); exit: mbedtls_ctr_drbg_free( &ctr_drbg ); mbedtls_entropy_free( &entropy ); #if defined(_WIN32) mbedtls_printf( " + Press Enter to exit this program.\n" ); fflush( stdout ); getchar(); #endif return( ret ); }
int main( int argc, char *argv[] ) { FILE *f; int i, k, ret; mbedtls_ctr_drbg_context ctr_drbg; mbedtls_entropy_context entropy; unsigned char buf[1024]; mbedtls_ctr_drbg_init( &ctr_drbg ); if( argc < 2 ) { mbedtls_fprintf( stderr, "usage: %s <output filename>\n", argv[0] ); return( 1 ); } if( ( f = fopen( argv[1], "wb+" ) ) == NULL ) { mbedtls_printf( "failed to open '%s' for writing.\n", argv[1] ); return( 1 ); } mbedtls_entropy_init( &entropy ); ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func, &entropy, (const unsigned char *) "RANDOM_GEN", 10 ); if( ret != 0 ) { mbedtls_printf( "failed in mbedtls_ctr_drbg_seed: %d\n", ret ); goto cleanup; } mbedtls_ctr_drbg_set_prediction_resistance( &ctr_drbg, MBEDTLS_CTR_DRBG_PR_OFF ); #if defined(MBEDTLS_FS_IO) ret = mbedtls_ctr_drbg_update_seed_file( &ctr_drbg, "seedfile" ); if( ret == MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR ) { mbedtls_printf( "Failed to open seedfile. Generating one.\n" ); ret = mbedtls_ctr_drbg_write_seed_file( &ctr_drbg, "seedfile" ); if( ret != 0 ) { mbedtls_printf( "failed in mbedtls_ctr_drbg_write_seed_file: %d\n", ret ); goto cleanup; } } else if( ret != 0 ) { mbedtls_printf( "failed in mbedtls_ctr_drbg_update_seed_file: %d\n", ret ); goto cleanup; } #endif for( i = 0, k = 768; i < k; i++ ) { ret = mbedtls_ctr_drbg_random( &ctr_drbg, buf, sizeof( buf ) ); if( ret != 0 ) { mbedtls_printf("failed!\n"); goto cleanup; } fwrite( buf, 1, sizeof( buf ), f ); mbedtls_printf( "Generating %ldkb of data in file '%s'... %04.1f" \ "%% done\r", (long)(sizeof(buf) * k / 1024), argv[1], (100 * (float) (i + 1)) / k ); fflush( stdout ); } ret = 0; cleanup: mbedtls_printf("\n"); fclose( f ); mbedtls_ctr_drbg_free( &ctr_drbg ); mbedtls_entropy_free( &entropy ); return( ret ); }
int main( int argc, char *argv[] ) { FILE *f; int ret = 1; int exit_code = MBEDTLS_EXIT_FAILURE; size_t i; mbedtls_rsa_context rsa; unsigned char hash[32]; unsigned char buf[MBEDTLS_MPI_MAX_SIZE]; char filename[512]; mbedtls_mpi N, P, Q, D, E, DP, DQ, QP; mbedtls_rsa_init( &rsa, MBEDTLS_RSA_PKCS_V15, 0 ); mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &D ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &DP ); mbedtls_mpi_init( &DQ ); mbedtls_mpi_init( &QP ); if( argc != 2 ) { mbedtls_printf( "usage: rsa_sign <filename>\n" ); #if defined(_WIN32) mbedtls_printf( "\n" ); #endif goto exit; } mbedtls_printf( "\n . Reading private key from rsa_priv.txt" ); fflush( stdout ); if( ( f = fopen( "rsa_priv.txt", "rb" ) ) == NULL ) { mbedtls_printf( " failed\n ! Could not open rsa_priv.txt\n" \ " ! Please run rsa_genkey first\n\n" ); goto exit; } if( ( ret = mbedtls_mpi_read_file( &N , 16, f ) ) != 0 || ( ret = mbedtls_mpi_read_file( &E , 16, f ) ) != 0 || ( ret = mbedtls_mpi_read_file( &D , 16, f ) ) != 0 || ( ret = mbedtls_mpi_read_file( &P , 16, f ) ) != 0 || ( ret = mbedtls_mpi_read_file( &Q , 16, f ) ) != 0 || ( ret = mbedtls_mpi_read_file( &DP , 16, f ) ) != 0 || ( ret = mbedtls_mpi_read_file( &DQ , 16, f ) ) != 0 || ( ret = mbedtls_mpi_read_file( &QP , 16, f ) ) != 0 ) { mbedtls_printf( " failed\n ! mbedtls_mpi_read_file returned %d\n\n", ret ); fclose( f ); goto exit; } fclose( f ); if( ( ret = mbedtls_rsa_import( &rsa, &N, &P, &Q, &D, &E ) ) != 0 ) { mbedtls_printf( " failed\n ! mbedtls_rsa_import returned %d\n\n", ret ); goto exit; } if( ( ret = mbedtls_rsa_complete( &rsa ) ) != 0 ) { mbedtls_printf( " failed\n ! mbedtls_rsa_complete returned %d\n\n", ret ); goto exit; } mbedtls_printf( "\n . Checking the private key" ); fflush( stdout ); if( ( ret = mbedtls_rsa_check_privkey( &rsa ) ) != 0 ) { mbedtls_printf( " failed\n ! mbedtls_rsa_check_privkey failed with -0x%0x\n", -ret ); goto exit; } /* * Compute the SHA-256 hash of the input file, * then calculate the RSA signature of the hash. */ mbedtls_printf( "\n . Generating the RSA/SHA-256 signature" ); fflush( stdout ); if( ( ret = mbedtls_md_file( mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 ), argv[1], hash ) ) != 0 ) { mbedtls_printf( " failed\n ! Could not open or read %s\n\n", argv[1] ); goto exit; } if( ( ret = mbedtls_rsa_pkcs1_sign( &rsa, NULL, NULL, MBEDTLS_RSA_PRIVATE, MBEDTLS_MD_SHA256, 20, hash, buf ) ) != 0 ) { mbedtls_printf( " failed\n ! mbedtls_rsa_pkcs1_sign returned -0x%0x\n\n", -ret ); goto exit; } /* * Write the signature into <filename>.sig */ mbedtls_snprintf( filename, sizeof(filename), "%s.sig", argv[1] ); if( ( f = fopen( filename, "wb+" ) ) == NULL ) { mbedtls_printf( " failed\n ! Could not create %s\n\n", argv[1] ); goto exit; } for( i = 0; i < rsa.len; i++ ) mbedtls_fprintf( f, "%02X%s", buf[i], ( i + 1 ) % 16 == 0 ? "\r\n" : " " ); fclose( f ); mbedtls_printf( "\n . Done (created \"%s\")\n\n", filename ); exit_code = MBEDTLS_EXIT_SUCCESS; exit: mbedtls_rsa_free( &rsa ); mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &D ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &DP ); mbedtls_mpi_free( &DQ ); mbedtls_mpi_free( &QP ); #if defined(_WIN32) mbedtls_printf( " + Press Enter to exit this program.\n" ); fflush( stdout ); getchar(); #endif return( exit_code ); }