ake6mntt.c

比较新的功能强大的rsa算法源代码,方便使用.

    t4.b=mr_mip->w14;
    t4.c=mr_mip->w15;

    zzn3_from_int(_MIPP_ 1,&t1);

    s=size(e);
    if (s==0)
    {
        zzn3_copy(&t1,w);
        return;
    }
    zzn3_copy(x,w);
    if (s==1 || s==(-1)) return;

    i=logb2(_MIPP_ e)-1;

    zzn3_copy(w,&t3);
    zzn3_mul(_MIPP_ w,w,&t4);
    zzn3_add(_MIPP_ &t4,&t4,&t4);
    zzn3_sub(_MIPP_ &t4,&t1,&t4);

    while (i--)
    {
        if (mr_testbit(_MIPP_ e,i))
        {
            zzn3_mul(_MIPP_ &t3,&t4,&t3);
            zzn3_add(_MIPP_ &t3,&t3,&t3);
            zzn3_sub(_MIPP_ &t3,w,&t3);
            zzn3_mul(_MIPP_ &t4,&t4,&t4);
            zzn3_add(_MIPP_ &t4,&t4,&t4);
            zzn3_sub(_MIPP_ &t4,&t1,&t4);
        }
        else
        {
            zzn3_mul(_MIPP_ &t4,&t3,&t4);
            zzn3_add(_MIPP_ &t4,&t4,&t4);
            zzn3_sub(_MIPP_ &t4,w,&t4);
            zzn3_mul(_MIPP_ &t3,&t3,&t3);
            zzn3_add(_MIPP_ &t3,&t3,&t3);
            zzn3_sub(_MIPP_ &t3,&t1,&t3);
        }
    }
    zzn3_copy(&t3,w);
}

void zzn6_powq(_MIPD_ zzn6 *w)
{
    zzn3_powq(_MIPP_ &(w->x),&(w->x));
    zzn3_powq(_MIPP_ &(w->y),&(w->y));
    zzn3_smul(_MIPP_ &(w->y),mr_mip->sru,&(w->y));
}

void zzn6_inv(_MIPD_ zzn6 *w)
{
    zzn3 t1,t2;
    if (w->unitary)
    {
        zzn6_conj(_MIPP_ w,w);
        return;
    }
    t1.a=mr_mip->w7;
    t1.b=mr_mip->w8;
    t1.c=mr_mip->w9;
    t2.a=mr_mip->w10;
    t2.b=mr_mip->w11;
    t2.c=mr_mip->w12;

    zzn3_copy(&(w->x),&t1);
    zzn3_copy(&(w->y),&t2);
    zzn3_mul(_MIPP_ &t1,&t1,&t1);
    zzn3_mul(_MIPP_ &t2,&t2,&t2);
    zzn3_timesi(_MIPP_ &t2);
    zzn3_sub(_MIPP_ &t1,&t2,&t2);
    zzn3_inv(_MIPP_ &t2);
    zzn3_mul(_MIPP_ &(w->x),&t2,&(w->x));
    zzn3_negate(_MIPP_ &(w->y),&(w->y));
    zzn3_mul(_MIPP_ &(w->y),&t2,&(w->y));
}

