使用AES+自己算法设计加密解密算法

因为需要，需要将字符串进行加密，所以就自己设计了一套加密算法
代码如下：

package com.htinf.enandDEcrypt;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.Key;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
/**
 * 加密解密处理
 *      加密的密钥可以自行配置（也可以配置在systemConfig.properties文件中）
 *      为了防止过多的进行操作，或者被看到，本系统直接将加密密钥设置成"htinf";
 * 加密算法：AES+自己设计算法
 * @author zcg
 * @time 2016-11-24 16:23:55
 * 
 * 常见的加密算法: AES
 *                  DES
 *                  RC4
 *                  Rabbit
 *                  TripleDes
 *
 */
public class EnorDecryptTools {
    private Key key;
    private static String generateKey="htinf";
    private String encryptAlgorithm="AES";
    private static EnorDecryptTools tools;
    private EnorDecryptTools(){}
    public static EnorDecryptTools getInstance(){
        if(tools==null){
            tools=new EnorDecryptTools();
        }
        tools.getKey(generateKey);
        return tools;
    }
    private void getKey(String strKey){
        try { 
            //防止加密过后在window和linux系统下产生不一样的效果
            KeyGenerator _generator = KeyGenerator.getInstance(encryptAlgorithm);
            SecureRandom random=null;
            random = SecureRandom.getInstance("SHA1PRNG","SUN");
            random.setSeed(strKey.getBytes()); 
            _generator.init(random);  
            this.key = _generator.generateKey();  
            _generator = null;  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }
    /**
     * 
     * 加密String明文输入,String密文输出  
     *   
     * @param strMing  
     *            String明文  
     * @return String密文  
     * 
     */
    public String getEncString(String strMing){
         byte[] byteMi = null;  
            byte[] byteMing = null;  
            String strMi = "";  
            BASE64Encoder base64en = new BASE64Encoder();  
            try {  
                byteMing = strMing.getBytes("UTF8");  
                byteMi = this.getEncCode(byteMing);  
                strMi = base64en.encode(byteMi);
                //DES加密算法之後，進行二級加密
                strMi=deepencrypt(strMi);
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                base64en = null;  
                byteMing = null;  
                byteMi = null;  
            }  
            return strMi;
    }
    /**  
     * 解密 以String密文输入,String明文输出  
     *   
     * @param strMi  
     *            String密文  
     * @return String明文  
     */ 
    public String getDesString(String strMi){
        BASE64Decoder base64De = new BASE64Decoder();  
        byte[] byteMing = null;  
        byte[] byteMi = null;  
        String strMing = "";  
        try {  
            //DES算法解密之前，進行一級解密
            strMi=deepdecrypt(strMi);
            byteMi = base64De.decodeBuffer(strMi);  
            byteMing = this.getDesCode(byteMi);  
            strMing = new String(byteMing, "UTF8");  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            base64De = null;  
            byteMing = null;  
            byteMi = null;  
        }  
        return strMing;  
    }
    /**  
     *  为getEncString方法提供服务  
     *    
     * 加密以byte[]明文输入,byte[]密文输出  
     *   
     * @param byteS  
     *            byte[]明文  
     * @return byte[]密文  
     */  
    private byte[] getEncCode(byte[] byteS) {  
        byte[] byteFina = null;  
        Cipher cipher;  
        try {  
            cipher = Cipher.getInstance(encryptAlgorithm);  
            cipher.init(Cipher.ENCRYPT_MODE, key);  
            byteFina = cipher.doFinal(byteS);  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            cipher = null;  
        }  
        return byteFina;  
    }
    /**  
     * 为getDesString方法提供服务  
     *   
     * 解密以byte[]密文输入,以byte[]明文输出  
     *   
     * @param byteD  
     *            byte[]密文  
     * @return byte[]明文  
     */  
    private byte[] getDesCode(byte[] byteD) {  
        Cipher cipher;  
        byte[] byteFina = null;  
        try {  
            cipher = Cipher.getInstance(encryptAlgorithm);  
            cipher.init(Cipher.DECRYPT_MODE, key);  
            byteFina = cipher.doFinal(byteD);  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            cipher = null;  
        }  
        return byteFina;  
    }
    /**
     * 加密文件，明文经过DES加密之后，获取密文中的第一个字符，如果大于70.进行倒入，
     *          小于70，如果字符长度大于6，进行前三个和后三个字符的替换，如果是小于6
     *          不进行操作
     *          并在后面追加四位的随机数
     * @param entryptStr DES加密后的字符  
     *                      String
     * @return String  深度加密后的字符
     * */
    private String deepencrypt(String entryptStr){
        String newStr="";
        String finalStr="";
        int len=entryptStr.length();
        char firstIndex=entryptStr.charAt(0);
        int charToInt=(int)firstIndex;

        // 使用倒叙的方式
        if(charToInt>=70){
            char[] charArray=entryptStr.toCharArray();
            for(int i=charArray.length-1;i>=0;i--){
                newStr+=charArray[i];
            }
        }
        else{
            if(len>=6){
                String firstStr=entryptStr.substring(0, 3);
                String lastStr=entryptStr.substring(len-3, len);
                String indexStr=entryptStr.substring(3,len-3);
                newStr =lastStr+indexStr+firstStr;
            }
            //不进行替换，直接这样
            else{
                newStr=entryptStr;
            }
        }

        int a = (int)(Math.random()*(9999-1000+1))+1000;
        finalStr=newStr+a;
        return finalStr;
    } 
    /**
     * 解密文件:收到密文之後,首先進行後綴四位數字清除,然后解析字符串，如果长度是小于6
     *                      不进行任何操作，如果是大于6，检测最后一个字符，如果是大于70，进行倒叙，
     *                      如果是小于70，将字符的后三个和前三个进行替换，
     * @param decryptStr DES+自定義算法密文
     *                  String
     * @return String 一級解密之後的密文
     * */
    private String deepdecrypt(String decryptStr){
        int len=decryptStr.length();
        String interStr=decryptStr.substring(0,len-4);
        int interlen=interStr.length();
        String newStr="";
        //如果他的长度小于6，不进行操作，将后面的数字替换掉就好
        if(interlen<6){
            newStr=interStr;
        }
        else{
            char lastIndex=interStr.charAt(interlen-1);
            int charToInt=(int)lastIndex;
            if(charToInt>=70){
                //说明是替换的
                char[] charArray=interStr.toCharArray();
                for(int i=charArray.length-1;i>=0;i--){
                    newStr+=charArray[i];
                }
            }
            else{
                String firstStr=interStr.substring(0,3);
                String lastStr=interStr.substring(interlen-3,interlen);
                String indexStr=interStr.substring(3,interlen-3);
                newStr=lastStr+indexStr+firstStr;
            }
        }
        return newStr;
    } 



    public static void main(String[] args) throws IOException {
//      EnorDecryptTools enEncrypt=new EnorDecryptTools();
//      enEncrypt.getKey(EnorDecryptTools.generateKey); // 生成密匙 （同一个key）
//      //对密码进行加密操作
//      //设置加密的密码
//      String passward="123";
//      byte[] bt=enEncrypt.getEncCode(passward.getBytes("UTF-8"));
//      //加密之后文件进行操作
//      String openPassward=new String(bt,"UTF-8");
//      System.out.println("加密之后的文件"+new String(bt));
//      
//      //解密之后文件
//      String closePassward=enEncrypt.getDesString(openPassward);
//      System.out.println("解密之后的文件"+closePassward);

        String encryStr="123";  
        EnorDecryptTools enEncrypt=new EnorDecryptTools(); // 实例化一个对象（对外提供使用单例设计模式）  
        enEncrypt.getKey(generateKey);  
        String strEnc = enEncrypt.getEncString(encryStr);// 加密字符串,返回String的密文  
        System.out.println("加密之後的文件"+strEnc);  
        String strDes = enEncrypt.getDesString("==Q4zAFjsKVaZGoOY2osWo4Z9632");// 把String 类型的密文解密  
        System.out.println("解密之後的文件"+strDes);
        //将这个文件打包成jar包的同时对其进行混淆，达到加密的效果原因
        //加密的程序是在原有的基础上进行加密的操作
//      String test="'sdfasz'''.,.;.,;";
//      char a=test.charAt(0);
//      
//      System.out.println((int)a);

    }
}

然后在导成jar包，使用混淆器进行混淆，这个时候就可以对外使用