RSA非对称加解密算法以及签名验证

最新推荐文章于 2023-08-28 18:01:47 发布
最新推荐文章于 2023-08-28 18:01:47 发布
阅读量279 收藏
点赞数 1
文章标签： java rsa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36175890/article/details/116206056
版权

目录

1.生成证书

2.导出公钥 

3.导出私钥

4.加解密签名RSAUtils工具

5.Base64Utils工具

6.测试验证

1.生成证书

  • keytool -genkeypair -v -alias rsa1 -keyalg RSA -sigalg MD5withRSA -keysize 2048 -validity 36500 -storetype PKCS12 -keystore rsa1.keystore

2.导出公钥 

  • keytool -export -alias rsa1 -keystore /user/rsa1.keystore -file rsa1.cer

       注：rsa1.keystore 路径保证正确

3.导出私钥

      注：分三步

       3.1 第一步

  • keytool -importkeystore -srckeystore rsa1.keystore -destkeystore rsa1.p12 -deststoretype pkcs12

       3.2 第二步

  • openssl pkcs12 -in rsa1.p12 -out rsa1.pem

       3.3 第三步

        用文本编辑器打开PEM格式文件，从PEM格式的certificate chain中取出私钥，保存为rsa1.key

  • openssl rsa -in rsa1.key  -check

           或

  • openssl req -new -config openssl.cnf -key rsa1.key >rsa1.csr

4.加解密签名RSAUtils工具

  • package com.example.demo.util;


import org.springframework.core.io.ClassPathResource;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.security.*;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
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;

/**
 * <p>
 * RSA公钥/私钥/签名工具包
 */
public class RSAUtils {

    /**
     * 加密算法RSA
     */
    public static final String KEY_ALGORITHM = "RSA";

     /**
     * 签名算法
     *
     * 常用的数字签名算法包括：MD5withRSA／SHA1withRSA／SHA256withRSA／SHA1withDSA／SHA256withDSA／SHA512withDSA／ECDSA等
     *
     */
    public static final String SIGNATURE_ALGORITHM = "SHA256withRSA";

    /**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";

    /**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 245;

    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 256;

    /**
     * <p>
     * 生成密钥对(公钥和私钥)
     * </p>
     *
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(2048);
        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;
    }

    public static Map<String, Object> genKeyPairToFile() throws Exception {
        PublicKey publicKey = getPublicKeyFromFile();
        PrivateKey privateKey = getPrivateKeyFromFile();
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }


    // 从文件中获取公钥
    public static PublicKey getPublicKeyFromFile() throws Exception {
        CertificateFactory cff = CertificateFactory.getInstance("X.509");
        // resources 下的文件
        ClassPathResource classPathResource = new ClassPathResource("keystore/rsa1.cer");
        InputStream fis1 =classPathResource.getInputStream();
        Certificate cf = cff.generateCertificate(fis1);
        return cf.getPublicKey();
    }
    
    // 从文件中获取私钥 
    // 用证书的私钥解密 - 该私钥存在生成该证书的密钥库中
    public static PrivateKey getPrivateKeyFromFile() throws Exception{
        // resources 下的文件
        ClassPathResource classPathResource = new ClassPathResource("keystore/rsa1.keystore");
        InputStream fis2 =classPathResource.getInputStream();
        KeyStore ks = KeyStore.getInstance("JKS");         // 加载证书库
        char[] kspwd = "123321".toCharArray();          // 证书库密码
        char[] keypwd = "123321".toCharArray();          // 证书密码
        ks.load(fis2, kspwd);              // 加载证书
        PrivateKey pk2 = (PrivateKey)ks.getKey("rsa1", keypwd);     // 获取证书私钥
        fis2.close();
        return pk2;
    }

    /**
     * <p>
     * 用私钥对信息生成数字签名
     * </p>
     *
     * @param data 已加密数据
     * @param privateKey 私钥(BASE64编码)
     *
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateK);
        signature.update(data);
        return Base64Utils.encode(signature.sign());
    }

    /**
     * <p>
     * 校验数字签名
     * </p>
     *
     * @param data 已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @param sign 数字签名
     *
     * @return
     * @throws Exception
     *
     */
    public static boolean verify(byte[] data, String publicKey, String sign)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PublicKey publicK = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicK);
        signature.update(data);
        return signature.verify(Base64Utils.decode(sign));
    }

    /**
     * <P>
     * 私钥解密
     * </p>
     *
     * @param encryptedData 已加密数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /**
     * <p>
     * 公钥解密
     * </p>
     *
     * @param encryptedData 已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /**
     * <p>
     * 公钥加密
     * </p>
     *
     * @param data 源数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /**
     * <p>
     * 私钥加密
     * </p>
     *
     * @param data 源数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /**
     * <p>
     * 获取私钥
     * </p>
     *
     * @param keyMap 密钥对
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map<String, Object> keyMap)
            throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return Base64Utils.encode(key.getEncoded());
    }

    /**
     * <p>
     * 获取公钥
     * </p>
     *
     * @param keyMap 密钥对
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map<String, Object> keyMap)
            throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return Base64Utils.encode(key.getEncoded());
    }

}

5.Base64Utils工具

  • package com.example.demo.util;



import com.sun.org.apache.xml.internal.security.utils.Base64;

import java.io.*;


/**
 * <p>
 * BASE64编码解码工具包
 * </p>
 */
