ECC （加解密、ECDSA签证 代码收集整合）

最新推荐文章于 2024-08-31 19:56:26 发布
最新推荐文章于 2024-08-31 19:56:26 发布
阅读量2.1k 收藏 3
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/phone13144830339/article/details/89280376
版权 
package work.superstr;

import java.security.MessageDigest;  

import javax.crypto.KeyGenerator;  
import javax.crypto.Mac;  
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import sun.misc.BASE64Decoder;  
import sun.misc.BASE64Encoder;  
  
public abstract class Coder {  
    public static final String KEY_SHA = "SHA";  
    public static final String KEY_MD5 = "MD5";  
  
    /** 
     * MAC算法可选以下多种算法 
     *  
     * <pre> 
     * HmacMD5  
     * HmacSHA1  
     * HmacSHA256  
     * HmacSHA384  
     * HmacSHA512 
     * </pre> 
     */  
    public static final String KEY_MAC = "HmacMD5";  
  
    /** 
     * BASE64解密 
     *  
     * @param key 
     * @return 
     * @throws Exception 
     */  
    public static byte[] decryptBASE64(String key) throws Exception {  
        return (new BASE64Decoder()).decodeBuffer(key);  
    }  
  
    /** 
     * BASE64加密 
     *  
     * @param key 
     * @return 
     * @throws Exception 
     */  
    public static String encryptBASE64(byte[] key) throws Exception {  
        return (new BASE64Encoder()).encodeBuffer(key);  
    }  
  
    /** 
     * MD5加密 
     *  
     * @param data 
     * @return 
     * @throws Exception 
     */  
    public static byte[] encryptMD5(byte[] data) throws Exception {  
  
        MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);  
        md5.update(data);  
  
        return md5.digest();  
  
    }  
  
    /** 
     * SHA加密 
     *  
     * @param data 
     * @return 
     * @throws Exception 
     */  
    public static byte[] encryptSHA(byte[] data) throws Exception {  
  
        MessageDigest sha = MessageDigest.getInstance(KEY_SHA);  
        sha.update(data);  
  
        return sha.digest();  
  
    }  
  
    /** 
     * 初始化HMAC密钥 
     *  
     * @return 
     * @throws Exception 
     */  
    public static String initMacKey() throws Exception {  
        KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);  
  
        SecretKey secretKey = keyGenerator.generateKey();  
        return encryptBASE64(secretKey.getEncoded());  
    }  
  
    /** 
     * HMAC加密 
     *  
     * @param data 
     * @param key 
     * @return 
     * @throws Exception 
     */  
    public static byte[] encryptHMAC(byte[] data, String key) throws Exception {  
  
        SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);  
        Mac mac = Mac.getInstance(secretKey.getAlgorithm());  
        mac.init(secretKey);  
  
        return mac.doFinal(data);  
  
    }  
}  
package work.superstr;


import java.math.BigInteger;
import java.security.Key;
import java.security.KeyFactory;
import java.security.interfaces.ECPrivateKey;
import java.security.interfaces.ECPublicKey;
import java.security.spec.ECFieldF2m;
import java.security.spec.ECParameterSpec;
import java.security.spec.ECPoint;
import java.security.spec.ECPrivateKeySpec;
import java.security.spec.ECPublicKeySpec;
import java.security.spec.EllipticCurve;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;
import javax.crypto.NullCipher;

import sun.security.ec.ECKeyFactory;
import sun.security.ec.ECPrivateKeyImpl;
import sun.security.ec.ECPublicKeyImpl;  
  
/** 
 * ECC安全编码组件 
 *  
 * @author 梁栋 
 * @version 1.0 
 * @since 1.0 
 */  
public abstract class ECCCoder extends Coder {  
  
    public static final String ALGORITHM = "EC";  
    private static final String PUBLIC_KEY = "ECCPublicKey";  
    private static final String PRIVATE_KEY = "ECCPrivateKey";  
  
    /** 
     * 解密<br> 
     * 用私钥解密 
     *  
     * @param data 
     * @param key 
     * @return 
     * @throws Exception 
     */  
    public static byte[] decrypt(byte[] data, String key) throws Exception {  
        // 对密钥解密  
        byte[] keyBytes = decryptBASE64(key);  
  
        // 取得私钥  
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
    
        KeyFactory keyFactory =KeyFactory.getInstance("EC");  
    
        ECPrivateKey priKey = (ECPrivateKey) keyFactory  
                .generatePrivate(pkcs8KeySpec);  
  
        ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(priKey.getS(),  
                priKey.getParams());  
  
        // 对数据解密  
        // TODO Chipher不支持EC算法 未能实现  
        Cipher cipher = new NullCipher();  
        // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());  
        cipher.init(Cipher.DECRYPT_MODE, priKey, ecPrivateKeySpec.getParams());  
  
        return cipher.doFinal(data);  
    }  
  
