lib_test_main.c

用于ECC公钥密码算法的大数运算库

#include <string.h>
#include <stdlib.h>

#include "lib_bgnz.h"
#include "lib_bgnzn.h"
#include "lib_bgnz2.h"
#include "lib_bgnf2n.h"
#include "lib_bgnfp.h"
#include "lib_ecf2n.h"
#include "lib_eccf2n.h"
#include "lib_ecfp.h"
#include "lib_eccfp.h"

#include "lib_functest.h"
#include "lib_print.h"

void main_bgn_z_module()
{
    bgn_z_start();

    //test_bgn_z_dshr_no_shift_out();
    test_bgn_z_dshl_no_shift_out();

    bgn_z_end();
}
void main_bgn_z2_module()
{
    BGNZ2_MD_ID bgnz2_md_id;

    bgnz2_md_id = bgn_z2_start();

    //test_bgn_z2_dshr_onewordsize(bgnz2_md_id);
    //test_bgn_z2_dshr_lesswordsize(bgnz2_md_id);
    //test_bgn_z2_dshl_onewordsize(bgnz2_md_id);
    //test_bgn_z2_dshl_lesswordsize(bgnz2_md_id);
    //test_bgn_z2_squ(bgnz2_md_id);
    //test_bgn_z2_mul(bgnz2_md_id);

    //test_bgn_z2_div(bgnz2_md_id);
    test_bgn_z2_ddiv(bgnz2_md_id);

    bgn_z2_end( bgnz2_md_id );

    print_bgn_z2_status();
}

void main_bgn_fp_module()
{
    BIGINT n;
    BGNFP_MD_ID bgnfp_md_id;

    n.data[ 0 ] = 0xB4D22831;
    n.data[ 1 ] = 0x146BC9B1;
    n.data[ 2 ] = 0x99DEF836;
    n.data[ 3 ] = 0xFFFFFFFF;
    n.data[ 4 ] = 0xFFFFFFFF;
    n.data[ 5 ] = 0xFFFFFFFF;
    n.len = 6;

    bgnfp_md_id = bgn_fp_start( &n );

    //test_bgn_fp_add( bgnfp_md_id, &n );
    //test_bgn_fp_sub( bgnfp_md_id, &n );
    //test_bgn_fp_mul( bgnfp_md_id, &n );
    //test_bgn_fp_squ( bgnfp_md_id, &n );
    //test_bgn_fp_sexp( bgnfp_md_id, &n );
    //test_bgn_fp_exp( bgnfp_md_id, &n ); 
    test_bgn_fp_inv( bgnfp_md_id, &n );

    bgn_fp_end( bgnfp_md_id );
  
}


void main_bgn_f2n_module()
{
    BIGINT f_x = {
        0x000000c9,0x00000000,0x00000000,0x00000000,0x00000000,0x00000008,
        6
    };
    BGNF2N_MD_ID bgnf2n_md_id;

    bgnf2n_md_id = bgn_f2n_start( &f_x );

    //test_bgn_f2n_mul(bgnf2n_md_id, &f_x);
    test_bgn_f2n_inv(bgnf2n_md_id, &f_x);

    bgn_f2n_end( bgnf2n_md_id );
}

