JS客戶端RSA加密，Java服務端解密

原創 世逍遥 2020-02-20 23:20
在客戶端瀏覽器，Javascript使用RSA算法，以公鑰對密碼進行加密，服務端使用相應的私鑰進行解密。一般用於註冊時或登錄時填寫的密碼。 
Java引用到的包： 
commons-lang 
bouncycastle 
slf4j 
commons-codec 
commons-io 


RSA加密工具類——RSAUtils.java
package my.tools.security;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.math.BigInteger;
import java.security.KeyPair;
import java.security.KeyFactory;
import java.security.KeyPairGenerator;
import java.security.Provider;
import java.security.PublicKey;
import java.security.PrivateKey;
import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;
import java.security.InvalidParameterException;
import java.security.interfaces.RSAPublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.spec.RSAPublicKeySpec;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.InvalidKeySpecException;
 
import javax.crypto.Cipher;
 
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.FileUtils;
import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateFormatUtils;
 
/**
 * RSA算法加密/解密工具類。
 *
 * @author fuchun
 * @version 1.0.0, 2010-05-05
 */
public abstract class RSAUtils {
 
    private static final Logger LOGGER = LoggerFactory.getLogger(RSAUtils.class);
 
    /** 算法名稱 */
    private static final String ALGORITHOM = "RSA";
    /**保存生成的密鑰對的文件名稱。 */
    private static final String RSA_PAIR_FILENAME = "/__RSA_PAIR.txt";
    /** 密鑰大小 */
    private static final int KEY_SIZE = 1024;
    /** 默認的安全服務提供者 */
    private static final Provider DEFAULT_PROVIDER = new BouncyCastleProvider();
 
    private static KeyPairGenerator keyPairGen = null;
    private static KeyFactory keyFactory = null;
    /** 緩存的密鑰對。 */
    private static KeyPair oneKeyPair = null;
 
    private static File rsaPairFile = null;
 
    static {
        try {
            keyPairGen = KeyPairGenerator.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
            keyFactory = KeyFactory.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
        } catch (NoSuchAlgorithmException ex) {
            LOGGER.error(ex.getMessage());
        }
        rsaPairFile = new File(getRSAPairFilePath());
    }
 
    private RSAUtils() {
    }
 
    /**
     * 生成並返回RSA密鑰對。
     */
    private static synchronized KeyPair generateKeyPair() {
        try {
            keyPairGen.initialize(KEY_SIZE, new SecureRandom(DateFormatUtils.format("yyyyMMdd").getBytes()));
            oneKeyPair = keyPairGen.generateKeyPair();
            saveKeyPair(oneKeyPair);
            return oneKeyPair;
        } catch (InvalidParameterException ex) {
            LOGGER.error("KeyPairGenerator does not support a key length of " + KEY_SIZE + ".", ex);
        } catch (NullPointerException ex) {
            LOGGER.error("RSAUtils#KEY_PAIR_GEN is null, can not generate KeyPairGenerator instance.",
                    ex);
        }
        return null;
    }
 
    /**
     * 返回生成/讀取的密鑰對文件的路徑。
     */
    private static String getRSAPairFilePath() {
        String urlPath = RSAUtils.class.getResource("/").getPath();
        return (new File(urlPath).getParent() + RSA_PAIR_FILENAME);
    }
 
    /**
     * 若需要創建新的密鑰對文件，則返回 {@code true}，否則 {@code false}。
     */
    private static boolean isCreateKeyPairFile() {
        // 是否創建新的密鑰對文件
        boolean createNewKeyPair = false;
        if (!rsaPairFile.exists() || rsaPairFile.isDirectory()) {
            createNewKeyPair = true;
        }
        return createNewKeyPair;
    }
 
    /**
     * 將指定的RSA密鑰對以文件形式保存。
     *
     * @param keyPair 要保存的密鑰對。
     */
    private static void saveKeyPair(KeyPair keyPair) {
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
        try {
            fos = FileUtils.openOutputStream(rsaPairFile);
            oos = new ObjectOutputStream(fos);
            oos.writeObject(keyPair);
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            IOUtils.closeQuietly(oos);
            IOUtils.closeQuietly(fos);
        }
    }
 
