static int sha1_wrapper( char *filename, unsigned char *sum ) { int ret = sha1_file( filename, sum ); if( ret == 1 ) polarssl_fprintf( stderr, "failed to open: %s\n", filename ); if( ret == 2 ) polarssl_fprintf( stderr, "failed to read: %s\n", filename ); return( ret ); }
static int verify_chain() { memory_header *prv = heap.first, *cur = heap.first->next; if( verify_header( heap.first ) != 0 ) { #if defined(POLARSSL_MEMORY_DEBUG) polarssl_fprintf( stderr, "FATAL: verification of first header " "failed\n" ); #endif return( 1 ); } if( heap.first->prev != NULL ) { #if defined(POLARSSL_MEMORY_DEBUG) polarssl_fprintf( stderr, "FATAL: verification failed: " "first->prev != NULL\n" ); #endif return( 1 ); } while( cur != NULL ) { if( verify_header( cur ) != 0 ) { #if defined(POLARSSL_MEMORY_DEBUG) polarssl_fprintf( stderr, "FATAL: verification of header " "failed\n" ); #endif return( 1 ); } if( cur->prev != prv ) { #if defined(POLARSSL_MEMORY_DEBUG) polarssl_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 *str ) { ((void) level); polarssl_fprintf( (FILE *) ctx, "%s", str ); fflush( (FILE *) ctx ); }
static void my_debug( void *ctx, int level, const char *str ) { if( level < opt.debug_level ) { polarssl_fprintf( (FILE *) ctx, "%s", str ); fflush( (FILE *) ctx ); } }
static int verify_header( memory_header *hdr ) { if( hdr->magic1 != MAGIC1 ) { #if defined(POLARSSL_MEMORY_DEBUG) polarssl_fprintf( stderr, "FATAL: MAGIC1 mismatch\n" ); #endif return( 1 ); } if( hdr->magic2 != MAGIC2 ) { #if defined(POLARSSL_MEMORY_DEBUG) polarssl_fprintf( stderr, "FATAL: MAGIC2 mismatch\n" ); #endif return( 1 ); } if( hdr->alloc > 1 ) { #if defined(POLARSSL_MEMORY_DEBUG) polarssl_fprintf( stderr, "FATAL: alloc has illegal value\n" ); #endif return( 1 ); } if( hdr->prev != NULL && hdr->prev == hdr->next ) { #if defined(POLARSSL_MEMORY_DEBUG) polarssl_fprintf( stderr, "FATAL: prev == next\n" ); #endif return( 1 ); } if( hdr->prev_free != NULL && hdr->prev_free == hdr->next_free ) { #if defined(POLARSSL_MEMORY_DEBUG) polarssl_fprintf( stderr, "FATAL: prev_free == next_free\n" ); #endif return( 1 ); } return( 0 ); }
static void my_mutexed_debug( void *ctx, int level, const char *str ) { polarssl_mutex_lock( &debug_mutex ); if( level < DEBUG_LEVEL ) { polarssl_fprintf( (FILE *) ctx, "%s", str ); fflush( (FILE *) ctx ); } polarssl_mutex_unlock( &debug_mutex ); }
static void debug_header( memory_header *hdr ) { #if defined(POLARSSL_MEMORY_BACKTRACE) size_t i; #endif polarssl_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 ); polarssl_fprintf( stderr, " FPREV(%10zu), FNEXT(%10zu)\n", (size_t) hdr->prev_free, (size_t) hdr->next_free ); #if defined(POLARSSL_MEMORY_BACKTRACE) polarssl_fprintf( stderr, "TRACE: \n" ); for( i = 0; i < hdr->trace_count; i++ ) polarssl_fprintf( stderr, "%s\n", hdr->trace[i] ); polarssl_fprintf( stderr, "\n" ); #endif }
static void debug_chain() { memory_header *cur = heap.first; polarssl_fprintf( stderr, "\nBlock list\n" ); while( cur != NULL ) { debug_header( cur ); cur = cur->next; } polarssl_fprintf( stderr, "Free list\n" ); cur = heap.first_free; while( cur != NULL ) { debug_header( cur ); cur = cur->next_free; } }
static void usage( const char *prog ) { polarssl_fprintf( stderr, "Usage: %s [packet number] [packet file]\n", prog ); }
/* * 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 send_custom( void *ctx, const unsigned char *buf, size_t len ) { int ret; #if SOCKET_COMMUNICATION int fd = *((int *) ctx); if( fd < 0 ) return( POLARSSL_ERR_NET_SOCKET_FAILED ); #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 ) { polarssl_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( fd ) != 0 ) return( POLARSSL_ERR_NET_WANT_WRITE ); #if( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \ !defined(EFI32) if( WSAGetLastError() == WSAECONNRESET ) return( POLARSSL_ERR_NET_CONN_RESET ); #else if( errno == EPIPE || errno == ECONNRESET ) return( POLARSSL_ERR_NET_CONN_RESET ); if( errno == EINTR ) return( POLARSSL_ERR_NET_WANT_WRITE ); #endif return( POLARSSL_ERR_NET_SEND_FAILED ); } #endif return( ret ); }
int main( int argc, char *argv[] ) { FILE *f; int ret; size_t i, olen = 0; pk_context pk; entropy_context entropy; ctr_drbg_context ctr_drbg; unsigned char input[1024]; unsigned char buf[512]; const char *pers = "pk_encrypt"; ret = 1; if( argc != 3 ) { polarssl_printf( "usage: pk_encrypt <key_file> <string of max 100 characters>\n" ); #if defined(_WIN32) polarssl_printf( "\n" ); #endif goto exit; } polarssl_printf( "\n . Seeding the random number generator..." ); fflush( stdout ); entropy_init( &entropy ); if( ( ret = ctr_drbg_init( &ctr_drbg, entropy_func, &entropy, (const unsigned char *) pers, strlen( pers ) ) ) != 0 ) { polarssl_printf( " failed\n ! ctr_drbg_init returned -0x%04x\n", -ret ); goto exit; } polarssl_printf( "\n . Reading public key from '%s'", argv[1] ); fflush( stdout ); pk_init( &pk ); if( ( ret = pk_parse_public_keyfile( &pk, argv[1] ) ) != 0 ) { polarssl_printf( " failed\n ! pk_parse_public_keyfile returned -0x%04x\n", -ret ); goto exit; } if( strlen( argv[2] ) > 100 ) { polarssl_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. */ polarssl_printf( "\n . Generating the encrypted value" ); fflush( stdout ); if( ( ret = pk_encrypt( &pk, input, strlen( argv[2] ), buf, &olen, sizeof(buf), ctr_drbg_random, &ctr_drbg ) ) != 0 ) { polarssl_printf( " failed\n ! 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; polarssl_printf( " failed\n ! Could not create %s\n\n", "result-enc.txt" ); goto exit; } for( i = 0; i < olen; i++ ) polarssl_fprintf( f, "%02X%s", buf[i], ( i + 1 ) % 16 == 0 ? "\r\n" : " " ); fclose( f ); polarssl_printf( "\n . Done (created \"%s\")\n\n", "result-enc.txt" ); exit: ctr_drbg_free( &ctr_drbg ); entropy_free( &entropy ); #if defined(POLARSSL_ERROR_C) polarssl_strerror( ret, (char *) buf, sizeof(buf) ); polarssl_printf( " ! Last error was: %s\n", buf ); #endif #if defined(_WIN32) polarssl_printf( " + Press Enter to exit this program.\n" ); fflush( stdout ); getchar(); #endif return( ret ); }
static int sha1_check( char *filename ) { int i; size_t n; FILE *f; int nb_err1, nb_err2; int nb_tot1, nb_tot2; unsigned char sum[20]; char buf[41], line[1024]; char diff; if( ( f = fopen( filename, "rb" ) ) == NULL ) { polarssl_printf( "failed to open: %s\n", filename ); return( 1 ); } nb_err1 = nb_err2 = 0; nb_tot1 = nb_tot2 = 0; memset( line, 0, sizeof( line ) ); n = sizeof( line ); while( fgets( line, (int) n - 1, f ) != NULL ) { n = strlen( line ); if( n < 44 ) continue; if( line[40] != ' ' || line[41] != ' ' ) continue; if( line[n - 1] == '\n' ) { n--; line[n] = '\0'; } if( line[n - 1] == '\r' ) { n--; line[n] = '\0'; } nb_tot1++; if( sha1_wrapper( line + 42, sum ) != 0 ) { nb_err1++; continue; } nb_tot2++; for( i = 0; i < 20; i++ ) sprintf( buf + i * 2, "%02x", sum[i] ); /* Use constant-time buffer comparison */ diff = 0; for( i = 0; i < 40; i++ ) diff |= line[i] ^ buf[i]; if( diff != 0 ) { nb_err2++; polarssl_fprintf( stderr, "wrong checksum: %s\n", line + 42 ); } n = sizeof( line ); } fclose( f ); if( nb_err1 != 0 ) { polarssl_printf( "WARNING: %d (out of %d) input files could " "not be read\n", nb_err1, nb_tot1 ); } if( nb_err2 != 0 ) { polarssl_printf( "WARNING: %d (out of %d) computed checksums did " "not match\n", nb_err2, nb_tot2 ); } return( nb_err1 != 0 || nb_err2 != 0 ); }