Python 爬取 热词并进行分类数据分析-[安全性改造]

日期：2020.03.01

博客期：159

星期日

　　【本博客的代码如若要使用，请在下方评论区留言，之后再用（就是跟我说一声）】

　　　　所有相关跳转：

　　　　a.【简单准备】

　　　　b.【云图制作+数据导入】

　　　　c.【拓扑数据】

　　　　d.【数据修复】

　　　　e.【解释修复+热词引用】

　　 　　f.【JSP演示+页面跳转】

　　　　g.【热词分类+目录生成】

　　　　h.【热词关系图+报告生成】

　　　　i . 【App制作】

　　　　j . 【安全性改造】（本期博客）

---

 　　我打算从五方面去实现安全性的保障！

　　1、访问的数据库权限

　　　　因为毕竟在做项目的时候，只是需要从数据库中抽取数据，并不需要对其进行增加、删除或修改。所以，我们 DBLink 需要使用仅支持复合查询或者简单查询的用户来访问数据库！这样，就不怕代码被恶意篡改了，反正你这个用户只能“读”！

　　

　　2、访问的语句要实现完整！

　　　　这个是怎么一回事呢？就是我们平常使用的 sql 查询语句结构可以是 Select * From ... 这样的结构很容易被推算出我们数据表的表结构！这样也不好！不安全！

　　　　本片博客会以本人的大二的一个《石家庄地铁线路》的项目为例子（热词分析的部分已经改造好了，但是要等到开学我再公布），那个项目如果说仅仅从实现的角度来说的话，我觉得已经比较完美了，所有现在咱们来找一下它的其他方面的问题。

　　　　地铁线路表的结构如下：

 　　　　我们对上面的 line 表进行查询的时候，写 Select 要写全， like this: select code as code ,name as name ,line1 as line1 ,seat1 as seat1 ,line2 as line2, seat2 as seat2 from line

　　　　不可以使用 Select * From line ! 这样相当于直接给数据看！

　　3、输入查询数据的内部监听

　　　　我们要到我们的 Servlet 层来做数据的错误检测，因为 js 层可以在浏览器上篡改！

　　　　对的，我要提醒大家 html 文件和 jsp 文件最好不要写 javascript 的内容，有需要的话把它写到 js 文件里，然后内部调用就好了！我们使用浏览器打开有一个程序员调试模式，打开以后可以直接性的修改我们的内容。如果你的健壮性与页面上的存储内容有关，那么用户的 “瞎操作” 就极有可能对整个项目的运转产生不可磨灭的影响。

　　　　对于调用 Servlet 传参数是使用 doPost 好，还是 doGet 好呢？处于安全性的考虑，我给你的建议是 doPost 。

　　4、数据的加密（如果没有涉及密码，就没有做的必要了）

　　　　不过，我会简单介绍一下，想不想制造一个密码管理器？在保存密码的时候以自定义的方式将密码加密，连同加密方法，一并保存到文件或数据库中！我现在一般都是使用 DES 的加密算法，IDEA加密算法怎么说呢，加密好用，解密不好用。

　　　　我之前有过一期博客是专门讲加密的，而且附有封装的 Java 包。

　　　　所以，这里就简单给大家看一下：（测试用例就在类中）

package test;

import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;

import com.sun.org.apache.xml.internal.security.exceptions.Base64DecodingException;
import com.sun.org.apache.xml.internal.security.utils.Base64;

import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;

