GF(p)上的ELGamal型椭圆曲线密码详解（Java实现）

Posted 2021-02-06 mx-lqk

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了GF(p)上的ELGamal型椭圆曲线密码详解（Java实现）相关的知识，希望对你有一定的参考价值。

GitHub

椭圆曲线密码

　　椭圆曲线密码（Elliptic Curve Cryptosystem），简称ECC，是Neal Koblitz和Victor Miller于1985年提出的。

　　研究发现，有限域上的椭圆曲线上的一些点构成交换群，而且离散对数问题是难解的。于是在此群上定义ELGamal密码，并称为椭圆曲线密码。

　　目前，椭圆曲线密码已成为除RSA密码之外呼声最高的公钥密码之一。它密钥短、签名短、软件实现规模小、硬件实现电路省电。普遍认为，160位长的椭圆曲线密码的安全性相当于1024位的RSA密码，而且运算速度也较快。

GF(p)上的椭圆曲线

　　设p是大于3的素数，且4a³+27b²≠0(mod p)，称曲线

y²=x³+ax+b（a,b∈GF(p)）

为GF(p)上的椭圆曲线。

　　由椭圆曲线方程可得到一同余方程：

y²=x³+ax+b(mod p)（a,b∈GF(p)）

其解为一个二元组(x,y)，其中x,y∈GF(p)，表示椭圆曲线上的一个点，称为该椭圆曲线上的解点。

无穷点O

　　定义一个点O(∞,∞)表示无穷点，作为0元素。

两解点相加

　　设P(x₁,y₁)和Q(x₂,y₂)是解点，R(x₃,y₃)=P(x₁,y₁)+Q(x₂,y₂)：

　　1.若P为无穷点，即P=O，此时R=P+Q=Q；若Q为无穷点，即Q=O，此时R=P+Q=P；若P和Q都为无穷点，即P=Q=O，则R=P+Q=O。

　　2.若x₁=x₂且y₁=y₂，即P=Q，此时R=P+Q=2P，其中

技术分享图片

　　3.若x1=x2而y1=-y2，此时称Q点为P点的逆，记为P=-Q，且R=P+Q=O。

　　4.除上述特殊情况之外的一般情况，即P≠±Q时，R=P+Q，其中

技术分享图片

　　集合E={所有的解点,无穷点O}和加法运算构成加法交换群。设G(G≠O，即G为一个解点)为一个加法群的生成元，则使得nG=G+G+...+G=O的倍数n为该加法群的阶。加法群的阶整除集合E的阶，即n | |E|。

求椭圆曲线的所有解点

　　当p较小，即GF(p)较小时，可以利用穷举的方法根据同余方程y²=x³+ax+b(mod p)（a,b∈GF(p)）求出所有解点。

　　具体方法为：求出x取0~p-1，x³+ax+b(mod p)的结果是否为模p的二次剩余。如果是，则一个x值可得到两个对应的y值，也就得到互逆的两个解点。

　　e.m.取p=11，椭圆曲线y²=x³+x+6

技术分享图片

　　由此表得到所有的解点：(2,4)、(2,7)、(3,5)、(3,6)、(5,2)、(5,9)、(7,2)、(7,9)、(8,3)、(8,8)、(10,2)、(10,9)，再加上无穷点O共13个点的集合E加上加法运算就构成一个加法交换群。

　　因为集合E的阶|E|=13为素数，所以该加法群的阶为13。

　　取G=(2,7)为生成元，

G=(2,7)，2G=(5,2)，

3G=(8,3)，4G=(10,2)，

5G=(3,6)，6G=(7,9)，

7G=(7,2)，8G=(3,5)，

9G=(10,9)，10G=(8,8)，

11G=(5,9)，12G=(2,4)，

　　最终得到13G=O，所以加法群的阶为13。

ELGamal型椭圆曲线密码

　　1.选择一个素数p，从而确定有限域GF(p)，将p公开。

　　2.选择元素a,b∈GF(p)，从而确定一条GF(p)上的椭圆曲线，确定加法交换群E，将a和b公开。

　　3.选择一个大素数n，并确定一个阶为n的基点G(x,y)，将n和G(x,y)公开。

　　4.余因子h=|E|/n，将h公开。

　　5.随机选择一个整数d(0<d<n)作为私钥保密。

　　6.定义Q=dG作为公钥公开。

加密

　　1.随机选择一个整数k(0<k<n)。

　　2.计算X₁=kG。

　　3.计算X₂=kQ，若x₂=∞，则回到第1步。

　　4.加密：C=Mx₂(mod n)。

　　5.将(X₁,C)作为密文发送。

解密

　　1.用私钥d求出X₂=dX₁。

　　2.解密：M=Cx₂^-1(mod n)。

椭圆曲线密码的安全性

　　椭圆曲线密码的安全性建立在椭圆曲线离散对数问题的困难性之上。当素数p和n足够大时椭圆曲线密码是安全的。这就要求椭圆曲线解点群的阶要有大素数因子的根本原因，在理想情况下群的阶本身就是一个大素数。

　　为了确保椭圆曲线密码的安全，应当避免使用弱的椭圆曲线。所谓弱的椭圆曲线主要指超奇异椭圆曲线和反常椭圆曲线。

　　椭圆曲线密码的密钥越长，自然越安全，但是技术实现也就越困难，效率也越低。一般认为，在目前的技术水平下采用190~256位的椭圆曲线，其安全性就足够了。