void g(_MIPD_ epoint *A,epoint *B,zzn3 *Qx,zzn3 *Qy,zzn6 *w)
{
    int type;
    big slope;
    zzn3 nn,dd;

    copy(A->X,mr_mip->w10);

    type=ecurve_add(_MIPP_ B,A);
    if (!type)  
    {
        zzn6_from_int(_MIPP_ 1,w);
        return;
    }
    slope=mr_mip->w8; /* slope in w8 */

    nn.a=mr_mip->w13;
    nn.b=mr_mip->w14;
    nn.c=mr_mip->w15;

    dd.a=mr_mip->w5;
    dd.b=mr_mip->w11;
    dd.c=mr_mip->w9;

    zzn3_copy(Qx,&nn);
    zzn3_copy(Qy,&dd);
    zzn3_negate(_MIPP_ &dd,&dd);

#ifndef MR_AFFINE_ONLY
    if (A->marker!=MR_EPOINT_GENERAL)
        copy(mr_mip->one,mr_mip->w12);
    else copy(A->Z,mr_mip->w12);       
#else
    copy(mr_mip->one,mr_mip->w12);
#endif
    if (type==MR_ADD)
    {
        zzn3_ssub(_MIPP_ &nn,B->X,&nn);
        zzn3_smul(_MIPP_ &nn,slope,&nn);
        nres_modmult(_MIPP_ mr_mip->w12,B->Y,mr_mip->w2);
        zzn3_sadd(_MIPP_ &nn,mr_mip->w2,&nn);
        zzn3_smul(_MIPP_ &dd,mr_mip->w12,&dd);
        zzn3_copy(&nn,&(w->x));
        zzn3_copy(&dd,&(w->y));
        return;
    }

    if (type==MR_DOUBLE)
    { /* note that ecurve_add has left useful things for us in w6 and w7! */     
        nres_modmult(_MIPP_ slope,mr_mip->w6,mr_mip->w2);
        zzn3_smul(_MIPP_ &nn,mr_mip->w2,&nn);
        nres_modmult(_MIPP_ slope,mr_mip->w10,slope);
        zzn3_ssub(_MIPP_ &nn,slope,&nn);
        zzn3_sadd(_MIPP_ &nn,mr_mip->w7,&nn);
        nres_modmult(_MIPP_ mr_mip->w12,mr_mip->w6,mr_mip->w12);
        zzn3_smul(_MIPP_ &dd,mr_mip->w12,&dd);
        zzn3_copy(&nn,&(w->x));
        zzn3_copy(&dd,&(w->y));
        return;
    }
}

void fast_tate_pairing(_MIPD_ epoint *P,zzn3 *Qx,zzn3 *Qy,big q,big cf,zzn6 *w,zzn6* res)
{
    int i,j,n,nb,nbw,nzs;
    epoint *t[4],*A,*P2;
    zzn6 zn[4];
    big work[4];

#ifndef MR_STATIC
    char *mem=memalloc(_MIPP_ 28);
	char *mem1=ecp_memalloc(_MIPP_ 6);
#else
    char mem[MR_BIG_RESERVE(28)];  
    char mem1[MR_ECP_RESERVE(6)]; 
    memset(mem,0,MR_BIG_RESERVE(28));
    memset(mem1,0,MR_ECP_RESERVE(6));
#endif

    for (i=0;i<4;i++)
        t[i]=epoint_init_mem(_MIPP_ mem1,i);
    A=epoint_init_mem(_MIPP_ mem1,4);
    P2=epoint_init_mem(_MIPP_ mem1,5);
  
    for (j=i=0;i<4;i++)
    {
        work[i]=mirvar_mem(_MIPP_ mem,j++);
        zn[i].x.a=mirvar_mem(_MIPP_ mem,j++);
        zn[i].x.b=mirvar_mem(_MIPP_ mem,j++);
        zn[i].x.c=mirvar_mem(_MIPP_ mem,j++);
        zn[i].y.a=mirvar_mem(_MIPP_ mem,j++);
        zn[i].y.b=mirvar_mem(_MIPP_ mem,j++);
        zn[i].y.c=mirvar_mem(_MIPP_ mem,j++);
        zn[i].unitary=FALSE;
    }

    zzn6_from_int(_MIPP_ 1,&zn[0]); 
    epoint_copy(P,A);
    epoint_copy(P,P2);
    epoint_copy(P,t[0]);

    g(_MIPP_ P2,P2,Qx,Qy,res);
    epoint_norm(_MIPP_ P2);

    for (i=1;i<4;i++)
    {
        g(_MIPP_ A,P2,Qx,Qy,w);
        epoint_copy(A,t[i]);
        zzn6_mul(_MIPP_ &zn[i-1],w,&zn[i]);
        zzn6_mul(_MIPP_ &zn[i],res,&zn[i]);
    }

    epoint_multi_norm(_MIPP_ 4,work,t);

    epoint_copy(P,A);
    zzn6_from_int(_MIPP_ 1,res);
 
    nb=logb2(_MIPP_ q);
    for (i=nb-2;i>=0;i-=(nbw+nzs))
    {
        n=mr_window(_MIPP_ q,i,&nbw,&nzs,3);
        for (j=0;j<nbw;j++)
        {
            zzn6_mul(_MIPP_ res,res,res);
            g(_MIPP_ A,A,Qx,Qy,w);
            zzn6_mul(_MIPP_ res,w,res);
        }
        if (n>0)
        {
            zzn6_mul(_MIPP_ res,&zn[n/2],res);
            g(_MIPP_ A,t[n/2],Qx,Qy,w);
            zzn6_mul(_MIPP_ res,w,res);
        }
        for (j=0;j<nzs;j++) 
        {
            zzn6_mul(_MIPP_ res,res,res);
            g(_MIPP_ A,A,Qx,Qy,w);
            zzn6_mul(_MIPP_ res,w,res);
        }
    }

    zzn6_copy(res,w);
    zzn6_powq(_MIPP_ w);
    zzn6_mul(_MIPP_ res,w,res);

    zzn6_copy(res,w);
    zzn6_powq(_MIPP_ w);
    zzn6_powq(_MIPP_ w);
    zzn6_powq(_MIPP_ w);

    zzn6_inv(_MIPP_ res);
    zzn6_mul(_MIPP_ res,w,res);

    res->unitary=TRUE;

#ifndef MR_STATIC      
    memkill(_MIPP_ mem,28);
    ecp_memkill(_MIPP_ mem1,6);
#else
    memset(mem,0,MR_BIG_RESERVE(28)); 
    memset(mem1,0,MR_ECP_RESERVE(6));
#endif
}

