RSA加密算法

最新推荐文章于 2023-06-05 17:15:09 发布
最新推荐文章于 2023-06-05 17:15:09 发布
阅读量345 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44204751/article/details/106526457
版权

简介:

RSA是一种非对称加密算法,随机生成公钥，私钥，公钥加密,私钥解密。因为这种算法有最大长度加密的限制，所以需要分段加密。

下面是RSA工具类:

package com.meeno.wzq.util;


import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.io.UnsupportedEncodingException;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;


/**
 * @description:
 * @author: Wzq
 * @create: 2019-10-17 16:03
 */
public class RsaTool {


    /**
     * 测试方法
     */
    public static void main(String[] args) throws UnsupportedEncodingException {


        Map<String, String> map = new HashMap<String, String>();
        map = RsaTool.init();
        //由前四行代码获得公、私密钥
        String publicKey = map.get("publicKey");
        String privateKey = map.get("privateKey");
        String str = "wzq好帅.";
        String enStr1 = RsaTool.encryptByPublicKey(str, publicKey);
        System.out.println("公钥加密后：" + enStr1);
        String deStr1 = RsaTool.decryptByPrivateKey(enStr1,privateKey);
        System.out.println("私钥解密后：" + deStr1);


    }


    //定义加密方式
    public static final String KEY_RSA = "RSA";
    //定义公钥关键词
    public static final String KEY_RSA_PUBLICKEY = "RSAPublicKey";
    //定义私钥关键词
    public static final String KEY_RSA_PRIVATEKEY = "RSAPrivateKey";
    //定义签名算法
    private final static String KEY_RSA_SIGNATURE = "MD5withRSA";
    /**
     * **
     * RSA最大加密大小
     */
    private final static int MAX_ENCRYPT_BLOCK = 117;


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


    /**
     * 生成公私密钥对
     */
    public static Map<String, String> init()
    {
        Map<String, Object> map = null;
        Map<String, String> keyPairMap = new HashMap<String, String>();
        try
        {
            KeyPairGenerator generator = KeyPairGenerator.getInstance(KEY_RSA);
            //设置密钥对的bit数，越大越安全，但速度减慢，一般使用512或1024
            generator.initialize(1024);
            KeyPair keyPair = generator.generateKeyPair();
            // 获取公钥
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            // 获取私钥
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            // 将密钥对封装为Map
            map = new HashMap<String, Object>();
            map.put(KEY_RSA_PUBLICKEY, publicKey);
            map.put(KEY_RSA_PRIVATEKEY, privateKey);


            String publicKeyStr = RsaTool.getPublicKey(map);
            String privateKeyStr = RsaTool.getPrivateKey(map);
            System.out.println("公钥："+publicKeyStr);
            System.out.println("私钥："+privateKeyStr);


            keyPairMap.put("publicKey", publicKeyStr);
            keyPairMap.put("privateKey", privateKeyStr);


        } catch (NoSuchAlgorithmException e)
        {
            e.printStackTrace();
        }


        return keyPairMap;
    }


    /**
     * 获取Base64编码的公钥字符串
     */
    public static String getPublicKey(Map<String, Object> map)
    {
        String str = "";
        Key key = (Key) map.get(KEY_RSA_PUBLICKEY);
        str = encryptBase64(key.getEncoded());
        return str;
    }


    /**
     * 获取Base64编码的私钥字符串
     */
    public static String getPrivateKey(Map<String, Object> map)
    {
        String str = "";
        Key key = (Key) map.get(KEY_RSA_PRIVATEKEY);
        str = encryptBase64(key.getEncoded());
        return str;
    }


    /**
     * BASE64 解码
     *
     * @param key 需要Base64解码的字符串
     * @return 字节数组
     */
    public static byte[] decryptBase64(String key)
    {
        return Base64.getDecoder().decode(key);
//        return Base64Utils.decryptionBase64(key).getBytes();
    }


