客戶端安全傳輸密碼至服務端的實現改進

来源:https://www.cnblogs.com/linjisong/archive/2018/04/09/8748683.html
-Advertisement-
Play Games

兩年前在做Java EE開發平臺時，因為用戶登錄相關的模塊是委托給另一位同事完成的，所以雖然知道大體概念，但是對客戶端怎麼安全傳輸密碼到服務端的具體細節並不甚瞭解。然而這次在做4A系統（認證、授權、監控、審計）時，無論怎樣都繞不過這一塊內容了，於是在仔細研究了一下之前的方案，並參考網上的一些資料後， ...


兩年前在做Java EE開發平臺時，因為用戶登錄相關的模塊是委托給另一位同事完成的，所以雖然知道大體概念，但是對客戶端怎麼安全傳輸密碼到服務端的具體細節並不甚瞭解。然而這次在做4A系統（認證、授權、監控、審計）時，無論怎樣都繞不過這一塊內容了，於是在仔細研究了一下之前的方案，並參考網上的一些資料後，做了一些改進，特此記錄一下。

總體方案

  1. 服務端生成RSA密鑰對，並將公鑰返回給客戶端
  2. 客戶端在提交登錄時，將密碼使用公鑰加密，傳輸給服務端
  3. 服務端收到登錄請求後，使用私鑰解密，併進行下一步處理

方案很簡單，也很容易理解，只需要知道非對稱加密的一般概念即可，但是在具體的實現時還是有一些細節需要註意的。

原有的實現（實際上同事也是參考了網上的資料）

  1. 創建一個表BF_KEY_CFG（module，public_empoent，private_empoent VARCHAR(200)）
    這裡需要對RSA的具體實現有一點點瞭解，知道模、公鑰指數、私鑰指數等概念。
  2. 引入加密工具包bouncycastle-1.0.jar，在系統每次啟動的時候，利用該工具包生成密鑰對（模、公鑰指數、私鑰指數）並保存到資料庫
  3. 在客戶端提交登錄時，先從伺服器獲取公鑰，然後再加密發送登錄請求
  4. 服務端在進行密碼驗證前，先用私鑰解密，然後再進行其他認證處理

這個實現有幾個問題：

  1. 創建的表包含三個欄位（模、公鑰指數、私鑰指數）並不那麼容易理解，不像公鑰、私鑰那麼大眾化
  2. 需要額外引入第三方包
  3. 多個服務端節點時，啟動時會有潛在的衝突
  4. 使用的JS加密演算法，在服務端解密時，出現順序顛倒的問題，因此也不能很好的處理中文等字元
  5. 在提交登錄時，是重寫了原來的密碼表單域的值，導致不能記住密碼（每次加密的公鑰不相同）
  6. 在服務端，也不能很好的利用Spring MVC的表單校驗，比如需要自己單獨寫邏輯判斷密碼長度不能大於16等

此外，網上的資料大都是你抄我、我抄你，一些基本的工具類代碼都很醜陋，到處充斥著重覆的代碼。

改進後的實現

改進主要是針對上面提到的問題進行的。

  1. 首先，表欄位只保留PUBLIC_KEY、PRIVATE_KEY
  2. 其次，使用JDK原生的加密provider
  3. 解決JS和JAVA加解密順序顛倒的問題，從而也解決了中文加密問題
  4. 在前端設置一個隱藏域，提交登錄表單時，先將隱藏域的值設置為加密後的密碼，然後將表單域設置為disable（從而不會傳送至後臺），最後再提交登錄表單，登錄失敗返回登錄頁時重新啟用密碼域，這樣可以解決記住密碼，回退到登錄頁等許多問題
  5. 在Spring MVC綁定參數後，進行參數校驗前，進行解密，從而可以利用Spring MVC的原生校驗

這幾個改進，前端使用JSEncrypt庫配合jQuery非常容易實現

後端則主要包括兩個部分：加密工具類、Spring MVC參數綁定後和參數校驗前的處理邏輯插入

（1）加密工具類：

import java.security.NoSuchAlgorithmException;
import java.security.Provider;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;

import org.springframework.util.Base64Utils;//在JDK8中可以直接使用JDK原生Base64工具類