    /**
     * 返回RSA密鑰對。
     */
    public static KeyPair getKeyPair() {
        // 首先判斷是否需要重新生成新的密鑰對文件
        if (isCreateKeyPairFile()) {
            // 直接強制生成密鑰對文件，並存入緩存。
            return generateKeyPair();
        }
        if (oneKeyPair != null) {
            return oneKeyPair;
        }
        return readKeyPair();
    }
     
    // 同步讀出保存的密鑰對
    private static KeyPair readKeyPair() {
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            fis = FileUtils.openInputStream(rsaPairFile);
            ois = new ObjectInputStream(fis);
            oneKeyPair = (KeyPair) ois.readObject();
            return oneKeyPair;
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            IOUtils.closeQuietly(ois);
            IOUtils.closeQuietly(fis);
        }
        return null;
    }
 
    /**
     * 根據給定的係數和專用指數構造一個RSA專用的公鑰對象。
     *
     * @param modulus 係數。
     * @param publicExponent 專用指數。
     * @return RSA專用公鑰對象。
     */
    public static RSAPublicKey generateRSAPublicKey(byte[] modulus, byte[] publicExponent) {
        RSAPublicKeySpec publicKeySpec = new RSAPublicKeySpec(new BigInteger(modulus),
                new BigInteger(publicExponent));
        try {
            return (RSAPublicKey) keyFactory.generatePublic(publicKeySpec);
        } catch (InvalidKeySpecException ex) {
            LOGGER.error("RSAPublicKeySpec is unavailable.", ex);
        } catch (NullPointerException ex) {
            LOGGER.error("RSAUtils#KEY_FACTORY is null, can not generate KeyFactory instance.", ex);
        }
        return null;
    }
 
    /**
     * 根據給定的係數和專用指數構造一個RSA專用的私鑰對象。
     *
     * @param modulus 係數。
     * @param privateExponent 專用指數。
     * @return RSA專用私鑰對象。
     */
    public static RSAPrivateKey generateRSAPrivateKey(byte[] modulus, byte[] privateExponent) {
        RSAPrivateKeySpec privateKeySpec = new RSAPrivateKeySpec(new BigInteger(modulus),
                new BigInteger(privateExponent));
        try {
            return (RSAPrivateKey) keyFactory.generatePrivate(privateKeySpec);
        } catch (InvalidKeySpecException ex) {
            LOGGER.error("RSAPrivateKeySpec is unavailable.", ex);
        } catch (NullPointerException ex) {
            LOGGER.error("RSAUtils#KEY_FACTORY is null, can not generate KeyFactory instance.", ex);
        }
        return null;
    }
     
    /**
     * 根據給定的16進制係數和專用指數字符串構造一個RSA專用的私鑰對象。
     *
     * @param modulus 係數。
     * @param privateExponent 專用指數。
     * @return RSA專用私鑰對象。
     */
    public static RSAPrivateKey getRSAPrivateKey(String hexModulus, String hexPrivateExponent) {
        if(StringUtils.isBlank(hexModulus) || StringUtils.isBlank(hexPrivateExponent)) {
            if(LOGGER.isDebugEnabled()) {
                LOGGER.debug("hexModulus and hexPrivateExponent cannot be empty. RSAPrivateKey value is null to return.");
            }
            return null;
        }
        byte[] modulus = null;
        byte[] privateExponent = null;
        try {
            modulus = Hex.decodeHex(hexModulus.toCharArray());
            privateExponent = Hex.decodeHex(hexPrivateExponent.toCharArray());
        } catch(DecoderException ex) {
            LOGGER.error("hexModulus or hexPrivateExponent value is invalid. return null(RSAPrivateKey).");
        }
        if(modulus != null && privateExponent != null) {
            return generateRSAPrivateKey(modulus, privateExponent);
        }
        return null;
    }
     
    /**
     * 根據給定的16進制係數和專用指數字符串構造一個RSA專用的公鑰對象。
     *
     * @param modulus 係數。
     * @param publicExponent 專用指數。
     * @return RSA專用公鑰對象。
     */
    public static RSAPublicKey getRSAPublidKey(String hexModulus, String hexPublicExponent) {
        if(StringUtils.isBlank(hexModulus) || StringUtils.isBlank(hexPublicExponent)) {
            if(LOGGER.isDebugEnabled()) {
                LOGGER.debug("hexModulus and hexPublicExponent cannot be empty. return null(RSAPublicKey).");
            }
            return null;
        }
        byte[] modulus = null;
        byte[] publicExponent = null;
        try {
            modulus = Hex.decodeHex(hexModulus.toCharArray());
            publicExponent = Hex.decodeHex(hexPublicExponent.toCharArray());
        } catch(DecoderException ex) {
            LOGGER.error("hexModulus or hexPublicExponent value is invalid. return null(RSAPublicKey).");
        }
        if(modulus != null && publicExponent != null) {
            return generateRSAPublicKey(modulus, publicExponent);
        }
        return null;
    }
 
    /**
     * 使用指定的公鑰加密數據。
     *
     * @param publicKey 給定的公鑰。
     * @param data 要加密的數據。
     * @return 加密後的數據。
     */
    public static byte[] encrypt(PublicKey publicKey, byte[] data) throws Exception {
        Cipher ci = Cipher.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
        ci.init(Cipher.ENCRYPT_MODE, publicKey);
        return ci.doFinal(data);
    }
 
    /**
     * 使用指定的私鑰解密數據。
     *
     * @param privateKey 給定的私鑰。
     * @param data 要解密的數據。
     * @return 原數據。
     */
    public static byte[] decrypt(PrivateKey privateKey, byte[] data) throws Exception {
        Cipher ci = Cipher.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
        ci.init(Cipher.DECRYPT_MODE, privateKey);
        return ci.doFinal(data);
    }
 
    /**
     * 使用給定的公鑰加密給定的字符串。
     * <p />
     * 若 {@code publicKey} 爲 {@code null}，或者 {@code plaintext} 爲 {@code null} 則返回 {@code
     * null}。
     *
     * @param publicKey 給定的公鑰。
     * @param plaintext 字符串。
     * @return 給定字符串的密文。
     */
    public static String encryptString(PublicKey publicKey, String plaintext) {
        if (publicKey == null || plaintext == null) {
            return null;
        }
        byte[] data = plaintext.getBytes();
        try {
            byte[] en_data = encrypt(publicKey, data);
            return new String(Hex.encodeHex(en_data));
        } catch (Exception ex) {
            LOGGER.error(ex.getCause().getMessage());
        }
        return null;
    }
     
    /**
     * 使用默認的公鑰加密給定的字符串。
     * <p />
     * 若{@code plaintext} 爲 {@code null} 則返回 {@code null}。
     *
     * @param plaintext 字符串。
     * @return 給定字符串的密文。
     */
    public static String encryptString(String plaintext) {
        if(plaintext == null) {
            return null;
        }
        byte[] data = plaintext.getBytes();
        KeyPair keyPair = getKeyPair();
        try {
            byte[] en_data = encrypt((RSAPublicKey)keyPair.getPublic(), data);
            return new String(Hex.encodeHex(en_data));
        } catch(NullPointerException ex) {
            LOGGER.error("keyPair cannot be null.");
        } catch(Exception ex) {
            LOGGER.error(ex.getCause().getMessage());
        }
        return null;
    }
 
    /**
     * 使用給定的私鑰解密給定的字符串。
     * <p />
     * 若私鑰爲 {@code null}，或者 {@code encrypttext} 爲 {@code null}或空字符串則返回 {@code null}。
     * 私鑰不匹配時，返回 {@code null}。
     *
     * @param privateKey 給定的私鑰。
     * @param encrypttext 密文。
     * @return 原文字符串。
     */
    public static String decryptString(PrivateKey privateKey, String encrypttext) {
        if (privateKey == null || StringUtils.isBlank(encrypttext)) {
            return null;
        }
        try {
            byte[] en_data = Hex.decodeHex(encrypttext.toCharArray());
            byte[] data = decrypt(privateKey, en_data);
            return new String(data);
        } catch (Exception ex) {
            LOGGER.error(String.format("\"%s\" Decryption failed. Cause: %s", encrypttext, ex.getCause().getMessage()));
        }
        return null;
    }
     
    /**
     * 使用默認的私鑰解密給定的字符串。
     * <p />
     * 若{@code encrypttext} 爲 {@code null}或空字符串則返回 {@code null}。
     * 私鑰不匹配時，返回 {@code null}。
     *
     * @param encrypttext 密文。
     * @return 原文字符串。
     */
    public static String decryptString(String encrypttext) {
        if(StringUtils.isBlank(encrypttext)) {
            return null;
        }
        KeyPair keyPair = getKeyPair();
        try {
            byte[] en_data = Hex.decodeHex(encrypttext.toCharArray());
            byte[] data = decrypt((RSAPrivateKey)keyPair.getPrivate(), en_data);
            return new String(data);
        } catch(NullPointerException ex) {
            LOGGER.error("keyPair cannot be null.");
        } catch (Exception ex) {
            LOGGER.error(String.format("\"%s\" Decryption failed. Cause: %s", encrypttext, ex.getMessage()));
        }
        return null;
    }
     
    /**
     * 使用默認的私鑰解密由JS加密（使用此類提供的公鑰加密）的字符串。
     *
     * @param encrypttext 密文。
     * @return {@code encrypttext} 的原文字符串。
     */
    public static String decryptStringByJs(String encrypttext) {
        String text = decryptString(encrypttext);
        if(text == null) {
            return null;
        }
        return StringUtils.reverse(text);
    }
     
    /** 返回已初始化的默認的公鑰。*/
    public static RSAPublicKey getDefaultPublicKey() {
        KeyPair keyPair = getKeyPair();
        if(keyPair != null) {
            return (RSAPublicKey)keyPair.getPublic();
        }
        return null;
    }
     
    /** 返回已初始化的默認的私鑰。*/
    public static RSAPrivateKey getDefaultPrivateKey() {
        KeyPair keyPair = getKeyPair();
        if(keyPair != null) {
            return (RSAPrivateKey)keyPair.getPrivate();
        }
        return null;
    }
}