    /**
     * BASE64 编码
     *
     * @param key 需要Base64编码的字节数组
     * @return 字符串
     */
    public static String encryptBase64(byte[] key)
    {
        try {
            return new String(Base64.getEncoder().encode(key),"UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
//        return Base64Utils.encryptionBase64(key);
    }


    /**
     * 公钥加密
     *
     * @param encryptingStr
     * @param publicKeyStr
     * @return
     */
    public static String encryptByPublicKey(String encryptingStr, String publicKeyStr)
    {
        try
        {
            // 将公钥由字符串转为UTF-8格式的字节数组
            byte[] publicKeyBytes = decryptBase64(publicKeyStr);
            // 获得公钥
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
            //encryptingStr base64加密
            encryptingStr = encryptBase64(encryptingStr.getBytes("UTF-8"));
            // 取得待加密数据
            byte[] data = encryptingStr.getBytes("UTF-8");
            KeyFactory factory;
            factory = KeyFactory.getInstance(KEY_RSA);
            PublicKey publicKey = factory.generatePublic(keySpec);
            // 对数据加密
            Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            // 返回加密后由Base64编码的加密信息
            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);
                    /*System.out.println(new String(cache,"GBK"));
                    System.out.println(new String(cache,"UTF-8"));
                    System.out.println(new String(cache,"UTF-16"));
                    System.out.println(encryptBase64(cache));*/
                } else
                {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                    offSet = i * MAX_ENCRYPT_BLOCK;
                }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return encryptBase64(decryptedData);
        } catch (Exception e)
        {
            e.printStackTrace();
        }


        return null;
    }


    /**
     * 私钥解密
     *
     * @param encryptedStr
     * @param privateKeyStr
     * @return
     */
    public static String decryptByPrivateKey(String encryptedStr, String privateKeyStr)
    {
        try
        {
            // 对私钥解密
            byte[] privateKeyBytes = decryptBase64(privateKeyStr);
            // 获得私钥
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
            // 获得待解密数据
            byte[] data = decryptBase64(encryptedStr);
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            PrivateKey privateKey = factory.generatePrivate(keySpec);
            // 对数据解密
            Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            // 返回UTF-8编码的解密信息
            int inputLen = data.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(data, offSet, MAX_DECRYPT_BLOCK);
                } else
                {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            String resultStr = new String(decryptedData, "UTF-8");
            return new String(decryptBase64(resultStr),"UTF-8");
        } catch (Exception e)
        {
            e.printStackTrace();
        }


        return null;
    }


    /**
     * 私钥加密
     *
     * @param encryptingStr
     * @param privateKeyStr
     * @return
     */
    public static String encryptByPrivateKey(String encryptingStr, String privateKeyStr)
    {
        try
        {
            byte[] privateKeyBytes = decryptBase64(privateKeyStr);
            // 获得私钥
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
            // 取得待加密数据
            byte[] data = encryptingStr.getBytes("UTF-8");
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            PrivateKey privateKey = factory.generatePrivate(keySpec);
            // 对数据加密
            Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            // 返回加密后由Base64编码的加密信息
            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[] decryptedData = out.toByteArray();
            out.close();
            return encryptBase64(decryptedData);
        } catch (Exception e)
        {
            e.printStackTrace();
        }


        return null;
    }


    /**
     * 公钥解密
     *
     * @param encryptedStr
     * @param publicKeyStr
     * @return
     */
    public static String decryptByPublicKey(String encryptedStr, String publicKeyStr)
    {
        try
        {
            // 对公钥解密
            byte[] publicKeyBytes = decryptBase64(publicKeyStr);
            // 取得公钥
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
            // 取得待加密数据
            byte[] data = decryptBase64(encryptedStr);
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            PublicKey publicKey = factory.generatePublic(keySpec);
            // 对数据解密
            Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
            // 返回UTF-8编码的解密信息
            int inputLen = data.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(data, offSet, MAX_DECRYPT_BLOCK);
                } else
                {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return new String(decryptedData, "UTF-8");
        } catch (Exception e)
        {
            e.printStackTrace();
        }


        return null;
    }


