java+vue+rsa前后端加密解密

最新推荐文章于 2024-06-23 17:44:38 发布
最新推荐文章于 2024-06-23 17:44:38 发布
阅读量1.4k 收藏 4
点赞数
分类专栏： java基础 文章标签： 加密解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26789867/article/details/118975984
版权

Base64Utils

package com.zhhgyj.zhmall.core.util;

import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * BASE64编码解码工具包
 */
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);
    }

    /** */
    /**
     * <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();
    }

}

RSAUtils

package com.zhhgyj.zhmall.core.util;

import java.io.ByteArrayOutputStream;
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;

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

    /** */
    /**
     * <p>
     * 生成密钥对(公钥和私钥)
     * </p>
     * 
     * @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;
    }

    /** */
    /**
     * <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());
    }

    /**
     * java端公钥加密
     */
    public static String encryptedDataOnJava(String data, String PUBLICKEY) {
        try {
            data = Base64Utils.encode(encryptByPublicKey(data.getBytes(), PUBLICKEY));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return data;
    }

    /**
     * java端私钥解密
     */
    public static String decryptDataOnJava(String data, String PRIVATEKEY) {
        String temp = "";
        try {
            byte[] rs = Base64Utils.decode(data);
            temp = new String(RSAUtils.decryptByPrivateKey(rs, PRIVATEKEY),"UTF-8"); //以utf-8的方式生成字符串

        } catch (Exception e) {
            e.printStackTrace();
        }
        return temp;
    }

}

测试

package com.zhhgyj.zhmall.core.util;

import java.util.Map;

/**
 * @author Xupf xupengfei131276@126.com
 */
public class Test {

    private static String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDGkoPlSQZ2fW5+uZrP0RUbVBCQZ1sz5KmKyj6HCicb0xlcfwzRHhbVqJCO2owuO4Ln4/iGJYLX5UB/JvYUk2dClpBYL7OCJ7JZrCd4+rlEG0A1TWcKsjyXl0cyBRg+r9KuZjN0CXHZsxVmGrkyiPNJ7Pacdvv04SAaYfdCGHjSywIDAQAB";
    private static String privateKey = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAMaSg+VJBnZ9bn65ms/RFRtUEJBnWzPkqYrKPocKJxvTGVx/DNEeFtWokI7ajC47gufj+IYlgtflQH8m9hSTZ0KWkFgvs4InslmsJ3j6uUQbQDVNZwqyPJeXRzIFGD6v0q5mM3QJcdmzFWYauTKI80ns9px2+/ThIBph90IYeNLLAgMBAAECgYBW5r30NQ4wAtq9eOrIcf8js5mAKMtgHX0ZMUNGA+pzoeHiefOY/OsPXDLPYdOhVAgJBdq4kmf9peWg/+MHxC6WzsIru3AZhOmwM0VzZW84LwtnGEj/vd9EMcbJTZkMHms4oPDJRMZdC1EA7wyo6F960UybjBHlUQ0BMs7IDpmyAQJBAPJ1OOutDJNIy6ti6y5cHKGXzZP1D77VLkStd/Bj/73bIDYzCin8aSz5hHvIW1fHfoWNznxbpEeG0q5PQIiQs8sCQQDRqcvSe2Vsif+1b/ntFIvljmTsq10iqnPIhN3cYR0hVUH6U8dEYr3eVve6wdHs8q1Fw63ig4aZ8/Ih0XxAmn0BAkEAmeXcRoQmSkrXtKbqPxgKuGuB+xt/bhMk9kThr73ZtCol7SFCn1nvbLPI60VG7ZXccmuLmJYW1av3iNsXTFgFNwJATyw7V6RZTH9gHHfIfQqBOZJn8idT6D9Nsa7ayNmzUl8Lpyfz25Md99QHgHKofz20yN93zk20inZgPP0KWqr8AQJAVS06PQVAEA34MlkUy5Cg1kOpp5h4Gglc4P2x6FHH+P86jOIjPzmVqwJCD/wNlXvTky6nkk+yBo2b61Epy7Ppvw==";