@SuppressWarnings("unused")
public class DESDemo {
    public static void main(String[] args) {
        String clearText ="hello";
        String originKey ="12345678";
        try {
            String cipherText = desEncrpt(clearText,originKey);
            System.out.println(cipherText);
            String clearText2 = desDecrpt(cipherText,originKey);
            System.out.println(clearText2);
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
    }
    //ÓÃDESËã·¨½øÐнâÃÜ
    public static String desDecrpt(String cipherText, String originKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        //»ñÈ¡¼ÓÃÜÀà¶ÔÏó
        Cipher cipher =Cipher.getInstance("DES");
        SecretKey key =getKey(originKey);
        //¶Ô¼ÓÃÜÀà¶ÔÏó½øÐгõʼ»¯
        //mode:¼ÓÃÜ/½âÃÜ
        //key:¶ÔԭʼÃØÔ¿´¦ÀíÖ®ºóµÄÃØÔ¿
        cipher.init(Cipher.DECRYPT_MODE,key);
        byte[] decodebytes = null;
        try {
            decodebytes = Base64.decode(cipherText);
        } catch (Base64DecodingException e) {
            System.out.println("Ò¯Ò¯£¡ÄúµÄ³ÌÐò±¨´íÀ²£¡³öÏÖ Base64DecodingException À²£¡");
        }
        //ʹÓüÓÃܹ¤¾ßÀà¶ÔÏó¶ÔÃ÷ÎĽøÐнâÃÜ ±ä³ÉÃ÷ÎÄ
        byte[] doFinal= cipher.doFinal(decodebytes);
       // String encodetext =Base64.encode(doFinal);
        return new String(doFinal);
    }
    
    //ÓÃDESËã·¨½øÐмÓÃÜ£ºÍ¨¹ý¶Ô±ÈÌØΪ½øÐÐÊýѧÔËËã
    public static String desEncrpt(String clearText, String originKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        //»ñÈ¡¼ÓÃÜÀà¶ÔÏó
        Cipher cipher = Cipher.getInstance("DES");
        SecretKey key = getKey(originKey);
        //¶Ô¼ÓÃÜÀà¶ÔÏó½øÐгõʼ»¯
        //mode:¼ÓÃÜ/½âÃÜ
        //key:¶ÔԭʼÃØÔ¿´¦ÀíÖ®ºóµÄÃØÔ¿
        cipher.init(Cipher.ENCRYPT_MODE,key);
        //ʹÓüÓÃܹ¤¾ßÀà¶ÔÏó¶ÔÃ÷ÎĽøÐмÓÃÜ ±ä³ÉÃÜÎÄ
        byte[] doFinal= cipher.doFinal(clearText.getBytes());
        //System.out.println(doFinal);
           String encode = Base64.encode(doFinal);
        return encode;
    }
    //»ñÈ¡SecretKey
    private static SecretKey getKey(String originKey) {
        //²»¹» ³õʼֵΪ0
        byte[]buffer = new byte[8];
        //»ñÈ¡Óû§ÌṩµÄԭʼÃÜÔ¿×Ö½ÚÊý×é
        byte[] originBytes = originKey.getBytes();
        for(int i=0;i<8&&i<originBytes.length;i++){
            buffer[i]= originBytes[i];
        }
        SecretKeySpec key= new SecretKeySpec(buffer,"DES");
        return key;
    }
}

package test;

public class IDEADemo {

    private byte[] bytekey;

    public byte[] getKey(String key) {

        int len1 = key.length();

        if (len1 >= 16) {

             key = key.substring(0,16);

        } else {

             for (int i = 0; i < 16 - len1; i++) {

                  key = key.concat("0");

             }

        }

        bytekey = key.getBytes();

        return bytekey;

    }
    
    public String killNotChar(String agr){
        String str = "";
        
        char [] args = agr.toCharArray();
        
        int leng = args.length;
        
        for(int i=0;i<leng;++i)
        {
            char c = args[i];
            if(!((c<='Z'&c>='A')||(c<='z'&c>='a')||(c<='9'&c>='0')))
            {
                args[i] = '';
                break;
            }
            str = str + c;
        }
        
        return str;
    }

   /** ¼ÓÃÜStringÃ÷ÎÄÊäÈë,StringÃÜÎÄÊä³ö */

    @SuppressWarnings("unused")
     public String getEncString(String strMing) {

        byte[] byteMi = null;

        byte[] byteMing = null;

        String strMi = "";

        try {

             return byte2hex(IdeaEncrypt(bytekey, strMing.getBytes(), true));

        } catch (Exception e) {

             e.printStackTrace();

        } finally {

             byteMing = null;

             byteMi = null;

        }

        return strMi;

    }

    /** ½âÃÜ ÒÔStringÃÜÎÄÊäÈë,StringÃ÷ÎÄÊä³ö*/    

    @SuppressWarnings("unused")
    public String getDesString(String strMi) {

        byte[] byteMing = null;

        byte[] byteMi = null;

        String strMing = "";

        try {

             String tmp = new String(IdeaEncrypt(bytekey, hex2byte(strMi

                      .getBytes()), false));

             int len1 = tmp.length();
             
             String str_new = tmp.substring(0, len1 - 6 );
             
             //System.out.println(len1-6);
             //System.out.println(bytekey.length);
             //System.out.println(strMi.length());
             
             //str_new = killNotChar(str_new);
             
             return str_new;

        } catch (Exception e) {

             e.printStackTrace();

        } finally {

             byteMing = null;

             byteMi = null;

        }

        return strMing;
    }