/* package */ class CryptoUtils {

    protected static final SecureRandom random = new SecureRandom();

    /**
     * 獲取Provider對象：註意單例
     * 
     * 方便使用其它的Provider
     * @return
     */
    protected static Provider getProvider() {
        return null;//provider;
    }

    /**
     * 位元組轉換為字元串
     * 
     * @param data
     * @return
     */
    protected static String encodeToString(byte[] data) {
        return Base64Utils.encodeToString(data);
    }

    /**
     * 字元串轉換為位元組
     * 
     * @param src
     * @return
     */
    protected static byte[] decodeFromString(String src) {
        return Base64Utils.decodeFromString(src);
    }

    /**
     * 獲取Cipher對象
     * 
     * @param keyAlgorithm
     * @return
     */
    protected static Cipher getCipher(String keyAlgorithm) {
        try {
            Provider provider = getProvider();
            Cipher cipher = null;
            if (null == provider) {
                cipher = Cipher.getInstance(keyAlgorithm);
            } else {
                cipher = Cipher.getInstance(keyAlgorithm, provider);
            }
            return cipher;
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        } catch (NoSuchPaddingException e) {
            throw new RuntimeException(e);
        }
    }
}
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.Serializable;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;

public class RSAUtils extends CryptoUtils {

    /**
     * 加密演算法RSA
     */
    private static final String KEY_ALGORITHM = "RSA";