void main_ecc_f2n_encryption(ECCF2N_MD_ID eccf2n_md_id)
{    
    UINT8 encmsg[ 128 ];
    UINT8 decmsg[ 128 ];

    EC_CURVE_POINT buf_1;
    EC_CURVE_POINT buf_2;
    EC_CURVE_POINT buf_3;
    EC_CURVE_POINT buf_4;
    ECC_KEYPAIR buf_5;

    EC_CURVE_POINT *c1;
    EC_CURVE_POINT *c2;
    EC_CURVE_POINT *encpoint;
    EC_CURVE_POINT *decpoint;
    ECC_KEYPAIR *keypair;

    BIGINT *prikey;
    EC_CURVE_POINT *pubkey;  

    UINT32 encmsglen;
    UINT32 decmsglen;

    c1 = &buf_1;
    c2 = &buf_2;
    encpoint = &buf_3;
    decpoint = &buf_4;
    keypair  = &buf_5;

    prikey = &(keypair->private_key);
    pubkey = &(keypair->public_key);

    do
    {
        ecc_f2n_generate_keypair(eccf2n_md_id,keypair);      
        print_keypair(stdout, keypair);

        input_msg( encmsg, 128 ,&encmsglen );
        fprintf(stdout,"main_ecc_f2n_encryption: encmsg:\n");
        print_msg(stdout, encmsg, encmsglen);
        
        /* imbed the msg to a point on the EC */
        if ( 0 != ecc_f2n_encoding(eccf2n_md_id, encmsg, encmsglen, encpoint))
        {
            fprintf(stdout, "error:main_ecc_f2n_encryption: failed to imbed the msg to ec.\n");
            return ;
        }

        fprintf(stdout,"main_ecc_f2n_encryption: Pm: \n");
        print_point(stdout, encpoint);

        /* Encrypt : */
        ecc_f2n_encryption(eccf2n_md_id, pubkey, encpoint, c1, c2);

        fprintf(stdout,"main_ecc_f2n_encryption: the ciphertxt is (c1,c2):\n");
        fprintf(stdout,"main_ecc_f2n_encryption: c1: \n");
        print_point(stdout,c1);
        fprintf(stdout,"main_ecc_f2n_encryption: c2: \n");
        print_point(stdout,c2);

        /* Decrypt : */
        ecc_f2n_decryption(eccf2n_md_id, prikey, c1, c2, decpoint);

        fprintf(stdout, "main_ecc_f2n_encryption: recovered Pm: \n");
        print_point(stdout, decpoint);

        ecc_f2n_decoding(eccf2n_md_id, decpoint, 128 ,decmsg,&decmsglen);

        fprintf(stdout,"main_ecc_f2n_encryption: decmsg (len = %ld):\n",decmsglen);  
        print_msg(stdout, decmsg, decmsglen);
    }while( E_GOON == query_goon() );

}

void main_ecc_f2n_ecdsa(ECCF2N_MD_ID eccf2n_md_id)
{   
    ECC_KEYPAIR buf_1;
    ECC_SIGNATURE buf_2;
   
    UINT8 * message =" Hello Every One!";
    ECC_KEYPAIR *key_pair;
    BIGINT *prikey;
    EC_CURVE_POINT *pubkey;
    ECC_SIGNATURE *signature;
    UINT32 messagelen;
    EC_BOOL ret;

    fprintf(stdout,"ECCF2N Module ECDSA Demo Begin:\n");

    key_pair = &buf_1;
    signature = &buf_2;

    ecc_f2n_generate_keypair(eccf2n_md_id, key_pair);
    prikey = &( key_pair->private_key );
    pubkey = & ( key_pair->public_key );

    fprintf(stdout,"ECDSA Private key = \n");
	print_bigint(stdout,prikey);

    fprintf(stdout,"ECDSA Public key = \n");
    print_point(stdout,pubkey);

    fprintf(stdout,"ECDSA Message:\n %s\n",message);
    
    messagelen = strlen(message);
    ecc_f2n_signate(eccf2n_md_id, prikey, message,messagelen,signature);
 
    fprintf(stdout,"ECDSA Signature: \n");    
    fprintf(stdout,"r : "); 
    print_bigint(stdout, &(signature->r));
    fprintf(stdout,"s : "); 
    print_bigint(stdout, &(signature->s));

    fprintf(stdout,"\n");
    
    ret = ecc_f2n_verify(eccf2n_md_id, pubkey,message,messagelen,signature);
   
    if ( EC_TRUE == ret )
    {
        fprintf(stdout,"ECDSA verification passed\n");
    }
    else
    {
        fprintf(stdout,"ECDSA verification failed\n");
    }

    fprintf(stdout,"ECCF2N Module ECDSA Demo End:\n");

    return ;
}