public class Base64Utils {

    /**
     * 文件读取缓冲区大小
     */
    private static final int CACHE_SIZE = 1024;

    /**
     * <p>
     * BASE64字符串解码为二进制数据
     * </p>
     *
     * @param base64
     * @return
     * @throws Exception
     */
    public static byte[] decode(String base64) throws Exception {
        return Base64.decode(base64.getBytes());
    }

    /**
     * <p>
     * 二进制数据编码为BASE64字符串
     * </p>
     *
     * @param bytes
     * @return
     * @throws Exception
     */
    public static String encode(byte[] bytes) throws Exception {
        return new String(Base64.encode(bytes));
    }

    /**
     * <p>
     * 将文件编码为BASE64字符串
     * </p>
     * <p>
     * 大文件慎用，可能会导致内存溢出
     * </p>
     *
     * @param filePath
     *            文件绝对路径
     * @return
     * @throws Exception
     */
    public static String encodeFile(String filePath) throws Exception {
        byte[] bytes = fileToByte(filePath);
        return encode(bytes);
    }

    /**
     * <p>
     * BASE64字符串转回文件
     * </p>
     *
     * @param filePath
     *            文件绝对路径
     * @param base64
     *            编码字符串
     * @throws Exception
     */
    public static void decodeToFile(String filePath, String base64) throws Exception {
        byte[] bytes = decode(base64);
        byteArrayToFile(bytes, filePath);
    }

    /**
     * <p>
     * 文件转换为二进制数组
     * </p>
     *
     * @param filePath
     *            文件路径
     * @return
     * @throws Exception
     */
    public static byte[] fileToByte(String filePath) throws Exception {
        byte[] data = new byte[0];
        File file = new File(filePath);
        if (file.exists()) {
            FileInputStream in = new FileInputStream(file);
            ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
            byte[] cache = new byte[CACHE_SIZE];
            int nRead = 0;
            while ((nRead = in.read(cache)) != -1) {
                out.write(cache, 0, nRead);
                out.flush();
            }
            out.close();
            in.close();
            data = out.toByteArray();
        }
        return data;
    }

    /**
     * <p>
     * 二进制数据写文件
     * </p>
     *
     * @param bytes
     *            二进制数据
     * @param filePath
     *            文件生成目录
     */
    public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {
        InputStream in = new ByteArrayInputStream(bytes);
        File destFile = new File(filePath);
        if (!destFile.getParentFile().exists()) {
            destFile.getParentFile().mkdirs();
        }
        destFile.createNewFile();
        OutputStream out = new FileOutputStream(destFile);
        byte[] cache = new byte[CACHE_SIZE];
        int nRead = 0;
        while ((nRead = in.read(cache)) != -1) {
            out.write(cache, 0, nRead);
            out.flush();
        }
        out.close();
        in.close();
    }

}