    /**
     * 用私钥对加密数据进行签名
     *
     * @param encryptedStr
     * @param privateKey
     * @return
     */
    public static String sign(String encryptedStr, String privateKey)
    {
        String str = "";
        try
        {
            //将私钥加密数据字符串转换为字节数组
            byte[] data = encryptedStr.getBytes();
            // 解密由base64编码的私钥
            byte[] bytes = decryptBase64(privateKey);
            // 构造PKCS8EncodedKeySpec对象
            PKCS8EncodedKeySpec pkcs = new PKCS8EncodedKeySpec(bytes);
            // 指定的加密算法
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            // 取私钥对象
            PrivateKey key = factory.generatePrivate(pkcs);
            // 用私钥对信息生成数字签名
            Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);
            signature.initSign(key);
            signature.update(data);
            str = encryptBase64(signature.sign());
        } catch (Exception e)
        {
            e.printStackTrace();
        }
        return str;
    }


    /**
     * 校验数字签名
     *
     * @param encryptedStr
     * @param publicKey
     * @param sign
     * @return 校验成功返回true，失败返回false
     */
    public static boolean verify(String encryptedStr, String publicKey, String sign)
    {
        boolean flag = false;
        try
        {
            //将私钥加密数据字符串转换为字节数组
            byte[] data = encryptedStr.getBytes();
            // 解密由base64编码的公钥
            byte[] bytes = decryptBase64(publicKey);
            // 构造X509EncodedKeySpec对象
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
            // 指定的加密算法
            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
            // 取公钥对象
            PublicKey key = factory.generatePublic(keySpec);
            // 用公钥验证数字签名
            Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);
            signature.initVerify(key);
            signature.update(data);
            flag = signature.verify(decryptBase64(sign));
        } catch (Exception e)
        {
            e.printStackTrace();
        }
        return flag;
    }


}

技术支持:高岳峰,闫宇峰,施凯雷,杨珂

他的个人博客地址:http://120.78.93.197/

这是我的公众号 有最新的it咨询,和个人工作的记录:

这是我的个人微信遇到问题欢迎，提问：

最后加上高质量的淘宝店:如有质量问题随时滴滴我，童叟无欺!