void main_ecc_f2n_module()
{
    BIGINT f_x = {
        0x000000c9,0x00000000,0x00000000,0x00000000,0x00000000,0x00000008,6
    };
    ///*
	//curve parameters
    ECF2N_CURVE curve = {
        { 0x00000001,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000, 1 },
        { 0x4a3205fd,0x512f7874,0x1481eb10,0xb8c953ca,0x0a601907,0x00000002, 6 },
    };
    BIGINT order = {
        0xa4234c33,0x77e70c12,0x000292fe,0x00000000,0x00000000,0x00000004, 6
    };
    EC_CURVE_POINT base_point = {
        { 0xe8343e36,0xd4994637,0xa0991168,0x86a2d57e,0xf0eba162,0x00000003, 6},
        { 0x797324f1,0xb11c5c0c,0xa2cdd545,0x71a0094f,0xd51fbc6c,0x00000000, 5},
    };
   ECCF2N_MD_ID eccf2n_md_id;


    //
	//*/

	//curve parameters
    /*
    ECF2N_CURVE curve = {
        { 0x00000001,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000, 1 },
        { 0x00000001,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000, 1 },
    };
    BIGINT order = {
        0x99f8a5ef,0xa2e0cc0d,0x00020108,0x00000000,0x00000000,0x00000004, 6
    };
    EC_CURVE_POINT base_point = {
        { 0x5c94eee8,0xde4e6d5e,0xaa07d793,0x7bbc11ac,0xfe13c053,0x00000002, 6},
        { 0xccdaa3d9,0x0536d538,0x321f2e80,0x5d38ff58,0x89070fb0,0x00000002, 6},
    };
    ECCF2N_MD_ID eccf2n_md_id;
    */

    eccf2n_md_id = ecc_f2n_start(&f_x, &curve, (&order), &base_point, 0, 0);

    //main_ecc_f2n_encryption( eccf2n_md_id );
    main_ecc_f2n_ecdsa( eccf2n_md_id );

    ecc_f2n_end( eccf2n_md_id );
}

void main_ecc_fp_encryption(ECCFP_MD_ID eccfp_md_id)
{    
    UINT8 encmsg[ 128 ];
    UINT8 decmsg[ 128 ];

    EC_CURVE_POINT buf_1;
    EC_CURVE_POINT buf_2;
    EC_CURVE_POINT buf_3;
    EC_CURVE_POINT buf_4;
    ECC_KEYPAIR buf_5;

    EC_CURVE_POINT *c1;
    EC_CURVE_POINT *c2;
    EC_CURVE_POINT *encpoint;
    EC_CURVE_POINT *decpoint;
    ECC_KEYPAIR *keypair;

    BIGINT *prikey;
    EC_CURVE_POINT *pubkey;  

    UINT32 encmsglen;
    UINT32 decmsglen;

    c1 = &buf_1;
    c2 = &buf_2;
    encpoint = &buf_3;
    decpoint = &buf_4;
    keypair  = &buf_5;

    prikey = &(keypair->private_key);
    pubkey = &(keypair->public_key);

    encmsglen = 46;
    decmsglen = 46;

    do
    {
        /* select a random number as the private key */
        ecc_fp_rnd_private_key(eccfp_md_id, prikey);
        
        /* compute the public key according to the private key */
        ecc_fp_get_public_key(eccfp_md_id, prikey, pubkey);
        print_keypair(stdout, keypair);

        input_msg( encmsg, 128 ,&encmsglen );
        fprintf(stdout,"main_ecc_fp_encryption: encmsg:\n");
        print_msg(stdout, encmsg, encmsglen);
        
        /* imbed the msg to a point on the EC */
        if ( 0 != ecc_fp_encoding(eccfp_md_id, encmsg, encmsglen, encpoint))
        {
            fprintf(stdout, "error:main_ecc_fp_encryption: failed to imbed the msg to ec.\n");
            return ;
        }

        fprintf(stdout,"main_ecc_fp_encryption: Pm: \n");
        print_point(stdout, encpoint);

        /* Encrypt : */
        ecc_fp_encryption(eccfp_md_id, pubkey, encpoint, c1, c2);

        fprintf(stdout,"main_ecc_fp_encryption: the ciphertxt is (c1,c2):\n");
        fprintf(stdout,"main_ecc_fp_encryption: c1: \n");
        print_point(stdout,c1);
        fprintf(stdout,"main_ecc_fp_encryption: c2: \n");
        print_point(stdout,c2);

        /* Decrypt : */
        ecc_fp_decryption(eccfp_md_id, prikey, c1, c2, decpoint);

        fprintf(stdout, "main_ecc_fp_encryption: recovered Pm: \n");
        print_point(stdout, decpoint);

        ecc_fp_decoding(eccfp_md_id, decpoint, 128 ,decmsg,&decmsglen);

        fprintf(stdout,"main_ecc_fp_encryption: decmsg (len = %ld):\n",decmsglen);  
        print_msg(stdout, decmsg, decmsglen);
    }while( E_GOON == query_goon() );

}

