RSA签名和验签Util

最新推荐文章于 2024-06-14 10:02:06 发布
最新推荐文章于 2024-06-14 10:02:06 发布
阅读量386 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： c#
原文链接：http://www.cnblogs.com/ranandrun/p/DigitalSign.html

目录

1502888-20190427165710247-646166787.jpg

1、DigitalSign类

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.security.KeyStore;
import java.security.Signature;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.interfaces.RSAPrivateCrtKey;
import java.security.interfaces.RSAPublicKey;
import java.util.Enumeration;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 证书加解密/签名/验签类
 */
public class DigitalSign {
    
    private static DigitalSign single=null;

    /** 编码 格式*/
    private static String encoding = "UTF-8";
    /** 算法 */
    private String arithmetic = "SHA1withRSA";

    /**私钥缓存**/
    private ConcurrentHashMap<String, RSAPrivateCrtKey> map = new ConcurrentHashMap<String, RSAPrivateCrtKey>();

    private DigitalSign(String encoding){
    }

    private DigitalSign(){

    }
    
    /**
     * 初始化 实例
     */
    public static synchronized void init() {  
        if (single == null) {    
            single = new DigitalSign(encoding); 
        }    
    }

    /**
     * 初始化 实例
     */
    public static synchronized void init(String charset) {
        if (single == null) {
            single = new DigitalSign();
            encoding = charset;
        }
    }

    //静态工厂方法   
    public static DigitalSign getInstance() {
        if (single == null) {    
            init(); //为空的时候同步实例
        }    
        return single;  
    }

    //静态工厂方法
    public static DigitalSign getInstance(String charset) {
        if (single == null) {
            init(charset); //为空的时候同步实例
        }
        return single;
    }
    
    /**
     * 私钥签名  
     * @param tobeSigned
     * @param priKeyPath classpath 下路径
     * @param password
     * @return
     * @throws CryptException
     */
    public String SignMsgByRelativePath(final String tobeSigned, final String priKeyPath, final String password) throws CryptException {
        RSAPrivateCrtKey priKey = getPriKeyByRelativePath(priKeyPath, password);
        return sign(priKey, tobeSigned);
    }
    
    
    /**
     * 私钥签名
     * @param tobeSigned
     * @param priKeyStream 私钥文件流
     * @param password
     * @return
     * @throws CryptException
     */
    public String SignMsgByInputStream(String tobeSigned,InputStream priKeyStream,String password) throws CryptException{
        RSAPrivateCrtKey priKey = getPriKeyByInputStream(priKeyStream, password);
        return sign(priKey, tobeSigned);
    }
    
    /**
     * 私钥签名
     * @param tobeSigned
     * @param priKeyPath 私钥绝对路径
     * @param password
     * @return
     * @throws CryptException
     */
    public String signMsgByAbsolutePath(String tobeSigned,String priKeyPath,String password) throws CryptException{
        RSAPrivateCrtKey priKey = map.get(priKeyPath);
        if(priKey == null){
            priKey = getPriKeyByAbsolutePath(priKeyPath, password);
        }
        return sign(priKey, tobeSigned);
    }


    /**
     * 私钥签名
     * @param tobeSigned
     * @param priKeyPath 私钥绝对路径
     * @param password
     * @return
     * @throws CryptException
     */
    public String signMsgByAbsolutePath(Map<String, Object> tobeSigned,String priKeyPath,String password) throws CryptException{
        RSAPrivateCrtKey priKey = map.get(priKeyPath);
        if(priKey == null){
            priKey = getPriKeyByAbsolutePath(priKeyPath, password);
        }
        return sign(priKey, tobeSigned);
    }
    
    /**
     * 公钥验签 
     * @param tobeVerfied
     * @param plainText
     * @param pubKey 文件输入流
     * @return
     * @throws CryptException
     */
    public boolean verifyMsgByInputSteam(String tobeVerfied,String plainText,InputStream pubKey) throws CryptException{
        //获取公钥
        RSAPublicKey pubkey = getPubKeyByInputSteam(pubKey);
        return verify(pubkey, tobeVerfied, plainText);
    }
    
    /**
     * 通过公钥验签
     * @param tobeVerified
     * @param plainText
     * @param pubkeyPath 公钥绝对路径
     * @return
     * @throws CryptException
     */
    public boolean verifyMsgByAbsolutePath(String tobeVerified,String plainText,String pubkeyPath) throws CryptException{
        RSAPublicKey pubkey = getPubKeyByAbsolutePath(pubkeyPath);
        return verify(pubkey, tobeVerified, plainText);
    }


