mrecn2.c

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

/*
 *    No matter where you got this code, be aware that MIRACL is NOT 
 *    free software. For commercial use a license is required.
 *	  See www.shamus.ie
 *
 *   MIRACL E(F_p^2) support functions 
 *   mrecn2.c
 *
 *   Copyright (c) 2008 Shamus Software Ltd.
 */

#include <stdlib.h> 
#include "miracl.h"
#ifdef MR_STATIC
#include <string.h>
#endif

#ifndef MR_EDWARDS

BOOL ecn2_iszero(ecn2 *a)
{
    if (a->marker==MR_EPOINT_INFINITY) return TRUE;
    return FALSE;
}

void ecn2_copy(ecn2 *a,ecn2 *b)
{
    zzn2_copy(&(a->x),&(b->x));
    zzn2_copy(&(a->y),&(b->y));
#ifndef MR_AFFINE_ONLY
    if (a->marker==MR_EPOINT_GENERAL)  zzn2_copy(&(a->z),&(b->z));
#endif
    b->marker=a->marker;
}

void ecn2_zero(ecn2 *a)
{
    zzn2_zero(&(a->x)); zzn2_zero(&(a->y)); 
#ifndef MR_AFFINE_ONLY
    if (a->marker==MR_EPOINT_GENERAL) zzn2_zero(&(a->z));
#endif
    a->marker=MR_EPOINT_INFINITY;
}

BOOL ecn2_compare(_MIPD_ ecn2 *a,ecn2 *b)
{
#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif
    if (mr_mip->ERNUM) return FALSE;

    MR_IN(193)
    ecn2_norm(_MIPP_ a);
    ecn2_norm(_MIPP_ b);
    MR_OUT
    if (zzn2_compare(&(a->x),&(b->x)) && zzn2_compare(&(a->y),&(b->y)) && a->marker==b->marker) return TRUE;
    return FALSE;
}

void ecn2_norm(_MIPD_ ecn2 *a)
{
    zzn2 t;
#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif
#ifndef MR_AFFINE_ONLY
    if (mr_mip->ERNUM) return;
    if (a->marker!=MR_EPOINT_GENERAL) return;

    MR_IN(194)

    zzn2_inv(_MIPP_ &(a->z));

    t.a=mr_mip->w3;
    t.b=mr_mip->w4;
    zzn2_copy(&(a->z),&t);

    zzn2_sqr(_MIPP_ &(a->z),&(a->z));
    zzn2_mul(_MIPP_ &(a->x),&(a->z),&(a->x));
    zzn2_mul(_MIPP_ &(a->z),&t,&(a->z));
    zzn2_mul(_MIPP_ &(a->y),&(a->z),&(a->y));
    zzn2_from_zzn(mr_mip->one,&(a->z));
    a->marker=MR_EPOINT_NORMALIZED;

    MR_OUT
#endif
}

void ecn2_get(_MIPD_ ecn2 *e,zzn2 *x,zzn2 *y,zzn2 *z)
{
#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif
    
    zzn2_copy(&(e->x),x);
    zzn2_copy(&(e->y),y);
#ifndef MR_AFFINE_ONLY
    if (e->marker==MR_EPOINT_GENERAL) zzn2_copy(&(e->z),z);
    else                              zzn2_from_zzn(mr_mip->one,z);
#endif
}

void ecn2_getxy(ecn2 *e,zzn2 *x,zzn2 *y)
{
    zzn2_copy(&(e->x),x);
    zzn2_copy(&(e->y),y);
}

void ecn2_getx(ecn2 *e,zzn2 *x)
{
    zzn2_copy(&(e->x),x);
}

void ecn2_psi(_MIPD_ zzn2 *psi,ecn2 *P)
{ /* apply GLS morphism to P */
#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif

    MR_IN(212)
    ecn2_norm(_MIPP_ P);
    zzn2_conj(_MIPP_ &(P->x),&(P->x));
    zzn2_conj(_MIPP_ &(P->y),&(P->y));
    zzn2_mul(_MIPP_ &(P->x),&psi[0],&(P->x));
    zzn2_mul(_MIPP_ &(P->y),&psi[1],&(P->y));

    MR_OUT
}