void main_ecc_fp_ecdsa(ECCFP_MD_ID eccfp_md_id)
{   
    ECC_KEYPAIR buf_1;
    ECC_SIGNATURE buf_2;
   
    UINT8 * message =" Hello Every One!";
    ECC_KEYPAIR *key_pair;
    BIGINT *prikey;
    EC_CURVE_POINT *pubkey;
    ECC_SIGNATURE *signature;
    EC_BOOL ret;

    fprintf(stdout,"ECCFP Module ECDSA Demo Begin:\n");

    key_pair = &buf_1;
    signature = &buf_2;

    ecc_fp_generate_keypair(eccfp_md_id, key_pair);
    prikey = &( key_pair->private_key );
    pubkey = & ( key_pair->public_key );

    fprintf(stdout,"ECDSA Private key = \n");
    print_bigint(stdout,prikey);

    fprintf(stdout,"ECDSA Public key = \n");
    print_point(stdout,pubkey);

    fprintf(stdout,"ECDSA Message:\n %s\n",message);
    
    ecc_fp_signate(eccfp_md_id, prikey, message,strlen(message),signature);
 
    fprintf(stdout,"ECDSA Signature: \n");    
    fprintf(stdout,"r : "); 
    print_bigint(stdout, &(signature->r));
    fprintf(stdout,"s : "); 
    print_bigint(stdout, &(signature->s));

    fprintf(stdout,"\n");
    
    ret = ecc_fp_verify(eccfp_md_id, pubkey,message,strlen(message),signature);
   
    if ( EC_TRUE == ret )
    {
        fprintf(stdout,"ECDSA verification passed\n");
    }
    else
    {
        fprintf(stdout,"ECDSA verification failed\n");
    }

    fprintf(stdout,"ECCFP Module ECDSA Demo End:\n");

    return ;
}

void main_ecc_fp_module()
{
    BIGINT p = {
         0xffffffff,0xffffffff,0xfffffffe,0xffffffff,0xffffffff,0xffffffff, 6
    };
    ECFP_CURVE curve = {
        {0xfffffffc,0xffffffff,0xfffffffe,0xffffffff,0xffffffff,0xffffffff, 6},
        {0xC146B9B1,0xFEB8DEEC,0x72243049,0x0FA7E9AB,0xE59C80E7,0x64210519, 6},
    };
    BIGINT order = {
        0xB4D22831,0x146BC9B1,0x99DEF836,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,6
    };
    EC_CURVE_POINT basepoint = {
        { 0x8f81d6e4,0x01bccb80,0xbb3705b4,0x98a23123,0xafd3debd,0xedf5e267, 6},
        { 0x1d0535aa,0x6c48a8d3,0x2b81d887,0xd2a4c0a5,0x6e09ffc2,0x202b9c28, 6},
    };
   
    ECCFP_MD_ID eccfp_md_id;

    eccfp_md_id = ecc_fp_start(&p, &curve, &order, &basepoint, 0, 0);
 
    main_ecc_fp_encryption( eccfp_md_id );
    main_ecc_fp_ecdsa( eccfp_md_id );

    ecc_fp_end(eccfp_md_id);
}

void main()
{
    //main_bgn_z2_module();
    //main_bgn_fp_module();
    //main_bgn_f2n_module();
    main_ecc_f2n_module();

    //main_ecc_fp_module();
}