    /**
     * 通过公钥验签
     * @param tobeVerified
     * @param map
     * @param pubkeyPath 公钥绝对路径
     * @return
     * @throws CryptException
     */
    public boolean verifyMsgByAbsolutePath(String tobeVerified,Map<String, Object> map,String pubkeyPath) throws CryptException{
        RSAPublicKey pubkey = getPubKeyByAbsolutePath(pubkeyPath);
        return verify(pubkey, tobeVerified, map);
    }
    
    /**
     * 公钥验签
     * @param tobeVerfied
     * @param plainText
     * @param CertFile 文件classpath下路径
     * @return
     * @throws CryptException
     */
    public boolean verifyMsgByRelativePath(String tobeVerfied, String plainText, String CertFile) throws CryptException {
        RSAPublicKey pubkey = getPubKeyByRelativePath(CertFile);
        return verify(pubkey, tobeVerfied, plainText);
    }

    /**
     * 使用公钥对数据加密
     * @param TobeEncryptMsg 待加密的明文字符串
     * @param certFile 公钥路径[相对地址 classpath下]
     * @return 加密后的字符串
     * @throws CryptException 错误信息
     */
    public String encryptMsg(String TobeEncryptMsg, String certFile) throws CryptException {
        //获取公钥
        RSAPublicKey pubKey = getPubKeyByRelativePath(certFile);
        Cipher instance;
        try {
            instance = Cipher.getInstance(pubKey.getAlgorithm());
            instance.init(Cipher.ENCRYPT_MODE, pubKey);
            String encryMsg = Base64.encodeBase64String(instance.doFinal(Base64.encodeBase64(TobeEncryptMsg.getBytes(encoding))));
            return encryMsg;
        } catch (Exception e) {
            throw new CryptException("加密失败",e);
        }
    }   
    
    /**
     * 私钥解密
     * @param TobeDecodeMsg 待解密的加密字符串
     * @param priFile 私钥路径[相对路径 classpath下]
     * @param passWord 私钥密码
     * @return 解密后的明文字符串
     * @throws CryptException 错误信息
     */
    public String decodeMsg(String TobeDecodeMsg, String priFile,
            String passWord) throws CryptException{
        RSAPrivateCrtKey priKey = getPriKeyByRelativePath(priFile, passWord);
        Cipher instance;
        try {
            instance = Cipher.getInstance(priKey.getAlgorithm());
            instance.init(Cipher.DECRYPT_MODE, priKey);
            String string = new String(Base64.decodeBase64(instance.doFinal(Base64.decodeBase64(TobeDecodeMsg))), encoding);
            return string;
        } catch (Exception e) {
            throw new CryptException("解密失败",e);
        }
    }

    /**
     * 获取私钥 文件流
     * @param keyfileStream
     * @param password
     * @return
     * @throws CryptException
     */
    private RSAPrivateCrtKey getPriKeyByInputStream(InputStream keyfileStream,String password) throws CryptException{
        return getPriKey(keyfileStream, password);      
    }
    
    /**
     * 通过文件绝对路径加载私钥
     * @param priKeyPath 绝对路径
     * @param password
     * @return
     * @throws CryptException
     */
    private RSAPrivateCrtKey getPriKeyByAbsolutePath(String priKeyPath,String password) throws CryptException{
        FileInputStream file;
        try {
            file = new FileInputStream(priKeyPath);
        } catch (FileNotFoundException e) {
            throw new CryptException("秘钥路径不正确",e);
        }
        RSAPrivateCrtKey priKey = getPriKey(file, password);
        map.put(priKeyPath, priKey);
        return priKey;
    }
    
    /**
     * 获取私钥 [classpath]
     * @param KeyFile
     * @param passWord
     * @return
     */
    private RSAPrivateCrtKey getPriKeyByRelativePath(String KeyFile,String passWord) throws CryptException{
        //获取项目 相对路径
        ClassLoader cl = DigitalSign.class.getClassLoader();
        InputStream fiKeyFile = cl.getResourceAsStream(KeyFile);
        return getPriKey(fiKeyFile, passWord);
    }
    
