漫谈Java加密技术（四）

最新推荐文章于 2023-06-02 09:05:24 发布
最新推荐文章于 2023-06-02 09:05:24 发布
阅读量1k 收藏
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anlovejing/article/details/8642018
版权
RSA

    这种算法1978年就出现了，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。算法的名字以发明者的名字命名：Ron Rivest， AdiShamir 和Leonard Adleman.这种加密算法的特点主要是密钥的变化，上文我们看到DES只有一个密钥。相当于只有一把钥匙，如果这把钥匙丢了，数据也就不安全了。RSA同时有两把钥匙，公钥与私钥。同时支持数字签名。数字签名的意义在于，对传输过来的数据进行校验。确保数据在传输工程中不被修改。

    流程分析：

    1、甲方构建密钥对儿，将公钥公布给乙方，将私钥保留。

    2、甲方使用私钥加密数据，然后用私钥对加密后的数据签名，发送给乙方签名以及加密后的数据；乙方使用公钥、签名来验证待解密数据是否有效，如果有效使用公钥对数据解密。

    3、乙方使用公钥加密数据，向甲方发送经过加密后的数据；甲方获得加密数据，通过私钥解密。

    通过java代码实现如下：

import java.security.Key;   
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.RSAPrivateKey;   
import java.security.interfaces.RSAPublicKey;   
import java.security.spec.PKCS8EncodedKeySpec;   
import java.security.spec.X509EncodedKeySpec;   
  
import java.util.HashMap;   
import java.util.Map;   
  
import javax.crypto.Cipher;   
  
/** *//**  
 * RSA安全编码组件  
 *   
 * @author 梁栋  http://www.bt285.cn http://www.5a520.cn 
 * @version 1.0  
 * @since 1.0  
 */  
public abstract class RSACoder extends Coder {   
    public static final String KEY_ALGORITHM = "RSA";   
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";   
  
    private static final String PUBLIC_KEY = "RSAPublicKey";   
    private static final String PRIVATE_KEY = "RSAPrivateKey";   
  
    /** *//**  
     * 用私钥对信息生成数字签名  
     *   
     * @param data  
     *            加密数据  
     * @param privateKey  
     *            私钥  
     *   
     * @return  
     * @throws Exception  
     */  
    public static String sign(byte[] data, String privateKey) throws Exception {   
        // 解密由base64编码的私钥   
        byte[] keyBytes = decryptBASE64(privateKey);   
  
        // 构造PKCS8EncodedKeySpec对象   
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);   
  