    public static void main(String[] args) {
        try {
            Map<String, Object> map = RSAUtils.genKeyPair();
            String privateKey = RSAUtils.getPrivateKey(map);
            String publicKey = RSAUtils.getPublicKey(map);
            System.out.println("publicKey:" + publicKey);
            System.out.println("privateKey:" + privateKey);

            String aa = "Hello rsa!";
            byte[] bytes = RSAUtils.encryptByPublicKey(aa.getBytes(), publicKey); // 公钥加密
            byte[] bytes1 = RSAUtils.decryptByPrivateKey(bytes, privateKey); // 私钥解密
            System.out.println(new String(bytes1));

            String s = RSAUtils.decryptDataOnJava("c9fxOrlpfH4WJ0GgV3TZM5Z4+BEcO96gPmZHrksMAu6wt5zWp9kAYu9vTgDW+vq4lhyy+ujnAFovdGSGPeNbqiqMDOu8fgcjCtxA1P29AZWnIwc2CnEVUrC7EZjQkj2xd4Ikti5Ch8WHGcOvmW5z3VRhV3+7m8i46oOo268COVQ=", Test.privateKey);
            System.out.println(s);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

vue端操作

1.下载jsencrypt

npm install jsencrypt

2.在main.js中安装

import JsEncrypt from 'jsencrypt' // res加密

Vue.prototype.$jsEncrypt = JsEncrypt

3.使用

var a = '123456'
      var publicKey = 'MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDGkoPlSQZ2fW5+uZrP0RUbVBCQZ1sz5KmKyj6HCicb0xlcfwzRHhbVqJCO2owuO4Ln4/iGJYLX5UB/JvYUk2dClpBYL7OCJ7JZrCd4+rlEG0A1TWcKsjyXl0cyBRg+r9KuZjN0CXHZsxVmGrkyiPNJ7Pacdvv04SAaYfdCGHjSywIDAQAB'
      let jse = new this.$jsEncrypt()
      jse.setPublicKey(publicKey)
      let b = jse.encrypt(a)
      console.log(b)
随便的码农
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java 解密后为空_java RSA加密解密
weixin_42349645的博客
02-27 1092
该工具类中用到了BASE64，需要借助第三方类库：javabase64-1.3.1.jar注意：RSA加密明文最大长度117字节，解密要求密文最大长度为128字节，所以在加密和解密的过程中需要分块进行。RSA加密对明文的长度是有限制的，如果加密数据过大会抛出如下异常：Exceptioninthread"main"javax.crypto.IllegalBlockSizeException:...
如何在 vue 用 RSA加密，java 后端 RSA解密
Ecloss
07-18 2681
第一步：安装crypto-js 库 npm install crypto-js --save-dev 第二步：在Vue项目中导入全局变量 import crypto from "crypto"; Vue.prototype.$crypto = crypto; 第三步：前端页面加密 submitLogin() { // key值 let key = CryptoJ...
vue RSA加解密（完美解决加解密文本过长问题）
12-21
rsa加解密
SpringBoot+vue加解密
04-25
通过一个简单的登录Demo演示SpringBoot+vue的加解密, vue前端实现密码加密，SpringBoot后端实现密码解密，前期准备:前端需要npm install crypto-js，后端基于JDK17
vue登陆密码加密，java后端解密
最新发布
while(life)++；
06-23 581
登陆之前调用encrypt给pwd加密。
PHP RSA无法解密出来 解密为空 解决方法
吴朝洪
10-27 6597
PHP RSA无法解密出来 解密为空，如何解决，非常简单把解密的字符串里的，空格转换为+号，再去解密，就搞定了。$encryptData = str_replace(' ','+', $encryptData); RSA的加密解密，对加密串的格式要求非常严格，不同语言，像java，.net 加密输出的串，到达php页面，会出现加号被转成空格的情况，因为php get 会默认执行一遍 urldecod
vue+java+aes进行加密解密（ECB、CBC模式）
m0_71817461的博客
11-24 2836
vue+java+aes进行加密解密
【Vue功能实现】JAVA+VUE前后端RES加解密
xudingg的博客
05-31 3016
JAVA+VUE前后端RES加解密，RES加密过程中的关键参数解析
【Bcrypt+AES】 Vue+Java前后端分离信息加解密详解和问题解决
热门推荐
NineWaited的博客
03-12 1万+
Vue+SpringBoot实现 登录信息Bcrypt加密+后端匹配 与注册信息AES加密+后端解密。
RSA非对称加密，前台vue加密，后台java解密
水蜜桃桃桃的博客
12-06 2206
目录 前言 公钥和私钥的获取 公钥私钥例子 公钥 私钥 一、前端vue加密 1.1安装jsencrypt 1.2安装好后，在文件里引用 1.3 使用私钥加密 2.后端java解密 2.1调用代码 2.2 RSAUtils工具类 2.3RSAUtils运行结果 参考文档 前言 RSA加密非对称加密，简单理解为就是有一个私钥一个公钥，我们在前台用私钥进行加密，到后台以后再使用对应的公钥进行解密。(这一对公钥和私钥可以由后台实时生成,每次生成的公钥和私钥都不...
Vue使用JSEncrypt实现rsa加密及挂载方法
10-15
在Vue中，我们可以借助第三方库JSEncrypt来实现RSA加密。 JSEncrypt 是一个JavaScript库，它提供了RSA加密的功能。在Vue项目中使用JSEncrypt时，我们需要先安装这个库，可以通过npm或yarn完成安装： ```bash # ...
python Django RSA 前台加密 后端解密。
12-06
在这个场景中，我们将讨论如何在Django应用中实现RSA加密和解密，以便于前端与后端的安全通信。 首先，让我们理解RSA的基本原理。RSA是一种基于大素数因子分解困难性的公钥加密算法。它包括一对密钥：公钥（可公开...
java js RSA加密支持超长加密
03-04
在Java和JavaScript中实现RSA加密，对于处理较长的数据至关重要，因为这两种语言的标准库默认的RSA加密只能处理相对较小的块。这里我们将深入探讨如何在Java和JavaScript中实现超长数据的RSA加密，并解决跨平台兼容...
使用CryptoJS实现Vue前端加密,Java后台解密的步骤和方法
向心行者
09-11 6173
CryptoJS 是一个 JavaScript 库，提供了一系列密码学函数和工具，用于加密、解密、生成摘要等任务。它支持多种加密算法，包括常见的对称加密算法（如 AES、DES）和非对称加密算法（如 RSA）。同时，CryptoJS还包括了ECB和CBC两种模式，其中ECB模式：全称Electronic Codebook（电码本），在ECB模式中，每个明文分组都被单独加密，且每个明文分组都被加密为相同的密文分组。也就是说，如果两个明文分组相同，那么它们的密文分组也相同。CBC模式。
springboot + vue 前后端加密传输 RSA互相加解密、加签验签、密钥对生成
nalanxiaoxiao2011的博客
01-05 3972
springboot + vue RSA加密传输 加签 验签 非对称加密
RSA加解密
Kiven 每天都需要有所获，每天都需要进步.........
05-01 963
前言        最近项目中需要利用RSA进行加解密，RSA是目前最流行的，也是最为安全的一种加密方式，RSA利用公钥和私钥来作为密钥，可以私钥加密公钥解密，也可以私钥解密公钥加密。         坑点:         当服务器端给到我私钥的时候（利用openssL生成），我无论怎么去解析私钥，都会抛出私钥非法，后来发现在生成私钥的时候并没有转换成PCK8标准的，由于后台是php，php中是不
在Java下进行RSA加密(私钥加密,公钥解密)
huang007guo的专栏
03-03 8836
加密过长的会报错: Data must not be longer than 245 bytes 原因是应为不同长度的密钥对应可以加密不同最大长度的原文,2048就对应245 解决办法是: 1.分段 2.RSA加密是有长度限制的.单纯用RSA加密较长数据时得使用分段加密,效率低下.用RSA+AES是比较主流的做法:AES加密数据产生密文,RSA加密AES密钥产生加密后的AES密钥,然后将...
decrypt解密失败，无论什么解密出都是null
cxh20777的专栏
11-29 2501
通过仔细检查以上可能的原因，并进行适当的调试和日志记录，你应该能够找到解密失败的原因，并采取相应的措施来解决问题。1. 错误的密钥或密钥对：确保在解密时使用的密钥或密钥对与加密时使用的相匹配。3. 加密算法不匹配：确保在解密时使用的算法与加密时使用的算法相匹配。2. 损坏的密文：在传输或存储过程中，密文可能会被损坏。6. 异常情况处理：在解密过程中，捕获可能的异常并进行适当的处理，例如记录日志或返回错误信息。4. 填充方式不匹配：在使用块加密算法（如AES）时，确保加密和解密时使用相同的填充方式。
java rsa 解密,JAVA RSA解密无法正常工作，抛出InvalidKeySpecException
weixin_39771987的博客
02-16 537
I used phpseclib to generate RSA public and private key.$rsa = new Crypt_RSA();$rsa->setHash('sha1');$rsa->setMGFHash('sha1');$rsa->setEncryptionMode(CRYPT_RSA_ENCRYPTION_OAEP);$rsa->setPr...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

随便的码农

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值