记RSA非对称加密实战

最新推荐文章于 2024-04-15 17:15:25 发布
最新推荐文章于 2024-04-15 17:15:25 发布
阅读量327 收藏
点赞数
分类专栏： 密码学 文章标签： RSA 密码 加密算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/seanlal/article/details/79374038
版权

本来觉得挺简单的不用写了，之前看到有人在讲密码学加密算法，发现有点不记得了。重新来贴一下流程
RSA加密算法的原理不再赘述，网上都有讲的比我好，我也懒得转载。
网上都有的RSAUtils 贴一下，有好几个版本了，之前找了一个前后端加密用不了，这个可以用

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.math.BigInteger;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

public class RSAUtils2 {

    private static String RSAKeyStore = "C:/RSAKey.txt";
    /**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";

    /**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";
    /**
     * * 生成密钥对 *
     *
     * @return KeyPair *
     * @throws Exception
     */

    public static Map<String, Object> genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
        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;
    }
    public static KeyPair generateKeyPair() throws Exception {
        try {
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA",  
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());  
            final int KEY_SIZE = 1024;// 没什么好说的了，这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低  
            keyPairGen.initialize(KEY_SIZE, new SecureRandom());  
            KeyPair keyPair = keyPairGen.generateKeyPair();  

            System.out.println(keyPair.getPrivate());  
            System.out.println(keyPair.getPublic());  

            saveKeyPair(keyPair);
            return keyPair;
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }

    public static KeyPair getKeyPair() throws Exception {
        FileInputStream fis = new FileInputStream(RSAKeyStore);
        ObjectInputStream oos = new ObjectInputStream(fis);
        KeyPair kp = (KeyPair) oos.readObject();
        oos.close();
        fis.close();
        return kp;
    }

    public static void saveKeyPair(KeyPair kp) throws Exception {

        FileOutputStream fos = new FileOutputStream(RSAKeyStore);
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        // 生成密钥
        oos.writeObject(kp);
        oos.close();
        fos.close();
    }

    /**
     * * 生成公钥 *
     *
     * @param modulus *
     * @param publicExponent *
     * @return RSAPublicKey *
     * @throws Exception
     */
    public static RSAPublicKey generateRSAPublicKey(byte[] modulus,  
            byte[] publicExponent) throws Exception {  
        KeyFactory keyFac = null;  
        try {  
            keyFac = KeyFactory.getInstance("RSA",  
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());  
        } catch (NoSuchAlgorithmException ex) {  
            throw new Exception(ex.getMessage());  
        }  

        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(  
                modulus), new BigInteger(publicExponent));  
        try {  
            return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);  
        } catch (InvalidKeySpecException ex) {  
            throw new Exception(ex.getMessage());  
        }  
    }  

    /**
     * * 生成私钥 *
     *
     * @param modulus *
     * @param privateExponent *
     * @return RSAPrivateKey *
     * @throws Exception
     */
    public static RSAPrivateKey generateRSAPrivateKey(byte[] modulus,  
            byte[] privateExponent) throws Exception {  
        KeyFactory keyFac = null;  
        try {  
            keyFac = KeyFactory.getInstance("RSA",  
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());  
        } catch (NoSuchAlgorithmException ex) {  
            throw new Exception(ex.getMessage());  
        }  

        RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(  
                modulus), new BigInteger(privateExponent));  
        try {  
            return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);  
        } catch (InvalidKeySpecException ex) {  
            throw new Exception(ex.getMessage());  
        }  
    }  

    /**
     * * 加密 *
     *  
     * @param pk
     *            加密的密钥 *
     * @param data
     *            待加密的明文数据 *
     * @return 加密后的数据 *
     * @throws Exception
     */
    public static byte[] encrypt(PublicKey pk, byte[] data) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance("RSA",
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());
            cipher.init(Cipher.ENCRYPT_MODE, pk);
            int blockSize = cipher.getBlockSize();// 获得加密块大小，如：加密前数据为128个byte，而key_size=1024
            // 加密块大小为127
            // byte,加密后为128个byte;因此共有2个加密块，第一个127
            // byte第二个为1个byte
            int outputSize = cipher.getOutputSize(data.length);// 获得加密块加密后块大小
            int leavedSize = data.length % blockSize;
            int blocksSize = leavedSize != 0 ? data.length / blockSize + 1
                    : data.length / blockSize;
            byte[] raw = new byte[outputSize * blocksSize];
            int i = 0;
            while (data.length - i * blockSize > 0) {
                if (data.length - i * blockSize > blockSize) {
                    cipher.doFinal(data, i * blockSize, blockSize, raw, i
                            * outputSize);
                }else {
                    cipher.doFinal(data, i * blockSize, data.length - i
                            * blockSize, raw, i * outputSize);
                }
                // 这里面doUpdate方法不可用，查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到
                // ByteArrayOutputStream中，而最后doFinal的时候才将所有的byte[]进行加密，可是到了此时加密块大小很可能已经超出了
                // OutputSize所以只好用dofinal方法。

                i++;
            }
            return raw;
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }

    /**
     * * 解密 *
     *
     * @param pk
     *            解密的密钥 *
     * @param raw
     *            已经加密的数据 *
     * @return 解密后的明文 *
     * @throws Exception
     */
    public static byte[] decrypt(PrivateKey pk, byte[] raw) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance("RSA",
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());
            cipher.init(Cipher.DECRYPT_MODE, pk);
            int blockSize = cipher.getBlockSize();
            ByteArrayOutputStream bout = new ByteArrayOutputStream(64);
            int j = 0;

            while (raw.length - j * blockSize > 0) {
                bout.write(cipher.doFinal(raw, j * blockSize, blockSize));
                j++;
            }
            return bout.toByteArray();
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }


    /**  
     * 16进制 To byte[]  
     * @param hexString  
     * @return byte[]  
     */  
    public static byte[] hexStringToBytes(String hexString) {  
        if (hexString == null || hexString.equals("")) {  
            return null;  
        }  
        hexString = hexString.toUpperCase();  
        int length = hexString.length() / 2;  
        char[] hexChars = hexString.toCharArray();  
        byte[] d = new byte[length];  
        for (int i = 0; i < length; i++) {  
            int pos = i * 2;  
            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));  
        }  
        return d;  
    }  

    /**  
     * Convert char to byte  
     * @param c char  
     * @return byte  
     */  
     private static byte charToByte(char c) {  
        return (byte) "0123456789ABCDEF".indexOf(c);  
    }  
    /**
     * * *
     *
     * @param args *
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        RSAPublicKey rsap = (RSAPublicKey) RSAUtils2.getKeyPair().getPublic();
        String test = "hello world";
        System.out.println(rsap.getModulus().toString(16));
        //System.out.println(new BigInteger(getKeyPair().getPublic().getEncoded()).toString(16));
        byte[] en_test = encrypt(getKeyPair().getPublic(), test.getBytes());
        byte[] de_test = decrypt(getKeyPair().getPrivate(), en_test);
        System.out.println(new String(de_test));
    }
}

其他的还有RSA.js前台加密等 官网可以下载到 这里就不贴了。还有一个生成密钥对的类

import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.Map;



public class RSAData {

    public static  Map<String, Object> keyMap;
    public static String publicKey;
    public static String privateKey;
    public static RSAPublicKey pubk;
    public static RSAPrivateKey prik;
    static {
        try {
            long time1 = System.currentTimeMillis();
            //生成密钥对
            RSAUtils2.generateKeyPair();
            keyMap = RSAUtils2.genKeyPair();
            pubk= (RSAPublicKey)RSAUtils2.getKeyPair().getPublic();
            publicKey = pubk.getModulus().toString(16);
            prik =  (RSAPrivateKey) RSAUtils2.getKeyPair().getPrivate();
            privateKey = prik.getModulus().toString(16);
            System.err.println("公钥: \n\r" + publicKey);
            System.err.println("私钥： \n\r" + privateKey);
            long time2 =System.currentTimeMillis();
            System.out.println("花费时间为："+(time2-time1));
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("公钥: \n\r" + publicKey);
            System.err.println("私钥： \n\r" + privateKey);
        }
    }
}

先从类中提取公钥

 try {
            publicKey= RSAData.publicKey;
        } catch (Exception e) {
            e.printStackTrace();
        }

将publicKey传入到前台页面用于加密
前台页面需要引入Barrett.js，BigInt.js，RSA.js，Base64.js

 var key;
 function enRSA() {
     setMaxDigits(130);

    //你传入的公钥
     var t=document.getElementById("publickey").value;
     //console.log(t);
     key = new RSAKeyPair("10001","",t);
 }

将密码使用base64加密

    password=Base.encode(password);
    enRSA();
    var token=encryptedString(key,encodeURIComponent('你要加密的东西'));
            // 转码
            token = (String) req.getAttr("token");
            //解析token转换为byte数组
            byte[] tokenBytes = RSAUtils2.hexStringToBytes(token);
            //获取私钥
            RSAPrivateKey privatekey1 = RSAData.prik;
            //使用私钥解密byte数组
            unencrypt_tokenbytes = RSAUtils2.decrypt(privatekey1, tokenBytes);
            //byte数组转换为字符串
            unencrypt_token = new String(unencrypt_tokenbytes);
            StringBuffer sb = new StringBuffer();
            sb.append(new String(unencrypt_token));
            //翻转字符串，前面翻转过现在翻转回来
            pwd = sb.reverse().toString();
            //用utf-8解码
            pwd = URLDecoder.decode(pwd, "UTF-8");//

总之RSA加密就是公钥加密私钥解密 RSA签名就是私钥加密 公钥解密 欢迎大神前来指导 - -

seanlal
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java非对称加密源码实例.7z
07-06
在Java中，非对称加密主要通过Java Cryptography Extension (JCE) 库来实现，它提供了丰富的加密算法，如RSA、DSA和Elliptic Curve Cryptography (ECC)。 在"Java非对称加密源码实例"中，我们可以期待看到以下几个...
RSA编码错误：Bad arguments（有时出现，有时不出现）
Fenf的专栏
03-02 8487
js前台使用公钥加密，后台java解密 问题是： String result = request.getParameter("encryedPwd"); byte[] en_result = new BigInteger(result, 16).toByteArray(); 这里:byte[] en_result = new BigInteger(result, 16).toByt
RSA Bad Arguments
懒虫一个V
06-14 6063
浏览器通过服务端提供的公钥进行加密，然后发到服务器上，通过私钥解密， 但是使用这个解密方法的时候有时可以解密成功，但有时却在解密的时候报 Bad arguments异常，我看见那个帖子的回复说问题出在这句话上 byte[] en_result = new BigInteger(result, 16).toByteArray();    我查了查，还真是， 秘文传过来一共有256个字符，通过转
RSA加密解密算法原理以及实现_rsa简介及源码实现，网络安全面试题2024基础
最新发布
m0_60147147的博客
04-15 1043
设F(x,y）表示为x，y的最大公约数，取k=x/y，b=x%y,那么x=ky+b，如果一个数能够整除x和y,那么一定可以整除y和b，也就是说，能够整除y和b的数，一定能够整除x和y，所以x和y的公约数和y和b的公约数相同，其最大公约数也相同，则有F(x,y)=F(y,x%y)(x>=y>0),这样就把求两个数的最大公约数转化为求两个更小的数的公约数，直到其中一个数为0，那么另一个数就是两者的最大公约数。φ(n)=n−1，因为质数在大于1的自然数中，除了1和它本身以外不会再有其他因数的自然数。
2、加密算法介绍及RSA实战
Java__EE小白成长之路
08-02 942
面试宝典：加密相关看这一篇文章就够了
Python项目开发实战_PyCrypto模块-数据加密_编程案例解析实例详解课程教程.pdf
03-28
总的来说，PyCrypto为Python开发者提供了全面的加密工具，无论是需要快速实现简单的AES加密，还是进行复杂的RSA非对称加密，PyCrypto都能满足需求。在实际项目开发中，结合Python的易用性，PyCrypto成为实现数据安全...
windows平台加密技术
03-31
加密技术的核心在于加密算法，如对称加密（如AES，高级加密标准）和非对称加密（如RSA，公钥加密）。对称加密使用同一密钥进行加密和解密，操作速度快，适合大量数据加密；非对称加密则使用一对公钥和私钥，一个用于...
.NET Core加解密实战系列之——RSA非对称加密算法
dotNET跨平台
06-15 1658
简介加解密现状，编写此项目的背景：需要考虑系统环境兼容性问题（Linux、Windows）语言互通问题（如C#、Java）网上资料版本不一、不全面.NET官方库密码算法提供不全面，很难针...
非对称加密及案例
qq_31639829的博客
11-02 2438
1. 概述 对称加密算法在加密时使用的是同一个密钥，为了解决信息公开传送和密钥管理的问题，于是提出了一种新的密钥交换协议，这种协议允许在不安全的媒体上的通讯双方交换信息、安全地达成一致的密钥，这就是非对称加密（公钥加密）。之所以称为非对称加密，是因为使用非对称加密算法时，加密和解密的使用的是不同的密钥。这两个密钥分别是私钥（private key）和公钥（public key）。 常用的非对称加密算法有：RSA、ECDSA 2. 特点 使用公钥加密后，只有对应的私钥才能解密 使用私钥加密后，只有对应的公钥
RSA加密实战心得
weixin_33725722的博客
03-14 259
网络天生就是不安全的，甚至于识别两次请求来自于同一个客户都不是件容易的事情。就像下面这几个小家伙，您认为昨天尿床的会是哪一个呢？   也许可以给他们购买不同颜色的尿布？但是下面这两个小孩可就没那么容易对付了：   如果是下面这种情况呢？   究竟是谁？也许可以摘掉其中一个baby的帽子？或者给左边那个小女孩带个红色的发卡？能不能在墨镜上做点文章呢？这些办法有一个共同的缺陷是“可逆”，b...
单点登录(SSO)实战，基于非对称加密双向RSA + AES加密
weixin_44951037的博客
11-15 2747
文章目录前言非对称性加密，双向加密(RSA+AES)单点登录(SSO)解决方案 前言 关于单点登录(SSO)网上也有很多帖子，但是以我个人的角度来看，大多都是一知半解，看完一圈也还是懵的，而且基本上都是理念，实实在在的去实践的基本上没有，而且内容基本上就是一模一样，这篇文章给大家也是提供一个单点登录的解决方案，至少看完和实践完之后，你知道大概怎么去实现，我这种实现方案也只适用于两个服务之间的通信登录，但是我认为哪有那么多的大型服务通信，又不是人人项目皆淘宝 非对称性加密，双向加密(RSA+AES) 本文
RSA解密过程中遇到的报错
热门推荐
jim_007的博客
07-11 1万+
报错：org.bouncycastle.crypto.DataLengthException: input too large for RSA cipher.问题所在：没留意被解密的报文是“content=XXX”，应该是“XXX”的解决办法：把接收的报文过滤掉“content=”就行；--------------------------------------------------------...
非对称加密解密算法RSA的小实例，
cuichunchi的博客
03-27 400
package Encoder.notSymmetry; import java.security.InvalidKeyException; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; i...
密码传输中Rsa加密
fan的学习笔记
10-20 2100
在用户登录和修改密码的地方，将密码直接传输到后台能看到传输密码的明文参数，所以需要加密一次。此处用RSA加密的方法，至于优缺点，我再研究。 首先定义一个RsaEncrypt公用类  public class GetRsaPublicKeyResult     {         public int Code { get; set; }         public string Rsa
rsa非对称加密解密python
09-12
RSA是一种非对称加密技术，可以用于数据的加密和解密。在Python中，可以使用rsa模块来实现RSA非对称加密和解密操作。通过引用中的文章，我们可以了解到如何在Python中使用rsa模块进行非对称加密和解密。 首先，需要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值