devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

(ECC)椭圆曲线加密算法原理和C++实现源码

作者：繁依Fanyi0 | 2024-06-17 12:30:28

赞

踩

椭圆曲线加密算法原理

目录

（1）ECC加密原理：

（2）编译生成LibTommath静态库

（3）ECC源码

今天介绍一下利用LibTommath数学库实现椭圆曲线加密算法的原理和源码。

（1）ECC加密原理：

　1、用户A选定一条适合加密的椭圆曲线Ep(a,b)(如:y2=x3+ax+b)，并取椭圆曲线上一点，作为基点G。
　2、用户A选择一个私有密钥k，并生成公开密钥K=kG。
　3、用户A将Ep(a,b)和点K，G传给用户B。
　4、用户B接到信息后 ，将待传输的明文编码到Ep(a,b)上一点M，并产生一个随机整数r（r<n）。
　5、用户B计算点C1=M+rK；C2=rG。
　6、用户B将C1、C2传给用户A。
　7、用户A接到信息后，计算C1-kC2，结果就是点M。因为
          C1-kC2=M+rK-k(rG)=M+rK-r(kG)=M
　　　再对点M进行解码就可以得到明文。

  密码学中，描述一条Fp上的椭圆曲线，常用到六个参量： T=(p,a,b,G,n,h)。
　　（p 、a 、b 用来确定一条椭圆曲线，G为基点，n为点G的阶，h 是椭圆曲线上所有点的个数m与n相除的整数部分）

　　这几个参量取值的选择，直接影响了加密的安全性。参量值一般要求满足以下几个条件：

　　1、p 当然越大越安全，但越大，计算速度会变慢，200位左右可以满足一般安全要求；
　　2、p≠n×h；
　　3、pt≠1 (mod n)，1≤t<20；
　　4、4a3+27b2≠0 (mod p)；
　　5、n 为素数；
　　6、h≤4。

（2）编译生成LibTommath静态库

经评论区提醒，原LibTommath库已经删除了，大家可以在Github上来下载：https://github.com/libtom/libtommath。

以下内容可直接跳过：

首先下载LibTommath的源码，网址为：Best Open Source Mac Libraries Software 2022

下载后，解压如图所示：

打开bn.pdf文件后，这是该库的使用手册，在第10页会看到如下指令，在终端执行make命令即可生成静态库:libtommath.a。

附：在执行编译时可能会生成一些小问题，那就是需要把tommath.h和tommath_superclass.h需要钱修改一下，如下：

只是头文件包含的问题，视具体情况来修改。

（3）ECC源码

