ECC 算法原理&JAVA 实现

最新推荐文章于 2024-07-09 00:36:27 发布
最新推荐文章于 2024-07-09 00:36:27 发布
阅读量2.1k 收藏 7
点赞数 1
文章标签： 算法 密码学 java python 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42653356/article/details/119889020
版权

遗留问题

  1. ECCurve.Fp与ECCurve.F2m区别？

概述

椭圆曲线算法依赖于椭圆曲线，只有椭圆曲线确定之后，才能基于此曲线去做加密、解密，加签、验签。

椭圆曲线算法同样有多种密钥长度，常用的有160bit、192bit、224bit、256bit、320bit、384bit、512bit。

常用的曲线有：secp192r1、secp192k1、secp224r1、secp256r1、secp256k1等

具体椭圆曲线参数名称可见：椭圆曲线名称

数学原理简述

ECC算法基于离散对数数学难题

算法具体过程

① 用户A选定一条椭圆曲线Ep(a , b)，并取椭圆曲线上一点，作为基点G。

② 用户A选择一个私有密钥k，并生成公开密钥K=kG。

③ 用户A将Ep(a , b)和点K，G传给用户B。

④ 用户B接到信息后 ，将待传输的明文编码到Ep(a , b)上一点M(编码方法很多，这里不作讨论)，并产生一个随机整数r(r<n)。

⑤ 用户B计算点C1=M+rK；C2=rG。

⑥ 用户B将C1、C2传给用户A。

⑦ 用户A接到信息后，计算C1 - kC2，结果就是点M。C1-kC2=M+rK-k(rG)=M+rK-r(rG)=M

⑧ 再对点M进行解码就可以得到明文。

椭圆曲线相关参数及含义

参数含义
p椭圆曲线从连续变为离散，使其适合用于加密。所以将曲线限制在有限域Fp上，其中p为素数，Fp上只有p个元素
aa、b与p共同确定一条曲线。在Fp上，选择小于P的两个素数a、b，使其满足方程 4a^3+27b^2≠0 (mod p) 则满足方程 y^2=x^3+ax^2+b (mod p) 的所有点(x , y)，再加上无穷远点O∞ ，构成一条椭圆曲线我们记为：Ep(a , b)
b
G用户选择Ep(a,b)上的一个G点，作为基点，用于生成公钥、私钥
具体生成公私钥的原理
考虑如下等式：K=kG [其中 K,G为Ep(a,b)上的点，k为小于n(n是点G的阶)的整数]不难发现，给定k和G，根据加法法则，计算K很容易；但给定K和G，求k就相对困难了。这就是椭圆曲线加密算法采用的难题。我们把点G称为基点，k(k<n，n为基点G的阶)称为私钥，K称为公钥
nn为基点G的阶，并且为素数
椭圆曲线上点的阶
如果椭圆曲线上一点P，存在最小的正整数n，使得数乘nP=O∞，则将n称为P的 阶，若n不存在，我们说P是无限阶的。 事实上，在有限域上定义的椭圆曲线上所有的点的阶n都是存在的(证明，请参考近世代数方面的书)
h椭圆曲线上所有点的个数m与n相除的整数部分，h<=4

密钥格式

密钥类型格式
公钥公钥是椭圆曲线上的一个点，由 x轴坐标 和 y轴坐标组成。
02/03 + x轴坐标：压缩法表示的公钥，02表示y轴坐标为偶数，03表示y轴坐标为奇数
04 + x轴坐标 + y轴坐标：完整公钥表示法
私钥公式：K=kG，其中k为私钥，G为基点
用户选择的私钥k<n(n为点G的阶)
曲线选择为多少位，则私钥长度也是多少位

SM2

sm2 曲线名称为：sm2p256v1

JAVA实现

ECC JAVA示例

import com.google.common.collect.Maps;
import com.sankuai.cx.etcp.code.util.HexUtil;
import com.sankuai.cx.etcp.code.util.sm.newer.ASNUtil;
import javafx.print.PageLayout;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.bouncycastle.asn1.*;
import org.bouncycastle.jce.provider.JCEECPrivateKey;
import org.bouncycastle.jce.provider.JCEECPublicKey;
import org.bouncycastle.math.ec.ECCurve;
import org.bouncycastle.math.ec.ECFieldElement;
import sun.security.ec.ECPublicKeyImpl;
import sun.security.util.DerOutputStream;
import sun.security.util.DerValue;

