ECDH算法(Elliptic Curve Diffie–Hellman Key Exchange)
1.Alice 生成一个随机ECC密钥对:{alicePrivKey,alicePubKey=alicePrivKey*G}
2.Bob生成一个随机ECC密钥对:{bobPrivKey,bobPubKey=bobpriwkey*G}
3.Alice和Bob通过不安全的渠道(例如,通过互联网)交换公钥
4.Alice 计算sharedKey=bobPubKey*alicePrivKey
5.Bob计算sharedKey=alicePubKey*bobPrivKey
6.现在,Alice 和Bob拥有相同的sharedKey==bobPubKey*alicePrivKey==alicePubKey*bobPrivKey
BC库的部分源代码
关键是处理密钥
calculateAgreement是用来计算ECDH(椭圆曲线Diffie-Hellman)协议中的共享密钥的。
代码的步骤如下:
1. 将传入的公钥参数转换为ECPublicKeyParameters类型的对象pub。
2. 检查pub的参数是否与key的参数相同,如果不相同,则抛出一个异常,表示公钥的域参数不正确。
3. 使用pub的Q点与key的D(私钥)进行乘法运算,并对结果进行归一化(normalize),得到点P。
4. 检查点P是否为无穷远点(Infinity),如果是,则抛出一个异常,表示无穷远点不是有效的协议值。
5. 返回点P的仿射X坐标的BigInteger值作为共享密钥。
public BigInteger calculateAgreement(
CipherParameters pubKey)
{
ECPublicKeyParameters pub = (ECPublicKeyParameters)pubKey;
if (!pub.getParameters().equals(key.getParameters()))
{
throw new IllegalStateException("ECDH public key has wrong domain parameters");
}
ECPoint P = pub.getQ().multiply(key.getD()).normalize();
if (P.isInfinity())
{
throw new IllegalStateException("Infinity is not a valid agreement value for ECDH");
}
return P.getAffineXCoord().toBigInteger();
}
multiply(),ECC乘法函数(ECC原理这里就不展开讲了)
normalize 函数,返回类型是ECPoint。该方法的作用是将椭圆曲线上的点规范化。
1.判断当前点是否为无穷远点(isInfinity()方法),如果是,则直接返回当前点。
2.根据椭圆曲线的坐标系统(getCurveCoordinateSystem()方法),进行不同的处理。 如果坐标系统是AFFINE或LAMBDA_AFFINE,表示当前点已经是规范化的,直接返回当前点。
如果坐标系统不是AFFINE或LAMBDA_AFFINE,表示当前点需要进行规范化操作。 首先获取当前点的Z坐标(getZCoord(0)方法),并判断Z坐标是否为1。如果是,则表示当前点已经是规范化的,直接返回当前点。 如果Z坐标不为1,则调用normalize方法,传入Z坐标的倒数(Z1.invert()方法),进行规范化操作,并返回规范化后的点。
public ECPoint normalize()
{
if (this.isInfinity())
{
return this;
}
switch (this.getCurveCoordinateSystem())
{
case ECCurve.COORD_AFFINE:
case ECCurve.COORD_LAMBDA_AFFINE:
{
return this;
}
default:
{
ECFieldElement Z1 = getZCoord(0);
if (Z1.isOne())
{
return this;
}
return normalize(Z1.invert());
}
}
}
实现ECDH
最后输出G点、双方公钥私钥和最后的共享密钥,比较共享密钥是否相同。
这里的代码只是经过学习后参考BC库的一些函数实现ECDH基本流程
import org.bouncycastle.jce.ECNamedCurveTable;
import org.bouncycastle.jce.spec.ECNamedCurveParameterSpec;
import org.bouncycastle.math.ec.ECPoint;
import java.math.BigInteger;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
public class ECC_DH {
public static void main(String[] args) throws Exception {
// 添加 Bouncy Castle 作为安全提供程序
Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
// 选择椭圆曲线参数
ECNamedCurveParameterSpec ecSpec = ECNamedCurveTable.getParameterSpec("secp256r1");
// 生成密钥对
//创建一个KeyPairGenerator对象,使用参数"ECDH"和"BC"来指定生成ECDH密钥对的算法和提供者
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("ECDH", "BC");
//初始化密钥对生成器
keyPairGenerator.initialize(ecSpec);
ECPoint G = ecSpec.getG();
BigInteger n = ecSpec.getN();
// Alice 和 Bob 分别生成私钥和公钥
BigInteger dA = new BigInteger(n.bitLength(), new SecureRandom()).mod(n.subtract(BigInteger.ONE)).add(BigInteger.ONE); // 1 <= dA < n
BigInteger dB = new BigInteger(n.bitLength(), new SecureRandom()).mod(n.subtract(BigInteger.ONE)).add(BigInteger.ONE); // 1 <= dB < n
ECPoint Qa = G.multiply(dA).normalize(); // 公钥 QA = dA * G
ECPoint Qb = G.multiply(dB).normalize(); // 公钥 QB = dB * G
// Alice 使用自己的私钥和 Bob 的公钥计算共享密钥
ECPoint sharedKeyA = Qb.multiply(dA).normalize(); // 共享密钥 = dB * QA
// Bob 使用自己的私钥和 Alice 的公钥计算共享密钥
ECPoint sharedKeyB = Qa.multiply(dB).normalize(); // 共享密钥 = dA * QB
System.out.println("Alice's key pair: " + dA);
System.out.println("Bob's key pair:"+ dB);
System.out.println("G="+G);
System.out.println("\n");
System.out.println("A的公钥:"+ Qa);
System.out.println("B的公钥:"+ Qb);
BigInteger a=sharedKeyA.getAffineXCoord().toBigInteger();
BigInteger b=sharedKeyB.getAffineXCoord().toBigInteger();
//输出共享密钥
System.out.println("Shared key A: " + a);
System.out.println("Shared key B: " + b);
System.out.println("比较结果:" + sharedKeyA.equals(sharedKeyB));
}
}
其他
写完后出现了最后共享密钥不同的结果,经过分析BC库源代码发现计算时没有规范化,在计算时加normalize()