AES加密算法工具类和MD5工具类_aes 加密工具类 偏移量

AES加密算法工具类

AES加密算法是对称加密算法，加密和解密用到的密钥是相同的，发送方将数据用秘钥通过加密算法加密后变成密文，传输到接收方，接收方通过秘钥解密，得到数据。
在这里秘钥必须是16位的。

package com.urovo.kms.common.util;


import java.io.UnsupportedEncodingException;
import java.util.Base64;
import javax.crypto.Cipher;  
import javax.crypto.spec.IvParameterSpec;  
import javax.crypto.spec.SecretKeySpec;
 
 



/**
 * AES对称加密工具类

 */
public class AESUtils {

    //偏移量
    public static final String VIPARA = "1234567876543210";   //AES 为16bytes. DES 为8bytes  
      
    //编码方式
    public static final String CODE_TYPE = "UTF-8";
//    public static final String CODE_TYPE = "GBK";
    
    //填充类型
    public static final String AES_TYPE = "AES/ECB/PKCS5Padding";
    //PKCS7Padding可支持IOS加解密  
    //public static final String AES_TYPE = "AES/ECB/PKCS7Padding";
    //此类型 加密内容和密钥必须为16字节的倍数位,否则抛异常,需要字节补全再进行加密
    //public static final String AES_TYPE = "AES/ECB/NoPadding";
    //java 不支持ZeroPadding
    //public static final String AES_TYPE = "AES/CBC/ZeroPadding";
      
    //私钥  
    private static final String AES_KEY="1234567876543210";   //AES固定格式为128/192/256 bits.即：16/24/32bytes。DES固定格式为128bits，即8bytes。  
    
    //字符补全
    private static final String[] consult = new String[]{"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F","G"};
 
    
    /** 
     * 加密 
     *  
     * @param cleartext 
     * @return 
     */  
    public static String encrypt(String cleartext) {  
        //加密方式： AES128(CBC/PKCS5Padding) + Base64, 私钥：1111222233334444  
        try {  
            IvParameterSpec zeroIv = new IvParameterSpec(VIPARA.getBytes());  
            //两个参数，第一个为私钥字节数组， 第二个为加密方式 AES或者DES  
            SecretKeySpec key = new SecretKeySpec(AES_KEY.getBytes(), "AES");  
            //实例化加密类，参数为加密方式，要写全  
            Cipher cipher = Cipher.getInstance(AES_TYPE); //PKCS5Padding比PKCS7Padding效率高，PKCS7Padding可支持IOS加解密  
            //初始化，此方法可以采用三种方式，按加密算法要求来添加。（1）无第三个参数（2）第三个参数为SecureRandom random = new SecureRandom();中random对象，随机数。(AES不可采用这种方法)（3）采用此代码中的IVParameterSpec  
            //加密时使用:ENCRYPT_MODE;  解密时使用:DECRYPT_MODE;
            cipher.init(Cipher.ENCRYPT_MODE, key); //CBC类型的可以在第三个参数传递偏移量zeroIv,ECB没有偏移量
            //加密操作,返回加密后的字节数组，然后需要编码。主要编解码方式有Base64, HEX, UUE,7bit等等。此处看服务器需要什么编码方式 
            byte[] encryptedData = cipher.doFinal(cleartext.getBytes(CODE_TYPE));  
  
            Base64.Encoder encoder = Base64.getEncoder();
            return encoder.encodeToString(encryptedData);  
            //return new BASE64Encoder().encode(encryptedData);
        } catch (Exception e) {  
            e.printStackTrace();  
            return "";   
        }  
    }  
  
    /** 
     * 解密 
     *  
     * @param encrypted 
     * @return 
     */  
    public static String decrypt(String encrypted) {  
        try {  
            
            Base64.Decoder decoder = Base64.getDecoder();
            byte[] byteMi = decoder.decode(encrypted);
            //byte[] byteMi = new BASE64Decoder().decodeBuffer(encrypted);  
            IvParameterSpec zeroIv = new IvParameterSpec(VIPARA.getBytes());  
            SecretKeySpec key = new SecretKeySpec(  
                    AES_KEY.getBytes(), "AES");  
            Cipher cipher = Cipher.getInstance(AES_TYPE);  
            //与加密时不同MODE:Cipher.DECRYPT_MODE  
            cipher.init(Cipher.DECRYPT_MODE, key);  //CBC类型的可以在第三个参数传递偏移量zeroIv,ECB没有偏移量
            byte[] decryptedData = cipher.doFinal(byteMi);  
            return new String(decryptedData, CODE_TYPE);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return "";  
        }  
    }  
  
    /** 
     * 测试 
     *  
     * @param args 
     * @throws Exception 
     */  
    public static void main(String[] args) throws Exception {  
        String content = "userid dvcid";
        test(content);
    }
    