    /** 
     * 加密<br> 
     * 用公钥加密 
     *  
     * @param data 
     * @param privateKey 
     * @return 
     * @throws Exception 
     */  
    public static byte[] encrypt(byte[] data, String privateKey)  
            throws Exception {  
        // 对公钥解密  
        byte[] keyBytes = decryptBASE64(privateKey);  
  
        // 取得公钥  
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance("EC") ;
  
        ECPublicKey pubKey = (ECPublicKey) keyFactory  
                .generatePublic(x509KeySpec);  
  
        ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(pubKey.getW(),  
                pubKey.getParams());  
  
        // 对数据加密  
        // TODO Chipher不支持EC算法 未能实现  
        Cipher cipher = new NullCipher();  
        // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());  
        cipher.init(Cipher.ENCRYPT_MODE, pubKey, ecPublicKeySpec.getParams());  
  
        return cipher.doFinal(data);  
    }  
  
    /** 
     * 取得私钥 
     *  
     * @param keyMap 
     * @return 
     * @throws Exception 
     */  
    public static String getPrivateKey(Map<String, Object> keyMap)  
            throws Exception {  
        Key key = (Key) keyMap.get(PRIVATE_KEY);  
  
        return encryptBASE64(key.getEncoded());  
    }  
  
    /** 
     * 取得公钥 
     *  
     * @param keyMap 
     * @return 
     * @throws Exception 
     */  
    public static String getPublicKey(Map<String, Object> keyMap)  
            throws Exception {  
        Key key = (Key) keyMap.get(PUBLIC_KEY);  
  
        return encryptBASE64(key.getEncoded());  
    }  
  
    /** 
     * 初始化密钥 
     *  
     * @return 
     * @throws Exception 
     */  
    public static Map<String, Object> initKey() throws Exception {  
        BigInteger x1 = new BigInteger(  
                "2fe13c0537bbc11acaa07d793de4e6d5e5c94eee8", 16);  
        BigInteger x2 = new BigInteger(  
                "289070fb05d38ff58321f2e800536d538ccdaa3d9", 16);  
  
        ECPoint g = new ECPoint(x1, x2);  
  
        // the order of generator  
        BigInteger n = new BigInteger(  
                "5846006549323611672814741753598448348329118574063", 10);  
        // the cofactor  
        int h = 2;  
        int m = 163;  
        int[] ks = { 7, 6, 3 };  
        ECFieldF2m ecField = new ECFieldF2m(m, ks);  
        // y^2+xy=x^3+x^2+1  
        BigInteger a = new BigInteger("1", 2);  
        BigInteger b = new BigInteger("1", 2);  
  
        EllipticCurve ellipticCurve = new EllipticCurve(ecField, a, b);  
  
        ECParameterSpec ecParameterSpec = new ECParameterSpec(ellipticCurve, g,  
                n, h);  
        // 公钥  
        ECPublicKey publicKey = new ECPublicKeyImpl(g, ecParameterSpec);  
  
        BigInteger s = new BigInteger(  
                "1234006549323611672814741753598448348329118574063", 10);  
        // 私钥  
        ECPrivateKey privateKey = new ECPrivateKeyImpl(s, ecParameterSpec);  
  
        Map<String, Object> keyMap = new HashMap<String, Object>(2);  
  
        keyMap.put(PUBLIC_KEY, publicKey);  
        keyMap.put(PRIVATE_KEY, privateKey);  
  
        return keyMap;  
    }  
  
}  
package work.superstr;

import java.util.Map;  

/** 
 *  
 * @author 梁栋 
 * @version 1.0 
 * @since 1.0 
 */  
