text: /*
   *  Example ECDSA program
   *
   *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
   *  SPDX-License-Identifier: GPL-2.0
   *
   *  This program is free software; you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation; either version 2 of the License, or
   *  (at your option) any later version.
   *
   *  This program is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License along
   *  with this program; if not, write to the Free Software Foundation, Inc.,
   *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   *  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>
  #define mbedtls_printf     printf
  #endif
  
  #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 <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");
      return( 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;
      mbedtls_ecdsa_context ctx_sign, ctx_verify;
      mbedtls_entropy_context entropy;
      mbedtls_ctr_drbg_context ctr_drbg;
      unsigned char hash[] = "This should be the hash of a message.";
      unsigned char sig[512];
      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 ) );
      ret = 1;
  
      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 );
  
      /*
       * Sign some message hash
       */
      mbedtls_printf( "  . Signing message..." );
      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_genkey returned %d\n", ret );
          goto exit;
      }
      mbedtls_printf( " ok (signature length = %u)\n", (unsigned int) sig_len );
  
      dump_buf( "  + Hash: ", hash, sizeof hash );
      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;
      }
  
      ret = 0;
  
      /*
       * 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:
  
  #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 );
  
      return( ret );
  }
  #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ENTROPY_C && MBEDTLS_CTR_DRBG_C &&
            ECPARAMS */
  