服務端Action中調用RSAUtils工具類
// Struts2 Action方法中：
// 將公鑰的 modulus 和 exponent 傳給頁面。
// Hex -> apache commons-codec
RSAPublicKey publicKey = RSAUtils.getDefaultPublicKey();
            ActionContext.getContext().put("modulus", new String(Hex.encodeHex(publicKey.getModulus().toByteArray())));
            ActionContext.getContext().put("exponent", new String(Hex.encodeHex(publicKey.getPublicExponent().toByteArray())));
 
// 頁面裏，Javascript對明文進行加密：
var modulus = $('#hid_modulus').val(), exponent = $('#hid_exponent').val();
var key = RSAUtils.getKeyPair(exponent, '', modulus);
pwd1 = RSAUtils.encryptedString(key, pwd1);
pwd2 = RSAUtils.encryptedString(key, pwd2);
 
// 服務器端，使用RSAUtils工具類對密文進行解密
RSAUtils.decryptStringByJs(password1);
世逍遙
發佈了18 篇原創文章 · 獲贊 2 · 訪問量 4萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

MySQL注入技巧性研究

0x00 前言MySQL是一個關係型數據庫管理系統，由瑞典MySQL AB 公司開發，目前屬於 Oracle 旗下產品。MySQL 是最流行的關係型數據庫管理系統之一，本人最近針對MySQL注入做了一下研究，針對一些注入技巧進行了分析，本

