奋斗的小青年~

Java安全开发注意事项

互联网安全架构设计

前言
一、如何防御xss攻击？
二、抓包如何防止篡改数据？
三、对接口实现加密
四、相关安全架构设计方案说明

前言

本文是对Java开发做安全的架构设计。

一、如何防御xss攻击？

攻击场景说明：在客户端发起请求时，如果URL的请求参数被篡改为网页脚本的话，而且后台没有对参数做处理的话，在当前页面中会受到恶意攻击。
如何解决：在后台编写一个过滤器，对后台接收到的请求参数做过滤处理。
代码说明：

@Component
@WebFilter
public class XssFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //重写该方法（对接收的参数做处理）
        XssHttpServletRequestWrapper xssHttpServletRequestWrapper = new XssHttpServletRequestWrapper((HttpServletRequest) request);
        chain.doFilter(xssHttpServletRequestWrapper, response);
    }

    @Override
    public void destroy() {

    }
}

```java
public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private HttpServletRequest request;

    public XssHttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
        this.request = request;
    }

    @Override
    //重写该方法，对接收到的参数做过滤处理
    public String getParameter(String name) {
        String oldValue = super.getParameter(name);
        if(StringUtils.isEmpty(oldVa[添加链接描述](https://pc.qq.com/detail/10/detail_3330.html)lue)){
            return oldValue;
        }
        String newValue = StringEscapeUtils.escapeHtml4(oldValue);
        return newValue;
    }
    
}

二、抓包如何防止篡改数据？

攻击场景说明：可以使用第三方抓包工具，对请求前后实现代理，可以修改参数请求内容和参数响应内容。
Fiddler4抓包工具下载地址：

https://pc.qq.com/detail/10/detail_3330.html

使用Fiddler4篡改请求之前：

解决方案：
使用MD5对参数做加密处理，防止参数被篡改
使用MD5可以直接验证签名参数 MD5 属于单向加密，只能够暴力破解。
MD5应用场景：在nacos分布式配置中心中，使用MD5 比对文件内容是否发生改变

MD5在线暴力破解地址：https://www.cmd5.com/

三、对接口实现加密

攻击场景说明：对接口实现对称加密，抓包的时候看不到明文的数据，但是可以被破解，因为客户端与服务器都是采用同一个密钥实现加解密，可以通过反编译客户端代码得出密钥实现破解。
对称加密

加密和解密都是同一个秘钥
优势：算法公开、加密快、效率高。
缺点：可以采用反编译破解客户端真实秘钥

常用对称加密框架：
1.DES（Data Encryption Standard）
2.3DES（DES加强版，使用3次DES计算，Triple DES，DESede）
3.AES（Advanced Encryption Standard，3DES加强版）

工具类代码如下：

/**
 * 字符串加密解密工具，可逆加密，秘钥很重要，一定要自己改秘钥，打死也不要告诉其他人
 */
public class DESUtil {

    // 密钥，是加密解密的凭据，长度为8的倍数
    private static String PASSWORD_CRYPT_KEY = "12345678";
    private final static String DES = "DES";

    /**
     * 加密
     *
     * @param src 数据源
     * @param key 密钥，长度必须是8的倍数
     * @return 返回加密后的数据
     * @throws Exception
     */
    public static byte[] encrypt(byte[] src, byte[] key) throws Exception {

        // DES算法要求有一个可信任的随机数源
        SecureRandom sr = new SecureRandom();

        // 从原始密匙数据创建DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(key);

        // 创建一个密匙工厂，然后用它把DESKeySpec转换成
        // 一个SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);

        SecretKey securekey = keyFactory.generateSecret(dks);

        // Cipher对象实际完成加密操作
        Cipher cipher = Cipher.getInstance(DES);

        // 用密匙初始化Cipher对象
        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);

        // 现在，获取数据并加密
        // 正式执行加密操作
        return cipher.doFinal(src);

    }

    /**
     * 解密
     *
     * @param src 数据源
     * @param key 密钥，长度必须是8的倍数
     * @return 返回解密后的原始数据
     * @throws Exception
     */
    public static byte[] decrypt(byte[] src, byte[] key) throws Exception {

        // DES算法要求有一个可信任的随机数源
        SecureRandom sr = new SecureRandom();
        // 从原始密匙数据创建一个DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(key);

        // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成
        // 一个SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);

        SecretKey securekey = keyFactory.generateSecret(dks);

        // Cipher对象实际完成解密操作
        Cipher cipher = Cipher.getInstance(DES);

        // 用密匙初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, securekey, sr);

        // 现在，获取数据并解密
        // 正式执行解密操作
        return cipher.doFinal(src);

    }

    /**
     * 密码解密
     *
     * @param data
     * @return
     * @throws Exception
     */
    public final static String decrypt(String data) {

        try {
            return new String(decrypt(hex2byte(data.getBytes()), PASSWORD_CRYPT_KEY.getBytes()));
        } catch (Exception e) {

        }
        return null;
    }

    /**
     * 密码加密
     *
     * @param password
     * @return
     * @throws Exception
     */
    public final static String encrypt(String password) {
        try {
            return byte2hex(encrypt(password.getBytes(), PASSWORD_CRYPT_KEY.getBytes()));
        } catch (Exception e) {

        }
        return null;
    }

    /**
     * 二行制转字符串
     *
     * @param b
     * @return
     */
    public static String byte2hex(byte[] b) {

        String hs = "";
        String stmp = "";
        for (int n = 0; n < b.length; n++) {
            stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
            if (stmp.length() == 1)
                hs = hs + "0" + stmp;
            else
                hs = hs + stmp;
        }
        return hs.toUpperCase();
    }

    public static byte[] hex2byte(byte[] b) {

        if ((b.length % 2) != 0)
            throw new IllegalArgumentException("长度不是偶数");
        byte[] b2 = new byte[b.length / 2];
        for (int n = 0; n < b.length; n += 2) {
            String item = new String(b, n, 2);
            b2[n / 2] = (byte) Integer.parseInt(item, 16);
        }
        return b2;
    }

    // 测试用例，不需要传递任何参数，直接执行即可。
    public static void main(String[] args) {
        String basestr = "mayikt";
        String str1 = encrypt(basestr);
        System.out.println("原始值: " + basestr);
        System.out.println("加密后: " + str1);
        System.out.println("解密后: " + decrypt(str1));
    }

}

非对称加密
公钥和私钥互换，生成一对秘钥对，分别为公钥和私钥。

公钥加密，必须私钥解密
私钥加密，必须公钥解密
所以在很多支付接口中为了保证安全性，客户端采用公钥加密，服务器端采用私钥解密，就算别人客户端的公钥，也无法解密，因为解密数据必须要私钥，而私钥存放在服务器端。
最为著名的就是RSA