JS前端加密 后端java解密

问题背景:

　　前几天项目做渗透测试的时候出现了两个高危漏洞

经过排查发现是因为前端在登录的时候没有对密码等用户信息做加密处理

解决方案: 

　　做一下最简单的处理,前端采用JS自带的 atob加密,后端采用工具解密

前端JS代码:

//加密字符串,可以先将中文加密，然后再用btoa加密
      encryption(str) {
        var encStr = encodeURIComponent(str);
        encStr = btoa(encStr);
        return encStr;
      },

      //解密，可以先将ascii解密，然后再将非ascii解密
      decrypt(str) {
        var decStr = atob(str);
        decStr = decodeURIComponent(decStr);
        return decStr;
      },

后端Java代码:

package com.fudian.project.system.utils;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;

/**
 * Window.atob 加解密
 * @author ZYGisComputer
 */
public class BtoaEncode {

    public static void main(String[] args) {
        String admin = BtoaEncode.encryption("admin");
        System.out.println(admin);
        System.out.println(BtoaEncode.decrypt(admin));
    }

    private static String base64hash = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    public static boolean isMatcher(String inStr, String reg) {
        Pattern pattern = Pattern.compile(reg);
        Matcher matcher = pattern.matcher(inStr);
        if (matcher.matches()) {
            return true;
        }
        return false;
    }

    /**
     * btoa method
     * @param inStr
     * @return
     */
    public static String btoa(String inStr) {

        if (inStr == null || isMatcher(inStr, "([^\u0000-\u00ff])")) {
            return null;
        }

        StringBuilder result = new StringBuilder();
        int i = 0;
        int mod = 0;
        int ascii;
        int prev = 0;
        while (i < inStr.length()) {
            ascii = inStr.charAt(i);
            mod = i % 3;
            switch (mod) {
                case 0:
                    result.append(String.valueOf(base64hash.charAt(ascii >> 2)));
                    break;
                case 1:
                    result.append(String.valueOf(base64hash.charAt((prev & 3) << 4 | (ascii >> 4))));
                    break;
                case 2:
                    result.append(String.valueOf(base64hash.charAt((prev & 0x0f) << 2 | (ascii >> 6))));
                    result.append(String.valueOf(base64hash.charAt(ascii & 0x3f)));
                    break;
            }
            prev = ascii;
            i++;
        }
        if (mod == 0) {
            result.append(String.valueOf(base64hash.charAt((prev & 3) << 4)));
            result.append("==");
        } else if (mod == 1) {
            result.append(String.valueOf(base64hash.charAt((prev & 0x0f) << 2)));
            result.append("=");
        }
        return result.toString();
    }

    /**
     * atob method  逆转encode的思路即可
     * @param inStr
     * @return
     */
    public static String atob(String inStr) {
        if (inStr == null)
            return null;
        inStr = inStr.replaceAll("\s|=", "");
        StringBuilder result = new StringBuilder();
        int cur;
        int prev = -1;
        int mod;
        int i = 0;
        while (i < inStr.length()) {
            cur = base64hash.indexOf(inStr.charAt(i));
            mod = i % 4;
            switch (mod) {
                case 0:
                    break;
                case 1:
                    result.append(String.valueOf((char) (prev << 2 | cur >> 4)));
                    break;
                case 2:

                    result.append(String.valueOf((char) ((prev & 0x0f) << 4 | cur >> 2)));
                    break;
                case 3:

                    result.append(String.valueOf((char) ((prev & 3) << 6 | cur)));
                    break;
            }
            prev = cur;
            i++;
        }
        return result.toString();
    }

    /**
     * 加密字符串
     * @return
     */
    public static String encryption(String str) {
        String encode;
        try {
            encode = URLEncoder.encode(str,"utf-8");
            //URLEncoder.encode 会将空格解释为+号
            encode=encode.replaceAll("\+", "%20");
            String btoa = BtoaEncode.btoa(encode);
            return btoa;
        } catch (UnsupportedEncodingException e) {
            System.out.println("btoa加密函数出现错误。");
        }
        return str;
    }

    /**
     * 解密字符串
     * @return
     */
    public static String decrypt(String str) {
        String atob = BtoaEncode.atob(str);
        try {
            String decode = URLDecoder.decode(atob, "utf-8");
            return decode;
        } catch (UnsupportedEncodingException e) {
            System.out.println("atob加密函数出现错误。");
        }
        return str;
    }

}

测试:

前端测试:

 通过输入密码为admin加密后得到 YW... 解密后得到admin 

后端测试:

 和前端一致,这样才能做到加密解密的效果

建议:

　　整体来说就是一次最简单的加密解密,当然这个相对不是特别安全,可以在这个基础之上,对等于号做一些处理,再通过一些其他的算法来多次加密也可以,最好是一些带随机盐的

作者：彼岸舞

时间：20201223

内容关于：工作中用到的小技术

本文来源于网络，只做技术分享，一概不负任何责任