#ifndef MR_AFFINE_ONLY
void ecn2_getz(_MIPD_ ecn2 *e,zzn2 *z)
{
#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif

    if (e->marker==MR_EPOINT_GENERAL) zzn2_copy(&(e->z),z);
    else                              zzn2_from_zzn(mr_mip->one,z);
}
#endif

void ecn2_rhs(_MIPD_ zzn2 *x,zzn2 *rhs)
{ /* calculate RHS of elliptic curve equation */
    BOOL twist;
    zzn2 A,B;
#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif
    if (mr_mip->ERNUM) return;
    twist=mr_mip->TWIST;

    MR_IN(202)

    A.a=mr_mip->w10;
    A.b=mr_mip->w11;
    B.a=mr_mip->w12;
    B.b=mr_mip->w13;

    if (mr_abs(mr_mip->Asize)<MR_TOOBIG) zzn2_from_int(_MIPP_ mr_mip->Asize,&A);
    else zzn2_from_zzn(mr_mip->A,&A);

    if (mr_abs(mr_mip->Bsize)<MR_TOOBIG) zzn2_from_int(_MIPP_ mr_mip->Bsize,&B);
    else zzn2_from_zzn(mr_mip->B,&B);
  
    if (twist)
    {
        if (mr_mip->Asize==0 || mr_mip->Bsize==0)
        {
            if (mr_mip->Asize==0)
            {
                zzn2_txd(_MIPP_ &B);
            }
            if (mr_mip->Bsize==0)
            {
                zzn2_mul(_MIPP_ &A,x,&B);
                zzn2_txd(_MIPP_ &B);
            }
            zzn2_negate(_MIPP_ &B,&B);
        }
        else
        {

            zzn2_txx(_MIPP_ &B);
            zzn2_txx(_MIPP_ &B);
            zzn2_txx(_MIPP_ &B);

            zzn2_mul(_MIPP_ &A,x,&A);
            zzn2_txx(_MIPP_ &A);
            zzn2_txx(_MIPP_ &A);
            zzn2_add(_MIPP_ &B,&A,&B);

        }
    }
    else
    {
        zzn2_mul(_MIPP_ &A,x,&A);
        zzn2_add(_MIPP_ &B,&A,&B);
    }

    zzn2_sqr(_MIPP_ x,&A);
    zzn2_mul(_MIPP_ &A,x,&A);
    zzn2_add(_MIPP_ &B,&A,rhs);

    MR_OUT
}

BOOL ecn2_set(_MIPD_ zzn2 *x,zzn2 *y,ecn2 *e)
{
    zzn2 lhs,rhs;
#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif
    if (mr_mip->ERNUM) return FALSE;

    MR_IN(195)

    lhs.a=mr_mip->w10;
    lhs.b=mr_mip->w11;
    rhs.a=mr_mip->w12;
    rhs.b=mr_mip->w13;

    ecn2_rhs(_MIPP_ x,&rhs);

    zzn2_sqr(_MIPP_ y,&lhs);

    if (!zzn2_compare(&lhs,&rhs))
    {
        MR_OUT
        return FALSE;
    }

    zzn2_copy(x,&(e->x));
    zzn2_copy(y,&(e->y));

    e->marker=MR_EPOINT_NORMALIZED;

    MR_OUT
    return TRUE;
}

#ifndef MR_NOSUPPORT_COMPRESSION


BOOL ecn2_setx(_MIPD_ zzn2 *x,ecn2 *e)
{
    zzn2 rhs;
#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif
    if (mr_mip->ERNUM) return FALSE;

    MR_IN(201)

    rhs.a=mr_mip->w12;
    rhs.b=mr_mip->w13;

    ecn2_rhs(_MIPP_ x,&rhs);
    if (!zzn2_iszero(&rhs))
    {
        if (!zzn2_sqrt(_MIPP_ &rhs,&rhs)) 
        {
            MR_OUT
            return FALSE;
        }
    }

    zzn2_copy(x,&(e->x));
    zzn2_copy(&rhs,&(e->y));

    e->marker=MR_EPOINT_NORMALIZED;

    MR_OUT
    return TRUE;
}