public class ECCCoderTest {  
	/**
	 * 公钥加密，私钥解密
	 * @throws Exception
	 */
	public static void test1() throws Exception {
		String inputStr = "abc";  
        byte[] data = inputStr.getBytes();  
  
        Map<String, Object> keyMap = ECCCoder.initKey();  
  
        String publicKey = ECCCoder.getPublicKey(keyMap);  
        String privateKey = ECCCoder.getPrivateKey(keyMap);  
        System.err.println("公钥: \n" + publicKey);  
        System.err.println("私钥： \n" + privateKey);  
  
        byte[] encodedData = ECCCoder.encrypt(data, publicKey);  
        byte[] decodedData = ECCCoder.decrypt(encodedData, privateKey);  
        
       
        String outputStr = new String(decodedData);  
        System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);  
        System.out.println(inputStr.equals(outputStr));  
	}
	
	public static void test2() throws Exception {
		String inputStr = "abc";  
        byte[] data = inputStr.getBytes();  
  
        Map<String, Object> keyMap = ECCCoder.initKey();  
  
        String publicKey = ECCCoder.getPublicKey(keyMap);  
        String privateKey = ECCCoder.getPrivateKey(keyMap);  
        System.err.println("公钥: \n" + publicKey);  
        System.err.println("私钥： \n" + privateKey);  
  
        byte[] encodedData = ECCCoder.encrypt(data, privateKey);  
        byte[] decodedData = ECCCoder.decrypt(encodedData, publicKey);  
        
       
        String outputStr = new String(decodedData);  
        System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);  
        System.out.println(inputStr.equals(outputStr));  
	}
    public static void main(String[] args ) throws Exception  {  
        test2();
    }  
}  
package work.superstr;

import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.interfaces.ECPrivateKey;
import java.security.interfaces.ECPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
 
/**
 * 椭圆曲线签名算法
 * 
 * 速度快 强度高 签名短
 * 
 * 实现方 JDK1.7/BC
 */
public class ECDSAUtil {
 
    private static String str = "hello";
 
    public static void main(String[] args) {
        jdkECDSA();
    }
 
