登录密码加密，RSA加密算法

已于 2022-01-23 10:55:05 修改
阅读量5.6k 收藏 7
点赞数
分类专栏： 单点登录sso 文章标签： 安全 https
于 2022-01-21 17:36:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_14815383/article/details/122625746
版权

公钥加密，私钥解密

前端：密文RSA公钥加密，得到base64编码的加密密文，jsencrypt.min.js

var publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDQZX1Kg0I59W4KwMq0VsZRHp5GE5me474JefjiDK/ewrftAxeKMAnjAfAe2mEb6ZYMz2UKDF2fDKhi3Ctqkqa04HbbuDVu8+fU7A436RUGouyge+MK0hjpLlUKvDL+dknUq4twpArpWjYtXgikQI1nh8XPTNH/nRSy50kQ3ComRwIDAQAB";
        var encrypt = new JSEncrypt();
        encrypt.setPublicKey(publicKey);

  mmVal = encrypt.encrypt("123456");

后端：

  • 生成公钥和私钥，Map<String, Object> map = RSAUtils.genKeyPair();
  • 收到机密密文，把base64密码解码为二进制数组，再解密，得到密文二进制数组
  • 二进制数组转换成密文

1、base64编码工具类

**
 * BASE64编码解码工具包
 *
 * @author Created by zqc on 2018/11/02.
 */
public class BaseUtils {

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

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

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

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

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

    /**
     * 文件转换为二进制数组
     *
     * @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;
    }

    /**
     * 二进制数据写文件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();
    }
}

2、RSA加密解密工具类


/**
 * <p>
 * RSA公钥/私钥/签名工具包
 * </p>
 * <p>
 * 罗纳德・李维斯特（Ron [R]ivest）、阿迪・萨莫尔（Adi [S]hamir）和伦纳德・阿德曼（Leonard [A]dleman）
 * </p>
 * <p>
 * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
 * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/>
 * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全
 * </p>
 *
 * @author Created by zqc on 2018/11/02.
 */
public class RSAUtils {

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

    /**
     * 签名算法
     */
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

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

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

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

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

    /**
     * 生成密钥对(公钥和私钥)
     *
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair() 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;
    }

    /**
     * 用私钥对信息生成数字签名
     *
     * @param data       已加密数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = BaseUtils.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 BaseUtils.encode(signature.sign());
    }

    /**
     * 校验数字签名
     *
     * @param data      已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @param sign      数字签名
     * @return
     * @throws Exception
     */
    public static boolean verify(byte[] data, String publicKey, String sign)
            throws Exception {
        byte[] keyBytes = BaseUtils.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(BaseUtils.decode(sign));
    }