#endif

#ifndef MR_AFFINE_ONLY
void ecn2_setxyz(zzn2 *x,zzn2 *y,zzn2 *z,ecn2 *e)
{
    zzn2_copy(x,&(e->x));
    zzn2_copy(y,&(e->y));
    zzn2_copy(z,&(e->z));
    e->marker=MR_EPOINT_GENERAL;
}
#endif

/* Normalise an array of points of length m<MR_MAX_M_T_S - requires a zzn2 workspace array of length m */
/*
BOOL ecn2_multi_norm(_MIPD_ int m,zzn2 *work,ecn2 *p)
{ 

#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif
 
#ifndef MR_AFFINE_ONLY
    int i;
    zzn2 one,t;
    zzn2 w[MR_MAX_M_T_S];
    if (mr_mip->coord==MR_AFFINE) return TRUE;
    if (mr_mip->ERNUM) return FALSE;   
    if (m>MR_MAX_M_T_S) return FALSE;

    MR_IN(215)

    one.a=mr_mip->w12;
    one.b=mr_mip->w13;
    t.a=mr_mip->w14;
    t.b=mr_mip->w15;

    zzn2_from_int(_MIPP_ 1,&one);

    for (i=0;i<m;i++)
    {
        if (p[i].marker==MR_EPOINT_NORMALIZED) w[i]=one;
        else w[i]=p[i].z;
    }
  
    if (!zzn2_multi_inverse(_MIPP_ m,w,work)) 
    {
       MR_OUT
       return FALSE;
    }

    for (i=0;i<m;i++)
    {
        p[i].marker=MR_EPOINT_NORMALIZED;
        if (!zzn2_isunity(_MIPP_ &work[i]))
        {
            zzn2_sqr(_MIPP_ &work[i],&t);
            zzn2_mul(_MIPP_ &(p[i].x),&t,&(p[i].x));    
            zzn2_mul(_MIPP_ &t,&work[i],&t);
            zzn2_mul(_MIPP_ &(p[i].y),&t,&(p[i].y));  
        }
    }    
    MR_OUT
#endif
    return TRUE;   
}

*/

void ecn2_negate(_MIPD_ ecn2 *u,ecn2 *w)
{
#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif

    ecn2_copy(u,w);
    if (w->marker!=MR_EPOINT_INFINITY)
        zzn2_negate(_MIPP_ &(w->y),&(w->y));
}

BOOL ecn2_add2(_MIPD_ ecn2 *Q,ecn2 *P,zzn2 *lam,zzn2 *ex1)
{
    BOOL Doubling;
#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif

    Doubling=ecn2_add3(_MIPP_ Q,P,lam,ex1,NULL);

    return Doubling;
}

BOOL ecn2_add1(_MIPD_ ecn2 *Q,ecn2 *P,zzn2 *lam)
{
    BOOL Doubling;
#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif
    Doubling=ecn2_add3(_MIPP_ Q,P,lam,NULL,NULL);

    return Doubling;
}

BOOL ecn2_add(_MIPD_ ecn2 *Q,ecn2 *P)
{
    BOOL Doubling;
#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif
    zzn2 lam;

    lam.a = mr_mip->w14;
    lam.b = mr_mip->w15;

    Doubling=ecn2_add3(_MIPP_ Q,P,&lam,NULL,NULL);

    return Doubling;
}

BOOL ecn2_sub(_MIPD_ ecn2 *Q,ecn2 *P)
{
    BOOL Doubling;
#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif
    zzn2 lam;

    lam.a = mr_mip->w14;
    lam.b = mr_mip->w15;

    ecn2_negate(_MIPP_ Q,Q);

    Doubling=ecn2_add3(_MIPP_ Q,P,&lam,NULL,NULL);

    ecn2_negate(_MIPP_ Q,Q);

    return Doubling;
}