    public static void jdkECDSA() {
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC");
            keyPairGenerator.initialize(256);
 
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            ECPublicKey ecPublicKey = (ECPublicKey) keyPair.getPublic();
            ECPrivateKey ecPrivateKey = (ECPrivateKey) keyPair.getPrivate();
 
            // 2.执行签名
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(ecPrivateKey.getEncoded());
            KeyFactory keyFactory = KeyFactory.getInstance("EC");
 
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            Signature signature = Signature.getInstance("SHA1withECDSA");
            signature.initSign(privateKey);
 
            signature.update(str.getBytes());
            byte[] sign = signature.sign();
 
            // 验证签名
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(ecPublicKey.getEncoded());
            keyFactory = KeyFactory.getInstance("EC");
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            signature = Signature.getInstance("SHA1withECDSA");
            signature.initVerify(publicKey);
            signature.update(str.getBytes());
            boolean bool = signature.verify(sign);
            System.out.println(bool);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

bear_cab
关注
ECC和ECDSA算法
04-25
此算法为256bit椭圆加密算法（ECC）和签名算法ECDSA，此算法已在航芯ACH512（cortex-M3）芯片上验证过，而且该算法是国际通用算法，在Google、facebook上验证过，使用此算法的产品也通过了国外的一些安全认证,如FIDO...
基于ECDSA公私钥实现的“非对称加解密“方案(带源码)
zhengluohai1的专栏
12-22 2729
需求 ECDSA(elliptic curve digital signature algorithm) 椭圆曲线数字签名算法是区块链应用常用的签名算法(例如比特币，腾讯的trustsql等)，这个算法具有速度快，强度高，签名短等特点。这个算法适合用于签名，但是在openssl库里找不到对应的加解密方案。 在工作中遇到这样的需求，区块链用户(客户端)本身已经拥有了ECDSA的公私钥，现在服务端......
C#使用ECC椭圆曲线算法实现加密与解密&签名与验签，有完整代码
flyinmind的专栏
06-14 2833
C#使用EC椭圆曲线算法实现加解密&签名与验签，有完整代码。 实现了将公钥、私钥转为base64字符串，以及反向转换。 转换的公私钥可以与Java互通。
python实现椭圆曲线加密算法（ECC）
最新发布
qq_42568323的博客
08-31 1187
椭圆曲线加密算法（Elliptic Curve Cryptography, ECC）是一种基于椭圆曲线数学结构的公钥加密算法。ECC以其较高的安全性和较小的密钥长度而闻名，被认为是现代密码学的重要组成部分。ECC广泛应用于数字签名、密钥交换、加密等领域。相比于传统的RSA算法，ECC在提供同等安全性的情况下使用的密钥长度更短，这使得ECC的加密过程更加高效，尤其适合在资源受限的环境中使用，如移动设备、嵌入式系统等。椭圆曲线通常在有限域（如素数域𝔽_p或二进制域𝔽_2^my2x3axbmo。
ECDSA算法加解密验签
qq_39562689的博客
11-30 1111
前段时间，因为公司业务需求研究了一下加密验签算法，找到了网上一位大佬的研究代码参考 Java中加密算法介绍及其实现 - 枫飘雪落 - 博客园 在大佬的研究中说明中找到了我需要的算法介绍，但是下载了大佬的源码发现没有相关的实现（或者是我没找到？），就自己写了一个，再此处记录一下，也希望能帮到其他需要的同行。 最后附上我写的源码地址：Learning_algorithm: 算法学习 加解密验签算法参考： https://www.cnblogs.com/yanlong300/p/8884150.html
C++的AES及ECC加解密
weixin_41989340的博客
10-10 2150
使用C++语言，使用AES库及ECC库，实现对明文的加解密处理
Go-ecc加密解密详解与代码
关注网络安全、云原生安全
07-03 6048
参考 《现代密码学教程 谷利泽，杨义先等》 Go标准库-crypto/des Go标准库-crypto/cipher 更多Go相关内容：Go-Golang学习总结笔记 有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。如果您感觉有所收获，自愿打赏，可选择支付宝18833895206（小于），您的支持是我不断更新的动力。 ...
ECC密钥生成、加密解密、签名验签工具
01-29
在这个项目中，开发者使用C语言和Visual Studio 2010创建了三个工具：ECC密钥生成器、ECC加密解密工具以及ECC签名验签工具，这些工具都基于OpenSSL库进行关键操作。 首先，ECC密钥生成器是用于创建ECC密钥对的核心...
ECC数字签名的实现（C语言）
03-30
在给定的文件列表中，我们看到几个可能的源代码文件（如11.18.c、未命名2.c）和开发环境文件（ECC.dev、项目1.dev）。这些文件可能包含了实现ECC签名算法的代码和相关配置。`Makefile.win`表明有一个针对Windows系统...
详解椭圆曲线加密（Elliptic Curves Cryptography，ECC）与ECDSA.doc
07-05
### 椭圆曲线加密（ECC）与ECDSA详解 #### 一、椭圆曲线加密（ECC）概述 **椭圆曲线加密**(Elliptic Curve Cryptography, ECC)是一种基于椭圆曲线数学特性的公开密钥加密技术。ECC因其在保持安全性的同时能够使用...
ECDSA.rar_ECDSA_ecdsa C代码_ecdsa openssl
09-19
在C代码实现ECDSA时，可以使用OpenSSL库，这是一个广泛使用的开源加密库，提供了各种加密算法的实现，包括ECDSA。在`ECDSA密码算法.cpp`这个文件中，可能包含了使用OpenSSL库进行ECDSA签名和验证的示例代码。OpenSSL...
ECC加密算法的C代码以及说明文档
03-28
ecc算法的代码以及说明文档，含有大数运算库
ECC加密算法源代码
12-07
ECC 加密算法C源代码，包括ZIGBEE的加密算法。椭圆加密算法源代码
ECC加密算法实现C源码
09-03
ECC（Elliptic Curves Cryptography） 中文是椭圆曲线密码编码学。这是该算法实现的C源码。
关于ECDSA/ECC(密钥加密传输)和ECDSA/ECDH(密钥磋商)
在JAVA的世界中“乘风破浪”
03-16 1万+
最近项目中用到了ECC的相关算法，恶补了一下相关知识 ECC：Elliptic Curves Cryptography，椭圆曲线密码编码学 ECDSA：用于数字签名，是ECC与DSA的结合，整个签名过程与DSA类似，所不一样的是签名中采取的算法为ECC，最后签名出来的值也是分为r,s。 ECDH：是基于ECC（Elliptic Curve Cryptosystems，椭圆曲线密码
(ECC)椭圆曲线加密算法原理和C++实现源码
热门推荐
10点43的博客
11-08 1万+
目录 （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...
ECC加密——C++/OPENssl实现
niujinya的博客
10-14 3286
ECC加密——C++/OPENssl实现
ECDSA加密算法
qq_41987680的博客
05-20 7100
title: ECDSA加密算法 date: 2021-12-31 16:42:15 categories: tags: - openssl - c/c++ 1、ECDSA简述 ECDSA的全名是Elliptic Curve DSA，即椭圆曲线DSA。它是Digital Signature Algorithm (DSA)应用了椭圆曲线加密算法的变种。椭圆曲线算法的原理很复杂，但是具有很好的公开密钥算法特性，通过公钥无法逆向获得私钥。 ECDSA算法用于数字签名，是ECC与DSA的结合，整个签名过程与DSA
【区块链】椭圆曲线数字签名算法（ECDSA）
qq_64585761的博客
04-27 5834
椭圆曲线数字签名算法的原理。
ECC加密与解密技术的深入探讨与应用实例
资源摘要信息:"ECC加密解密技术" ECC（Elliptic Curve Cryptography，椭圆曲线密码学）是一种公钥加密技术，它基于椭圆曲线数学原理。与传统的加密算法如RSA相比，ECC在同等安全级别下可以使用更短的密钥长度，这...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值