【Java】使用RSA进行数字签名详解（复制即用，内有详细注释）

最新推荐文章于 2025-04-15 18:20:55 发布

你住过的屋檐

最新推荐文章于 2025-04-15 18:20:55 发布

阅读量1.4k

点赞数 19

分类专栏： Java技术专栏文章标签： java 哈希算法开发语言

本文链接：https://blog.youkuaiyun.com/weixin_43219644/article/details/144563396

版权

Java技术专栏专栏收录该内容

14 篇文章

订阅专栏

前言

RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。
RSA除了用于非对称加密还可以用来做数字签名，在签名过程中，可以加入随机码和时间戳来增强安全性，防止重放攻击。随机码是一个随机生成的字符串，每次请求都不同。这使得每个请求的签名都是唯一的，即使请求的内容相同。时间戳可以通过程序来控制签名的有效期，超过一定时间后拒绝校验。

一、RSA签名原理

RSA签名通过生成公钥和私钥对。私钥用于签名，公钥用于验证签名，生成的签名是一个字节数组，验证签名的过程包括重新计算数据的哈希值，并与签名中的哈希值进行比较
RSA签名算法可以与不同的哈希函数结合使用，以生成不同的签名方案。常见的组合包括SHA512withRSA、 SHA256withRSA、SHA1withRSA、MD5withRSA 等，下面是一些优缺点。

SHA256withRSA
优点:
安全性高: SHA-256提供了较高的安全性，能够抵抗碰撞攻击。
广泛支持: 大多数现代系统和库都支持 SHA-256，兼容性好。
抗碰撞性强: SHA-256 的输出长度为256位，比 SHA-1 更难受到碰撞攻击。
缺点:
性能稍低:SHA-256 的计算开销较大，可能会对性能产生一定影响。
SHA1withRSA
优点:
性能较好: SHA-1 的计算速度较快，适合对性能要求较高的场景。
广泛支持: 早期的系统和库广泛支持 SHA-1，兼容性好。
缺点:
安全性较低: SHA-1 已经被证明存在碰撞漏洞，不再被认为是安全的哈希函数。
不推荐使用: 许多安全标准和最佳实践已经不再推荐使用 SHA-1，因为它容易受到攻击。
MD5withRSA
优点:
性能极佳: MD5 的计算速度非常快，适合对性能要求极高的场景。
简单易用: 实现简单，易于集成。
缺点:
安全性极低: MD5 存在严重的碰撞漏洞，已经被广泛弃用，不再被认为是安全的哈希函数。
不推荐使用: 绝大多数安全标准和最佳实践都不推荐使用 MD5，因为它容易受到攻击。
SHA512withRSA
优点:
安全性最高: SHA-512 是 SHA-2 系列的一部分，提供了最高的安全性，能够抵抗碰撞攻击。
抗碰撞性强: SHA-512 的输出长度为512位，比 SHA-256 更难受到碰撞攻击。
缺点:
性能稍差: SHA-512 的计算开销更大，可能会对性能产生影响。
签名较大: 由于哈希值较长，生成的签名也会较大，可能会影响存储和传输效率。
SHA384withRSA
优点:
安全性高: SHA-384提供了较高的安全性，能够抵抗碰撞攻击。
抗碰撞性强: SHA-384 的输出长度为384位，比 SHA-256 更难受到碰撞攻击。
缺点:
性能稍差: SHA-384 的计算比SHA-256开销更大，可能会对性能产生一定影响。
签名较大: 由于哈希值较长，生成的签名也会较大，可能会影响存储和传输效率。

SHA256withRSA 是目前最常用且推荐的组合之一，提供了良好的平衡性，兼顾了安全性和性能。如果需要更高的安全性，可以考虑选择 SHA512withRSA 或 SHA384withRSA，但需要注意它们的性能。实际应用中，应根据具体的安全需求和性能要求选择合适的RSA签名算法。

二、使用案例

下属案例使用SHA256withRSA实现数字签名，并增加签名有效期校验，关键位置注释我都有标注，一看即懂，大家在项目中有遇到签名需求可以直接复制使用。


import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

/**
 * 该工具类是使用RSA进行数字签名工具类，私钥生成签名，公钥验证签名，保证数据的完整性
 */