    /**
     * 私钥解密
     *
     * @param encryptedData 已加密数据
     * @param privateKey    私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
            throws Exception {
        byte[] keyBytes = BaseUtils.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);
        return getByteArray(encryptedData, cipher, MAX_DECRYPT_BLOCK);
    }

    private static byte[] getByteArray(byte[] data, Cipher cipher, int maxBlockSize) throws IllegalBlockSizeException, BadPaddingException, IOException {
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > maxBlockSize) {
                cache = cipher.doFinal(data, offSet, maxBlockSize);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * maxBlockSize;
        }
        byte[] endeData = out.toByteArray();
        out.close();
        return endeData;
    }

    /**
     * 公钥解密
     *
     * @param encryptedData 已加密数据
     * @param publicKey     公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
            throws Exception {
        byte[] keyBytes = BaseUtils.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);
        return getByteArray(encryptedData, cipher, MAX_DECRYPT_BLOCK);
    }

    /**
     * 公钥加密
     *
     * @param data      源数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey)
            throws Exception {
        byte[] keyBytes = BaseUtils.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);
        return getByteArray(data, cipher, MAX_ENCRYPT_BLOCK);
    }

    /**
     * 私钥加密
     *
     * @param data       源数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
            throws Exception {
        byte[] keyBytes = BaseUtils.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);
        return getByteArray(data, cipher, MAX_ENCRYPT_BLOCK);
    }

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

}

3、解密测试


public class Base64Test {
    public static void main(String[] args) throws Exception {
     //生成公钥私钥，生成一次就可以，公钥不变，私钥会变
		/*Map<String, Object> map = RSAUtils.genKeyPair();
		System.out.println(map);
		String publicKey = RSAUtils.getPublicKey(map);
		String privateKey = RSAUtils.getPrivateKey(map);
		*/
        String publicKey="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCbj3V1MC7zFGnyPWDcv/55nQRklXB1KyZ7mpglV2SiCoDcWqArAEUjfp5iHQT59Wfyg+56fBnKV0nuvBEXRICytaZuGFiQYeDqEkuR5mkSIEnvcld+TgHAbeXRAIry8LE59efeJcyqQoCDG2sA8pMgEqVNhfP/hDb5+uH0QAvLWQIDAQAB";
        String privateKey="MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAJuPdXUwLvMUafI9YNy//nmdBGSVcHUrJnuamCVXZKIKgNxaoCsARSN+nmIdBPn1Z/KD7np8GcpXSe68ERdEgLK1pm4YWJBh4OoSS5HmaRIgSe9yV35OAcBt5dEAivLwsTn1594lzKpCgIMbawDykyASpU2F8/+ENvn64fRAC8tZAgMBAAECgYB0YGXKDwsAtYPxQrPlUglJ6ArySM5CCc8XZ3dtcC0MAPmYYIA0y1XuEPrigb1IVqy2RLczkQYmVxkrbi0HECuK2y1xx3Pf7AxiZUSCK4Cpdcq7QBUHHhGcFqK3sFcNQD2JfnQk2mE6o9BAmEfTb8G2OpDIDOQa/PDApNodcPLREQJBANkkEiIg70MP1tnT2ntLG4rY89GyvFw6Og3GK9xcrTBXNbQfSjb+O44GRUjBay425cSxf6g/Ph7q2oga9FP0pX0CQQC3Zi9NvtSRNfNAc6A252eun4a4qnFSADJ4tlKR346JQauuYqI3QhIXwfyS0XUFRZ0rlcYj3Cght9etU37eqjQNAkEAkYjoknFKi8MQ+HxSwjIr6prQiCrorlPkVxkMiqye83hwKSKTplotZlpzk3j3skjfJT7mVcjVhPlZsMGIIsElLQJBAK2ntSzRf+dLhVxG37J9JKClbuRWh1yU0TWZtc9oNkfjBdPmkyDtj8ItLaI7cKmgQ/UsKWR1Jw7eS/tTrzLZSNUCQEWnEoO8qvJES1+qAkmg/WHWOaJlM/LHnjHf2O+Srv9ISUizMhnSIwr3d//SAQB6AAhFDRm6cGxkiNq4DtW1mQ4=";

        String encode="LE60PdTwuMo4rH4vnC53vEVyVez3J/1uXYRozVJWFnyXcOoZHvJSU2/5RlHIi/ws600hbzDJsmP/w19hVL+u8NbI2AXtJ0jnLMcsAOVLN/ryL98oHkdVTO1aQfthNIRx28NgVnPYwfdodxbHLym3wLXCi6JbmzBr2wuyBC+9cME=";
       
        byte[] decrypt = RSAUtils.decryptByPrivateKey(BaseUtils.decode(encode), privateKey);//把base64密码解码为二进制数组，再解密，得到密文二进制数组
        String encode1 = new String(decrypt);//二进制数组转换成密文
        System.out.println("解密："+encode1);
    }
}

参考博客：