        // KEY_ALGORITHM 指定的加密算法   
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);   
  
        // 取私钥匙对象   
        PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);   
  
        // 用私钥对信息生成数字签名   
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);   
        signature.initSign(priKey);   
        signature.update(data);   
  
        return encryptBASE64(signature.sign());   
    }   
  
    /** *//**  
     * 校验数字签名  
     *   
     * @param data  
     *            加密数据  
     * @param publicKey  
     *            公钥  
     * @param sign  
     *            数字签名  
     *   
     * @return 校验成功返回true 失败返回false  
     * @throws Exception  
     *   
     */  
    public static boolean verify(byte[] data, String publicKey, String sign)   
            throws Exception {   
  
        // 解密由base64编码的公钥   
        byte[] keyBytes = decryptBASE64(publicKey);   
  
        // 构造X509EncodedKeySpec对象   
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);   
  
        // KEY_ALGORITHM 指定的加密算法   
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);   
  
        // 取公钥匙对象   
        PublicKey pubKey = keyFactory.generatePublic(keySpec);   
  
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);   
        signature.initVerify(pubKey);   
        signature.update(data);   
  
        // 验证签名是否正常   
        return signature.verify(decryptBASE64(sign));   
    }   
  
    /** *//**  
     * 解密<br>  
     * 用私钥解密  http://www.5a520.cn http://www.feng123.com
     *   
     * @param data  
     * @param key  
     * @return  
     * @throws Exception  
     */  
    public static byte[] decryptByPrivateKey(byte[] data, String key)   
            throws Exception {   
        // 对密钥解密   
        byte[] keyBytes = decryptBASE64(key);   
  
        // 取得私钥   
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);   
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);   
        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);   
  
        // 对数据解密   
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());   
        cipher.init(Cipher.DECRYPT_MODE, privateKey);   
  
        return cipher.doFinal(data);   
    }   
  
    /** *//**  
     * 解密<br>  
     * 用私钥解密  
     *   
     * @param data  
     * @param key  
     * @return  
     * @throws Exception  
     */  
    public static byte[] decryptByPublicKey(byte[] data, String key)   
            throws Exception {   
        // 对密钥解密   
        byte[] keyBytes = decryptBASE64(key);   
  
        // 取得公钥   
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);   
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);   
        Key publicKey = keyFactory.generatePublic(x509KeySpec);   
  
        // 对数据解密   
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());   
        cipher.init(Cipher.DECRYPT_MODE, publicKey);   
  
        return cipher.doFinal(data);   
    }   
  
    /** *//**  
     * 加密<br>  
     * 用公钥加密  
     *   
     * @param data  
     * @param key  
     * @return  
     * @throws Exception  
     */  
    public static byte[] encryptByPublicKey(byte[] data, String key)   
            throws Exception {   
        // 对公钥解密   
        byte[] keyBytes = decryptBASE64(key);   
  
        // 取得公钥   
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);   
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);   
        Key publicKey = keyFactory.generatePublic(x509KeySpec);   
  
        // 对数据加密   
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());   
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);   
  
        return cipher.doFinal(data);   
    }   
  
    /** *//**  
     * 加密<br>  
     * 用私钥加密  
     *   
     * @param data  
     * @param key  
     * @return  
     * @throws Exception  
     */  
    public static byte[] encryptByPrivateKey(byte[] data, String key)   
            throws Exception {   
        // 对密钥解密   
        byte[] keyBytes = decryptBASE64(key);   
  
        // 取得私钥   
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);   
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);   
        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);   
  
        // 对数据加密   
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());   
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);   
  
        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 {   
        KeyPairGenerator keyPairGen = KeyPairGenerator   
                .getInstance(KEY_ALGORITHM);   
        keyPairGen.initialize(1024);   
  
        KeyPair keyPair = keyPairGen.generateKeyPair();   
  
        // 公钥   
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();   
  
        // 私钥   
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();   
  
        Map<String, Object> keyMap = new HashMap<String, Object>(2);   
  
        keyMap.put(PUBLIC_KEY, publicKey);   
        keyMap.put(PRIVATE_KEY, privateKey);   
        return keyMap;   
    }   
} 

再给出一个 测试类：

import static org.junit.Assert.*;   
  
import org.junit.Before;   
import org.junit.Test;   
  
import java.util.Map;   
  
/** *//**  
 *   
 * @author 梁栋  http://www.bt285.cn  http://www.guihua.org
 * @version 1.0  
 * @since 1.0  
 */  
public class RSACoderTest {   
    private String publicKey;   
    private String privateKey;   
  
    @Before  
    public void setUp() throws Exception {   
        Map<String, Object> keyMap = RSACoder.initKey();   
  
        publicKey = RSACoder.getPublicKey(keyMap);   
        privateKey = RSACoder.getPrivateKey(keyMap);   
        System.err.println("公钥: \n\r" + publicKey);   
        System.err.println("私钥： \n\r" + privateKey);   
    }   
  
    @Test  
    public void test() throws Exception {   
        System.err.println("公钥加密——私钥解密");   
        String inputStr = "abc";   
        byte[] data = inputStr.getBytes();   
  
        byte[] encodedData = RSACoder.encryptByPublicKey(data, publicKey);   
  
        byte[] decodedData = RSACoder.decryptByPrivateKey(encodedData,   
                privateKey);   
  
        String outputStr = new String(decodedData);   
        System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);   
        assertEquals(inputStr, outputStr);   
  
    }   
  
    @Test  
    public void testSign() throws Exception {   
        System.err.println("私钥加密——公钥解密");   
        String inputStr = "sign";   
        byte[] data = inputStr.getBytes();   
  
        byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);   
  
        byte[] decodedData = RSACoder   
                .decryptByPublicKey(encodedData, publicKey);   
  
        String outputStr = new String(decodedData);   
        System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);   
        assertEquals(inputStr, outputStr);   
  
        System.err.println("私钥签名——公钥验证签名");   
        // 产生签名   
        String sign = RSACoder.sign(encodedData, privateKey);   
        System.err.println("签名:\r" + sign);   
  
        // 验证签名   
        boolean status = RSACoder.verify(encodedData, publicKey, sign);   
        System.err.println("状态:\r" + status);   
        assertTrue(status);   
  
    }   
  
}

    Console代码：

公钥:

MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCYU/+I0+z1aBl5X6DUUOHQ7FZpmBSDbKTtx89J
EcB64jFCkunELT8qiKly7fzEqD03g8ALlu5XvX+bBqHFy7YPJJP0ekE2X3wjUnh2NxlqpH3/B/xm
1ZdSlCwDIkbijhBVDjA/bu5BObhZqQmDwIxlQInL9oVz+o6FbAZCyHBd7wIDAQAB

私钥：

MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJhT/4jT7PVoGXlfoNRQ4dDsVmmY
FINspO3Hz0kRwHriMUKS6cQtPyqIqXLt/MSoPTeDwAuW7le9f5sGocXLtg8kk/R6QTZffCNSeHY3
GWqkff8H/GbVl1KULAMiRuKOEFUOMD9u7kE5uFmpCYPAjGVAicv2hXP6joVsBkLIcF3vAgMBAAEC
gYBvZHWoZHmS2EZQqKqeuGr58eobG9hcZzWQoJ4nq/CarBAjw/VovUHE490uK3S9ht4FW7Yzg3LV
/MB06Huifh6qf/X9NQA7SeZRRC8gnCQk6JuDIEVJOud5jU+9tyumJakDKodQ3Jf2zQtNr+5ZdEPl
uwWgv9c4kmpjhAdyMuQmYQJBANn6pcgvyYaia52dnu+yBUsGkaFfwXkzFSExIbi0MXTkhEb/ER/D
rLytukkUu5S5ecz/KBa8U4xIslZDYQbLz5ECQQCy5dutt7RsxN4+dxCWn0/1FrkWl2G329Ucewm3
QU9CKu4D+7Kqdj+Ha3lXP8F0Etaaapi7+EfkRUpukn2ItZV/AkEAlk+I0iphxT1rCB0Q5CjWDY5S
Df2B5JmdEG5Y2o0nLXwG2w44OLct/k2uD4cEcuITY5Dvi/4BftMCZwm/dnhEgQJACIktJSnJwxLV
o9dchENPtlsCM9C/Sd2EWpqISSUlmfugZbJBwR5pQ5XeMUqKeXZYpP+HEBj1nS+tMH9u2/IGEwJA
fL8mZiZXan/oBKrblAbplNcKWGRVD/3y65042PAEeghahlJMiYquV5DzZajuuT0wbJ5xQuZB01+X
nfpFpBJ2dw==

公钥加密——私钥解密
加密前: abc

解密后: abc
公钥:

MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDdOj40yEB48XqWxmPILmJAc7UecIN7F32etSHF
9rwbuEh3+iTPOGSxhoSQpOED0vOb0ZIMkBXZSgsxLaBSin2RZ09YKWRjtpCA0kDkiD11gj4tzTiM
l9qq1kwSK7ZkGAgodEn3yIILVmQDuEImHOXFtulvJ71ka07u3LuwUNdB/wIDAQAB

私钥：

MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAN06PjTIQHjxepbGY8guYkBztR5w
g3sXfZ61IcX2vBu4SHf6JM84ZLGGhJCk4QPS85vRkgyQFdlKCzEtoFKKfZFnT1gpZGO2kIDSQOSI
PXWCPi3NOIyX2qrWTBIrtmQYCCh0SffIggtWZAO4QiYc5cW26W8nvWRrTu7cu7BQ10H/AgMBAAEC
gYEAz2JWBizjI31bqhP4XiP9PuY5F3vqBW4T+L9cFbQiyumKJc58yzTWUAUGKIIn3enXLG7dNqGr
mbJro4JeFIJ3CiVDpXR9+FluIgI4SXm7ioGKF2NOMA9LR5Fu82W+pLfpTN2y2SaLYWEDZyp53BxY
j9gUxaxi1MQs+C1ZgDF2xmECQQDy70bQntbRfysP+ppCtd56YRnES1Tyekw0wryS2tr+ivQJl7JF
gp5rPAOXpgrq36xHDwUspQ0sJ0vj0O7ywxr1AkEA6SAaLhrJJrYucC0jxwAhUYyaPN+aOsWymaRh
9jA/Wc0wp29SbGTh5CcMuGpXm1g0M+FKW3dGiHgS3rVUKim4owJAbnxgapUzAgiiHxxMeDaavnHW
9C2GrtjsO7qtZOTgYI/1uT8itvZW8lJTF+9OW8/qXE76fXl7ai9dFnl5kzMk2QJBALfHz/vCsArt
mkRiwY6zApE4Z6tPl1V33ymSVovvUzHnOdD1SKQdD5t+UV/crb3QVi8ED0t2B0u0ZSPfDT/D7kMC
QDpwdj9k2F5aokLHBHUNJPFDAp7a5QMaT64gv/d48ITJ68Co+v5WzLMpzJBYXK6PAtqIhxbuPEc2
I2k1Afmrwyw=