下面是ECC源码。

  1. /*　1、用户A选定一条适合加密的椭圆曲线Ep(a,b)(如:y2=x3+ax+b)，并取椭圆曲线上一点，作为基点G。
  2. 　　2、用户A选择一个私有密钥k，并生成公开密钥K=kG。
  3. 　　3、用户A将Ep(a,b)和点K，G传给用户B。
  4. 　　4、用户B接到信息后 ，将待传输的明文编码到Ep(a,b)上一点M，并产生一个随机整数r（r<n）。
  5. 　　5、用户B计算点C1=M+rK；C2=rG。
  6. 　　6、用户B将C1、C2传给用户A。
  7. 　　7、用户A接到信息后，计算C1-kC2，结果就是点M。因为
  8.           C1-kC2=M+rK-k(rG)=M+rK-r(kG)=M
  9. 　　　再对点M进行解码就可以得到明文。
  11.   　　密码学中，描述一条Fp上的椭圆曲线，常用到六个参量：
  12.        T=(p,a,b,G,n,h)。
  13. 　　（p 、a 、b 用来确定一条椭圆曲线，G为基点，n为点G的阶，h 是椭圆曲线上所有点的个数m与n相除的整数部分）
  15. 　　这几个参量取值的选择，直接影响了加密的安全性。参量值一般要求满足以下几个条件：
  17. 　　1、p 当然越大越安全，但越大，计算速度会变慢，200位左右可以满足一般安全要求；
  18. 　　2、p≠n×h；
  19. 　　3、pt≠1 (mod n)，1≤t<20；
  20. 　　4、4a3+27b2≠0 (mod p)；
  21. 　　5、n 为素数；
  22. 　　6、h≤4。
  23. */
  24. #include <stdio.h>
  25. #include <string.h>
  26. #include <stdlib.h>
  27. #include <iostream>
  28. #include "tommath.h"
  29. #include <time.h>
  30.  
  31.  
  32. #define BIT_LEN 800 
  33. #define KEY_LONG 128  //私钥比特长
  34. #define P_LONG 200    //有限域P比特长
  35. #define EN_LONG 40    //一次取明文字节数(x,20)(y,20)
  36.  
  37.  
  38. //得到lon比特长素数
  39. int GetPrime(mp_int *m,int lon);
  40. //得到B和G点X坐标G点Y坐标
  41. void Get_B_X_Y(mp_int *x1,mp_int *y1,mp_int *b,  mp_int *a,  mp_int *p);
  42. //点乘
  43. bool Ecc_points_mul(mp_int *qx,mp_int *qy, mp_int *px, mp_int *py,mp_int *d,mp_int *a,mp_int *p);
  44. //点加
  45. int Two_points_add(mp_int *x1,mp_int *y1,mp_int *x2,mp_int *y2,mp_int *x3,mp_int *y3,mp_int *a,bool zero,mp_int *p);
  46. //二进制存储密文
  47. int chmistore(mp_int *a,FILE *fp);
  48. //把读取的字符存入mp_int型数
  49. int putin(mp_int *a,char *ch,int chlong);
  50. //ECC加密
  51. void Ecc_encipher(mp_int *qx,mp_int *qy, mp_int *px, mp_int *py,mp_int *a,mp_int *p);
  52. //ECC解密
  53. void Ecc_decipher(mp_int *k, mp_int *a,mp_int *p);
  54. //实现将mp_int数a中的比特串还原为字符串并赋给字符串ch：
  55. int chdraw(mp_int *a,char *ch);
  56. //取密文
  57. int miwendraw(mp_int *a,char *ch,int chlong);
  58.  
  59.  
  60. int myrng(unsigned char *dst, int len, void *dat)
  61. {
  62.    int x;
  63.    for (x = 0; x < len; x++) dst[x] = rand() & 0xFF;
  64.    return len;
  65. }
  66.  
  67. using namespace std;
  68. int main(){
  69.  
  70.     cout<<"\n          本程序实现椭圆曲线的加密解密"<<endl;
  71.     
  72.     cout<<"\n------------------------------------------------------------------------\n"<<endl;
  73.    
  74.     mp_int GX;
  75.     mp_int GY;
  76.     mp_int K;//私有密钥
  77.     mp_int A;
  78.     mp_int B;
  79.     mp_int QX;
  80.     mp_int QY;
  81.     mp_int P;//Fp中的p(有限域P)
  82.     
  83.  
  84.     mp_init(&GX);
  85.     mp_init(&GY);
  86.     mp_init(&K);
  87.     mp_init(&A);
  88.     mp_init(&B);
  89.     mp_init(&QX);
  90.     mp_init(&QY);
  91.     mp_init(&P);
  92.     
  93.  
  94.     time_t t;           
  95.     srand( (unsigned) time( &t ) );
  96.  
  97.     printf("椭圆曲线的参数如下(以十进制显示):\n");    
  98.  
  99.     GetPrime(&P,P_LONG);
  100.     printf("有限域 P 是:\n");    
  101.     char temp[800]={0};
  102.     mp_toradix(&P,temp,10);
  103.     printf("%s\n",temp);    
  104.  
  105.     GetPrime(&A,30);
  106.     char tempA[800]={0};
  107.     printf("曲线参数 A 是:\n");    
  108.     mp_toradix(&A,tempA,10);
  109.     printf("%s\n",tempA); 
  110.     
  111.     Get_B_X_Y(&GX,&GY,&B,&A,&P);
  112.  
  113.     char tempB[800]={0};
  114.     printf("曲线参数 B 是:\n");    
  115.     mp_toradix(&B,tempB,10);
  116.     printf("%s\n",tempB); 
  117.     
  118.     char tempGX[800]={0};
  119.     printf("曲线G点X坐标是:\n");    
  120.     mp_toradix(&GX,tempGX,10);
  121.     printf("%s\n",tempGX);   
  122.  
  123.     char tempGY[800]={0};
  124.     printf("曲线G点Y坐标是:\n");
  125.     mp_toradix(&GY,tempGY,10);
  126.     printf("%s\n",tempGY); 
  127.     
  128.  
  129.     //------------------------------------------------------------------
  130.     GetPrime(&K,KEY_LONG);
  131.     char tempK[800]={0};
  132.     printf("私钥 K 是:\n");
  133.     mp_toradix(&K,tempK,10);
  134.     printf("%s\n",tempK); 
  135.  
  136.     Ecc_points_mul(&QX,&QY,&GX,&GY,&K,&A,&P);
  137.     
  138.  
  139.     char tempQX[800]={0};
  140.     printf("公钥X坐标是:\n");
  141.     mp_toradix(&QX,tempQX,10);
  142.     printf("%s\n",tempQX); 
  143.  
  144.     char tempQY[800]={0};
  145.     printf("公钥Y坐标是:\n");
  146.     mp_toradix(&QY,tempQY,10);
  147.     printf("%s\n",tempQY); 
  148.  
  149.  
  150.     printf("\n------------------------------------------------------------------------\n");
  151.  
  152.     Ecc_encipher(&QX,&QY,&GX,&GY,&A,&P);//加密
  153.  
  154.     printf("\n------------------------------------------------------------------------\n");
  155.  
  156.     Ecc_decipher(&K,&A,&P);//解密
  157.  
  158.     printf("\n------------------------------------------------------------------------\n");
  159.  
  160.     char cc;
  161.     cout<<"\n\n请击一键退出!\n";
  162.     cin>>cc;
  163.  
  164.     mp_clear(&GX);
  165.     mp_clear(&GY);
  166.     mp_clear(&K);//私有密钥
  167.     mp_clear(&A);
  168.     mp_clear(&B);
  169.     mp_clear(&QX);
  170.     mp_clear(&QY);
  171.     mp_clear(&P);//Fp中的p(有限域P)
  172. 	return 0;
  173. }
  174.  
  175.  
  176. int GetPrime(mp_int *m,int lon){
  177.    mp_prime_random_ex(m, 10, lon, 
  178.         (rand()&1)?LTM_PRIME_2MSB_OFF:LTM_PRIME_2MSB_ON, myrng, NULL);
  179.    return MP_OKAY;
  180. }
  181.  
  182. void Get_B_X_Y(mp_int *x1,mp_int *y1,mp_int *b, mp_int *a, mp_int *p)
  183. {
  184.     mp_int tempx,tempy;
  185.     mp_int temp;
  186.     mp_int compare;
  187.     mp_int temp1;
  188.     mp_int temp2;
  189.     mp_int temp3;
  190.     mp_int temp4;
  191.     mp_int temp5;
  192.     mp_int temp6;
  193.     mp_int temp7;
  194.     mp_int temp8;
  195.     
  196.     mp_init_set_int (&compare, 0);
  197.     mp_init(&tempx);
  198.     mp_init(&tempy);
  199.     mp_init(&temp);
  200.     mp_init(&temp1);
  201.     mp_init(&temp2);
  202.     mp_init(&temp3);
  203.     mp_init(&temp4);
  204.     mp_init(&temp5);
  205.     mp_init(&temp6);
  206.     mp_init(&temp7);
  207.     mp_init(&temp8);
  208.  
  209.  
  210.    while(1)
  211.    {
  212.      
  213.      //4a3+27b2≠0 (mod p)
  214.      GetPrime(b,40);
  215.      mp_expt_d(a, 3, &temp1);
  216.      mp_sqr(b, &temp2);
  217.      mp_mul_d(&temp1, 4, &temp3);
  218.      mp_mul_d(&temp2, 27, &temp4);
  219.      mp_add(&temp3, &temp4, &temp5);
  220.      mp_mod(&temp5,p,&temp);
  221.  
  222.      if(mp_cmp(&temp, &compare)!=0 )
  223.      {
  224.          break;
  225.      }
  226.    }
  227.  
  228.    //y2=x3+ax+b,随机产生X坐标,根据X坐标计算Y坐标
  229.    GetPrime(x1,30);
  230.    mp_expt_d(x1, 3, &temp6);
  231.    mp_mul(a, x1, &temp7);
  232.    mp_add(&temp6, &temp7, &temp8);
  233.    mp_add(&temp8, b, &tempx);
  234.    mp_sqrt(&tempx, y1);
  235.  
  236.  
  237.  
  238.    mp_clear(&tempx);
  239.    mp_clear(&tempy);
  240.    mp_clear(&temp);
  241.    mp_clear(&temp1);
  242.    mp_clear(&temp2);
  243.    mp_clear(&temp3);
  244.    mp_clear(&temp4);
  245.    mp_clear(&temp5);
  246.    mp_clear(&temp6);
  247.    mp_clear(&temp7);
  248.    mp_clear(&temp8);
  249.  
  250.  
  251. }
  252.  
  253. bool Ecc_points_mul(mp_int *qx,mp_int *qy, mp_int *px, mp_int *py,mp_int *d,mp_int *a,mp_int *p)
  254. {
  255. mp_int X1, Y1;
  256. mp_int X2, Y2;
  257. mp_int X3, Y3;
  258. mp_int XX1, YY1;
  259. mp_int A,P;
  260.  
  261. int i;
  262. bool zero=false;
  263. char Bt_array[800]={0};
  264. char cm='1';
  265.  
  266.     mp_toradix(d,Bt_array,2); 
  267.  
  268.     mp_init_set_int(&X3, 0);
  269.     mp_init_set_int(&Y3, 0);
  270.     mp_init_copy(&X1, px);
  271.     mp_init_copy(&X2, px);
  272.     mp_init_copy(&XX1, px);
  273.     mp_init_copy(&Y1, py);
  274.     mp_init_copy(&Y2, py);
  275.     mp_init_copy(&YY1, py);
  276.  
  277.     mp_init_copy(&A, a);
  278.     mp_init_copy(&P, p);
  279.  
  280.     for(i=1;i<=KEY_LONG-1;i++)
  281.     {
  282.        mp_copy(&X2, &X1);
  283.        mp_copy(&Y2, &Y1);
  284.        Two_points_add(&X1,&Y1,&X2,&Y2,&X3,&Y3,&A,zero,&P);  
  285.        mp_copy(&X3, &X2);
  286.        mp_copy(&Y3, &Y2);
  287.        if(Bt_array[i]==cm)
  288.        {
  289.           
  290.            mp_copy(&XX1, &X1);
  291.            mp_copy(&YY1, &Y1);
  292.            Two_points_add(&X1,&Y1,&X2,&Y2,&X3,&Y3,&A,zero,&P);
  293.            mp_copy(&X3, &X2);
  294.            mp_copy(&Y3, &Y2);
  295.  
  296.        }
  297.  
  298.     }
  299.         
  300.    if(zero)
  301.    {
  302.        cout<<"It is Zero_Unit!";
  303.        return false;//如果Q为零从新产生D
  304.    }
  305.  
  306.    mp_copy(&X3, qx);
  307.    mp_copy(&Y3, qy);
  308.  
  309.    mp_clear(&X1);
  310.    mp_clear(&Y1);
  311.    mp_clear(&X2);
  312.    mp_clear(&Y2);
  313.    mp_clear(&X3);
  314.    mp_clear(&Y3);
  315.    mp_clear(&XX1);
  316.    mp_clear(&YY1);
  317.    mp_clear(&A);
  318.    mp_clear(&P);
  319.   
  320.    return true;
  321. }
  322.  
  323. //两点加
  324. int Two_points_add(mp_int *x1,mp_int *y1,mp_int *x2,mp_int *y2,mp_int *x3,mp_int *y3,mp_int *a,bool zero,mp_int *p)
  325. {
  326. mp_int x2x1;
  327. mp_int y2y1;
  328. mp_int tempk;
  329. mp_int tempy;
  330. mp_int tempzero;
  331. mp_int k;
  332. mp_int temp1;
  333. mp_int temp2;
  334. mp_int temp3;
  335. mp_int temp4;
  336. mp_int temp5;
  337. mp_int temp6;
  338. mp_int temp7;
  339. mp_int temp8;
  340. mp_int temp9;
  341. mp_int temp10;
  342.  
  343.  
  344. mp_init(&x2x1);
  345. mp_init(&y2y1);
  346. mp_init(&tempk);
  347. mp_init(&tempy);
  348. mp_init(&tempzero);
  349. mp_init(&k);
  350. mp_init(&temp1);
  351. mp_init(&temp2);
  352. mp_init_set(&temp3,2);
  353. mp_init(&temp4);
  354. mp_init(&temp5);
  355. mp_init(&temp6);
  356. mp_init(&temp7);
  357. mp_init(&temp8);
  358. mp_init(&temp9);
  359. mp_init(&temp10);
  360.  
  361.  
  362.    if(zero)
  363.    {
  364.       mp_copy(x1, x3);
  365.       mp_copy(y1, y3);
  366.       zero=false;
  367.       goto L;
  368.    }
  369.    mp_zero(&tempzero);
  370.    mp_sub(x2, x1, &x2x1);
  371.    if(mp_cmp(&x2x1,&tempzero)==-1)
  372.    {
  373.       
  374.       mp_add(&x2x1, p, &temp1);
  375.       mp_zero(&x2x1);
  376.       mp_copy(&temp1, &x2x1);
  377.    }
  378.    mp_sub(y2, y1, &y2y1);
  379.    if(mp_cmp(&y2y1,&tempzero)==-1)
  380.    {
  381.      
  382.       mp_add(&y2y1, p, &temp2);
  383.       mp_zero(&y2y1);
  384.       mp_copy(&temp2, &y2y1);
  385.    }
  386.    if(mp_cmp(&x2x1, &tempzero)!=0)
  387.    {
  388.        
  389.        mp_invmod(&x2x1,p,&tempk);
  390.        
  391.        mp_mulmod(&y2y1, &tempk, p, &k);
  392.    }
  393.    else
  394.    {
  395.        if(mp_cmp(&y2y1, &tempzero)==0)
  396.        {
  397.           
  398.           mp_mulmod(&temp3,y1,p,&tempy);
  399.           mp_invmod(&tempy,p,&tempk);
  400.           mp_sqr(x1, &temp4);     
  401.           mp_mul_d(&temp4, 3, &temp5);
  402.           mp_add(&temp5, a, &temp6);
  403.           mp_mulmod(&temp6, &tempk, p, &k);
  404.           
  405.        }
  406.        else
  407.        {
  408.           zero=true;
  409.           goto L;
  410.        }
  411.    }  
  412.  
  413.    mp_sqr(&k, &temp7);
  414.    mp_sub(&temp7, x1, &temp8);
  415.    mp_submod(&temp8, x2, p, x3);
  416.  
  417.    mp_sub(x1, x3, &temp9);
  418.    mp_mul(&temp9, &k, &temp10);
  419.    mp_submod(&temp10, y1, p, y3);
  420.  
  421.  
  422. L:
  423.  
  424.    mp_clear(&x2x1);
  425.    mp_clear(&y2y1);
  426.    mp_clear(&tempk);
  427.    mp_clear(&tempy);
  428.    mp_clear(&tempzero);
  429.    mp_clear(&k);
  430.    mp_clear(&temp1);
  431.    mp_clear(&temp2);
  432.    mp_clear(&temp3);
  433.    mp_clear(&temp4);
  434.    mp_clear(&temp5);
  435.    mp_clear(&temp6);
  436.    mp_clear(&temp7);
  437.    mp_clear(&temp8);
  438.    mp_clear(&temp9);
  439.    mp_clear(&temp10);
  440.  
  441.    return 1;
  442.  
  443. }
  444.  
  445. //二进制存储密文
  446. int chmistore(mp_int *a,FILE *fp)
  447. {
  448.  
  449.    int i,j;
  450.    char ch;
  451.    char chtem[4];
  452.  
  453.    mp_digit yy=(mp_digit)255;
  454.    for (i=0; i <= a->used - 1;  i++) { 
  455.  
  456.       chtem[3]=(char)(a->dp[i] & yy);     
  457.       chtem[2]=(char)((a->dp[i] >> (mp_digit)8) & yy);        
  458.       chtem[1]=(char)((a->dp[i] >> (mp_digit)16) & yy);    
  459.       chtem[0]=(char)((a->dp[i] >> (mp_digit)24) & yy);
  460.  
  461.       for(j=0;j<4;j++)
  462.       {
  463.           fprintf(fp,"%c",chtem[j]);
  464.       }
  465.       
  466.   }  
  467.  
  468.   ch=char(255);
  469.   fprintf(fp, "%c", ch);
  470.   return MP_OKAY;
  471. }
  472.  
  473.  
  474. //把读取的字符存入mp_int型数
  475. int putin(mp_int *a,char *ch,int chlong)
  476. {
  477.     mp_digit *temp,yy;
  478.     int i,j,res;
  479.     if(a->alloc<chlong*2/7+2)
  480.     {
  481.         if((res=mp_grow(a,chlong*2/7+2))!=MP_OKAY)
  482.             return res;
  483.     }
  484.     
  485.     a->sign=0;
  486.     mp_zero(a);
  487.     temp=a->dp;
  488.     i=0;
  489.     yy=(mp_digit)15;
  490.  
  491.     if(chlong<4)
  492.     {
  493.             for(j=chlong-1;j>=0;j--)
  494.             {
  495.                *temp |= (mp_digit)(ch[j] & 255);
  496.                *temp <<= (mp_digit)CHAR_BIT;
  497.             }
  498.             *temp >>= (mp_digit)8;
  499.             a->used=1;
  500.             return MP_OKAY;
  501.     }
  502.  
  503.     if(chlong<7)
  504.     {
  505.             i+=4;
  506.             *++temp |= (mp_digit)(ch[i-1] & yy);
  507.             *temp <<= (mp_digit)CHAR_BIT;
  508.             *temp |= (mp_digit)(ch[i-2] & 255);
  509.             *temp <<= (mp_digit)CHAR_BIT;
  510.             *temp |= (mp_digit)(ch[i-3] & 255);
  511.             *temp <<= (mp_digit)CHAR_BIT;
  512.             *temp-- |= (mp_digit)(ch[i-4] & 255); //存放被切分的字符的低四位
  513.  
  514.             
  515.             for(j=chlong-1;j>=i;j--)
  516.             {  
  517.                *temp |= (mp_digit)(ch[j] & 255);
  518.                *temp <<= (mp_digit)CHAR_BIT;                            
  519.             }
  520.             *temp >>= (mp_digit)4;
  521.             *temp |= (mp_digit)((ch[i-1] & 255) >> 4);  //存放被切分的字符的高四位
  522.             
  523.             a->used=2;
  524.             return MP_OKAY;
  525.     }
  526.  
  527.         //以7个字符为单元循环，把七个字符放入的mp_int 的两个单元中
  528.     for(j=0;j<chlong/7;j++)
  529.     {
  530.         i+=7;
  531.         *++temp |= (mp_digit)(ch[i-1] & 255);
  532.         *temp <<= (mp_digit)CHAR_BIT;
  533.         *temp |= (mp_digit)(ch[i-2] & 255);
  534.         *temp <<= (mp_digit)CHAR_BIT;
  535.         *temp |= (mp_digit)(ch[i-3] & 255);
  536.         *temp <<= (mp_digit)4;
  537.         *temp-- |= (mp_digit)((ch[i-4] & 255) >> 4);    //存放被切分的字符的高四位
  538.  
  539.         *temp |= (mp_digit)(ch[i-4] & yy);      //存放被切分的字符的低四位
  540.         *temp <<= (mp_digit)CHAR_BIT;
  541.         *temp |= (mp_digit)(ch[i-5] & 255);
  542.         *temp <<= (mp_digit)CHAR_BIT;
  543.         *temp |= (mp_digit)(ch[i-6] & 255);
  544.         *temp <<= (mp_digit)CHAR_BIT;
  545.         *temp++ |= (mp_digit)(ch[i-7] & 255); 
  546.  
  547.         temp++;
  548.     
  549.     }
  550.  
  551.     if((chlong>=7)&&(chlong%7!=0))        //剩余字符的存放
  552.     {
  553.         if(chlong%7 < 4)           //剩余字符少余4个时，只需一个mp_digit单元存放
  554.         {
  555.             for(j=chlong-1;j>=i;j--)
  556.             {
  557.                *temp |= (mp_digit)(ch[j] & 255);
  558.                *temp <<= (mp_digit)CHAR_BIT;
  559.             }
  560.             *temp >>= (mp_digit)8;
  561.             a->used=chlong*2/7+1;
  562.         }
  563.         else
  564.         {                       //剩余字符不小于4个时，需两个mp_digit单元存放
  565.             i+=4;
  566.             *temp |= (mp_digit)(ch[i-1] & yy);
  567.             *temp <<= (mp_digit)CHAR_BIT;
  568.             *temp |= (mp_digit)(ch[i-2] & 255);
  569.             *temp <<= (mp_digit)CHAR_BIT;
  570.             *temp |= (mp_digit)(ch[i-3] & 255);
  571.             *temp <<= (mp_digit)CHAR_BIT;
  572.             *temp++ |= (mp_digit)(ch[i-4] & 255); //存放被切分的字符的低四位
  573.  
  574.             
  575.             for(j=chlong-1;j>=i;j--)
  576.             {  
  577.                *temp |= (mp_digit)(ch[j] & 255);
  578.                *temp <<= (mp_digit)CHAR_BIT;                            
  579.             }
  580.             *temp >>= (mp_digit)4;
  581.             *temp |= (mp_digit)((ch[i-1] & 255) >> 4);  //存放被切分的字符的高四位
  582.             
  583.             a->used=chlong*2/7+2;
  584.         }
  585.  
  586.     }
  587.     else
  588.     {
  589.        a->used=chlong*2/7;
  590.     }
  591.     return MP_OKAY;
  592. }
  593.  
  594.  
  595. void Ecc_encipher(mp_int *qx,mp_int *qy, mp_int *px, mp_int *py,mp_int *a,mp_int *p){  //公钥X、Y坐标，曲线G点X、Y坐标，曲线参数A，有限域P
  596.  
  597.     mp_int mx, my;
  598.     mp_int c1x, c1y;
  599.     mp_int c2x, c2y;
  600.     mp_int r;
  601.     mp_int tempx, tempy;
  602.     bool zero=false;
  603.     FILE *fp,*fq;
  604.     int i;
  605.     char miwenx[280]={0};
  606.     char miweny[280]={0};
  607.     char stemp[650]={0};
  608.  
  609.  
  610.     mp_init(&mx);
  611.     mp_init(&my);
  612.     mp_init(&c1x);
  613.     mp_init(&c1y);
  614.     mp_init(&c2x);
  615.     mp_init(&c2y);
  616.     mp_init(&r);
  617.     mp_init(&tempx);
  618.     mp_init(&tempy);
  619.  
  620.     GetPrime(&r, 100);
  621.  
  622.  
  623.     char filehead[60],filefoot[20],filename[85]={0};
  624.     cout<<"请输入您要加密文件的存放路径和文件名(如:  c:\\000\\大整数运算  ):"<<endl;
  625.     cin>>filehead;
  626.     cout<<"请输入您要加密文件的扩展名(如:  .doc  ):"<<endl;
  627.     cin>>filefoot;
  628.     strcpy(filename,filehead);
  629.     strcat(filename,filefoot);
  630.     
  631.  
  632. //打开要加密文件
  633.     if((fp=fopen(filename,"rb"))==NULL)
  634.     {
  635.         printf("can not open the file!");
  636.         exit(1);
  637.     }
  638.  
  639.     unsigned int FileLong=0;//文件字符长度
  640.     char ChTem;//临时字符变
  641.     int Frequency=0;
  642.     int Residue=0;
  643.  
  644.     while( !feof(fp) )//找文件字符长度
  645.     {
  646.         ChTem = fgetc( fp );
  647.         FileLong++;
  648.     }
  649.     --FileLong;
  650.  
  651.  
  652.     Frequency = FileLong/EN_LONG;
  653.     Residue = FileLong%EN_LONG;
  654. 	printf("Frequency= %d, Residue= %d\n", Frequency, Residue);
  655.  
  656.     int enlongtemp=EN_LONG/2;
  657.     //printf("%d\n",Frequency);  
  658.     //printf("%d\n",Residue);  
  659.  
  660.     char filemi[85];
  661.     strcpy(filemi,filehead);
  662.     strcat(filemi,"密文");
  663.     strcat(filemi,filefoot);
  664.     
  665.  
  666.  //打开保存密文文件
  667.     if((fq=fopen(filemi,"wb"))==NULL)
  668.     {
  669.          printf("can not open the file!\n");
  670.          exit(1);
  671.     }
  672.  
  673.     printf("\n开始加密...\n");
  674.  
  675.     rewind(fp);
  676. 	clock_t start, finish;
  677. 	double duration;
  678. 	
  679.     for(i=0; i<Frequency; i++)
  680.     {   
  681.   
  682.         fread(miwenx,1,enlongtemp,fp);//读入字符串
  683.         miwenx[enlongtemp]=char(255);
  684.  
  685.         fread(miweny,1,enlongtemp,fp);//读入字符串
  686.         miweny[enlongtemp]=char(255);
  687.  
  688.         putin(&mx, miwenx,enlongtemp+1);//文件存入         
  689.         putin(&my, miweny,enlongtemp+1);//文件存入
  690. 		
  691. 		
  692.         Ecc_points_mul(&c2x,&c2y,px,py,&r,a,p);//加密
  693.         Ecc_points_mul(&tempx,&tempy,qx,qy,&r,a,p); 
  694.         Two_points_add(&mx,&my,&tempx,&tempy,&c1x,&c1y,a,zero,p);
  695.  
  696.         //保存密文      
  697.         chmistore(&c1x,fq); 
  698.         chmistore(&c1y,fq);
  699.         chmistore(&c2x,fq);
  700.         chmistore(&c2y,fq);
  701.  
  702.     }
  703.     //剩余字符处理
  704.     if ( Residue > 0)
  705.     {
  706.          if (Residue <= enlongtemp ) 
  707.         {
  708.             fread(miwenx,1,Residue,fp);//读入字符串
  709.             miwenx[Residue]=char(255);
  710.      
  711.             putin(&mx, miwenx,Residue+1);//文件存入 
  712.  
  713.             mp_zero(&my);
  714.         
  715.         }
  716.         else
  717.         {
  718.  
  719.             fread(miwenx,1,enlongtemp,fp);//读入字符串
  720.             miwenx[enlongtemp]=char(255);
  721.         
  722.  
  723.             fread(miweny,1,Residue-enlongtemp,fp);//读入字符串
  724.             miweny[Residue-enlongtemp]=char(255);
  725.  
  726.              putin(&mx, miwenx,enlongtemp+1);//文件存入 
  727.  
  728.             putin(&my, miweny,Residue-enlongtemp+1);//文件存入 
  729.         }
  730. 		
  731.         Ecc_points_mul(&c2x,&c2y,px,py,&r,a,p);//加密
  732.         Ecc_points_mul(&tempx,&tempy,qx,qy,&r,a,p); 
  733.         Two_points_add(&mx,&my,&tempx,&tempy,&c1x,&c1y,a,zero,p);
  734. 	
  735.  
  736.         //保存密文      
  737.         chmistore(&c1x,fq); 
  738.  
  739.         chmistore(&c1y,fq);
  740.  
  741.         chmistore(&c2x,fq);
  742.  
  743.         chmistore(&c2y,fq);  
  744.     }
  745. 		
  746.         cout<<"\nok!加密完毕!"<<endl;
  747.         cout<<"密文以二进制保存"<<endl;
  748.         cout<<"密文存放路径为  "<<filemi<<endl ;
  749.  
  750.  
  751.         fclose(fq);
  752.         fclose(fp);
  753.         mp_clear(&mx);
  754.         mp_clear(&my);
  755.         mp_clear(&c1x);
  756.         mp_clear(&c1y);
  757.         mp_clear(&c2x);
  758.         mp_clear(&c2y);
  759.         mp_clear(&r);
  760.         mp_clear(&tempx);
  761.         mp_clear(&tempy);
  762.      
  763.  
  764. }
  765.  
  766. //取密文
  767.  
  768. int miwendraw(mp_int *a,char *ch,int chlong)
  769. {
  770.     mp_digit *temp;
  771.     int i,j,res;
  772.  
  773.     if(a->alloc<chlong/4)
  774.     {
  775.         if((res=mp_grow(a,chlong/4))!=MP_OKAY)
  776.             return res;
  777.     }
  778.  
  779.     a->alloc=chlong/4;
  780.     a->sign=0;
  781.     mp_zero(a);
  782.     temp=a->dp;
  783.     i=0;
  784.  
  785.     for(j=0;j<chlong/4;j++)
  786.     {
  787.         i+=4;
  788.         *temp |= (mp_digit)(ch[i-4] & 255);
  789.         *temp <<= (mp_digit)CHAR_BIT;
  790.         *temp |= (mp_digit)(ch[i-3] & 255);
  791.         *temp <<= (mp_digit)CHAR_BIT;
  792.         *temp |= (mp_digit)(ch[i-2] & 255);
  793.         *temp <<= (mp_digit)CHAR_BIT;
  794.         *temp++ |= (mp_digit)(ch[i-1] & 255); 
  795.     }
  796.     a->used=chlong/4;
  797.     return MP_OKAY;
  798. }
  799.  
  800. //实现将mp_int数a中的比特串还原为字符串并赋给字符串ch：
  801. int chdraw(mp_int *a,char *ch)
  802. {
  803.     int i,j;
  804.     mp_digit *temp,xx,yy;
  805.  
  806.     temp=a->dp;
  807.     i=0;
  808.     yy=(mp_digit)255;  //用于位与运算，取八位比特串
  809.     xx=(mp_digit)15;  //用于位与运算，取四位比特串
  810.  
  811.     for(j=0;j<a->used/2;j++)  //以两个单元为循环，把两个单元的比特串赋给7个字符
  812.     {
  813.         i+=7;
  814.         ch[i-4]=(char)(*++temp & xx);
  815.         ch[i-3]=(char)((*temp >> (mp_digit)4) & yy);    
  816.         ch[i-2]=(char)((*temp >> (mp_digit)12) & yy);
  817.         ch[i-1]=(char)((*temp-- >> (mp_digit)20) & yy);
  818.  
  819.         ch[i-7]=(char)(*temp & yy);
  820.         ch[i-6]=(char)((*temp >> (mp_digit)8) & yy);
  821.         ch[i-5]=(char)((*temp >> (mp_digit)16) & yy);
  822.         ch[i-4] <<= 4;
  823.         ch[i-4]+=(char)((*temp++ >> (mp_digit)24) & xx);
  824.         temp++;
  825.     }
  826.     if(a->used%2!=0)  //剩于一个单元的处理
  827.     {
  828.         ch[i++] = (char)(*temp & yy);
  829.         ch[i++] = (char)((*temp >> (mp_digit)8) & yy);
  830.         ch[i++] = (char)((*temp >> (mp_digit)16) & yy);
  831.     }
  832.     --i;
  833.     while(int(ch[i]&0xFF) != 255 && i>0) i--;
  834.     return i;
  835.    
  836. }
  837.  
  838. void Ecc_decipher(mp_int *k, mp_int *a,mp_int *p){
  839.  
  840.     mp_int c1x, c1y;
  841.     mp_int c2x, c2y;
  842.     mp_int tempx, tempy;
  843.     mp_int mx, my;
  844.     mp_int temp;
  845.  
  846.     mp_init(&temp);
  847.     mp_init(&c1x);
  848.     mp_init(&c1y);
  849.     mp_init(&c2x);
  850.     mp_init(&c2y);
  851.     mp_init(&tempx);
  852.     mp_init(&tempy);
  853.     mp_init(&mx);
  854.     mp_init(&my);
  855.  
  856.     mp_int tempzero;
  857.     mp_init(&tempzero);
  858.  
  859.     int i;
  860.     char stemp[700]={0};
  861.     FILE *fp,*fq;
  862.     bool zero=false;
  863. 	clock_t start, finish;
  864. 	double duration;
  865.  
  866.  
  867.     char filehead[60],filefoot[20],filename[85]={0};
  868.     cout<<"请输入您要解密的文件的存放路径和文件名(如:  c:\\000\\大整数运算  ):"<<endl;
  869.     cin>>filehead;
  870.     cout<<"请输入您要解密的文件的扩展名(如:  .doc  ):"<<endl;
  871.     cin>>filefoot;
  872.     strcpy(filename,filehead);
  873.     strcat(filename,filefoot);
  874.  
  875.     printf("\n开始解密\n");
  876.  
  877.     if((fp=fopen(filename,"rb"))==NULL)
  878.     {
  879.          printf("can not open the file!");
  880.          exit(1);
  881.     }
  882.  
  883.    //打开保存解密结果文件
  884.     char filemi[80];
  885.     strcpy(filemi, filehead);
  886.     strcat(filemi, "解密");
  887.     strcat(filemi, filefoot);
  888.  
  889.     if((fq=fopen(filemi,"wb"))==NULL)
  890.     {
  891.          printf("can not open the file!");
  892.          exit(1);
  893.     }
  894.  
  895.  
  896.     rewind(fp);
  897.     while(!feof(fp))
  898.     {
  899.          i=0;
  900.          while(1)
  901.         {
  902.              stemp[i]=fgetc(fp);
  903.              if(i%4==0)
  904.             {
  905.                  if(int(stemp[i]&0xFF) == 255 ) goto L1;
  906.             }
  907.             i++;
  908.         }
  909.              
  910. L1:     miwendraw(&c1x, stemp, i);
  911.          i=0;
  912.          while(1)
  913.         {
  914.              stemp[i]=fgetc(fp);
  915.              if(i%4==0)
  916.             {
  917.                  if(int(stemp[i]&0xFF) == 255 ) goto L2;
  918.             }
  919.             i++;
  920.         }
  921.              
  922. L2:     miwendraw(&c1y, stemp, i);
  923.          i=0;
  924.          while(1)
  925.         {
  926.              stemp[i]=fgetc(fp);
  927.              if(i%4==0)
  928.             {
  929.                  if(int(stemp[i]&0xFF) == 255 ) goto L3;
  930.             }
  931.             i++;
  932.         }
  933.              
  934. L3:     miwendraw(&c2x, stemp, i);
  935.                 i=0;
  936.          while(1)
  937.         {
  938.              stemp[i]=fgetc(fp);
  939.              if(i%4==0)
  940.             {
  941.                  if(int(stemp[i]&0xFF) == 255 ) goto L4;
  942.             }
  943.             i++;
  944.         }
  945.              
  946. L4:     miwendraw(&c2y, stemp, i);
  947.  
  948.         mp_zero(&tempzero);
  949.         if(mp_cmp(&c1x, &tempzero)==0) break;
  950.  
  951.         Ecc_points_mul(&tempx, &tempy, &c2x, &c2y, k, a, p); 
  952.  
  953.         mp_neg(&tempy, &temp);
  954.         Two_points_add(&c1x,&c1y,&tempx,&temp,&mx,&my,a,zero,p);
  955.      
  956. 		
  957.         int chtem;
  958.         chtem=chdraw(&mx,stemp);//从ming中取出字符串
  959.      
  960.  
  961.         //保存解密结果
  962.     
  963.         for(int kk=0;kk<chtem;kk++)
  964.         {
  965.              fprintf(fq,"%c",stemp[kk]);
  966.                    
  967.         }
  968.  
  969.         chtem=chdraw(&my,stemp);//从ming中取出字符串
  970.     
  971.              
  972.          //保存解密结果
  973.           for(int kk=0;kk<chtem;kk++)
  974.         {
  975.               fprintf(fq,"%c",stemp[kk]);
  976.             
  977.         }
  978.           
  979.         
  980.     }
  981.  
  982.        cout<<"\nok!解密完毕!"<<endl;
  983.     cout<<"解密后的文字存放路径为  "<<filemi<<endl;
  984.  
  985.     fclose(fq);
  986.     fclose(fp);
  987.     mp_clear(&c1x);
  988.     mp_clear(&c1y);
  989.     mp_clear(&c2x);
  990.     mp_clear(&c2y);
  991.     mp_clear(&tempx);
  992.     mp_clear(&tempy);
  993.     mp_clear(&mx);
  994.     mp_clear(&my);
  995.     mp_clear(&temp);
  996.  
  997.  
  998. }

在命令行执行：

$ g++ ecc.cpp -o main libtommath.a

生成可执行文件main。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/731216
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号