    private byte[] Encrypt(byte[] bytekey, byte[] inputBytes, boolean flag) {

        byte[] encryptCode = new byte[8];

        int[] key = get_subkey(flag, bytekey);// ·Ö½â×ÓÃÜÔ¿

        encrypt(key, inputBytes, encryptCode);// ½øÐмÓÃܲÙ×÷

        return encryptCode;// ·µ»Ø¼ÓÃÜÊý¾Ý

    }

    private int bytesToInt(byte[] inBytes, int startPos) {

        return ((inBytes[startPos] << 8) & 0xff00)

                  + (inBytes[startPos + 1] & 0xff);

    }

    private void intToBytes(int inputInt, byte[] outBytes, int startPos) {

        outBytes[startPos] = (byte) (inputInt >>> 8);

        outBytes[startPos + 1] = (byte) inputInt;

    }

    private int x_multiply_y(int x, int y) {

        if (x == 0) {

             x = 0x10001 - y;

        } else if (y == 0) {

             x = 0x10001 - x;

        } else {

             int tmp = x * y;

             y = tmp & 0xffff;

             x = tmp >>> 16;

             x = (y - x) + ((y < x) ? 1 : 0);

        }

        return x & 0xffff;

    }

    /** ¼ÓÃܺ¯Êý*/

    private void encrypt(int[] key, byte[] inbytes, byte[] outbytes) {

        int k = 0;

        int a = bytesToInt(inbytes, 0);

        int b = bytesToInt(inbytes, 2);

        int c = bytesToInt(inbytes, 4);

        int d = bytesToInt(inbytes, 6);

        for (int i = 0; i < 8; i++) {

             a = x_multiply_y(a, key[k++]);

             b += key[k++];

             b &= 0xffff;

             c += key[k++];

             c &= 0xffff;

             d = x_multiply_y(d, key[k++]);

             int tmp1 = b;

             int tmp2 = c;

             c ^= a;

             b ^= d;

             c = x_multiply_y(c, key[k++]);

             b += c;

             b &= 0xffff;

             b = x_multiply_y(b, key[k++]);

             c += b;

             c &= 0xffff;

             a ^= b;

             d ^= c;

             b ^= tmp2;

             c ^= tmp1;

        }

        intToBytes(x_multiply_y(a, key[k++]), outbytes, 0);

        intToBytes(c + key[k++], outbytes, 2);

        intToBytes(b + key[k++], outbytes, 4);

        intToBytes(x_multiply_y(d, key[k]), outbytes, 6);

    }

    private int[] encrypt_subkey(byte[] byteKey) {

        int[] key = new int[52];

        if (byteKey.length < 16) {

             byte[] tmpkey = new byte[16];

             System.arraycopy(byteKey, 0, tmpkey,

                      tmpkey.length - byteKey.length, byteKey.length);

             byteKey = tmpkey;

        }

        for (int i = 0; i < 8; i++) {

             key[i] = bytesToInt(byteKey, i * 2);

        }

        for (int j = 8; j < 52; j++) {

             if ((j & 0x7) < 6) {

                  key[j] = (((key[j - 7] & 0x7f) << 9) | (key[j - 6] >> 7)) & 0xffff;

             } else if ((j & 0x7) == 6) {

                  key[j] = (((key[j - 7] & 0x7f) << 9) | (key[j - 14] >> 7)) & 0xffff;

             } else {

                  key[j] = (((key[j - 15] & 0x7f) << 9) | (key[j - 14] >> 7)) & 0xffff;

             }

        }

        return key;

    }

    private int fun_a(int a) {

        if (a < 2) {

             return a;

        }

        int b = 1;

        int c = 0x10001 / a;

        for (int i = 0x10001 % a; i != 1;) {

             int d = a / i;

             a %= i;

             b = (b + (c * d)) & 0xffff;

             if (a == 1) {

                  return b;

             }

             d = i / a;

             i %= a;

             c = (c + (b * d)) & 0xffff;

        }

        return (1 - c) & 0xffff;

    }

    private int fun_b(int b) {

        return (0 - b) & 0xffff;

    }