    /**
     * 生成RSA密鑰對
     */
    public static RsaKeyPair getRsaKeyPair() {
        try {
            KeyPairGenerator keyPairGen = null;
            Provider provider = getProvider();
            if (null == provider) {
                keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
            } else {
                keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM, provider);
            }
            keyPairGen.initialize(1024, random);
            KeyPair keyPair = keyPairGen.generateKeyPair();
            String privateKey = encodeToString(keyPair.getPrivate().getEncoded());
            String publicKey = encodeToString(keyPair.getPublic().getEncoded());
            return new RsaKeyPair(publicKey, privateKey);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 獲取公鑰
     * 
     * @param publicKey
     * @return
     */
    public static PublicKey getPublicKey(String publicKey) {
        try {
            byte[] bytes = decodeFromString(publicKey);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(bytes);
            PublicKey pk = getKeyFactory().generatePublic(x509KeySpec);
            return pk;
        } catch (InvalidKeySpecException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 獲取私鑰
     * 
     * @param privateKey
     * @return
     */
    public static PrivateKey getPrivateKey(String privateKey) {
        try {
            byte[] bytes = decodeFromString(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(bytes);
            PrivateKey pk = getKeyFactory().generatePrivate(pkcs8KeySpec);
            return pk;
        } catch (InvalidKeySpecException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 公鑰加密
     * 
     * @param plainText
     * @param publicKey
     * @return
     */
    public static String encryptByPublicKey(String plainText, String publicKey) {
        Cipher cipher = getCipher(true, publicKey, true);
        byte[] src = plainText.getBytes();
        byte[] datas = cipherData(cipher, src, 117);
        return encodeToString(datas);
    }

    /**
     * 私鑰加密
     * 
     * @param plainText
     * @param privateKey
     * @return
     */
    public static String encryptByPrivateKey(String plainText, String privateKey) {
        Cipher cipher = getCipher(true, privateKey, false);
        byte[] src = plainText.getBytes();
        byte[] datas = cipherData(cipher, src, 117);
        return encodeToString(datas);
    }

    /**
     * 公鑰解密
     * 
     * @param plainText
     * @param publicKey
     * @return
     */
    public static String decryptByPublicKey(String encryptText, String publicKey) {
        Cipher cipher = getCipher(false, publicKey, true);
        byte[] src = decodeFromString(encryptText);
        byte[] datas = cipherData(cipher, src, 128);
        return new String(datas);
    }

    /**
     * 私鑰解密
     * 
     * @param encryptText
     * @param privateKey
     * @return
     */
    public static String decryptByPrivateKey(String encryptText, String privateKey) {
        Cipher cipher = getCipher(false, privateKey, false);
        byte[] src = decodeFromString(encryptText);
        byte[] datas = cipherData(cipher, src, 128);
        return new String(datas);
    }

    /**
     * 獲取KeyFactory對象
     * 
     * @return
     */
    private static KeyFactory getKeyFactory() {
        try {
            Provider provider = getProvider();
            if (null == provider) {
                return KeyFactory.getInstance(KEY_ALGORITHM);
            } else {
                return KeyFactory.getInstance(KEY_ALGORITHM, provider);
            }
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 獲取Cipher對象
     * 
     * @param encode
     * @param keyString
     * @param isPublicKey
     * @return
     */
    private static Cipher getCipher(boolean encode, String keyString, boolean isPublicKey) {
        try {
            Key key = isPublicKey ? getPublicKey(keyString) : getPrivateKey(keyString);
            Cipher cipher = getCipher(KEY_ALGORITHM);
            cipher.init(encode ? Cipher.ENCRYPT_MODE : Cipher.DECRYPT_MODE, key);
            return cipher;
        } catch (InvalidKeyException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 加解密數據
     * 
     * @param cipher
     * @param src
     * @param blockSize
     * @return
     */
    private static byte[] cipherData(Cipher cipher, byte[] src, int blockSize) {
        ByteArrayOutputStream out = null;
        try {
            int inputLen = src.length;
            out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > blockSize) {
                    cache = cipher.doFinal(src, offSet, blockSize);
                } else {
                    cache = cipher.doFinal(src, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * blockSize;
            }
            return out.toByteArray();
        } catch (IllegalBlockSizeException e) {
            throw new RuntimeException(e);
        } catch (BadPaddingException e) {
            throw new RuntimeException(e);
        } finally {
            if (null != out) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * RSA密鑰對象
     */
    public static class RsaKeyPair implements Serializable {

        private static final long serialVersionUID = 2130689702406754025L;

        /**
         * 公鑰
         */
        private String publicKey;

        /**
         * 私鑰
         */
        private String privateKey;

        public RsaKeyPair() {}

        public RsaKeyPair(String publicKey, String privateKey) {
            this.publicKey = publicKey;
            this.privateKey = privateKey;
        }

        public String getPublicKey() {
            return publicKey;
        }

        public void setPublicKey(String publicKey) {
            this.publicKey = publicKey;
        }

        public String getPrivateKey() {
            return privateKey;
        }

        public void setPrivateKey(String privateKey) {
            this.privateKey = privateKey;
        }
    }
}

（2）參數綁定後、校驗前的邏輯插入

實際上只要跟蹤調試一下，就可以發現關鍵在於ExtendedServletRequestDataBinder，覆蓋兩個方法即可：

import javax.servlet.ServletRequest;

import org.springframework.beans.MutablePropertyValues;
import org.springframework.validation.AbstractPropertyBindingResult;
import org.springframework.web.servlet.mvc.method.annotation.ExtendedServletRequestDataBinder;

/* package */ class RelaxedServletRequestDataBinder extends ExtendedServletRequestDataBinder {

    public RelaxedServletRequestDataBinder(Object target) {
        super(target);
    }

    public RelaxedServletRequestDataBinder(Object target, String objectName) {
        super(target, objectName);
    }

    /**
     * 添加屬性值提供器的相關處理
     */
    @Override
    protected void addBindValues(MutablePropertyValues mpvs, ServletRequest request) {
        super.addBindValues(mpvs, request);
        PropertyValuesProviders.addBindValues(mpvs, request, getTarget(), getObjectName());
    }

    /**
     * 常規綁定之後的處理
     */
    @Override
    public void bind(ServletRequest request) {
        super.bind(request);
        PropertyValuesProviders.afterBindValues(getPropertyAccessor(), request, getTarget(), getObjectName());
    }

    @Override
    protected AbstractPropertyBindingResult createBeanPropertyBindingResult() {
        return new RelaxedBeanPropertyBindingResult(getTarget(), getObjectName(), isAutoGrowNestedPaths(), getAutoGrowCollectionLimit());
    }
}

這個類只是提供一個入口，真正的邏輯委托給了PropertyValuesProviders處理。在我的實現中，這裡提取了一個介面：

import javax.servlet.ServletRequest;

import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.PropertyAccessor;

public interface IPropertyValuesProvider {//感謝JDK8中的預設實現

    default void addBindValues(MutablePropertyValues mpvs, ServletRequest request, Object target, String name) {};

    default void afterBindValues(PropertyAccessor accessor, ServletRequest request, Object target, String name) {};
}

import java.util.List;

import javax.servlet.ServletRequest;

import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.PropertyAccessor;
import org.springframework.beans.factory.annotation.Autowired;

public class PropertyValuesProviders {

    private static List<IPropertyValuesProvider> providers;

    @Autowired(required = false)
    public void setProviders(List<IPropertyValuesProvider> providers) {
        if (providers != null) {
            PropertyValuesProviders.providers = providers;
        }
    }

    public static void addBindValues(MutablePropertyValues mpvs, ServletRequest request, Object target, String name) {
        if (null != providers) {
            for (IPropertyValuesProvider provider : providers) {
                provider.addBindValues(mpvs, request, target, name);
            }
        }
    }

    public static void afterBindValues(PropertyAccessor accessor, ServletRequest request, Object target, String name) {
        if (null != providers) {
            for (IPropertyValuesProvider provider : providers) {
                provider.afterBindValues(accessor, request, target, name);
            }
        }
    }
}

然後添加RSA解密的實現：

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import javax.servlet.ServletRequest;

import org.springframework.beans.PropertyAccessor;

import com.autumn.platform.core.crypto.RSAUtils;
import com.autumn.platform.core.crypto.RSAUtils.RsaKeyPair;
import com.autumn.platform.core.logger.Logs;
import com.autumn.platform.web.annotation.RsaDecrypt;

public abstract class AbstractRsaDecryptPropertyValuesProvider implements IPropertyValuesProvider {

    private Map<Class<?>, List<Field>> cache = new ConcurrentHashMap<Class<?>, List<Field>>();

    @Override
    public void afterBindValues(PropertyAccessor accessor, ServletRequest request, Object target, String name) {
        RsaKeyPair pair = this.getRsaKeyPair(accessor, request, target, name);
        if (null == pair) {
            return;
        }
        for (Class<?> cls = target.getClass(); !cls.equals(Object.class); cls = cls.getSuperclass()) {
            List<Field> fields = resolveFields(cls);
            if (null != fields && !fields.isEmpty()) {
                for (Field field : fields) {
                    setDecryptValue(target, pair, field);
                }
            }
        }
    }

    abstract protected RsaKeyPair getRsaKeyPair(PropertyAccessor accessor, ServletRequest request, Object target, String name);

    private void setDecryptValue(Object target, RsaKeyPair pair, Field field) {
        try {
            Object value = field.get(target);
            if (value instanceof String) {
                String text = RSAUtils.decryptByPrivateKey((String) value, pair.getPrivateKey());
                field.set(target, text);
            }
        } catch (Exception e) {
            Logs.error("解密" + field + "的值時出現異常", e);
        }
    }

    private List<Field> resolveFields(Class<?> cls) {
        List<Field> fieldList = cache.get(cls);
        if (null == fieldList) {
            fieldList = new ArrayList<Field>();
            Field[] fields = cls.getDeclaredFields();
            if (null != fields) {
                for (Field field : fields) {
                    if (field.isAnnotationPresent(RsaDecrypt.class)) {
                        if (!field.isAccessible()) {
                            field.setAccessible(true);
                        }
                        fieldList.add(field);
                    }
                }
            }
            if (fieldList.isEmpty()) {
                fieldList = Collections.emptyList();
            }
            cache.put(cls, fieldList);
        }
        return fieldList;
    }
}

其中@RsaDecrypt註解是自定義的，用於表示這個表單欄位在接受參數時，需要先使用RSA解密。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Array-slice
    實用場景 一（處理類數組 如 arguments ） ...
  • JS-實用方法整理
    // 深拷貝 // 判斷類型 console.log(checkType(1)); //[object Number] console.log(checkType('1')); //[object String] console.log(checkType(true)); //[object Boo ...
  • vue組件詳解（一）——組件與復用
    一、什麼是組件 組件 (Component) 是 Vue.js 最強大的功能之一。組件可以擴展 HTML 元素，封裝可重用的代碼。 二、組件用法 組件需要註冊後才可以使用，註冊有全局註冊和局部註冊兩種方式。 2.1 全局註冊後，任何V ue 實例都可以使用。如： 要在父實例中使用這個組件，必須要在實 ...
  • vue表單詳解——小白速會
    一、基本用法 你可以用 v-model 指令在表單 <input> 及 <textarea> 元素上創建雙向數據綁定。 但 v-model 本質上不過是語法糖。它負責監聽用戶的輸入事件以更新數據，並對一些極端場景進行一些特殊處理。 v-model 會忽略所有表單元素的 value、checked、s ...
  • ES6學習筆記(10)----Set和Map數據結構
    參考書《ECMAScript 6入門》http://es6.ruanyifeng.com/Set和Map數據結構1.Set 基本用法 Set是一種新的數據結構，它的成員都是唯一的不重覆的。 let s1 = new Set(); s1.add({"name":"123"}); s1 // Set(1 ...
  • Nginx+Tomcat高性能負載均衡集群搭建
    轉載請註明出處：http://www.cnblogs.com/Joanna-Yan/p/8745794.html Nginx是一個高性能的HTTP伺服器/反向代理伺服器及電子郵件（IMAP/POP3）代理伺服器。其占有記憶體少，併發能力強，在同類型的網頁伺服器中表現較好。Nginx可以在大多數Unix ...
  • java學習--MAP集合類
    1.map集合遍歷方式 :keyset()方法 得到map集合中所有的鍵，裝到set集合中；然後可通過set集合作遍歷。 public class mapdemo { public static void main(String[] args) { //1.調用map集合的方法keyset，把所有的 ...
  • C++編程實現對工廠產品生產流程的模擬
    花費二個多月的時間編寫了可以實時模擬工廠產品生產流程的程式，工廠產品生產流程的模擬，就是計算在工藝文件所規定的工序下，不同種類的多件產品(同一類別的產品可以有多件)在不同類別的多台設備(同一類別的設備可以有多台)上全部生產完畢所需的總時間。每一件產品可以在生產流程中先後多次在同一類設備上生產而且生產 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類