    /**
     * 获取公钥 [文件输入流]
     * @param pubKey
     * @return
     * @throws CryptException
     */
    private RSAPublicKey getPubKeyByInputSteam(InputStream pubKey) throws CryptException{
        return getPublicKey(pubKey);
    }

    
    /**
     * 获取公钥 [classpath下]
     * @param CertFile
     * @return
     */
    private RSAPublicKey getPubKeyByRelativePath(String CertFile) throws CryptException{
        //读取公钥文件
        ClassLoader cl = DigitalSign.class.getClassLoader();
        InputStream certfile = cl.getResourceAsStream(CertFile);
        //获取公钥
        return getPublicKey(certfile);
    }
    
    /**
     * 获取公钥 通过绝对路径
     * @param pubKeyPath
     * @return
     * @throws CryptException
     */
    private RSAPublicKey getPubKeyByAbsolutePath(String pubKeyPath) throws CryptException{
        try{
            FileInputStream pubKey = new FileInputStream(pubKeyPath);
            return getPublicKey(pubKey);
        }catch(Exception e){
            throw new CryptException("文件读取失败",e);
        }
    }
    
    /**
     * 获取公钥
     * @param pubKey 公钥流
     * @return
     * @throws CryptException
     */
    private RSAPublicKey getPublicKey(InputStream pubKey) throws CryptException{
        X509Certificate x509cert = null;
        try {
            //实例化 x509
            CertificateFactory cf = CertificateFactory.getInstance("X.509");
            x509cert = (X509Certificate) cf.generateCertificate(pubKey);
        } catch (CertificateException e) {
            if (pubKey != null){
                try {
                    pubKey.close();
                } catch (IOException e1) {
                    throw new CryptException("文件流关闭异常",e1);
                }
            }           
            throw new CryptException("初始化公钥异常",e);
        }
        //读取公钥
        RSAPublicKey pubkey = (RSAPublicKey) x509cert.getPublicKey();       
        return pubkey;
    }
    
    /**
     * 获取私钥
     * @param priKey
     * @param keyPassword
     * @return
     * @throws CryptException
     */
    private RSAPrivateCrtKey getPriKey(InputStream priKey,String keyPassword) throws CryptException{
        String keyAlias = null;
        RSAPrivateCrtKey prikey = null;     
        try {
            KeyStore ks = KeyStore.getInstance("PKCS12");
            ks.load(priKey, keyPassword.toCharArray());
            
            Enumeration<?> myEnum = ks.aliases();
            while (myEnum.hasMoreElements()) {
                keyAlias = (String) myEnum.nextElement();
                if (ks.isKeyEntry(keyAlias)) {
                    prikey = (RSAPrivateCrtKey) ks.getKey(keyAlias, keyPassword.toCharArray());
                    break;
                }
            }           
        } catch (Exception e) {
            if (priKey != null){
                try {
                    priKey.close();
                } catch (IOException e1) {
                    throw new CryptException("流关闭异常",e1);
                }
            }
            throw new CryptException("加载私钥失败",e);
        }
        
        if(prikey == null){
            throw new CryptException("私钥不存在");
        }
        
        return prikey;      
    }
    
    /**
     * 签名
     * @param priKey 私钥
     * @param tobeSigned 待签字符串
     * @return 签名结果
     * @throws CryptException
     */
    private String sign(RSAPrivateCrtKey priKey,String tobeSigned) throws CryptException{
        try {
            Signature sign = Signature.getInstance(arithmetic);
            sign.initSign(priKey);  
            sign.update(tobeSigned.getBytes(encoding)); 
            byte signed[] = sign.sign();
//          byte sign_asc[] = new byte[signed.length * 2];  
//          Hex2Ascii(signed.length, signed, sign_asc);
            
//          return new String(signed,encoding); 
            return Base64.encodeBase64String(signed).replaceAll("\\+", "%2B");
        } catch (Exception e) {
            throw new CryptException("签名失败",e);
        }       
    }

    /**
     * 签名
     * @param priKey 私钥
     * @param map 待签字符串
     * @return 签名结果
     * @throws CryptException
     */
    private String sign(RSAPrivateCrtKey priKey,Map<String, Object> map) throws CryptException{
        try {
            String tobeSigned = appendMap(map);
            Signature sign = Signature.getInstance(arithmetic);
            sign.initSign(priKey);
            sign.update(tobeSigned.getBytes(encoding));
            byte signed[] = sign.sign();
//          byte sign_asc[] = new byte[signed.length * 2];
//          Hex2Ascii(signed.length, signed, sign_asc);

//          return new String(signed,encoding);
            return Base64.encodeBase64String(signed).replaceAll("\\+", "%2B");
        } catch (Exception e) {
            throw new CryptException("签名失败",e);
        }
    }