Java实现

解点类

 1 import java.math.BigInteger;
 2 
 3 public class ECPoint {
 4     BigInteger x;
 5     BigInteger y;
 6 
 7     public ECPoint() {
 8         x = null;
 9         y = null;
10     }
11 
12     public ECPoint(BigInteger x, BigInteger y) {
13         this.x = x;
14         this.y = y;
15     }
16 
17     @Override
18     public String toString() {
19         if (isO()) 
20             return "O";
21         return "(" + x.toString(16) + ", " + y.toString(16) + ")";
22     }
23 
24     boolean isO() {
25         if (x == null && y == null) 
26             return true;
27         return false;
28     }
29 }

两解点相加

 1 /**
 2  * 两解点相加
 3  * @param p1
 4  * @param p2
 5  * @return
 6  */
 7 ECPoint add(ECPoint p1, ECPoint p2) {
 8     if (p1.isO()) return p2;
 9     if (p2.isO()) return p1;
10     ECPoint p3 = new ECPoint();
11     BigInteger lambda;
12     if (p1.x.compareTo(p2.x) == 0) {
13         if (p1.y.compareTo(p2.y) == 0) {
14             lambda = new BigInteger("3").multiply(p1.x.pow(2)).add(a).multiply(new BigInteger("2").multiply(p1.y).modPow(new BigInteger("-1"), p)).mod(p);
15             p3.x = lambda.pow(2).subtract(new BigInteger("2").multiply(p1.x)).mod(p);
16             p3.y = lambda.multiply(p1.x.subtract(p3.x)).subtract(p1.y).mod(p);
17             return p3;
18         }
19         if (p1.y.compareTo(p.subtract(p2.y)) == 0) 
20             return p3;
21     }
22     lambda = p2.y.subtract(p1.y).multiply(p2.x.subtract(p1.x).modPow(new BigInteger("-1"), p)).mod(p);
23     p3.x = lambda.pow(2).subtract(p1.x).subtract(p2.x).mod(p);
24     p3.y = lambda.multiply(p1.x.subtract(p3.x)).subtract(p1.y).mod(p);
25     return p3;
26 }

倍乘

 1 /**
 2  * 倍乘
 3  * @param p
 4  * @param n
 5  * @return  np
 6  */
 7 ECPoint multiply(ECPoint p, BigInteger n) {
 8     ECPoint q = add(p, new ECPoint());
 9     ECPoint r = new ECPoint();
10     do {
11         if (n.and(new BigInteger("1")).intValue() == 1) 
12             r = add(r, q);
13         q = add(q, q);
14         n = n.shiftRight(1);
15     } while (n.intValue() != 0);
16     return r;
17 }

求所有解点

 1 /**
 2  * 求所有解点
 3  * @return
 4  */
 5 List<ECPoint> solutionPoints() {
 6     List<ECPoint> r = new ArrayList<ECPoint>();
 7     List<BigInteger> l = new ArrayList<BigInteger>();
 8     for (BigInteger y = new BigInteger("1"); y.compareTo(p.divide(new BigInteger("2"))) != 1; y = y.add(new BigInteger("1"))) 
 9         l.add(y.modPow(new BigInteger("2"), p));
10     for (BigInteger x = new BigInteger("0"); x.compareTo(p) == -1; x = x.add(new BigInteger("1"))) {
11         BigInteger t = x.pow(3).add(a.multiply(x)).add(b).mod(p);
12         if (isExist(t, l) != -1) {
13             BigInteger y = new BigInteger(isExist(t, l) + "");
14             r.add(new ECPoint(x, y));
15             r.add(new ECPoint(x, p.subtract(y)));
16         }
17     }
18     r.add(new ECPoint());
19     return r;
20 }

1 static int isExist(BigInteger b, List<BigInteger> l) {
2     for (int i = 0; i < l.size(); i++) 
3         if (l.get(i).compareTo(b) == 0) return (i + 1);
4     return -1;
5 }

求阶

 1 /**
 2  * 求阶
 3  * @param p  生成元
 4  * @return   p对应的阶
 5  */
 6 BigInteger o(ECPoint p) {
 7     BigInteger r = new BigInteger("1");
 8     while (! p.isO()) {
 9         r = r.add(new BigInteger("1"));
10         p = multiply(p, r);
11     }
12     return r;
13 }

加密

 1 /**
 2  * 加密
 3  * @param M
 4  * @return
 5  */
 6 BigInteger[] encrypt(BigInteger M) {
 7     BigInteger k;
 8     ECPoint X1, X2;
 9     do {
10         k = new BigInteger(n.bitLength(), new Random());
11     } while ((X2 = ec.multiply(Q, k)).x == null);
12     X1 = ec.multiply(G, k);
13     BigInteger[] C = new BigInteger[3];
14     C[0] = X1.x;
15     C[1] = X1.y;
16     C[2] = M.multiply(X2.x).mod(n);
17     return C;
18 }

解密

 1 /**
 2  * 解密
 3  * @param C
 4  * @return
 5  */
 6 BigInteger decrypt(BigInteger[] C) {
 7     ECPoint X1 = new ECPoint(C[0], C[1]);
 8     ECPoint X2 = ec.multiply(X1, d);
 9     BigInteger M = C[2].multiply(X2.x.modPow(new BigInteger("-1"), n)).mod(n);
10     return M;
11 }