    //测试
    public static void test(String content) throws UnsupportedEncodingException{
        System.out.println("加密内容：" + content);
        //字节数
        int num = content.getBytes(CODE_TYPE).length; 
        System.out.println("加密内容字节数: " + num);
        System.out.println("加密内容是否16倍数: " + (num%16 == 0 ? true : false));
      
        //字节补全
        if(AES_TYPE.equals("AES/ECB/NoPadding")){
            System.out.println();
            content = completionCodeFor16Bytes(content);
            System.out.println("加密内容补全后: "+content);
        }
        
        
        System.out.println();
        
        // 加密
        String encryptResult = encrypt(content);  
        content = new String(encryptResult);
        System.out.println("加密后：" + content);
        
        System.out.println();
        
        // 解密
        String decryptResult = decrypt(encryptResult);
        content = new String(decryptResult);
        //还原
        if(AES_TYPE.equals("AES/ECB/NoPadding")){
            System.out.println("解密内容还原前: "+content);
            content = resumeCodeOf16Bytes(content);
        }
        
        System.out.println("解密完成后：" + content);  
    }
    
    
    
    
    //NoPadding 
    //补全字符
    public static String completionCodeFor16Bytes(String str) throws UnsupportedEncodingException{
        int num = str.getBytes(CODE_TYPE).length;
        int index = num%16;
        //进行加密内容补全操作, 加密内容应该为 16字节的倍数, 当不足16*n字节是进行补全, 差一位时 补全16+1位
        //补全字符 以 $ 开始,$后一位代表$后补全字符位数,之后全部以0进行补全;
        if(index != 0){
            StringBuffer sbBuffer = new StringBuffer(str);
            if(16-index == 1){
                sbBuffer.append("$" + consult[16-1] + addStr(16-1-1));
            }else{
                sbBuffer.append("$" + consult[16-index-1] + addStr(16-index-1-1));
            }
            str = sbBuffer.toString();
        }
        return str;
    }
    
    //追加字符
    public static String addStr(int num){
        StringBuffer sbBuffer = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            sbBuffer.append("0");
        }
        return sbBuffer.toString();
    }
    
    
    //还原字符(进行字符判断)
    public static String resumeCodeOf16Bytes(String str){
        int indexOf = str.lastIndexOf("$");
//        System.out.println(indexOf);
        if(indexOf == -1){
            return str;
        }
        String trim = str.substring(indexOf+1,indexOf+2).trim();
//        System.out.println(trim);
        int num = 0;
        for (int i = 0; i < consult.length; i++) {
            if(trim.equals(consult[i])){
                num = i;
            }
        }
        if(num == 0){
            return str;
        }
        return str.substring(0,indexOf).trim();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199

MD5算法

MD5算法是散列算法，不可逆，只能加密，不能解密，可以用于验证，网络签名。

import java.security.MessageDigest;
import org.apache.commons.codec.digest.DigestUtils;
import java.math.BigInteger;
 
/**
 * Description: md5加密解密
 */
public class MD5Util {
 
    public static String md5(String dateString) throws Exception {
        MessageDigest md5 = null;
        byte[] digest = MessageDigest.getInstance("md5").digest(dateString.getBytes("utf-8"));
        String md5code = new BigInteger(1, digest).toString(16);
        // 如果生成数字未满32位，需要前面补0
        for (int i = 0; i < 32 - md5code.length(); i++) {
            md5code = "0" + md5code;
        }
        return md5code;
    }
 
    //ASCII 码使用指定的7 位或8 位二进制数组合来表示128 或256 种可能的字符。
    //（1）0～31及127(共33个)是控制字符或通信专用字符（其余为可显示字符），
    // 如控制符：LF（换行）、CR（回车）、FF（换页）、DEL（删除）、BS（退格)、BEL（响铃）等；通信专用字               符：SOH（文头）、EOT（文尾）、ACK（确认）等；
    // ASCII值为8、9、10 和13 分别转换为退格、制表、换行和回车字符。它们并没有特定的图形显示，但会依不同的    应用程序，而对文本显示有不同的影响。
    // 2）32～126(共95个)是字符(32是空格），其中48～57为0到9十个阿拉伯数字。
    //（3）65～90为26个大写英文字母，97～122号为26个小写英文字母，其余为一些标点符号、运算符号等
    public static String md5PlusSalt(String keyword)
    {
        //md5加密
        String md5 = DigestUtils.md5Hex(keyword);
        //md5+盐
        char[] cArray = md5.toCharArray();
        for(int i = 0;i < cArray.length; i++)
        {
            if(cArray[i] >= 48 &&cArray[i] <= 57)
            {
                cArray[i] = (char)(105-cArray[i]);
 
            }
        }
        //都可以使用
        return  String.valueOf(cArray);
        //return  "".valueOf(cArray);
 
    }
    //解密+盐
    public static String md5MinusSalt(String md5)
    {
        char[] cArray=md5.toCharArray();
        for(int i=0;i<cArray.length;i++)
        {
            if(cArray[i]>=48&&cArray[i]<=57)
            {
                cArray[i]=(char)(105-cArray[i]);
            }
        }
        return  String.valueOf(cArray);
        //return  "".valueOf(cArray);
    }
    public static void main(String[] args){
        String keyword="i love you";
        String md5= DigestUtils.md5Hex(keyword);
        System.out.println("md5加密后："+"\n"+md5);
        String md5salt= MD5Util.md5PlusSalt(keyword);
        System.out.println("加盐后："+"\n"+md5salt);
        String word= MD5Util.md5MinusSalt(md5salt);
        System.out.println("解密后："+"\n"+word);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69