import java.io.ByteArrayInputStream;
import java.math.BigInteger;
import java.security.*;
import java.security.interfaces.ECPrivateKey;
import java.security.interfaces.ECPublicKey;
import java.security.spec.*;
import java.util.Enumeration;
import java.util.Map;

/**
 * @Author:wangchao
 * @Date: 2019/5/29 2:34 PM
 * @Description:
 **/
@Slf4j
public class EccUtil {
    /**
     * 算法名称
     */
    private static final String ALGORITHM = "EC";

    private static final String SHA1WITHECDSA = "SHA1WITHECDSA";

    /**
     * 根据曲线名称生成 keypair
     * @param parameter
     * @return
     * @throws Exception
     */
    public static KeyPair initKey(String parameter) throws Exception{
        //生成密钥
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
        //指定曲线名称
        ECGenParameterSpec ecGenParameterSpec = new ECGenParameterSpec(parameter);
        //从具体曲线参数生成曲线
        keyPairGenerator.initialize(ecGenParameterSpec);
        return keyPairGenerator.generateKeyPair();
    }

    /**
     * 创建 EC 私钥
     * @param keyPair
     * @return
     */
    public static String createPrivateKey(KeyPair keyPair,Ecc ecc){
        ECPrivateKey ecPrivateKey = (ECPrivateKey) keyPair.getPrivate();
        byte[] b = ASNUtil.bigIntToFixexLengthBytes(ecPrivateKey.getS(),ecc.getKeyLen());
        return HexUtil.byteToHex(b);
    }

    /**
     * 创建公钥 Point
     * @param keyPair
     * @return
     */
    public static ECPoint createPublicKeyPoint(KeyPair keyPair){
        ECPublicKey ecPublicKey = (ECPublicKey) keyPair.getPublic();
        return ecPublicKey.getW();
    }

    /**
     * 创建公钥 pubx + puby
     * @param keyPair
     * @return
     */
    public static String createPublicKey(KeyPair keyPair,Ecc ecc){
        ECPublicKey ecPublicKey = (ECPublicKey) keyPair.getPublic();
        String x = HexUtil.byteToHex(ASNUtil.bigIntToFixexLengthBytes(ecPublicKey.getW().getAffineX(),ecc.getKeyLen()));
        String y = HexUtil.byteToHex(ASNUtil.bigIntToFixexLengthBytes(ecPublicKey.getW().getAffineY(),ecc.getKeyLen()));
        return x + y;
    }

    /**
     * 加载私钥
     * @param privateKey hex
     * @param ecc 曲线参数
     * @return
     * @throws Exception
     */
    public static ECPrivateKey loadPrivateKey(String privateKey,Ecc ecc) throws Exception{
        ECParameterSpec ecParameterSpec = createFromParameterName(ecc);
//        return new ECPrivateKeyImpl(new BigInteger(privateKey,16),ecParameterSpec);
        return new JCEECPrivateKey(ALGORITHM,new ECPrivateKeySpec(new BigInteger(privateKey,16),ecParameterSpec));
    }

    /**
     * 加载公钥
     * @param pubx x 点,hex
     * @param puby y 点,hex
     * @param ecc 曲线参数
     * @return
     * @throws Exception
     */
    public static ECPublicKey loadPublicKey(String pubx,String puby,Ecc ecc) throws Exception{
        ECParameterSpec ecParameterSpec = createFromParameterName(ecc);
//        return new ECPublicKeyImpl(new ECPoint(new BigInteger(pubx,16),new BigInteger(puby,16)),ecParameterSpec);
        return new JCEECPublicKey(ALGORITHM,new ECPublicKeySpec(new ECPoint(new BigInteger(pubx,16),new BigInteger(puby,16)),ecParameterSpec));
    }


    /**
     * 创建曲线参数
     * @param ecc
     * @return
     */
    public static ECParameterSpec createFromParameterName(Ecc ecc){
        BigInteger[] parameter = ecc.getParameter();
        BigInteger P = parameter[0];
        BigInteger A = parameter[1];
        BigInteger B = parameter[2];
        BigInteger X = parameter[3];
        BigInteger Y = parameter[4];
        BigInteger N = parameter[5];
        int H = parameter[6].intValue();
        ECParameterSpec ecParameterSpec = new ECParameterSpec(new EllipticCurve(new ECFieldFp(P),A,B),new ECPoint(X,Y),N,H);
        return ecParameterSpec;
    }