    /**
     * 连接参数
     * @param map
     * @return
     */
    private static String appendMap(Map<String, Object> map){
        Set<String> keySet = map.keySet();
        StringBuilder sb = new StringBuilder();
        for (String mapKey : keySet){
            String value = (String)map.get(mapKey);
            sb.append(mapKey).append("=").append(value).append("&");
        }
        return  sb.toString();
    }
    
    /**
     * 验证签名
     * @param pubkey 公钥
     * @param tobeVerfied 已签名字符串
     * @param plainText 待校验字符串
     * @return true || false
     * @throws CryptException
     */
    private boolean verify(RSAPublicKey pubkey,String tobeVerfied,String plainText) throws CryptException{
        try {
            Signature verify = Signature.getInstance(arithmetic);
            verify.initVerify(pubkey);
//          byte signeddata[] = new byte[tobeVerfied.length() / 2];
//          Ascii2Hex(tobeVerfied.length(), tobeVerfied.getBytes(encoding), signeddata);    
            verify.update(plainText.getBytes(encoding));    
            
            return verify.verify(Base64.decodeBase64(tobeVerfied.replaceAll("%2B", "\\+")));
        } catch (Exception e) {
            throw new CryptException("验签失败",e);
        }       
    }


    /**
     * 验证签名
     * @param pubkey 公钥
     * @param tobeVerfied 已经签名的map
     * @param map 待校验的map
     * @return true || false
     * @throws CryptException
     */
    private boolean verify(RSAPublicKey pubkey,String tobeVerfied,Map<String, Object> map) throws CryptException{
        try {
            String plainText =  appendMap(map);
            Signature verify = Signature.getInstance(arithmetic);
            verify.initVerify(pubkey);
//          byte signeddata[] = new byte[tobeVerfied.length() / 2];
//          Ascii2Hex(tobeVerfied.length(), tobeVerfied.getBytes(encoding), signeddata);
            verify.update(plainText.getBytes(encoding));

            return verify.verify(Base64.decodeBase64(tobeVerfied.replaceAll("%2B", "\\+")));
        } catch (Exception e) {
            throw new CryptException("验签失败",e);
        }
    }
}

2、CryptException异常类


/**
 * 密钥异常类
 */
public class CryptException extends Exception{

    private static final long serialVersionUID = 2843021655596315128L;

    public CryptException(String message){
        super(message);
    }

    public CryptException(String message, Throwable cause) {
        super(message, cause);
    }

    public CryptException(Throwable cause) {
        super(cause);
    }
}

3、加签示例

Map<String, String> map = new TreeMap<String, String>();
//....省略map put值...
String sign = DigitalSign.getInstance().signMsgByAbsolutePath(map, path, 
password);
map.put("sign", sign);

4、验签示例

map.remove("sign");
DigitalSign digitalSign = DigitalSign.getInstance();
boolean result = digitalSign.verifyMsgByAbsolutePath(sign, params, merchCertPath);

转载于:https://www.cnblogs.com/ranandrun/p/DigitalSign.html