6.测试验证

  • package com.example.demo.util;


import java.util.Map;

public class RSATest {

    static String publicKey;
    static String privateKey;

    static {
        try {
            // 直接生成秘钥对
            // Map<String, Object> keyMap = RSAUtils.genKeyPair();
            // 从文件中获取秘钥信息
             Map<String, Object> keyMap = RSAUtils.genKeyPairToFile();
            publicKey = RSAUtils.getPublicKey(keyMap);
            privateKey = RSAUtils.getPrivateKey(keyMap);
            System.err.println("公钥: \n\r" + publicKey);
            System.err.println("私钥： \n\r" + privateKey);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        test();
        System.out.println("========================");
        test1();
        System.out.println("========================");
        test2();
    }
    static void test() throws Exception {
        String source = "测试公钥加密私钥解密";
        System.out.println("\r加密前文字：\r\n" + source);
        byte[] data = source.getBytes();
        byte[] encodedData = RSAUtils.encryptByPublicKey(data, publicKey);
        System.out.println("加密后文字：\r\n" + new String(encodedData));
        byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData, privateKey);
        String target = new String(decodedData);
        System.out.println("解密后文字: \r\n" + target);
    }

    static void test1() throws Exception {
        String source = "测试私钥加密公钥解密";
        System.out.println("原文字：\r\n" + source);
        byte[] data = source.getBytes();
        byte[] encodedData = RSAUtils.encryptByPrivateKey(data, privateKey);
        System.out.println("加密后：\r\n" + new String(encodedData));
        byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey);
        String target = new String(decodedData);
        System.out.println("解密后: \r\n" + target);
    }

    static void test2() throws Exception {
        System.err.println("私钥签名——公钥验证签名");
        String str ="测试签名验签";
        String sign = RSAUtils.sign(str.getBytes(), privateKey);
        System.err.println("签名：" + sign);

        boolean status = RSAUtils.verify(str.getBytes(), publicKey, sign);
        System.err.println("签名验证结果：" + status);
    }

}

参考：https://www.cnblogs.com/linjiqin/p/6005626.html