    private int[] uncrypt_subkey(int[] key) {

        int dec = 52;

        int asc = 0;

        int[] unkey = new int[52];

        int aa = fun_a(key[asc++]);

        int bb = fun_b(key[asc++]);

        int cc = fun_b(key[asc++]);

        int dd = fun_a(key[asc++]);

        unkey[--dec] = dd;

        unkey[--dec] = cc;

        unkey[--dec] = bb;

        unkey[--dec] = aa;

        for (int k1 = 1; k1 < 8; k1++) {

             aa = key[asc++];

             bb = key[asc++];

             unkey[--dec] = bb;

             unkey[--dec] = aa;

             aa = fun_a(key[asc++]);

             bb = fun_b(key[asc++]);

             cc = fun_b(key[asc++]);

             dd = fun_a(key[asc++]);

             unkey[--dec] = dd;

             unkey[--dec] = bb;

             unkey[--dec] = cc;

             unkey[--dec] = aa;

        }

        aa = key[asc++];

        bb = key[asc++];

        unkey[--dec] = bb;

        unkey[--dec] = aa;

        aa = fun_a(key[asc++]);

        bb = fun_b(key[asc++]);

        cc = fun_b(key[asc++]);

        dd = fun_a(key[asc]);

        unkey[--dec] = dd;

        unkey[--dec] = cc;

        unkey[--dec] = bb;

        unkey[--dec] = aa;

        return unkey;

    }

    private int[] get_subkey(boolean flag, byte[] bytekey) {

        if (flag) {

             return encrypt_subkey(bytekey);

        } else {

             return uncrypt_subkey(encrypt_subkey(bytekey));

        }

    }

    private byte[] ByteDataFormat(byte[] data, int unit) {

        int len = data.length;

        int padlen = unit - (len % unit);

        int newlen = len + padlen;

        byte[] newdata = new byte[newlen];

        System.arraycopy(data, 0, newdata, 0, len);



        for (int i = len; i < newlen; i++)

             newdata[i] = (byte) padlen;

        return newdata;

    }

    public byte[] IdeaEncrypt(byte[] idea_key, byte[] idea_data, boolean flag) {

        byte[] format_key = ByteDataFormat(idea_key, 16);

        byte[] format_data = ByteDataFormat(idea_data, 8);

        int datalen = format_data.length;

        int unitcount = datalen / 8;

        byte[] result_data = new byte[datalen];

        for (int i = 0; i < unitcount; i++) {

             byte[] tmpkey = new byte[16];

             byte[] tmpdata = new byte[8];

             System.arraycopy(format_key, 0, tmpkey, 0, 16);

             System.arraycopy(format_data, i * 8, tmpdata, 0, 8);

             byte[] tmpresult = Encrypt(tmpkey, tmpdata, flag);

             System.arraycopy(tmpresult, 0, result_data, i * 8, 8);

        }

        return result_data;

    }

    /**¶þÐÐÖÆת×Ö·û´®*/

    public static String byte2hex(byte[] b) { // Ò»¸ö×Ö½ÚµÄÊý£¬

        // ת³É16½øÖÆ×Ö·û´®

        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);

             // Á½Î»Ò»×飬±íʾһ¸ö×Ö½Ú,°ÑÕâÑù±íʾµÄ16½øÖÆ×Ö·û´®£¬»¹Ô­³ÉÒ»¸ö½øÖÆ×Ö½Ú

             b2[n / 2] = (byte) Integer.parseInt(item, 16);

        }

        return b2;

    }

    public static void main(String[] args) {

        IDEADemo idea = new IDEADemo();

        idea.getKey("1234");//Éú³ÉÃܳ×
        
        String str_code = "321323313";
        
        int len_str = str_code.length();

        String strEnc = idea.getEncString(str_code);//¼ÓÃÜ×Ö·û´®,·µ»ØStringµÄÃÜÎÄ

        System.out.println("ÃÜÎÄΪ£º");

        System.out.println(strEnc);

        String strDes = idea.getDesString(strEnc);//°ÑString ÀàÐ͵ÄÃÜÎĽâÃÜ

        System.out.println("Ã÷ÎÄΪ£º");

        System.out.println(new String(strDes.toCharArray()).substring(0,len_str));
        
        // 1    ------- 6 -------- 13
        // 2       ------- 5 -------- 13
        // 3     ------- 4 -------- 13
        // 4    ------- 3 -------- 13
        // 5    ------- 2 -------- 13
        // 6    ------- 1 -------- 13
        // 7    ------- 0 -------- 13
        // 8    ------- 7 -------- 21
        // 9    ------- 6 -------- 21
        // 10    ------- 5 -------- 21
        // 
   }

}

　　　　这两个类分别对应 DES 和 IDEA 的加密或解密操作，里面有已经包装好的方法，经过自己的参数设定可以得到密文，用于数据保存真的是不要太合适！

　　5、视图的包装改造

　　　　我们在实际项目中应该调用的不是数据库的数据表，因为这个表结构是不应该暴露在外面的，应该使用建立视图的方法，将原数据表的结构进行隐秘改造。

　　　　就拿之前的数据表 line 不能直接进行增删改查！必须要使用视图来隐蔽原数据表（哪怕你就改个名字呢）