i春秋论坛 2020-07-07 05:14:23

i春秋在線挑戰詳細攻略-《你是會員嗎》

試驗地址：http://www.ichunqiu.com/racing/54399 實驗平臺：i春秋 Step 0 實驗環境 操作機：Windows XP [172.16.11.2] 目標網址：www.test.ichunqiu  [

i春秋论坛 2020-07-07 05:14:23

MySQL注入技巧性研究

0x00 前言MySQL是一個關係型數據庫管理系統，由瑞典MySQL AB 公司開發，目前屬於 Oracle 旗下產品。MySQL 是最流行的關係型數據庫管理系統之一，本人最近針對MySQL注入做了一下研究，針對一些注入技巧進行了分析，本

i春秋论坛 2020-07-07 05:14:23

WEB程序防SQL注入攻擊程序

場景： WEB程序容易被SQL注入攻擊，攻擊原理是在請求參數中傳入非法字符，造成SQL語句出現出現異常情況，已達到攻擊者想要的結果。 分析： 一般的攻擊者都是在傳入的請求參數上做文章，所以我們重點檢查的是request的參數，判斷requ

成都好男人 2020-07-06 07:55:56

網站安全等級保護制度到底是什麼

隨着時間推移《網絡安全法》的施行，網絡環境早已變成繼“海、陸、空、天”以後的第五個國家安全方面。與此同時網絡安全法明確了國家實行網絡信息安全等級保護測評規章制度以保證在我國網絡環境的安全可靠。網絡信息安全等級保護測評規章制度在我們國家經過