司徒苏
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RSA非对称加解密算法代码
07-31
RSA非对称加密算法是一种广泛应用于网络安全领域的加密技术，它基于数论中的大数因子分解难题，由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出，因此得名RSA。这个算法的核心在于一对密钥：公钥和私钥。...
C语言代码实现RSA非对称加密、解密
最新发布
06-26
RSA是一种广泛使用的非对称加密算法，由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出，因此得名RSA。它基于大整数因子分解的困难性，使得只有拥有正确私钥的人才能解密由公钥加密的信息，从而保证了数据的...
RSA加密解密坑
热门推荐
马志宇的专栏
02-22 1万+
RSA 跨语言加密解密常见的3坑。
RSA私钥解密操作
qq_44209563的博客
08-28 1887
密钥长度”一般只是指模值的位长度。目前主流可选值：1024、2048、3072、4096，我使用的密钥长度是2048，所以配置的最大解密长度应该是256。具体请参考代码中分段解密注释的部分。现在需要在使用的时候，使用私钥进行解密。MAX_DECRYPT_BLOCK应等于。代码中采取分段解密的方式时，配置的。项目数据库中存放的敏感字段已使用。的方式，将内容加密成密文存放,私钥转成byte数组时没有使用。变量配置长度有问题;
Android和JAVA后台实现RSA加解密
weixin_42872539的博客
02-23 733
Android和JAVA后台实现RSA加解密
Data must not be longer than 117 bytes
小单的博客专栏
07-12 6577
RSA 加密超长需要进行分段加密和分段解密，示例如下： // 分段加密 byte[] data = str.getBytes("UTF-8"); // 加密时超过117字节就报错。为此采用分段加密的办法来加密 byte[] enBytes = null; for (int i = 0; i < data.length; i += 64) { // 注意要使用2的倍数，否则会出现...
RSA分段解密 - Vue
Maggieq8324的博客
07-27 2477
前言 上一篇文章实现了 Java RSA的分段加解密，这里我们介绍在 Vue 项目中如何使用 RSA 分段解密，这里的加解密场景是： 后端私钥分段加密 - 前端公钥分段解密 前端如何使用公钥解密这里不做重复叙述，注重点是分段解密，有需要的参考之前的文章：RSA加密 - Vue 传送门 RSA分段加密 - Java 具体实现 src/libs/jsencrypt/lib/JSEncrypt.js中添加新的解密方法decryptLong /** * 分段解密 * @param string
非对称加解密——RSA加密、解密以及数字签名
01-02
本文将深入探讨RSA加密、解密以及数字签名的工作原理和应用。 RSA算法由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出，它的核心特点是存在一对密钥：公钥和私钥。公钥可以公开给任何人，而私钥必须严格...
RSA非对称签名、验签测试代码
06-26
在描述中提到的“RSA非对称签名、验签测试代码”是指使用RSA算法进行数字签名和验证签名的代码示例。数字签名是一种用于验证数据完整性和发送者身份的技术，它利用了非对称加密的特点。在RSA中，私钥用于创建数字...
C#自定义RSA加密解密及RSA签名和验证类实例
09-03
在C#编程中，RSA（Rivest–Shamir–Adleman）是一种广泛使用的非对称加密算法，适用于数据加密和数字签名。本文将深入解析如何在C#中自定义RSA加密解密以及签名和验证类。通过实例代码，我们可以理解C#中RSA算法的...
java 加密 解密 签名 验签工具类
weixin_45509211的博客
05-05 424
【代码】java 加密 解密 签名 验签工具类。
RSA实现对文件的加密解密
老朱的博客
05-12 3407
很多示例只能加密小文件 这个可以加密大点的文件 文件越大加解密时间越长 package com.harp.oa.utils; import org.bouncycastle.jce.provider.BouncyCastleProvider; import javax.crypto.Cipher; import java.io.*; import java.math.BigInteger; import java.security.*; import java.security.interface
JAVA架构之路（数据加密与常见加密算法）
JAVA领域优质创作者，基于分片网络查询方法专利发明者。
11-09 729
MD5（安全级别较高，一般不用做加密，常用在校验文件）DES（安全级别不高，消耗性能 较小）常见加密算法以及安全级别和使用场景。RSA（安全级别特别高，消耗性能大）SHA（不可解密，一般用在签名）AES（安全级别较高）
RSA 前端加密 后端解密
西瓜
04-15 1695
https://blog.csdn.net/qy20115549/article/details/83105736 package com.alipay; import cn.paypalm.commons.util.Logger; import cn.paypalm.commons.util.LoggerFactory; import org.apache.commons.codec.binary.Base64; import javax.crypto.Cipher; import java.io.
RSAUtils
Leven的博客
06-06 2496
import java.math.BigInteger; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.NoSuchAlgorithmExcept...
RSA相关秘钥问题
-
03-06 1029
package com.ljq.test; import java.io.ByteArrayOutputStream; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import jav...
SHA256withRSA证书签名，私钥签名/公钥验签（证书文件加载公私钥）
z69183787的专栏
07-17 6449
https://www.cnblogs.com/jinzhiming/p/10576385.html 证书签名 package test; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; impor...
Java加密算法 RSA
vrix的专栏
06-06 939
公钥加密也称为非对称加密、速度慢、加密和解密的钥匙不相同，某一个人持有私钥，任何人都可以知道公钥 [java] view plaincopyprint? package com.stone.security;      import java.security.KeyPair;   import java.security.KeyPairG
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值