私钥加密——公钥解密
加密前: sign

解密后: sign
私钥签名——公钥验证签名
签名:
ud1RsIwmSC1pN22I4IXteg1VD2FbiehKUfNxgVSHzvQNIK+d20FCkHCqh9djP3h94iWnIUY0ifU+
mbJkhAl/i5krExOE0hknOnPMcEP+lZV1RbJI2zG2YooSp2XDleqrQk5e/QF2Mx0Zxt8Xsg7ucVpn
i3wwbYWs9wSzIf0UjlM=

状态:
true

    简要总结一下，使用公钥加密、私钥解密，完成了乙方到甲方的一次数据传递，通过私钥加密、公钥解密，同时通过私钥签名、公钥验证签名，完成了一次甲方到乙方的数据传递与验证，两次数据传递完成一整套的数据交互！

    类似数字签名，数字信封是这样描述的：

    数字信封

    数字信封用加密技术来保证只有特定的收信人才能阅读信的内容。

    流程：

    信息发送方采用对称密钥来加密信息，然后再用接收方的公钥来加密此对称密钥（这部分称为数字信封），再将它和信息一起发送给接收方；接收方先用相应的私钥打开数字信封，得到对称密钥，然后使用对称密钥再解开信息。

anlovejing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PKCS7 数字信封项目源码
09-07
pkcs7数字信封，作为http://blog.csdn.net/yunnysunny/article/details/7899574 博客的配套附件。
Java RSA算法加密
hezelike的专栏
12-22 662
<br /><br />这种算法1978年就出现了，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。算法的名字以发明者的名字命名：Ron Rivest， AdiShamir 和Leonard Adleman.这种加密算法的特点主要是密钥的变化，上文我们看到DES只有一个密钥。相当于只有一把钥匙，如果这把钥匙丢了，数据也就不安全了。RSA同时有两把钥匙，公钥与私钥。同时支持数字签名。数字签名的意义在于，对传输过来的数据进行校验。确保数据在传输工程中不被修改。<br />    流
java密钥工厂中的KeyFactory.getInstance(“RSA“)翻译成C#的代码
Martin 的博客
12-22 5152
BouncyCastle用这个包 RSA公钥加密 publicstringRSAPublickEncrypt(stringpubkey,stringdata) { varrsaPubkey=(RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(pubkey)); RSAParametersrsaParameters=newR...
Java中的SecretKeyFactory类
qq_36138652的博客
02-16 1064
加密算法
2、加密算法介绍及RSA实战
Java__EE小白成长之路
08-02 949
面试宝典：加密相关看这一篇文章就够了
P神-Java安全漫谈
最新发布
04-20
数据加密和传输安全：Java提供了丰富的加密算法和API，可用于对敏感数据进行加密，以保护数据的隐私和完整性。同时，Java还支持安全的网络传输协议，如HTTPS，以确保数据在传输过程中的安全性。 安全漏洞和漏洞修复...
漫谈Java垃圾收集器.pdf
12-15
漫谈Java垃圾收集器 Java垃圾收集器是Java虚拟机（JVM）中的一种自动内存管理机制，旨在释放程序员从手动内存管理的繁琐工作中解脱出来。垃圾收集器通过跟踪对象的引用关系，确定哪些对象是可以被释放的，然后将其...
漫谈软件性能测试技术
01-31
随着我国加入WTO，各行各业都面临更多的机遇和挑战。如何提高产品的质量，增强市场竞争力，日益成为企业发展必须解决的迫切问题，对...16260信息技术软件产品评价质量特性及其使用指南》明确定义：软件质量是软件产品具
高清显示技术漫谈
01-19
当前家电领域“高清电视”或“高清显示技术”就是一个与此相关的热门话题。 　一、 电视扫描技术原理 　电视机屏幕显示的图像是由摄像机将光信号转换成电信号再通过同轴电缆传输到电视接收机，或者由电视信号发射...
Java进阶(七)Java加密技术之非对称加密算法RSA
热门推荐
IT全栈 华强工作室
07-23 5万+
Java加密技术（四）——非对称加密算法RSA 非对称加密算法——RSA 基本概念 非对称加密算法是一种密钥的保密方法。 非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥
keyfactory java_java keyfactory
weixin_32412379的博客
02-26 346
import java.io.ByteArrayInputStream; import java.io.FileInputStream; import java.io.ObjectInputStream; import java.security.KeyFactory; import java.security......本设计中以输入密钥的 hash 值生成 DESKeySpec 对象。 2) ...
【Java】Java实现非对称加密（RSA算法）
weixin_38538285的博客
07-05 748
1、 简介 非对称加密算法又叫做现代加密算法 非对称加密，有两个秘钥，一个公钥一个私钥.公钥和私钥是一对，叫做密钥对 如果使用公钥加密必须使用私钥解密 如果使用私钥加密必须使用公钥解密 处理数据的速度较慢，因为安全级别高 2、 对称加密算法的对比 优点：其安全性更好，对称加密的通信双方使用相同的秘钥，如果一方的秘钥遭泄露，那么整个通信就会被破解。而非对称加密使用一对秘钥，一个用来加密，一个用来解密，而且公钥是公开的，秘钥是自己保存的，不需要像对称加密那样在通信之前要先同步秘钥。 缺点：非对称加密的缺点
简述-非对称加密算法-RSA
weixin_42579622的博客
09-01 1445
RSA作为非对称加密算法，在实际开发中占据非常重要的角色。一般情况下，我们都使用DEA或者AES等对称加密算法(效率高)对数据进行加密，使用RSA对DES或AES的加密秘钥进行加密，以保证秘钥的安全性以及加密的高效性。
p7数字信封
TrustNature
01-27 2087
PKCS7的数字信封格式分为两种：带签名的数字信封和不带签名的数字信封。由于这个数字信封的生成过程比较复杂，所以这两种格式比较容易记混，导致都搞不清楚一个数字信封里面到底是存储的什么内容了。下面我就详细的解释一下，这两种数字信封的生成过程和其详细的数据结构。 不带签名的数字信封:不带签名的数字信封内容类型由任意类型的加密内容和加密的一个/多个接收者的内容加密密钥组成，其生成过程如下：1. 发送方...
非对称加密算法 - RSA（结合Java keytool与openssl工具生成证书）
楼上别吵了，我想睡觉
06-02 1719
DH算法的诞生为后续非对称加密算法奠定了基础，较为典型的对称加密算法（如ElGamal、RSA和ECC算法等）都是在DH算法提出后相继出现的，并且其算法核心都源于数学问题。RSA算法基于大数因子分解难题，而ElGamal算法和ECC算法则是基于离散对数难题。目前，各种主流计算机语言都提供了对RSA算法的支持。在Java 7中，我们可以很方便地构建该算法。
JAVA 非对称加密算法RSA
li_jiazhi的博客
03-07 2008
非对称加密算法 RSA过程 ： 以甲乙双方为例 　　1、初始化密钥 构建密钥对,生成公钥、私钥保存到keymap中 　　　　KeyPairGenerator ---&gt; KeyPair --&gt; RSAPublicKey、RSAPrivateKey 　　2、甲方使用私钥加密, 加密后在用私钥对加密数据进行数据签名，然后发送给乙方 　　　　RSACoder.encryptByPriva...
keyfactory java_java11教程--类KeyFactory用法
weixin_32918953的博客
02-13 1480
关键工厂用于将密钥 (类型为Key不透明加密密钥)转换为关键规范 (底层密钥材料的透明表示)，反之亦然。主要工厂是双向的。 也就是说，它们允许您根据给定的密钥规范(密钥材料)构建不透明的密钥对象，或者以适当的格式检索密钥对象的基础密钥材料。同一密钥可能存在多个兼容密钥规范。 例如，可以使用DSAPublicKeySpec或X509EncodedKeySpec指定DSA公钥。 密钥工厂可用于在兼容的...
java p7 数字签名_JAVA加密算法（5）- 数字签名算法（RSA、DSA）
weixin_35327824的博客
02-13 1296
##数字签名流程 (1)生成签名：对源文件的「数字摘要」，使用私钥加密，生成「加密数字摘要」；(2)验证签名：对「加密数字摘要」通过公钥进行解密，生成「数字摘要2」，比较「数字摘要」与「数字摘要2」，结果相同则签名验证通过。概念：带有「公钥」和「私钥」的「消息摘要」算法，是「非对称加密算法」和「消息摘要」算法的结合体私钥签名，公钥验证###常用签名算法RSASignatureDSASignatur...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值