BOOL ecn2_add_sub(_MIPD_ ecn2 *P,ecn2 *Q,ecn2 *PP,ecn2 *PM)
{ /* PP=P+Q, PM=P-Q. Assumes P and Q are both normalized, and P!=Q */
 #ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif
    zzn2 t1,t2,lam;

    if (mr_mip->ERNUM) return FALSE;

    if (P->marker==MR_EPOINT_GENERAL || Q->marker==MR_EPOINT_GENERAL)
    { /* Sorry, some restrictions.. */
        mr_berror(_MIPP_ MR_ERR_BAD_PARAMETERS);
        MR_OUT
        return FALSE;
    }

    if (zzn2_compare(&(P->x),&(Q->x)))
    { /* P=Q or P=-Q - shouldn't happen */
        ecn2_copy(P,PP);
        ecn2_add(_MIPP_ Q,PP);
        ecn2_copy(P,PM);
        ecn2_sub(_MIPP_ Q,PM);

        MR_OUT
        return TRUE;
    }

    t1.a = mr_mip->w8;
    t1.b = mr_mip->w9; 
    t2.a = mr_mip->w10; 
    t2.b = mr_mip->w11; 
    lam.a = mr_mip->w12; 
    lam.b = mr_mip->w13;    

    zzn2_copy(&(P->x),&t2);
    zzn2_sub(_MIPP_ &t2,&(Q->x),&t2);
    zzn2_inv(_MIPP_ &t2);   /* only one inverse required */
    zzn2_add(_MIPP_ &(P->x),&(Q->x),&(PP->x));
    zzn2_copy(&(PP->x),&(PM->x));

    zzn2_copy(&(P->y),&t1);
    zzn2_sub(_MIPP_ &t1,&(Q->y),&t1);
    zzn2_copy(&t1,&lam);
    zzn2_mul(_MIPP_ &lam,&t2,&lam);
    zzn2_copy(&lam,&t1);
    zzn2_sqr(_MIPP_ &t1,&t1);
    zzn2_sub(_MIPP_ &t1,&(PP->x),&(PP->x));
    zzn2_copy(&(Q->x),&(PP->y));
    zzn2_sub(_MIPP_ &(PP->y),&(PP->x),&(PP->y));
    zzn2_mul(_MIPP_ &(PP->y),&lam,&(PP->y));
    zzn2_sub(_MIPP_ &(PP->y),&(Q->y),&(PP->y));

    zzn2_copy(&(P->y),&t1);
    zzn2_add(_MIPP_ &t1,&(Q->y),&t1);
    zzn2_copy(&t1,&lam);
    zzn2_mul(_MIPP_ &lam,&t2,&lam);
    zzn2_copy(&lam,&t1);
    zzn2_sqr(_MIPP_ &t1,&t1);
    zzn2_sub(_MIPP_ &t1,&(PM->x),&(PM->x));
    zzn2_copy(&(Q->x),&(PM->y));
    zzn2_sub(_MIPP_ &(PM->y),&(PM->x),&(PM->y));
    zzn2_mul(_MIPP_ &(PM->y),&lam,&(PM->y));
    zzn2_add(_MIPP_ &(PM->y),&(Q->y),&(PM->y));

    PP->marker=MR_EPOINT_NORMALIZED;
    PM->marker=MR_EPOINT_NORMALIZED;

    return TRUE;
}

BOOL ecn2_add3(_MIPD_ ecn2 *Q,ecn2 *P,zzn2 *lam,zzn2 *ex1,zzn2 *ex2)
{ /* P+=Q */
    BOOL Doubling=FALSE;
    BOOL twist;
    int iA;
    zzn2 t1,t2,t3;
    zzn2 Yzzz;
 
#ifdef MR_OS_THREADS
    miracl *mr_mip=get_mip();
#endif

    t1.a = mr_mip->w8;
    t1.b = mr_mip->w9; 
    t2.a = mr_mip->w10; 
    t2.b = mr_mip->w11; 
    t3.a = mr_mip->w12; 
    t3.b = mr_mip->w13; 
    Yzzz.a = mr_mip->w3;
    Yzzz.b = mr_mip->w4;