    /**
     * 进行 ecdsa 签名
     * @param source hex
     * @param privateKey hex
     * @param ecc
     * @return
     * @throws Exception
     */
    public static String sign(String source,String privateKey,Ecc ecc) throws Exception{
        ECPrivateKey ecPrivateKey = loadPrivateKey(privateKey,ecc);
        Signature signature = Signature.getInstance(SHA1WITHECDSA);
        signature.initSign(ecPrivateKey);
        signature.update(HexUtil.hexStringToBytes(source));
        byte[] result = signature.sign();

        byte[] plainResult = ASNUtil.rsAsn1ToPlainByteArray(result,ecc.getKeyLen());

        return HexUtil.byteToHex(plainResult);
    }

    /**
     * ecdsa 验签,传入完整公钥
     * @param source hex
     * @param sign hex
     * @param pubx hex
     * @param puby hex
     * @param ecc
     * @return
     * @throws Exception
     */
    public static boolean verify(String source,String sign,String pubx,String puby,Ecc ecc) throws Exception{

        //将签名值按照der格式进行编码
        byte[] sig = HexUtil.hexStringToBytes(sign);
        byte[] encodeSig = ASNUtil.rsPlainByteArrayToAsn1(sig,ecc.getKeyLen());

        ECPublicKey ecPublicKey = loadPublicKey(pubx,puby,ecc);
        Signature signature = Signature.getInstance(SHA1WITHECDSA);
        signature.initVerify(ecPublicKey);
        signature.update(HexUtil.hexStringToBytes(source));
        return signature.verify(encodeSig);
    }

    /**
     * ecdsa 验签,传入压缩公钥
     * @param source hex
     * @param sign hex
     * @param compressedPubkey hex
     * @param ecc
     * @return
     * @throws Exception
     */
    public static boolean verify(String source,String sign,String compressedPubkey,Ecc ecc) throws Exception{
        org.bouncycastle.math.ec.ECPoint publicPoint = decompressPubkey(compressedPubkey,ecc);
        String pubx = HexUtil.byteToHex(publicPoint.getX().toBigInteger().toByteArray());
        String puby = HexUtil.byteToHex(publicPoint.getY().toBigInteger().toByteArray());
        ECPublicKey ecPublicKey = loadPublicKey(pubx,puby,ecc);

        //将签名值按照der格式进行编码
        byte[] sig = HexUtil.hexStringToBytes(sign);
        byte[] encodeSig = ASNUtil.rsPlainByteArrayToAsn1(sig,ecc.getKeyLen());

        Signature signature = Signature.getInstance(SHA1WITHECDSA);
        signature.initVerify(ecPublicKey);
        signature.update(HexUtil.hexStringToBytes(source));
        return signature.verify(encodeSig);
    }

    /**
     * 压缩公钥
     * @param pubx hex
     * @param puby hex
     * @param ecc
     * @return
     */
    public static String compressPubkey(String pubx,String puby,Ecc ecc){
        BigInteger[] paramter = ecc.getParameter();
        BigInteger ecc_p = paramter[0];
        BigInteger ecc_a = paramter[1];
        BigInteger ecc_b = paramter[2];
        ECCurve ecc_curve = new ECCurve.Fp(ecc_p, ecc_a, ecc_b);

        // 构造点
        BigInteger ecc_p1 = new BigInteger(pubx, 16);
        BigInteger ecc_p2 = new BigInteger(puby, 16);
        ECFieldElement aaaecc_gx_fieldelement = new ECFieldElement.Fp(ecc_p, ecc_p1);
        ECFieldElement aaaecc_gy_fieldelement = new ECFieldElement.Fp(ecc_p, ecc_p2);
        org.bouncycastle.math.ec.ECPoint ecPoint = new org.bouncycastle.math.ec.ECPoint.Fp(ecc_curve, aaaecc_gx_fieldelement, aaaecc_gy_fieldelement);
        // 得到压缩后的公钥
        byte[] compKey = ecPoint.getEncoded(true);
        return HexUtil.byteToHex(compKey);
    }

    public static String compress(String x,String y){
        BigInteger by = new BigInteger(y,16);
        if(by.testBit(0)){
            return "03" + x;
        }else {
            return "02" + x;
        }
    }