void ecap(_MIPD_ epoint *P,zzn3 *Qx,zzn3 *Qy,big q,big cf,zzn3* r)
{
    zzn6 res,w;
#ifndef MR_STATIC
    char *mem=memalloc(_MIPP_ 12);
#else
    char mem[MR_BIG_RESERVE(12)];        
    memset(mem,0,MR_BIG_RESERVE(12));
#endif
    res.x.a=mirvar_mem(_MIPP_ mem,0);
    res.x.b=mirvar_mem(_MIPP_ mem,1);
    res.x.c=mirvar_mem(_MIPP_ mem,2);
    res.y.a=mirvar_mem(_MIPP_ mem,3);
    res.y.b=mirvar_mem(_MIPP_ mem,4);
    res.y.c=mirvar_mem(_MIPP_ mem,5);
    w.x.a=mirvar_mem(_MIPP_ mem,6);
    w.x.b=mirvar_mem(_MIPP_ mem,7);
    w.x.c=mirvar_mem(_MIPP_ mem,8);
    w.y.a=mirvar_mem(_MIPP_ mem,9);
    w.y.b=mirvar_mem(_MIPP_ mem,10);
    w.y.c=mirvar_mem(_MIPP_ mem,11);
    res.unitary=FALSE;
    w.unitary=FALSE;

    epoint_norm(_MIPP_ P);
    fast_tate_pairing(_MIPP_ P,Qx,Qy,q,cf,&w,&res);

    zzn6_copy(&res,&w);
    zzn6_powq(_MIPP_ &res);
    zzn6_mul(_MIPP_ &res,&res,&res);

    zzn6_powu(_MIPP_ &w,cf,&w);
    zzn6_mul(_MIPP_ &res,&w,&res);

    zzn3_copy(&(res.x),r);        

#ifndef MR_STATIC      
    memkill(_MIPP_ mem,12);
#else
    memset(mem,0,MR_BIG_RESERVE(12)); 
#endif
}

