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 );
}