websinesafe 2020-07-02 13:17:33

網站數據如何才安全-雲端備份

很多站長手裏都有幾個網站或一些重要的企業站等，站長在學習做網站時很多老師或教材都會說到網站數據的備份重要性，尤其是當下互聯網安全意識增強，網站的數據安全是重中之重。 很多站長肯定會使用一些手動或簡單定時備份的工具備份到自己的服務

jenkinsli 2020-06-27 04:36:53

xss注入小例子

const httpManager = require('http'); const mysql = require('mysql'); // const urlManager = require('url'); var expre

Sakura__Lu 2020-06-25 04:07:18

我們來做一個不可破解的驗證碼

如果你因爲網站數據一直被爬，如果你因爲活動一直被刷，如果你的短信通道被當成人肉炸彈，如果你的論壇被機器人野蠻刷帖，如果你的賬戶系統一直被暴力破解，如果你用了各種驗證碼包括極驗也根本沒用，你可以來這裏瞭解一下 https://yuan.sh

宁无竹 2020-06-22 13:14:49

安全設計--CSRF跨站僞造

概念 定義 CSRF跨站點請求僞造(Cross—Site Request Forgery)：顧名思義，攻擊者僞造用戶請求請求服務端，但並非在官方站點發起，而是攻擊者的站點，或者攻擊者的腳本。而服務器認爲卻是合法的，有點借刀殺人的

yanbincn 2020-06-19 18:22:18

web-security第二期：Spring Security 框架概覽

閱讀本文之前，我默認您已經掌握 spring-web spring-boot 的基礎知識 本文的編寫依據是  Spring Security 官方文檔 Spring Security 是一個安全框架，前身是 Acegi Security，

秋.凝 2020-06-16 01:41:08

織夢DEDECMS安全防護設置及漏洞修復

一、程序一定要從織夢官網下載，其他地方下載的不能保證安全。 二、下載後的程序在正常運行後，要刪除下列文件夾（根據你的需要選擇刪除）。 member 會員文件夾整個刪除 special 專題文件夾整個刪除 install 安裝文件夾

丈哥SEO 2020-06-15 09:18:25

[網站安全]ngiinx設置如何屏蔽ip訪問網站

打開nginx配置文件，目錄一般爲/etc/nginx/sites-available sudo vi default進入 # 屏蔽ip訪問  注意是下面是隻對80端口生效 server {         listen 80 defau

大白白白白白白 2020-06-15 02:05:45

node中常用的幾大模塊

       最近一段時間工作不是很忙，抽空學習了一下node相關的知識，打算接下來學習一下VUE框架，配合VUE框架做一個小Demo。下面是小編總結的node中幾個常用的模塊。 Node中的模塊分爲三種類型： node天生自帶的模塊（核

青春微凉不悲伤 2020-06-14 09:44:41

Activex打包於發佈完整版---ActiveX打包

前面介紹了數字證書的原理與製作：http://blog.csdn.net/jiangtongcn/article/details/13508365，下面來看一下ActiveX組件的打包。 我現在有一個ActiveX組件：fq.ocx,目的

jiangtongcn 2020-06-13 07:39:30

Activex打包於發佈完整版---微軟證書製作

        衆所周知,Activex組件沒有進行有效的簽名，在IE上無法安裝的，除非你讓用戶手工開啓“接收任何未簽名的ActiveX”，這個很明顯不現實。而組件簽名需要證書,證書從哪裏來，你可以選擇付1000到3000元不等在專門的機

jiangtongcn 2020-06-13 07:39:30