| /* |
| * Example ECDSA 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 |
| |
| #if defined(MBEDTLS_PLATFORM_C) |
| #include "mbedtls/platform.h" |
| #else |
| #include <stdio.h> |
| #include <stdlib.h> |
| #define mbedtls_printf printf |
| #define mbedtls_exit exit |
| #define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS |
| #define MBEDTLS_EXIT_FAILURE EXIT_FAILURE |
| #endif /* MBEDTLS_PLATFORM_C */ |
| |
| #if defined(MBEDTLS_ECDSA_C) && \ |
| defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C) |
| #include "mbedtls/entropy.h" |
| #include "mbedtls/ctr_drbg.h" |
| #include "mbedtls/ecdsa.h" |
| #include "mbedtls/sha256.h" |
| |
| #include <string.h> |
| #endif |
| |
| /* |
| * Uncomment to show key and signature details |
| */ |
| #define VERBOSE |
| |
| /* |
| * Uncomment to force use of a specific curve |
| */ |
| #define ECPARAMS MBEDTLS_ECP_DP_SECP192R1 |
| |
| #if !defined(ECPARAMS) |
| #define ECPARAMS mbedtls_ecp_curve_list()->grp_id |
| #endif |
| |
| #if !defined(MBEDTLS_ECDSA_C) || !defined(MBEDTLS_SHA256_C) || \ |
| !defined(MBEDTLS_ENTROPY_C) || !defined(MBEDTLS_CTR_DRBG_C) |
| int main( void ) |
| { |
| mbedtls_printf("MBEDTLS_ECDSA_C and/or MBEDTLS_SHA256_C and/or " |
| "MBEDTLS_ENTROPY_C and/or MBEDTLS_CTR_DRBG_C not defined\n"); |
| mbedtls_exit( 0 ); |
| } |
| #else |
| #if defined(VERBOSE) |
| static void dump_buf( const char *title, unsigned char *buf, size_t len ) |
| { |
| size_t i; |
| |
| mbedtls_printf( "%s", title ); |
| for( i = 0; i < len; i++ ) |
| mbedtls_printf("%c%c", "0123456789ABCDEF" [buf[i] / 16], |
| "0123456789ABCDEF" [buf[i] % 16] ); |
| mbedtls_printf( "\n" ); |
| } |
| |
| static void dump_pubkey( const char *title, mbedtls_ecdsa_context *key ) |
| { |
| unsigned char buf[300]; |
| size_t len; |
| |
| if( mbedtls_ecp_point_write_binary( &key->grp, &key->Q, |
| MBEDTLS_ECP_PF_UNCOMPRESSED, &len, buf, sizeof buf ) != 0 ) |
| { |
| mbedtls_printf("internal error\n"); |
| return; |
| } |
| |
| dump_buf( title, buf, len ); |
| } |
| #else |
| #define dump_buf( a, b, c ) |
| #define dump_pubkey( a, b ) |
| #endif |
| |
| |
| int main( int argc, char *argv[] ) |
| { |
| int ret = 1; |
| int exit_code = MBEDTLS_EXIT_FAILURE; |
| mbedtls_ecdsa_context ctx_sign, ctx_verify; |
| mbedtls_entropy_context entropy; |
| mbedtls_ctr_drbg_context ctr_drbg; |
| unsigned char message[100]; |
| unsigned char hash[32]; |
| unsigned char sig[MBEDTLS_ECDSA_MAX_LEN]; |
| size_t sig_len; |
| const char *pers = "ecdsa"; |
| ((void) argv); |
| |
| mbedtls_ecdsa_init( &ctx_sign ); |
| mbedtls_ecdsa_init( &ctx_verify ); |
| mbedtls_ctr_drbg_init( &ctr_drbg ); |
| |
| memset( sig, 0, sizeof( sig ) ); |
| memset( message, 0x25, sizeof( message ) ); |
| |
| if( argc != 1 ) |
| { |
| mbedtls_printf( "usage: ecdsa\n" ); |
| |
| #if defined(_WIN32) |
| mbedtls_printf( "\n" ); |
| #endif |
| |
| goto exit; |
| } |
| |
| /* |
| * Generate a key pair for signing |
| */ |
| 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( " ok\n . Generating key pair..." ); |
| fflush( stdout ); |
| |
| if( ( ret = mbedtls_ecdsa_genkey( &ctx_sign, ECPARAMS, |
| mbedtls_ctr_drbg_random, &ctr_drbg ) ) != 0 ) |
| { |
| mbedtls_printf( " failed\n ! mbedtls_ecdsa_genkey returned %d\n", ret ); |
| goto exit; |
| } |
| |
| mbedtls_printf( " ok (key size: %d bits)\n", (int) ctx_sign.grp.pbits ); |
| |
| dump_pubkey( " + Public key: ", &ctx_sign ); |
| |
| /* |
| * Compute message hash |
| */ |
| mbedtls_printf( " . Computing message hash..." ); |
| fflush( stdout ); |
| |
| if( ( ret = mbedtls_sha256_ret( message, sizeof( message ), hash, 0 ) ) != 0 ) |
| { |
| mbedtls_printf( " failed\n ! mbedtls_sha256_ret returned %d\n", ret ); |
| goto exit; |
| } |
| |
| mbedtls_printf( " ok\n" ); |
| |
| dump_buf( " + Hash: ", hash, sizeof( hash ) ); |
| |
| /* |
| * Sign message hash |
| */ |
| mbedtls_printf( " . Signing message hash..." ); |
| fflush( stdout ); |
| |
| if( ( ret = mbedtls_ecdsa_write_signature( &ctx_sign, MBEDTLS_MD_SHA256, |
| hash, sizeof( hash ), |
| sig, &sig_len, |
| mbedtls_ctr_drbg_random, &ctr_drbg ) ) != 0 ) |
| { |
| mbedtls_printf( " failed\n ! mbedtls_ecdsa_write_signature returned %d\n", ret ); |
| goto exit; |
| } |
| mbedtls_printf( " ok (signature length = %u)\n", (unsigned int) sig_len ); |
| |
| dump_buf( " + Signature: ", sig, sig_len ); |
| |
| /* |
| * Transfer public information to verifying context |
| * |
| * We could use the same context for verification and signatures, but we |
| * chose to use a new one in order to make it clear that the verifying |
| * context only needs the public key (Q), and not the private key (d). |
| */ |
| mbedtls_printf( " . Preparing verification context..." ); |
| fflush( stdout ); |
| |
| if( ( ret = mbedtls_ecp_group_copy( &ctx_verify.grp, &ctx_sign.grp ) ) != 0 ) |
| { |
| mbedtls_printf( " failed\n ! mbedtls_ecp_group_copy returned %d\n", ret ); |
| goto exit; |
| } |
| |
| if( ( ret = mbedtls_ecp_copy( &ctx_verify.Q, &ctx_sign.Q ) ) != 0 ) |
| { |
| mbedtls_printf( " failed\n ! mbedtls_ecp_copy returned %d\n", ret ); |
| goto exit; |
| } |
| |
| /* |
| * Verify signature |
| */ |
| mbedtls_printf( " ok\n . Verifying signature..." ); |
| fflush( stdout ); |
| |
| if( ( ret = mbedtls_ecdsa_read_signature( &ctx_verify, |
| hash, sizeof( hash ), |
| sig, sig_len ) ) != 0 ) |
| { |
| mbedtls_printf( " failed\n ! mbedtls_ecdsa_read_signature returned %d\n", ret ); |
| goto exit; |
| } |
| |
| mbedtls_printf( " ok\n" ); |
| |
| exit_code = MBEDTLS_EXIT_SUCCESS; |
| |
| exit: |
| |
| #if defined(_WIN32) |
| mbedtls_printf( " + Press Enter to exit this program.\n" ); |
| fflush( stdout ); getchar(); |
| #endif |
| |
| mbedtls_ecdsa_free( &ctx_verify ); |
| mbedtls_ecdsa_free( &ctx_sign ); |
| mbedtls_ctr_drbg_free( &ctr_drbg ); |
| mbedtls_entropy_free( &entropy ); |
| |
| mbedtls_exit( exit_code ); |
| } |
| #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ENTROPY_C && MBEDTLS_CTR_DRBG_C && |
| ECPARAMS */ |