使用 RSA 算法进行加解密，签名和验签
简简单单Onlinezuozuo
03-17 1167
文章目录使用 RSA 算法进行加解密，签名和验签1、简介2、引入依赖3、生成公私钥对4、进行签名和验签5、进行加密和解密6、运行一下7、完整代码 使用 RSA 算法进行加解密，签名和验签 1、简介 RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的 是一种非对称加密算法 2、引入依赖 <depe
SignatureUtil接口签名工具类
陌上人如玉，公子世无双
07-01 1857
package com.ijourney.cloud.third.know.base.util; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import com.ijourney.cloud.core.common.utils.DateUtils; import org.apache.commons.codec.digest.DigestUtils; import java.io.Unsupporte
基于RSA的数字签名工具
weixin_33969116的博客
07-15 561
为什么80%的码农都做不了架构师？>>> ...
java p7 数字签名_JAVA加密算法（5）- 数字签名算法（RSA、DSA）
weixin_35327824的博客
02-13 1415
##数字签名流程 (1)生成签名：对源文件的「数字摘要」，使用私钥加密，生成「加密数字摘要」；(2)验证签名：对「加密数字摘要」通过公钥进行解密，生成「数字摘要2」，比较「数字摘要」与「数字摘要2」，结果相同则签名验证通过。概念：带有「公钥」和「私钥」的「消息摘要」算法，是「非对称加密算法」和「消息摘要」算法的结合体私钥签名，公钥验证###常用签名算法RSASignatureDSASignatur...
RSA签名加密工具类
拾一二的博客
07-18 1438
【代码】RSA签名加密工具类。
RSA公钥验签
WGH100817的博客
12-06 510
1.业务场景，公司做理财业务，但是可能有第三方合作。与第三方合作获得更多客户流量。别人可以在第三方进行购买理财产品。那么怎么保证交易信息的安全性那，我们这里给出rsa加密实现原理。2.工具类rsa：公钥私钥的生成百度一下有在线生成的网站。import java.security.KeyFactory;import java.security.Privat...
用Python实现RSA签名和验签
01-28 1555
一、首先看下Java 的RSA签名和验签 package com.hjdk.huijiedaikuannew.utils; import com.umeng.commonsdk.proguard.e; import java.io.UnsupportedEncodingException; import java.math.BigInteger; import java.security.Ke...
RSA签名和验签
oyy的博客
12-08 527
=========================签名验签方法一========================= 首先，需要有bcprov-jdk5on-1.53.jar 然后代码如下： import java.io.FileInputStream; import java.io.IOException; import java.io.UnsupportedEncodingExceptio...
rsa加签验签C#和js、java、微信小程序互通
qq_36437991的博客
06-14 836
rsa加签验签C#和js以及java互通
非对称加密算法 - RSA签名&验签授权
寻找小小的博客
12-27 3347
非对称加密算法 - RSA签名&验签授权
JAVA加密算法- 数字签名算法（RSA、DSA）
tony的专栏
05-12 1082
数字签名流程 （1）生成签名：对源文件的「数字摘要」，使用私钥加密，生成「加密数字摘要」； （2）验证签名：对「加密数字摘要」通过公钥进行解密，生成「数字摘要2」，比较「数字摘要」与「数字摘要2」，结果相同则签名验证通过。 概念：带有「公钥」和「私钥」的「消息摘要」算法，是「非对称加密算法」和「消息摘要」算法的结合体 私钥签名，公钥验证 常用签名算法 R
php rsa签名验签,PHP实现RSA或RSA2算法的签名和验签
weixin_39860975的博客
03-09 271
摘要：写了一个用PHP生成PSA和RSA2算法签名和验签的工具类，在支付等接口方面通常会用到，下面是代码：class RSA2{/*** RSA2签名...写了一个用PHP生成PSA和RSA2算法签名和验签的工具类，在支付等接口方面通常会用到，下面是代码：classRSA2{/***RSA2签名*@param$data待签名数据*@param$private_key私钥字符串*r...
RSA公钥加签验签
weixin_42060837的博客
07-03 770
package up.cpc.gw.test; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import org.apache.commons.codec.binary.Base64; import org.apache.commons.codec.digest.DigestUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; im
signature=c9e077ef93038bf703dbc146dd834bb7,基于RSASignUtil非对称私钥进行字符串加签及公钥解密验证的完整代码示例...
weixin_36012152的博客
05-29 251
一、前言通过之前定义RSAUtil工具类可以生成获取rsa非对称公私钥，基于私钥我们通过将字符串进行加签加密，再通过公钥进行解密验证，详情参见RSASignUtil代码工具类示例。二、代码示例importjava.security.KeyFactory;@b@importjava.security.PrivateKey;@b@importjava.security.PublicKey;@b@...
JAVA生成RSA公钥和私钥及RSA对数据的加签和验签
threelifeadv的博客
12-08 2190
背景： 最近来到了新的公司，公司做的是保险支付相关业务，对接渠道的时候经常会用到数据的加签和验签，初次涉及RSA加签验签，通过网站生成了RSA公钥和私钥，用私钥将我要传送的数据进行了加签，并将我的公钥提供给了渠道方进行验签，结果在联调的时候，验签总是错误，渠道方用自己的私钥对数据加签后再用自己的公钥对数据进行验签却能通过，于是我也用自己的私钥对数据进行加签后再用自己的公钥对数据进行验签，结果让我...
RSA加密、解密、加签、验签以及生成公私钥
爱吃袜子的二哈
02-24 6986
RSA加解密、加验签、生成公私钥代码如下： package util; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.IOExceptio...
RSAUtil
ygl6150373的博客
05-17 2853
package com.baoyun.linker.op.admin.controller.finance; import java.io.IOException; import java.security.InvalidKeyException; import java.security.Key; import java.security.KeyFactory; import
java基础-RSA签名验签
wwwzhouzy的专栏
08-13 4956
一、介绍 RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。 二、RSA加密、签名区别 　加密和签名都是为了安全性考虑，但略有不同。常有人问加密和签名是用私钥还是公钥？其实都是对加密和签名的作用有所混淆。简单的说，加密是为了防止信息被泄
java app rsa验签
最新发布
03-12
<think>嗯，用户想了解如何在Java应用中实现RSA验签。首先，我需要回忆一下RSA签名和验签的基本流程。根据引用[2]里的代码示例，签名的时候用的是私钥，而验签应该用公钥对吧？那验签的步骤应该是初始化Signature对象为验签模式，传入公钥，然后更新数据和验证签名。 然后，用户可能需要的代码结构。引用[2]展示了签名的代码，那么验签应该类似，但使用不同的方法，比如initVerify和verify。另外，引用[3]和[4]提到了公钥的使用和加密解密的过程，这可能对理解如何加载公钥有帮助。 需要注意的几个点：公钥的获取方式，比如从文件或者字符串加载。如何处理密钥的格式，比如PKCS#8还是其他。还有数据的一致性，比如签名和验签的数据是否相同，编码是否一致，比如Base64的处理。 可能的问题还有异常处理，比如InvalidKeyException或SignatureException，这些应该在代码中捕获和处理。此外，示例代码可能需要使用Java标准库中的类，比如KeyFactory、X509EncodedKeySpec等来生成公钥对象。 还要确保用户了解签名和验签的区别，引用[2]中提到签名的初始化是initSign，而验签是initVerify，这一点很重要。同时，引用[4]中的解密部分可能和验签混淆，需要区分清楚。 最后，根据用户的引用，可能需要补充关于前后台交互的场景，比如引用[3]提到的前台用jsrsasign库，后台用Java实现，但用户的问题集中在Java应用内的实现，所以可能需要专注于Java部分的代码。 总结步骤：加载公钥，初始化验签的Signature对象，更新数据，验证签名。给出具体的代码示例，并说明可能的异常和注意事项。</think>### Java应用中实现RSA验签的步骤 #### 1. **核心流程说明** RSA验签用于验证数据的完整性和来源真实性，需使用公钥验证私钥生成的签名。核心步骤包括： - **加载公钥**：从文件、证书或字符串中获取公钥 - **初始化验签对象**：指定算法（如`SHA256withRSA`） - **更新原始数据**：需与签名时的数据完全一致 - **执行验签**：比对签名结果 #### 2. **代码实现示例** ```java import java.security.*; import java.security.spec.X509EncodedKeySpec; import java.util.Base64; public class RSAVerifyExample { public static boolean verifySignature(String data, String publicKeyStr, String signatureStr) { try { // 1. 加载公钥 X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKeyStr)); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); PublicKey publicKey = keyFactory.generatePublic(keySpec); // 2. 初始化验签 Signature sig = Signature.getInstance("SHA256withRSA"); sig.initVerify(publicKey); // 3. 更新原始数据 sig.update(data.getBytes()); // 4. 执行验签 byte[] signature = Base64.getDecoder().decode(signatureStr); return sig.verify(signature); } catch (Exception e) { e.printStackTrace(); return false; } } } ``` #### 3. **关键注意点** 1. **密钥格式匹配**： - 公钥需符合X.509编码规范（`X509EncodedKeySpec`） - 若使用OpenSSL生成的密钥需转换格式：`openssl rsa -pubin -in public.pem -RSAPublicKey_out`[^3] 2. **数据一致性**： - 验签时输入的`data`必须与签名时的原始数据完全一致（包括编码格式） 3. **异常处理**： ```java catch (InvalidKeyException e) { // 密钥格式错误或类型不匹配 } catch (SignatureException e) { // 签名数据被篡改 } ``` #### 4. **典型应用场景** - API接口安全验证（如支付回调） - 软件更新包的完整性校验 - 电子合同签名验证（引用[3]中提到的前后端交互场景）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值