RSA加解密——前端JS/后端JAVA

最新推荐文章于 2024-05-13 22:19:04 发布

超级切图仔

最新推荐文章于 2024-05-13 22:19:04 发布

阅读量599

点赞数

分类专栏： Javascript Java 文章标签： java 前端 javascript

本文链接：https://blog.csdn.net/huang_wei_xiong/article/details/126465084

版权

Javascript 同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

Java

2 篇文章 0 订阅

订阅专栏

JAVA后端

.java文件


package demo;



import java.io.ByteArrayOutputStream;



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.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

import javax.crypto.CipherInputStream;

import org.apache.tomcat.util.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

public class demo {

    /**

     * RSA最大加密明文大小

     */

    private static final int MAX_ENCRYPT_BLOCK = 117;

    /**

     * RSA最大解密密文大小

     */

    private static final int MAX_DECRYPT_BLOCK = 128;

    /**

     * 获取密钥对

     *

     * @return 密钥对

     */

    public static KeyPair getKeyPair() throws Exception {

        KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");

        generator.initialize(1024);

        return generator.generateKeyPair();

    }

    /**

     * 获取私钥

     *

     * @param privateKey 私钥字符串

     * @return

     */

    public static PrivateKey getPrivateKey(String privateKey) throws Exception {

        KeyFactory keyFactory = KeyFactory.getInstance("RSA");

        byte[] decodedKey = org.apache.tomcat.util.codec.binary.Base64.decodeBase64(privateKey.getBytes());

        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);

        return keyFactory.generatePrivate(keySpec);

    }

    /**

     * 获取公钥

     *

     * @param publicKey 公钥字符串

     * @return

     */

    public static PublicKey getPublicKey(String publicKey) throws Exception {

        KeyFactory keyFactory = KeyFactory.getInstance("RSA");

        byte[] decodedKey = org.apache.tomcat.util.codec.binary.Base64.decodeBase64(publicKey.getBytes());

        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);

        return keyFactory.generatePublic(keySpec);

    }

    /**

     * RSA加密

     *

     * @param data 待加密数据

     * @param publicKey 公钥

     * @return

     */

    public static String encrypt(String data, PublicKey publicKey) throws Exception {

        Cipher cipher = Cipher.getInstance("RSA");

        cipher.init(Cipher.ENCRYPT_MODE, publicKey);

        int inputLen = data.getBytes().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.getBytes(), offset, MAX_ENCRYPT_BLOCK);

            } else {

                cache = cipher.doFinal(data.getBytes(), offset, inputLen - offset);

            }

            out.write(cache, 0, cache.length);

            i++;

            offset = i * MAX_ENCRYPT_BLOCK;

        }

        byte[] encryptedData = out.toByteArray();

        out.close();

// 获取加密内容使用base64进行编码,并以UTF-8为标准转化成字符串

// 加密后的字符串

        return new String(org.apache.tomcat.util.codec.binary.Base64.encodeBase64String(encryptedData));

    }

    /**

     * RSA解密

     *

     * @param data 待解密数据

     * @param privateKey 私钥

     * @return

     */

    public static String decrypt(String data, PrivateKey privateKey) throws Exception {

        Cipher cipher = Cipher.getInstance("RSA");

        cipher.init(Cipher.DECRYPT_MODE, privateKey);

        byte[] dataBytes = org.apache.tomcat.util.codec.binary.Base64.decodeBase64(data);

        int inputLen = dataBytes.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(dataBytes, offset, MAX_DECRYPT_BLOCK);

            } else {

                cache = cipher.doFinal(dataBytes, 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");

    }

    /**

     * 签名

     *

     * @param data 待签名数据

     * @param privateKey 私钥

     * @return 签名

     */

    public static String sign(String data, PrivateKey privateKey) throws Exception {

        byte[] keyBytes = privateKey.getEncoded();

        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance("RSA");

        PrivateKey key = keyFactory.generatePrivate(keySpec);

        Signature signature = Signature.getInstance("MD5withRSA");

        signature.initSign(key);

        signature.update(data.getBytes());

        return new String(org.apache.tomcat.util.codec.binary.Base64.encodeBase64(signature.sign()));

    }

    /**

     * 验签

     *

     * @param srcData 原始字符串

     * @param publicKey 公钥

     * @param sign 签名

     * @return 是否验签通过

     */

    public static boolean verify(String srcData, PublicKey publicKey, String sign) throws Exception {

        byte[] keyBytes = publicKey.getEncoded();

        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance("RSA");

        PublicKey key = keyFactory.generatePublic(keySpec);

        Signature signature = Signature.getInstance("MD5withRSA");

        signature.initVerify(key);

        signature.update(srcData.getBytes());

        return signature.verify(org.apache.tomcat.util.codec.binary.Base64.decodeBase64(sign.getBytes()));

    }



    public static void main(String[] args) {

        try {

// 生成密钥对

            KeyPair keyPair = getKeyPair();

            String privateKey = new String(org.apache.tomcat.util.codec.binary.Base64.encodeBase64(keyPair.getPrivate().getEncoded()));

            String publicKey = new String(Base64.encodeBase64(keyPair.getPublic().getEncoded()));

            privateKey = " ";
            publicKey =" ";

            System.out.println("私钥:" + privateKey);

            System.out.println("公钥:" + publicKey);

// RSA加密

            String data = "123秘密啊";

            String encryptData = encrypt(data, getPublicKey(publicKey));

            System.out.println("加密后内容:" + encryptData);

// RSA解密

            String decryptData = decrypt(encryptData, getPrivateKey(privateKey));

            System.out.println("解密后内容:" + decryptData);

// RSA签名

            String sign = sign(data, getPrivateKey(privateKey));

            System.out.println("sign==" + sign);

// RSA验签

            boolean result = verify(data, getPublicKey(publicKey), sign);

            System.out.println("验签结果:" + result);


        } catch (Exception e) {

            e.printStackTrace();

            System.out.print("加解密异常");

        }

    }

}

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>maven_demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <defaultGoal>compile</defaultGoal>

    </build>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.10</version>
        </dependency>
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk15on</artifactId>
            <version>1.56</version>
        </dependency>
    </dependencies>


</project>

JS

import JSEncrypt from 'jsencrypt/bin/jsencrypt';

// 加密
export const des_encrypt = (data, publicKey) => {
    publicKey =
        `-----BEGIN PUBLIC KEY-----
        **********************
  -----END PUBLIC KEY-----` //把之前生成的贴进来，实际开发过程中，可以是后台传过来的
    let encryptor = new JSEncrypt() // 新建JSEncrypt对象
    encryptor.setPublicKey(publicKey) // 设置公钥
    // 对需要加密的数据进行加密
    return encryptor.encrypt(data)
}
// 解密
export const des_decrypt = (data) => {
    let privateKey =
        `-----BEGIN RSA PRIVATE KEY-----
        **********************
 -----END RSA PRIVATE KEY-----`;
    let decrypt = new JSEncrypt();
    // 设置私钥
    decrypt.setPrivateKey(privateKey);
    return decrypt.decrypt(data);
}