public class RsaSignUtil {
    /**
     * 生成密钥对
     * @return
     * @throws NoSuchAlgorithmException
     */
    public static Map<String, String> generateKeyPair() throws NoSuchAlgorithmException, UnsupportedEncodingException {
        // 创建一个RSA密钥对生成器实例
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        // 初始化密钥对生成器，指定密钥长度为2048位
        keyPairGenerator.initialize(2048);
        // 生成RSA密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //私钥
        PrivateKey aPrivate = keyPair.getPrivate();
        String privateKey = new String(Base64.getEncoder().encode(aPrivate.getEncoded()),"UTF-8");
        //公钥
        PublicKey aPublic = keyPair.getPublic();
        String publicKey = new String(Base64.getEncoder().encode(aPublic.getEncoded()),"UTF-8");
        Map<String, String> resultMap = new HashMap<>();
        resultMap.put("privateKey",privateKey);
        resultMap.put("publicKey",publicKey);
        return resultMap;
    }

    /**
     * 使用私钥生成签名，使用SHA256withRSA算法计算
     * @param data
     * @param privateKeyStr
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeyException
     * @throws SignatureException
     */
    public static String signData(String data, String privateKeyStr) throws NoSuchAlgorithmException,
            InvalidKeyException, SignatureException, InvalidKeySpecException {
        // 创建一个Signature实例，使用SHA256withRSA算法
        Signature signature = Signature.getInstance("SHA256withRSA");
        byte[] decode = Base64.getDecoder().decode(privateKeyStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decode);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        // 初始化Signature实例，使用私钥进行签名
        signature.initSign(privateKey);
        // 更新要签名的数据
        signature.update(data.getBytes(StandardCharsets.UTF_8));
        // 对数据进行签名
        byte[] signatureBytes = signature.sign();
        String signatureStr= Base64.getEncoder().encodeToString(signatureBytes);
        return signatureStr;
    }

    /**
     * 生成指定长度的随机字符串
     *
     * @param length 字符串的长度
     * @return 一个随机字符串
     */
    public static String getRandomString(int length) {
        String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < length; i++) {
            int number = random.nextInt(62);
            sb.append(str.charAt(number));
        }
        return sb.toString();
    }

    /**
     * 公钥验证签名
     * @param data 数据
     * @param timestamp 时间戳
     * @param period 有效期
     * @param signature 签名
     * @param publicKeyStr 公钥
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeyException
     * @throws SignatureException
     * @throws InvalidKeySpecException
     */
    public static boolean verifySignature(String data,Long timestamp,Integer period,String signature, String publicKeyStr)
            throws NoSuchAlgorithmException, InvalidKeyException, SignatureException, InvalidKeySpecException {
        //校验时间戳
        if(timestamp==null){throw new RuntimeException();}
        Long now = ZonedDateTime.now(ZoneId.systemDefault()) .minusMinutes(period).toInstant().toEpochMilli();
        if(now.compareTo(timestamp)>0){throw new RuntimeException();}
        // 创建一个Signature实例
        Signature verifier = Signature.getInstance("SHA256withRSA");
        byte[] decode = Base64.getDecoder().decode(publicKeyStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decode);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        // 初始化Signature实例，使用公钥进行签名验证
        verifier.initVerify(publicKey);
        // 更新要验证的数据
        verifier.update(data.getBytes(StandardCharsets.UTF_8));
        // 验证签名的有效性
        byte[] signatureByte = Base64.getDecoder().decode(signature);
        return verifier.verify(signatureByte);
    }

    public static void main(String[] args) throws NoSuchAlgorithmException, SignatureException, InvalidKeyException, UnsupportedEncodingException, InvalidKeySpecException {
        //密钥生成
        Map<String, String> stringStringMap = RsaSignUtil.generateKeyPair();
        String publicKey = stringStringMap.get("publicKey");
        String privateKey = stringStringMap.get("privateKey");
        System.out.println("公钥："+publicKey);
        System.out.println("私钥："+privateKey);
        String randomString = RsaSignUtil.getRandomString(20);
        System.out.println("随机串："+randomString);
        //时间戳
        Long timestamp = System.currentTimeMillis();
        System.out.println("时间戳："+timestamp);
        //随机数+时间戳+数据
        String data=randomString+timestamp+"hello word！";
        System.out.println("数据："+data);
        //私钥生成签名
        String  signature = RsaSignUtil.signData(data,
                privateKey);
        System.out.println(signature);
        //公钥验证
        boolean b = RsaSignUtil.verifySignature(
                randomString+timestamp+"hello word！",timestamp,5, signature,
                publicKey);
        System.out.println(b);
    }

}