    /**
     * 解压公钥
     * @param compressedPubkey hex
     * @param ecc
     * @return
     */
    public static org.bouncycastle.math.ec.ECPoint decompressPubkey(String compressedPubkey,Ecc ecc){
        BigInteger[] parameter = ecc.getParameter();
        Map<String,BigInteger> m = Maps.newHashMap();
        BigInteger P = parameter[0];
        BigInteger A = parameter[1];
        BigInteger B = parameter[2];
        ECCurve ecc_curve = new ECCurve.Fp(P, A, B);
        // 根据X恢复点Y，
        return ecc_curve.decodePoint(
                HexUtil.hexStringToBytes(compressedPubkey));
    }

    /**
     * 创建 EC 私钥
     * @param keyPair
     * @return
     */
    public static String createPrivateKey11(KeyPair keyPair,Ecc ecc){
        ECPrivateKey ecPrivateKey = (ECPrivateKey) keyPair.getPrivate();
//        byte[] b = ASNUtil.bigIntToFixexLengthBytes(ecPrivateKey.getS(),ecc.getKeyLen());
        byte[] b = ecPrivateKey.getEncoded();
        ASN1Sequence seq = ASN1Sequence.getInstance(b);
        Enumeration enumeration = seq.getObjects();
        while(enumeration.hasMoreElements()){
            Object o = enumeration.nextElement();
            System.out.println(o);
        }
        return HexUtil.byteToHex(b);
    }

    /**
     * 创建公钥 pubx + puby
     * @param keyPair
     * @return
     */
    public static String createPublicKey11(KeyPair keyPair,Ecc ecc){
        ECPublicKey ecPublicKey = (ECPublicKey) keyPair.getPublic();
//        String x = HexUtil.byteToHex(ASNUtil.bigIntToFixexLengthBytes(ecPublicKey.getW().getAffineX(),ecc.getKeyLen()));
//        String y = HexUtil.byteToHex(ASNUtil.bigIntToFixexLengthBytes(ecPublicKey.getW().getAffineY(),ecc.getKeyLen()));
        System.out.println("pub : format = " + ecPublicKey.getFormat());
        byte[] b = ecPublicKey.getEncoded();
        ASN1Sequence seq = ASN1Sequence.getInstance(b);
//        Enumeration enumeration = seq.getObjects();
//        while(enumeration.hasMoreElements()){
//            Object o = enumeration.nextElement();
//            System.out.println(o);
//        }
        DERBitString derBitString = DERBitString.getInstance(seq.getObjectAt(1));
        ASN1Sequence seq1 = ASN1Sequence.getInstance(derBitString.getOctets());

        return "test";
    }

    public static void main(String[] args) throws Exception{
        Ecc ecc = Ecc.secp256r1;
        String source = "80021630303030303030303030303030303130031148303021000130880000215500002155000003200125B0ADD3791AF08B4A99F5EB05F7372AE473C1C32175CE57C958A29B6502B147203012310120010100F5F3FC7D63E0043CE0A06A559BA3B771C7E277B81B7488AAD4487A19316900E975A13AE7796E653C6D9E11029B1F78A6CF9C388F380D72D51151DAEC79C47AF74DB51CFB";
        KeyPair keyPair = initKey(ecc.getName());
        createPublicKey11(keyPair,ecc);
//        createPrivateKey11(keyPair,ecc);
    }
}

参考资料

https://blog.csdn.net/qq_30866297/article/details/51175305

https://blog.csdn.net/qq_35612816/article/details/78904225

