常用的MD5、SHA1加密等。

    1. import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
    3. import javax.crypto.Cipher;
    4. import javax.crypto.KeyGenerator;
    5. import javax.crypto.Mac;
    6. import javax.crypto.SecretKey;
    7. import javax.crypto.spec.SecretKeySpec;
    8. import java.security.MessageDigest;
    9. import java.security.SecureRandom;
    11. public class EncryptUtil {
    12.     public static final String MD5 = "MD5";
    13.     public static final String SHA1 = "SHA1";
    14.     public static final String HmacMD5 = "HmacMD5";
    15.     public static final String HmacSHA1 = "HmacSHA1";
    16.     public static final String DES = "DES";
    17.     public static final String AES = "AES";
    19.     /**编码格式；默认使用uft-8*/
    20.     public static String charset = "utf-8";
    21.     /**DES*/
    22.     public  static int keysizeDES = 0;
    23.     /**AES*/
    24.     public static int keysizeAES = 128;
    26.     public static EncryptUtil me;
    28.     private EncryptUtil(){
    29.         //单例
    30.     }
    31.     //双重锁
    32.     public static EncryptUtil getInstance(){
    33.         if (me==null) {
    34.             synchronized (EncryptUtil.class) {
    35.                 if(me == null){
    36.                     me = new EncryptUtil();
    37.                 }
    38.             }
    39.         }
    40.         return me;
    41.     }
    43.     /**
    44.      * 使用MessageDigest进行单向加密（无密码）
    45.      * @param res 被加密的文本
    46.      * @param algorithm 加密算法名称
    47.      * @return
    48.      */
    49.     private static String messageDigest(String res,String algorithm){
    50.         try {
    51.             MessageDigest md = MessageDigest.getInstance(algorithm);
    52.             byte[] resBytes = charset==null?res.getBytes():res.getBytes(charset);
    53.             return base64(md.digest(resBytes));
    54.         } catch (Exception e) {
    55.             e.printStackTrace();
    56.         }
    57.         return null;
    58.     }
    60.     /**
    61.      * 使用KeyGenerator进行单向/双向加密（可设密码）
    62.      * @param res 被加密的原文
    63.      * @param algorithm  加密使用的算法名称
    64.      * @param key 加密使用的秘钥
    65.      * @return
    66.      */
    67.     private static String keyGeneratorMac(String res,String algorithm,String key){
    68.         try {
    69.             SecretKey sk = null;
    70.             if (key==null) {
    71.                 KeyGenerator kg = KeyGenerator.getInstance(algorithm);
    72.                 sk = kg.generateKey();
    73.             }else {
    74.                 byte[] keyBytes = charset==null?key.getBytes():key.getBytes(charset);
    75.                 sk = new SecretKeySpec(keyBytes, algorithm);
    76.             }
    77.             Mac mac = Mac.getInstance(algorithm);
    78.             mac.init(sk);
    79.             byte[] result = mac.doFinal(res.getBytes());
    80.             return base64(result);
    81.         } catch (Exception e) {
    82.             e.printStackTrace();
    83.         }
    84.         return null;
    85.     }
    87.     /**
    88.      * 使用KeyGenerator双向加密，DES/AES，注意这里转化为字符串的时候是将2进制转为16进制格式的字符串，不是直接转，因为会出错
    89.      * @param res 加密的原文
    90.      * @param algorithm 加密使用的算法名称
    91.      * @param key  加密的秘钥
    92.      * @param keysize
    93.      * @param isEncode
    94.      * @return
    95.      */
    96.     private static String keyGeneratorES(String res,String algorithm,String key,int keysize,boolean isEncode){
    97.         try {
    98.             KeyGenerator kg = KeyGenerator.getInstance(algorithm);
    99.             if (keysize == 0) {
    100.                 byte[] keyBytes = charset==null?key.getBytes():key.getBytes(charset);
    101.                 kg.init(new SecureRandom(keyBytes));
    102.             }else if (key==null) {
    103.                 kg.init(keysize);
    104.             }else {
    105.                 byte[] keyBytes = charset==null?key.getBytes():key.getBytes(charset);
    106.                 kg.init(keysize, new SecureRandom(keyBytes));
    107.             }
    108.             SecretKey sk = kg.generateKey();
    109.             SecretKeySpec sks = new SecretKeySpec(sk.getEncoded(), algorithm);
    110.             Cipher cipher = Cipher.getInstance(algorithm);
    111.             if (isEncode) {
    112.                 cipher.init(Cipher.ENCRYPT_MODE, sks);
    113.                 byte[] resBytes = charset==null?res.getBytes():res.getBytes(charset);
    114.                 return parseByte2HexStr(cipher.doFinal(resBytes));
    115.             }else {
    116.                 cipher.init(Cipher.DECRYPT_MODE, sks);
    117.                 return new String(cipher.doFinal(parseHexStr2Byte(res)));
    118.             }
    119.         } catch (Exception e) {
    120.             e.printStackTrace();
    121.         }
    122.         return null;
    123.     }
    125.     private static String base64(byte[] res){
    126.         return Base64.encode(res);
    127.     }
    129.     /**将二进制转换成16进制 */
    130.     public static String parseByte2HexStr(byte buf[]) {
    131.         StringBuffer sb = new StringBuffer();
    132.         for (int i = 0; i < buf.length; i++) {
    133.             String hex = Integer.toHexString(buf[i] & 0xFF);
    134.             if (hex.length() == 1) {
    135.                 hex = '0' + hex;
    136.             }
    137.             sb.append(hex.toUpperCase());
    138.         }
    139.         return sb.toString();
    140.     }
    141.     /**将16进制转换为二进制*/
    142.     public static byte[] parseHexStr2Byte(String hexStr) {
    143.         if (hexStr.length() < 1) {
    144.             return null;
    145.         }
    146.         byte[] result = new byte[hexStr.length()/2];
    147.         for (int i = 0;i< hexStr.length()/2; i++) {
    148.             int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);
    149.             int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);
    150.             result[i] = (byte) (high * 16 + low);
    151.         }
    152.         return result;
    153.     }
    155.     /**
    156.      * md5加密算法进行加密（不可逆）
    157.      * @param res 需要加密的原文
    158.      * @return
    159.      */
    160.     public static String MD5(String res) {
    161.         return messageDigest(res, MD5);
    162.     }
    164.     /**
    165.      * md5加密算法进行加密（不可逆）
    166.      * @param res  需要加密的原文
    167.      * @param key  秘钥
    168.      * @return
    169.      */
    170.     public static String MD5(String res, String key) {
    171.         return keyGeneratorMac(res, HmacMD5, key);
    172.     }
    174.     /**
    175.      * 使用SHA1加密算法进行加密（不可逆）
    176.      * @param res 需要加密的原文
    177.      * @return
    178.      */
    179.     public static String SHA1(String res) {
    180.         return messageDigest(res, SHA1);
    181.     }
    183.     /**
    184.      * 使用SHA1加密算法进行加密（不可逆）
    185.      * @param res 需要加密的原文
    186.      * @param key 秘钥
    187.      * @return
    188.      */
    189.     public static String SHA1(String res, String key) {
    190.         return keyGeneratorMac(res, HmacSHA1, key);
    191.     }
    193.     /**
    194.      * 使用DES加密算法进行加密（可逆）
    195.      * @param res 需要加密的原文
    196.      * @param key 秘钥
    197.      * @return
    198.      */
    199.     public static String DESencode(String res, String key) {
    200.         return keyGeneratorES(res, DES, key, keysizeDES, true);
    201.     }
    203.     /**
    204.      * 对使用DES加密算法的密文进行解密（可逆）
    205.      * @param res 需要解密的密文
    206.      * @param key 秘钥
    207.      * @return
    208.      */
    209.     public static String DESdecode(String res, String key) {
    210.         return keyGeneratorES(res, DES, key, keysizeDES, false);
    211.     }
    213.     /**
    214.      * 使用AES加密算法经行加密（可逆）
    215.      * @param res 需要加密的密文
    216.      * @param key 秘钥
    217.      * @return
    218.      */
    219.     public static String AESencode(String res, String key) {
    220.         return keyGeneratorES(res, AES, key, keysizeAES, true);
    221.     }
    223.     /**
    224.      * 对使用AES加密算法的密文进行解密
    225.      * @param res 需要解密的密文
    226.      * @param key 秘钥
    227.      * @return
    228.      */
    229.     public static String AESdecode(String res, String key) {
    230.         return keyGeneratorES(res, AES, key, keysizeAES, false);
    231.     }
    233.     /**
    234.      * 使用异或进行加密
    235.      * @param res 需要加密的密文
    236.      * @param key 秘钥
    237.      * @return
    238.      */
    239.     public static String XORencode(String res, String key) {
    240.         byte[] bs = res.getBytes();
    241.         for (int i = 0; i < bs.length; i++) {
    242.             bs[i] = (byte) ((bs[i]) ^ key.hashCode());
    243.         }
    244.         return parseByte2HexStr(bs);
    245.     }
    247.     /**
    248.      * 使用异或进行解密
    249.      * @param res 需要解密的密文
    250.      * @param key 秘钥
    251.      * @return
    252.      */
    253.     public static String XORdecode(String res, String key) {
    254.         byte[] bs = parseHexStr2Byte(res);
    255.         for (int i = 0; i < bs.length; i++) {
    256.             bs[i] = (byte) ((bs[i]) ^ key.hashCode());
    257.         }
    258.         return new String(bs);
    259.     }
    261.     /**
    262.      * 直接使用异或（第一调用加密，第二次调用解密）
    263.      * @param res 密文
    264.      * @param key 秘钥
    265.      * @return
    266.      */
    267.     public int XOR(int res, String key) {
    268.         return res ^ key.hashCode();
    269.     }
    271.     /**
    272.      * 使用Base64进行加密
    273.      * @param res 密文
    274.      * @return
    275.      */
    276.     public static String Base64Encode(String res) {
    277.         return Base64.encode(res.getBytes());
    278.     }
    280.     /**
    281.      * 使用Base64进行解密
    282.      * @param res
    283.      * @return
    284.      */
    285.     public static String Base64Decode(String res) {
    286.         return new String(Base64.decode(res));
    287.     }
    288. }