FashionProgrammer
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RSA加密算法c++实现
04-07
RSA加密算法的实现，使用c++语言编程，使用dev c++平台编码，文件为cpp格式。经过反复测试代码正确，可搭配RSA讲解教程一起使用，讲解教程点击我的个人主页即可查看，希望能够对你有帮助，谢谢。
常用的登录加密算法
风华浪浪的博客
04-03 2547
##’’‘采用AES对称加密算法’’’ key字节串,在对称密码中使用的密钥,加密必须是文本必须是16/24/32的倍数, 如果不是成为补成的倍数 mode用于加密或解密的链接模式,默认为MODE_ECB block_size, 加密它以前缀为密文 from Crypto.Cipher import AES from binascii import b2a_hex, a2b_hex class ...
带密钥的消息摘要算法——数据签名算法
chiqiao5151的博客
04-19 863
数字签名算法可以看做是一种带有密钥（公钥+私钥）的消息摘要算法，也就是说，数据签名算法是非对称加密算法和消息摘要算法的结合体。该算法包含签名和验证两项操作，遵循 “私钥签名，公钥验证” 的签名/验证方式。 数字签名算法消息传递模型 1、甲方构建密钥对，并能公布公钥给乙方。 2、甲...
米游社登陆参数解析（RSA、webpack、RCP）
最新发布
m0_64560180的博客
06-06 572
我们来到登录的界面，然后输入账号密码，再观察这个登录的网络请求。能很清楚看到，我们输出的账号密码（123456，123456）被加密成了两串密文进行传送，如果我们要实现模拟登录的话，必须要能够复现它的加密逻辑。
RSA 公钥解密后置处理器
Radioman-lhq的博客
08-12 1114
一.RSA 公钥解密后置处理器截图： 二.RSA 公钥解密后置处理器使用说明： 公钥：RSA解密公钥； 填充算法：目前支持PKCS1 OAEP PADDING、PKCS1 PADDING、NO PADDING三种填充算法； 目标变量名：如上图RSA公钥解密结果存放到rsaPublic变量中，使用时，以${rsaPublic}这种形式引用即可。 三.示例 场景1：密文存储在JMeter变量rsaP...
RSA
f543711700的专栏
10-21 191
[code="java"]package com.ghca.roam.sync; import java.io.ByteArrayOutputStream; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyP...
RSA加密解密，String转PublicKey、PrivateKey；附Base64.JAR
weixin_30908707的博客
06-06 3662
网络请求的数据需要加密，服务器给的他们那一套在Android一直报错，自己写了一个；package com.cc.common.util; import javax.crypto.Cipher; import java.security.*; import java.security.spec.PKCS8EncodedKeySpec; import java....
Java加密算法RSA代码实例
08-25
Java加密算法RSA代码实例 Java加密算法RSA代码实例是Java中的一种常用加密算法，主要用于数据加密和解密。 RSA算法是基于大数分解的公钥加密算法，使用一对密钥对（公钥和私钥）来实现加密和解密。 在Java中，RSA...
密码学实验_对称加密算法DES_非对称加密算法RSA.pdf
02-20
本实验报告主要涉及两种加密算法：对称加密算法DES（Data Encryption Standard）和非对称加密算法RSA。实验旨在帮助学生深入理解这两种算法的基本原理，并通过Python编程实现加密和解密过程。 ### **对称加密算法...
RSA.rar_RSA 加密解密_密码算法
09-21
RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，它是现代密码学的基石之一。RSA的名字来源于它的三位发明者：Ron Rivest、Adi Shamir和Leonard Adleman。在1977年，他们公开了这一算法，开启了公钥密码学的新...
python实现公钥加密RSA算法工程文件
07-09
python实现公钥加密RSA算法工程文件 详解博客地址：https://blog.csdn.net/m0_52316372/article/details/125691807
AES和RSA加密简介+Java使用工具类
socct_yj的博客
12-14 5991
一、AES和RSA 1、对称加密和非对称加密简介 目前常见的加密方式是有两种，一种是对称加密(AES为代表），一种是非对称加密（RSA为代表）。 对称加密只有一个秘钥，加密和解密都是用同一个秘钥，所以叫做对称加密。 非对称加密有两个秘钥，一个是公钥，一个是私钥。非对称的特点在于，公钥加密的私钥可以解密，但私钥加密的，公钥解不出来，只能验证是否由私钥进行加密 这样可以保证就算有人拿到公钥，也解密不出私钥加密后的信息，公钥可以在网上安全的传输。而且公钥可以验证这个密文是不是由私钥加密出来的..
RSA工具类
qq_34004946的博客
02-06 585
public class RSAUtils { /** 加密算法RSA */ public static final String KEY_ALGORITHM = "RSA"; /**签名算法 */ public static final String SIGNATURE_ALGORITHM = "MD5withRSA"; /**获取公钥的key */
Java常用非对称加密算法-RSA
浅醉樱花雨的专栏
05-15 4427
RSA作为常用的非对称加密算法，用法基本就是首先生成公钥和私钥密钥对，然后用公钥加密私钥解密或者用私钥加密公钥解密。这里只写代码实现。import javax.crypto.Cipher; import java.security.*; import java.security.spec.PKCS8EncodedKeySpec; import java.security.spec.X509Enco...
高等数据加密——非对称加密算法
chiqiao5151的博客
04-19 147
对称加密算法仅有一个密钥，既可用于加密，亦可用于解密。而非对称加密算法拥有两个密钥，一个用于加密，另一个则用于解密。相比对称加密算法的单钥体系，非对称加密算法的双钥体系更为安全。但非对称加密的缺点是加解密速度要远远慢于对称加密。 目前，Java 6中仅仅提供了DH和RSA两种算法实现...
Java加密：四、非对称加密算法
学以致用 知行合一
03-03 2408
非对称加密算法与对称加密算法的主要差别在于非对称加密算法用于加密和解密的密钥不相同，一个公开，称为公钥；一个保密，称为私钥。 RSA算法实现易于理解，对于RSA算法的测试只需要注意经公钥加密的数据是否可以通过私钥将其解密，反之，经私钥加密的数据是否可以通过公钥将其解密。 与DH算法不同，RSA算法仅需要一套密钥即可完成加密/解密操作，并且公钥的密钥长度明显小于私钥的密钥长度，更便于发送和携带。
RSA算法原理
Alex Tam 的专栏
10-15 1205
原文链接 作者: 阮一峰 如果你问我，哪一种算法最重要？我可能会回答“公钥加密算法”。因为它是计算机通信安全的基石，保证了加密数据不会被破解。你可以想象一下，信用卡交易被破解的后果。 进入正题之前，我先简单介绍一下，什么是”公钥加密算法”。 一、一点历史 1976年以前，所有的加密方法都是同一种模式： （1）甲方选择某一种加密规则，对
常见登录密码加密方式
热门推荐
赵广陆
02-16 1万+
目录1 常见的加密方式1.1.可逆加密算法1.1.1. 对称加密1.1.2. 非对称加密1.2.不可逆加密算法1.3.Base64编码2 密码加密的方式选型2.1 MD5密码加密2.2 手动加密（md5+随机字符串）2.3 . BCrypt密码加密3 jwt介绍3.1 token认证-面试3.2 什么是JWT？3.3 生成token 1 常见的加密方式 由于在学习JWT的时候会涉及使用很多加密算法, 所以在这里做下扫盲, 简单了解就可以 加密算法种类有: 1.1.可逆加密算法 解释: 加密后, 密文可以反
使用RSA加密完成登录功能，防止用户信息被抓包泄漏！
New_Yao的博客
06-30 5273
前言 之前项目中，登录模块发送登录请求基本上都是明文传输用户名、密码，这样如果系统的请求被恶意抓取，用户的信息就会泄漏无疑，毫无安全可言，那么有什么办法可以提高安全性呢？ js加密 在js中加密用户的密码，使之在传输过程中程加密状态，这样，即使在被恶意拦截了请求，获取了用户名密码后，别人并不会知道密码，因此完成加密！ RSA加密算法 RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中...
Python实现RSA加密算法确保网络安全
"本文档详细介绍了基于Python的RSA加密算法软件的设计与实现，旨在保障网络信息安全。RSA是一种公钥密码体制，常用于数据加密，具有高度安全性。通过Python实现RSA算法，可以开发出一款有效保护网络中数据安全的加密...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值