static void *ecdsa_alloc_wrap( void ) { void *ctx = polarssl_malloc( sizeof( ecdsa_context ) ); if( ctx != NULL ) ecdsa_init( (ecdsa_context *) ctx ); return( ctx ); }
static int eckey_verify_wrap( void *ctx, md_type_t md_alg, const unsigned char *hash, size_t hash_len, const unsigned char *sig, size_t sig_len ) { int ret; ecdsa_context ecdsa; ecdsa_init( &ecdsa ); if( ( ret = ecdsa_from_keypair( &ecdsa, ctx ) ) == 0 ) ret = ecdsa_verify_wrap( &ecdsa, md_alg, hash, hash_len, sig, sig_len ); ecdsa_free( &ecdsa ); return( ret ); }
static mrb_value mrb_ecdsa_alloc(mrb_state *mrb, mrb_value self) { ecdsa_context *ecdsa; ecdsa = (ecdsa_context *)DATA_PTR(self); if (ecdsa) { mrb_ecdsa_free(mrb, ecdsa); } DATA_TYPE(self) = &mrb_ecdsa_type; DATA_PTR(self) = NULL; ecdsa = (ecdsa_context *)mrb_malloc(mrb, sizeof(ecdsa_context)); DATA_PTR(self) = ecdsa; ecdsa_init(ecdsa); return self; }
static int eckey_sign_wrap( void *ctx, md_type_t md_alg, const unsigned char *hash, size_t hash_len, unsigned char *sig, size_t *sig_len, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ) { int ret; ecdsa_context ecdsa; ecdsa_init( &ecdsa ); if( ( ret = ecdsa_from_keypair( &ecdsa, ctx ) ) == 0 ) ret = ecdsa_sign_wrap( &ecdsa, md_alg, hash, hash_len, sig, sig_len, f_rng, p_rng ); ecdsa_free( &ecdsa ); return( ret ); }
int main(int argc, char * argv[]) { uint8_t hash[SHA256_DIGEST_LENGTH] = {0}; NN_DIGIT signature_r[NUMWORDS], signature_s[NUMWORDS]; NN_DIGIT privKey[NUMWORDS]; point_t pubKey; uint8_t data [52] = { 1, 2, 3, 4, 5 }; SHA256_CTX ctx; memset(privKey, 0, NUMBYTES); memset(&pubKey, 0, sizeof(pubKey)); memset(signature_r, 0, NUMBYTES); memset(signature_s, 0, NUMBYTES); SHA256_Init(&ctx); SHA256_Update(&ctx, data, 52); SHA256_Final(hash, &ctx); ecc_init(); ecc_gen_private_key(privKey); ecc_gen_pub_key(privKey, &pubKey); ecdsa_init(&pubKey); ecdsa_sign(hash, signature_r, signature_s, privKey); assert(ecdsa_verify(hash, signature_r, signature_s, &pubKey) == 1); signature_r[0] ^= 0xff; assert(ecdsa_verify(hash, signature_r, signature_s, &pubKey) != 1); return 0; }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(startup_process, ev, data) { PROCESS_BEGIN(); memset(prKey_bob, 0, NUMWORDS*NN_DIGIT_LEN); memset(pbkey_bob.x, 0, NUMWORDS*NN_DIGIT_LEN); memset(pbkey_bob.y, 0, NUMWORDS*NN_DIGIT_LEN); /* set public key for Alice */ pbkey_alice.x[5] = 0x00000000; pbkey_alice.x[4] = 0x21961f69; pbkey_alice.x[3] = 0xf02d202b; pbkey_alice.x[2] = 0xa4b41f1a; pbkey_alice.x[1] = 0x0aa08a86; pbkey_alice.x[0] = 0xdf27908d; pbkey_alice.y[5] = 0x00000000; pbkey_alice.y[4] = 0x378e1278; pbkey_alice.y[3] = 0x62836d75; pbkey_alice.y[2] = 0x7acb7ca4; pbkey_alice.y[1] = 0x0dc0ad13; pbkey_alice.y[0] = 0x741e287c; /* Initialize ecc. */ ecc_init(); /* Initialize ecdsa with Alice's public key */ ecdsa_init(&pbkey_alice); button_sensor.configure(SENSORS_ACTIVE, 1); process_start(&bob_process, NULL); printf("signature size %d\n", 2*(NUMWORDS * NN_DIGIT_LEN)); PROCESS_END(); }
int main( int argc, char *argv[] ) { int ret; ecdsa_context ctx_sign, ctx_verify; entropy_context entropy; 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); ecdsa_init( &ctx_sign ); ecdsa_init( &ctx_verify ); memset(sig, 0, sizeof( sig ) ); ret = 1; if( argc != 1 ) { polarssl_printf( "usage: ecdsa\n" ); #if defined(_WIN32) polarssl_printf( "\n" ); #endif goto exit; } /* * Generate a key pair for signing */ 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 %d\n", ret ); goto exit; } polarssl_printf( " ok\n . Generating key pair..." ); fflush( stdout ); if( ( ret = ecdsa_genkey( &ctx_sign, ECPARAMS, ctr_drbg_random, &ctr_drbg ) ) != 0 ) { polarssl_printf( " failed\n ! ecdsa_genkey returned %d\n", ret ); goto exit; } polarssl_printf( " ok (key size: %d bits)\n", (int) ctx_sign.grp.pbits ); dump_pubkey( " + Public key: ", &ctx_sign ); /* * Sign some message hash */ polarssl_printf( " . Signing message..." ); fflush( stdout ); if( ( ret = ecdsa_write_signature( &ctx_sign, hash, sizeof( hash ), sig, &sig_len, ctr_drbg_random, &ctr_drbg ) ) != 0 ) { polarssl_printf( " failed\n ! ecdsa_genkey returned %d\n", ret ); goto exit; } polarssl_printf( " ok (signature length = %u)\n", (unsigned int) sig_len ); dump_buf( " + Hash: ", hash, sizeof hash ); dump_buf( " + Signature: ", sig, sig_len ); /* * Signature is serialized as defined by RFC 4492 p. 20, * but one can also access 'r' and 's' directly from the context */ #ifdef POLARSSL_FS_IO mpi_write_file( " r = ", &ctx_sign.r, 16, NULL ); mpi_write_file( " s = ", &ctx_sign.s, 16, NULL ); #endif /* * 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). */ polarssl_printf( " . Preparing verification context..." ); fflush( stdout ); if( ( ret = ecp_group_copy( &ctx_verify.grp, &ctx_sign.grp ) ) != 0 ) { polarssl_printf( " failed\n ! ecp_group_copy returned %d\n", ret ); goto exit; } if( ( ret = ecp_copy( &ctx_verify.Q, &ctx_sign.Q ) ) != 0 ) { polarssl_printf( " failed\n ! ecp_copy returned %d\n", ret ); goto exit; } ret = 0; /* * Verify signature */ polarssl_printf( " ok\n . Verifying signature..." ); fflush( stdout ); if( ( ret = ecdsa_read_signature( &ctx_verify, hash, sizeof( hash ), sig, sig_len ) ) != 0 ) { polarssl_printf( " failed\n ! ecdsa_read_signature returned %d\n", ret ); goto exit; } polarssl_printf( " ok\n" ); exit: #if defined(_WIN32) polarssl_printf( " + Press Enter to exit this program.\n" ); fflush( stdout ); getchar(); #endif ecdsa_free( &ctx_verify ); ecdsa_free( &ctx_sign ); ctr_drbg_free( &ctr_drbg ); entropy_free( &entropy ); return( ret ); }