通俗易懂--Java数字签名算法（RSA，DSA,ECDSA）

快乐懒洋洋

于 2024-05-10 20:31:04 发布

阅读量337

点赞数 4

文章标签：服务器运维

本文链接：https://blog.csdn.net/weixin_62844305/article/details/138680430

版权

流程：

数字签名算法——RSA

RSA算法列表：MD、SHA两类

代码实现：

package com.bxl.demo.service;
 
 
import org.apache.commons.codec.binary.Hex;
 
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
 
/**
 * Created by xiaobai on 2021-8-23
 */
public class RSA {
 
    private static String src = "xiaobai security rsa";
 
    public static void RsaMethod(){
 
        try {
            /* 一、初始化密钥 */
            // 1.获得RSA的KeyPairGenerator对象示例
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            // 2.修改key的长度
            keyPairGenerator.initialize(512);
            // 3.得到KeyPair对象
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            // 4.获取公钥
            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
            // 5.获取私钥
            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
 
            /* 二、执行签名 */
            // 1.通过私钥进行签名，获取PKCS8EncodedKeySpec对象示例
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
            // 2.通过RSA算法构建KeyFactory实例对象
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            // 3.声明privateKey
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            // 4.创建签名对象，这里我们使用的是JDK的方式实现的所以在这里我们使用"MD5withRSA"
            Signature signature = Signature.getInstance("MD5withRSA");
            // 5.执行签名的初始化方法
            signature.initSign(privateKey);
            // 6.修改需要处理的内容
            signature.update(src.getBytes());
            // 7.执行签名
            byte[] result = signature.sign();
            /*
            * Hex.encodeHexString() 是需要引入commons-codec依赖
            * <dependency>
                <groupId>org.wso2.orbit.org.bouncycastle</groupId>
                <artifactId>bcprov-jdk15on</artifactId>
                <version>1.60.0.wso2v1</version>
              </dependency>
            * */
            System.out.println("jdk rsa sign:"+ Hex.encodeHexString(result));
 
            /* 三、验证签名 */
            // 1.通过公钥进行签名，获取X509EncodedKeySpec对象示例
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            // 2.通过RSA算法构建KeyFactory实例对象  (此处是为了完整性，所以新创建了一个对象)
            keyFactory = KeyFactory.getInstance("RSA");
            // 3.获得PublicKey对象
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            // 4.创建签名对象，这里我们使用的是JDK的方式实现的所以在这里我们使用"MD5withRSA"
            signature = Signature.getInstance("MD5withRSA");
            // 5.验证签名的初始化方法
            signature.initVerify(publicKey);
            // 6.修改需要处理的内容
            signature.update(src.getBytes());
            // 7.验证签名
            boolean resultBool = signature.verify(result);
            System.out.println("jdk rsa verify:" + resultBool);
 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    public static void main(String[] args) {
        // 执行方法
        RsaMethod();
    }
}

数字签名算法——DSA

DSS（Digital Signture Standard）数字签名标准

DSA（Digital Signature Algorithm）数字签名算法

DSA仅包含数字签名

DSA算法列表：

代码实现:

package com.bxl.demo.service;
 
import org.apache.commons.codec.binary.Hex;
 
import java.security.*;
import java.security.interfaces.DSAPrivateKey;
import java.security.interfaces.DSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
 
/**
 * Created by xiaobai on 2021-8-23
 */
public class DSA {
 
    private static String src = "xiaobai security dsa";
 
    public static void JdkDsaMethod(){
        try {
            /* 一、初始化密钥 */
            // 1.获得DSA的KeyPairGenerator对象示例
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DSA");
            // 2.修改key的长度
            keyPairGenerator.initialize(512);
            // 3.得到KeyPair对象
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            // 4.获取公钥
            DSAPublicKey dsaPublicKey = (DSAPublicKey) keyPair.getPublic();
            // 5.获取私钥
            DSAPrivateKey dsaPrivateKey = (DSAPrivateKey) keyPair.getPrivate();
 
            /* 二、执行签名 */
            // 1.通过私钥进行签名，获取PKCS8EncodedKeySpec对象示例
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(dsaPrivateKey.getEncoded());
            // 2.通过DSA算法构建KeyFactory实例对象
            KeyFactory keyFactory = KeyFactory.getInstance("DSA");
            // 3.声明privateKey
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            // 4.创建签名对象，这里我们使用的是JDK的方式实现的所以在这里我们使用"SHA1withDSA"
            Signature signature = Signature.getInstance("SHA1withDSA");
            // 5.执行签名的初始化方法
            signature.initSign(privateKey);
            // 6.修改需要处理的内容
            signature.update(src.getBytes());
            // 7.执行签名
            byte[] result = signature.sign();
            /*
            * Hex.encodeHexString() 是需要引入commons-codec依赖
            * <dependency>
                <groupId>org.wso2.orbit.org.bouncycastle</groupId>
                <artifactId>bcprov-jdk15on</artifactId>
                <version>1.60.0.wso2v1</version>
              </dependency>
            * */
            System.out.println("jdk dsa sign:"+ Hex.encodeHexString(result));
 
            /* 三、验证签名 */
            // 1.通过公钥进行签名，获取X509EncodedKeySpec对象示例
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(dsaPublicKey.getEncoded());
            // 2.通过DSA算法构建KeyFactory实例对象  (此处是为了完整性，所以新创建了一个对象)
            keyFactory = KeyFactory.getInstance("DSA");
            // 3.获得PublicKey对象
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            // 4.创建签名对象，这里我们使用的是JDK的方式实现的所以在这里我们使用"SHA1withDSA"
            signature = Signature.getInstance("SHA1withDSA");
            // 5.验证签名的初始化方法
            signature.initVerify(publicKey);
            // 6.修改需要处理的内容
            signature.update(src.getBytes());
            // 7.验证签名
            boolean resultBool = signature.verify(result);
            System.out.println("jdk dsa verify:" + resultBool);
 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    public static void main(String[] args) {
        // 执行方法
        JdkDsaMethod();
    }
}

数字签名算法——ECDSA

微软
Elliptic Curve Digital Signature Algorithm（ECDSA），椭圆曲线数字签名算法
速度快、强度高、签名短

ECDSA算法列表:

代码实现：

package com.bxl.demo.service;
 
import org.apache.commons.codec.binary.Hex;
 
import java.security.*;
import java.security.interfaces.ECPrivateKey;
import java.security.interfaces.ECPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
 
/**
 * Created by xiaobai on 2021-8-23
 */
public class ECDSA {
 
    private static String src = "xiaobai security ecdsa";
 
    public static void JdkEcdsaMethod(){
        try {
            /* 一、初始化密钥 */
            // 1.获得EC的KeyPairGenerator对象示例
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC");
            // 2.修改key的长度
            keyPairGenerator.initialize(256);
            // 3.得到KeyPair对象
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            // 4.获取公钥
            ECPublicKey ecPublicKey = (ECPublicKey) keyPair.getPublic();
            // 5.获取私钥
            ECPrivateKey ecPrivateKey = (ECPrivateKey) keyPair.getPrivate();
 
            /* 二、执行签名 */
            // 1.通过私钥进行签名，获取PKCS8EncodedKeySpec对象示例
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(ecPrivateKey.getEncoded());
            // 2.通过EC算法构建KeyFactory实例对象
            KeyFactory keyFactory = KeyFactory.getInstance("EC");
            // 3.声明privateKey
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            // 4.创建签名对象，这里我们使用的是JDK的方式实现的所以在这里我们使用"SHA1withECDSA"
            Signature signature = Signature.getInstance("SHA1withECDSA");
            // 5.执行签名的初始化方法
            signature.initSign(privateKey);
            // 6.修改需要处理的内容
            signature.update(src.getBytes());
            // 7.执行签名
            byte[] result = signature.sign();
            /*
            * Hex.encodeHexString() 是需要引入commons-codec依赖
            * <dependency>
                <groupId>org.wso2.orbit.org.bouncycastle</groupId>
                <artifactId>bcprov-jdk15on</artifactId>
                <version>1.60.0.wso2v1</version>
              </dependency>
            * */
            System.out.println("jdk ecdsa sign:"+ Hex.encodeHexString(result));
 
            /* 三、验证签名 */
            // 1.通过公钥进行签名，获取X509EncodedKeySpec对象示例
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(ecPublicKey.getEncoded());
            // 2.通过EC算法构建KeyFactory实例对象  (此处是为了完整性，所以新创建了一个对象)
            keyFactory = KeyFactory.getInstance("EC");
            // 3.获得PublicKey对象
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            // 4.创建签名对象，这里我们使用的是JDK的方式实现的所以在这里我们使用"SHA1withECDSA"
            signature = Signature.getInstance("SHA1withECDSA");
            // 5.验证签名的初始化方法
            signature.initVerify(publicKey);
            // 6.修改需要处理的内容
            signature.update(src.getBytes());
            // 7.验证签名
            boolean resultBool = signature.verify(result);
            System.out.println("jdk ecdsa verify:" + resultBool);
 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    public static void main(String[] args) {
        // 执行方法
        JdkEcdsaMethod();
    }
}