精神病院长_001
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java的ecc算法.doc
08-31
椭圆双曲线加密方面的文档。
ECC的java实现
09-14
国密椭圆曲线ECC的java实现代码
ECC-算法原理
最新发布
weixin_43772705的博客
07-09 401
（1）所有的校验位正确，则数据正确；（2）PP错误，其他校验位错误，则出现单bit错误；（3）PP正确，其他校验位错误，则出现双bit错误；（4）PP错误，其他校验位正确，则PP数据错误；
基于java实现的ECC加密算法示例
08-29
主要介绍了基于java实现的ECC加密算法,简单说明了ECC算法的概念、原理,并结合实例形式分析了java实现ECC加密算法的定义与使用技巧,需要的朋友可以参考下
JavaECC:椭圆曲线密码学 - El Gamal (ECCEG) 算法在 Java 中的实现
06-15
JavaECC 椭圆曲线密码学 - El Gamal (ECCEG) 算法在 Java 中的实现
java使用bouncycastle实现椭圆曲线（ECC）双向加密解密
04-27
java借助bouncycastle库实现ECC双向加密解密算法Utils工具包。
ECC密码体系的java实现.zip
07-08
8. **源代码（src）**：压缩包中的“src”目录很可能包含了项目的Java源代码，包括ECC和SM2的相关类和方法，开发者可以查看这些代码来学习和理解ECC密码体系的具体实现细节。 9. **实验报告**：“18373055-第四次...
Java的椭圆曲线加密ecc算法
03-09
总结来说，Java中的椭圆曲线加密（ECC）算法提供了一种高效安全的加密手段，它依赖于特定的椭圆曲线参数，并通过Java Cryptography Extension (JCE)框架中的KeyPairGenerator和KeyFactory类进行实现和管理。...
java国密算法实现
01-07
Java国密算法主要涉及到我国自主研发的一系列密码学标准，包括SM2、SM3等。这些算法在保护信息安全、实现数据加密、...在具体编程时，需要对算法原理有深入理解，并熟练掌握相关库的使用，以确保代码的正确性和效率。
JAVA ECC 椭圆曲线加密算法源代码
02-24
JAVA ECC 椭圆曲线加密算法源代码， 公钥 String publicKey = ECCCoder.getPublicKey(keyMap); 私钥 String privateKey = ECCCoder.getPrivateKey(keyMap); 加密 byte[] encodedData = ECCCoder.encrypt(data, publicKey); 解密 byte[] decodedData = ECCCoder.decrypt(encodedData, privateKey);
ECC算法 C#实现代码
04-20
本资源内部包含两个CS文件，一个是Program.cs，另一个就是ECC.cs。Program.cs包含怎么将明文编码方式。
ECC加密算法实现C源码
01-16
ECC加密算法实现C源码 椭圆曲线密码学(Elliptic curve cryptography,缩写为ECC)是基于椭圆曲线数学的一种公钥密码的方法。
ECC密码体制的算法实现
05-19
基于椭圆曲线密码体制的加解密算法的实现。
ECC加密算法源代码
12-07
ECC 加密算法C源代码，包括ZIGBEE的加密算法。椭圆加密算法源代码
java实现加密算法
05-25
密码学课程设计代码实现，其中包括古典密码和简单的playfair密码。
【算法】Java实现ECC算法
热门推荐
分享Java硬核干货
06-27 1万+
ECC（Elliptic Curve Cryptography）是一种非对称加密算法，基于椭圆曲线数学。与传统的RSA和DSA等算法相比，ECC在相同的安全性下使用更短的密钥长度，提供了更高的加密效率和性能。ECC算法基于椭圆曲线的离散对数问题，它使用一对密钥：私钥和公钥。私钥用于签名和解密，公钥用于加密和验证签名。选择一个合适的椭圆曲线作为基础。椭圆曲线是由一组参数定义的曲线，例如secp256k1。选择一个随机数作为私钥，私钥通常是一个大整数。通过椭圆曲线上的点乘法，使用私钥生成公钥。
Java 实现 ECC 非对称加密算法加解密和签名验签
yuanjian0814的博客
11-19 5772
Java 实现 ECC 非对称加密算法加解密和签名验签前言一、ECC 椭圆曲线算法简介二、ECC 加解密代码实例1.生成 ECC 密钥2.ECC 加解密3.测试代码三、ECC 签名验签代码实例1. ECC 签名验签2. 测试代码 前言 文章字数比较多，可直接查看代码：源码地址，文中描述有误的地方欢迎各位大神指导。 一、ECC 椭圆曲线算法简介 ECC是椭圆曲线算法，其加密算法叫ECIES，签名算法叫ECDSA。JDK 并不支持 ECC 算法，可以引入 BouncyCastle 库使用。ECC算法相当耗费资源
椭圆曲线ECC ECDH原理&& javacard实现
weixin_34376986的博客
07-28 627
椭圆曲线原理： 椭圆曲线的图像并不是椭圆形，椭圆曲线源自于求椭圆弧长的椭圆积分的反函数。 定义： 椭圆曲线可用下列方程来表示，其中a,b,c,d为系数。 E： y2 =ax3 + bx2 +cx +d 椭圆曲线运算：（相当于交换群） A+B： 过曲线上两点A，B画一条直线，找到直线与椭圆曲线的的交点，将该交点关于x轴对称位置的点定义为A+B。 A+A： 画出曲线在A点的切线，找到...
Java ECC加密技术探索与实现
然而，实际运行这些代码可能需要物理硬件设备，如支持PKCS#11的硬件令牌或智能卡，因为纯软件实现的效率不足以应对ECC算法的计算需求。因此，对于开发者来说，理解ECC的工作原理以及如何在Java环境中与硬件安全设备...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值