int main()
{
#ifdef MR_GENERIC_MT
    miracl instance;
#endif
    big p,A,B,Fr,q,cf,sru,t,T;
    zzn3 res,Qx,Qy;
    epoint *P;
    int i,romptr;
#ifndef MR_STATIC
#ifdef MR_GENERIC_MT
    miracl *mr_mip=mirsys(&instance,WORDS*NPW,16);
#else
    miracl *mr_mip=mirsys(WORDS*NPW,16);
#endif
    char *mem=memalloc(_MIPP_ 18);   
	char *mem1=ecp_memalloc(_MIPP_ 1);
#else
#ifdef MR_GENERIC_MT
    miracl *mr_mip=mirsys(&instance,MR_STATIC*NPW,16);
#else
    miracl *mr_mip=mirsys(MR_STATIC*NPW,16);
#endif
    char mem[MR_BIG_RESERVE(18)];              /* reserve space on the stack for 18 bigs */
    char mem1[MR_ECP_RESERVE(1)];              /* reserve space on stack for 1 curve points */
    memset(mem,0,MR_BIG_RESERVE(18));          /* clear this memory */
    memset(mem1,0,MR_ECP_RESERVE(1));       
#endif
    p=mirvar_mem(_MIPP_ mem,0);
    A=mirvar_mem(_MIPP_ mem,1);
    B=mirvar_mem(_MIPP_ mem,2);
    T=mirvar_mem(_MIPP_ mem,3);
    q=mirvar_mem(_MIPP_ mem,4);
    Fr=mirvar_mem(_MIPP_ mem,5);
    cf=mirvar_mem(_MIPP_ mem,6);
    res.a=mirvar_mem(_MIPP_ mem,7);
    res.b=mirvar_mem(_MIPP_ mem,8);
    res.c=mirvar_mem(_MIPP_ mem,9);
    sru=mirvar_mem(_MIPP_ mem,10);
    t=mirvar_mem(_MIPP_ mem,11);
    Qx.a=mirvar_mem(_MIPP_ mem,12);
    Qx.b=mirvar_mem(_MIPP_ mem,13);
    Qx.c=mirvar_mem(_MIPP_ mem,14);
    Qy.a=mirvar_mem(_MIPP_ mem,15);
    Qy.b=mirvar_mem(_MIPP_ mem,16);
    Qy.c=mirvar_mem(_MIPP_ mem,17);

    P=epoint_init_mem(_MIPP_ mem1,0); 
    convert(_MIPP_ -3,A);

    romptr=0;
    init_big_from_rom(p,WORDS,romp,ROMSZ,&romptr);
    init_big_from_rom(B,WORDS,romp,ROMSZ,&romptr);
    init_big_from_rom(q,WORDS,romp,ROMSZ,&romptr);
    init_big_from_rom(cf,WORDS,romp,ROMSZ,&romptr);
    init_big_from_rom(sru,WORDS,romp,ROMSZ,&romptr);


#ifndef MR_NO_STANDARD_IO
printf("ROM size= %ld\n",sizeof(romp)+sizeof(Prom));
printf("sizeof(miracl)= %ld\n",sizeof(miracl));
#endif

    premult(_MIPP_ p,CF,t);
    subtract(_MIPP_ cf,t,cf);
    ecurve_init(_MIPP_ A,B,p,MR_BEST);
    zzn3_set(_MIPP_ CNR,sru);

    romptr=0;
    init_point_from_rom(P,WORDS,Prom,PROMSZ,&romptr);
    init_big_from_rom(Qx.a,WORDS,Prom,PROMSZ,&romptr);
    init_big_from_rom(Qx.b,WORDS,Prom,PROMSZ,&romptr);
    init_big_from_rom(Qx.c,WORDS,Prom,PROMSZ,&romptr);
    init_big_from_rom(Qy.a,WORDS,Prom,PROMSZ,&romptr);
    init_big_from_rom(Qy.b,WORDS,Prom,PROMSZ,&romptr);
    init_big_from_rom(Qy.c,WORDS,Prom,PROMSZ,&romptr);

#ifdef MR_COUNT_OPS
fpa=fpc=fpx=0;
#endif

    ecap(_MIPP_ P,&Qx,&Qy,q,cf,&res);

#ifdef MR_COUNT_OPS
printf("fpc= %d\n",fpc);
printf("fpa= %d\n",fpa);
printf("fpx= %d\n",fpx);
fpa=fpc=fpx=0;
#endif

    bigbits(_MIPP_ 160,t); 
    zzn3_powl(_MIPP_ &res,t,&res);

#ifndef MR_NO_STANDARD_IO
    zzn3_out(_MIPP_ "res= ",&res);
#endif

    ecurve_mult(_MIPP_ t,P,P);
    ecap(_MIPP_ P,&Qx,&Qy,q,cf,&res);

#ifndef MR_NO_STANDARD_IO
    zzn3_out(_MIPP_ "res= ",&res);
#endif

#ifndef MR_STATIC
    memkill(_MIPP_ mem,18);
    ecp_memkill(_MIPP_ mem1,1);
#else
    memset(mem,0,MR_BIG_RESERVE(18));        /* clear this stack memory */
    memset(mem1,0,MR_ECP_RESERVE(1));
#endif
    return 0;
}