GoslingWu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
RSA算法
且视他人之疑目如盏盏鬼火,大胆地去走你的夜路
04-22 1万+
RSA算法 RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。 RSA原理： RSA算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。通常是先生成一对RSA 密钥，其中之一是保密密钥，由用户保存；另一个为公开密钥，可对外公开，甚至可在网络服务器中注册。为提高保密强度，RSA密钥至少为500...
公开密钥加密算法RSA的理论概述
最新发布
FPGA/MATLAB学习教程/源码/项目合作开发
04-14 2114
RSA加密算法的最大优点就是不需要对密钥通信进行保密，所需传输的只有公开密钥，这样就省去了一条开销很大的密钥传输信道。其保密性强，密钥管理方便，并且具有数字签名、认证和签别等多种功能，特别适合于现代保密通信的需要。大多数使用公钥密码进行加密和数字签名的产品和标准使用的都是RSA算法。RSA的安全性是基于大数因子分解的困难性。目前一般认为RSA需要1024位以上的字长才有安全保障。由于RSA所采用的模幂运算耗时太多，因此它通常只能用于加密少量数据或者加密密钥。
RSA加密算法详解及例题
热门推荐
lesczx的博客
06-09 6万+
这是我自己在学习RSA加密算法的时候自己整理的笔记，如需转载请注明出处 RSA加密算法 我这里就不对RSA的发明背景做介绍了，你只要知道RSA加密算法是非常非常重要的加密算法，放在现在的时代亦是如此。 RSA加密算法的安全性是基于对极大整数做因数分解的困难。 RSA算法是一种非对称密码算法，所谓非对称，就是指该算法需要一对密钥，使用其中一个加密，则需要用另一个才能解密。例如： （1）乙方生成两把密钥（公钥和私钥）。公钥是公开的，任何人都可以获得，私钥则是保密的。 （2）甲方获取乙方的公钥，然后用它对信息加密
RSA加密算法（公钥+私钥加密）
浩星
07-09 3万+
公开密钥加密 公开密钥加密(public-key cryptography),也成为非对称加密，是密码学的一种算法，他需要两个密钥，一个是公开密钥，另一个是私有密钥，一个用作加密的时候，另一个则用作解密。 明文：需要加密的内容，成为明文。 密文：使用密钥把明文加密后的内容。只能用相应的另一个密钥才能解密得到原来的明文。甚至连最初用来加密的密钥也不能用作解密。 对称加密&&非对称加密 对称加密：加密和解密都是用同一个密钥的算法，称作对称加密。 非对称加密：加密和解密需要不
RSA加密算法解析
paycho的博客
06-05 4870
个人理解，n是两边都有的，具体加密中的p，q不知道，一个很大的数，想确定一对p*q=n很难（就算是质数也很难，因为数量真的很多） 用e加密，e是随机取的，用d解密 d是根据e和φ(n)算出来的 ,φ(n)是通过p和q算出来的 所以想破解d是很难的，关于怎么加密解密的过程， 注意点：M=C^d mod n 与C= M^e mod n的代换、ed的产生、1的n次幂还是1、以及欧拉定理 a^φ(n)=1 (mod n) 的同乘M。这样，一个具体用户就可以将自己设计的加密密钥和算法公诸于众，而只保密解密密钥。
RSA加密算法c++实现
04-07
RSA加密算法的实现，使用c++语言编程，使用dev c++平台编码，文件为cpp格式。经过反复测试代码正确，可搭配RSA讲解教程一起使用，讲解教程点击我的个人主页即可查看，希望能够对你有帮助，谢谢。
java实现的RSA加密算法详解
08-30
java实现的RSA加密算法详解 RSA加密算法是一种非对称加密算法，使用公钥和私钥对来实现加密和解密。下面是java实现的RSA加密算法的详细介绍： 一、什么是非对称加密 非对称加密是指使用一对密钥，一个公钥和一个...
python实现rsa加密算法
06-01
这个算法非原创，真心不错，所以上传分享出来．实测过，满足需求
RSA加密算法实验报告.pdf
11-21
"RSA加密算法实验报告.pdf" 本实验报告主要介绍了RSA加密算法的实现和原理，包括密钥对的产生、加密和解密过程、数字签名等。下面是该实验报告的详细知识点总结： 一、RSA加密算法的原理 RSA加密算法是基于大数...
RSA加密算法源码
02-23
RSA加密算法源码 详情参见：http://blog.csdn.net/lemon_tree12138/article/details/50696926
RSA在线加解密
封神之路~
05-05 5553
RSA加密/解密工具非常方便，只需要在网页上选择加密/解密模式，输入明文和公钥或私钥，就可以快速实现RSA加密和解密操作。使用RSA加密/解密工具，用户可以快速完成加密/解密操作，提高了加密效率，同时也保证了加密的安全性和准确性，让数据获得更好的保护，是加密通信、文件加密、数字签名等领域的好帮手。总之，如果您需要完成一个RSA加密任务，那么不妨去试一试RSA加密/解密工具，使用它，您可以快速、安全地完成加密任务。
RSA加解密工具类
yuer629
08-07 675
package com.fh.util; import javax.crypto.Cipher; import Decoder.BASE64Decoder; import Decoder.BASE64Encoder; import java.io.ByteArrayOutputStream; import java.security.*; import java.security.inte...
RSA算法原理——（1）目前常见加密算法简介
猪哥
06-18 3万+
今天为大家带来RSA算法的讲解文章，主要包括RSA算法的加解密过程和公式论证。文章可能会稍微有点长，但是内容绝对是目前全网最详细的，最通俗易懂的，跟着昌昌来一起揭开RSA非对称加密算法的面纱，保你看完本篇文章之后可以说：RSA just so so! 一、常见加密算法 目前常见的加密算法可以分成三类，对称加密算法，非对称加密算法和Hash算法。...
RSA加密算法加密与解密过程解析
firechungelaile的专栏
10-17 2万+
RSA加密算法剖析
RSA算法原理
runninghui的专栏
07-23 2383
一、一点历史 1976年以前，所有的加密方法都是同一种模式： （1）甲方选择某一种加密规则，对信息进行加密； （2）乙方使用同一种规则，对信息进行解密。 由于加密和解密使用同样规则（简称”密钥”），这被称为“对称加密算法”（Symmetric-key algorithm）。 这种加密模式有一个最大弱点：甲方必须把加密规则告诉乙方，否则无法解密。保存和传递密钥，就成了最
基于python的RSA加密算法软件设计与实现.docx
08-17
"本文档详细介绍了基于Python的RSA加密算法软件的设计与实现，旨在保障网络信息安全。RSA是一种公钥密码体制，常用于数据加密，具有高度安全性。通过Python实现RSA算法，可以开发出一款有效保护网络中数据安全的加密...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值