package longshu.utils.security;
 
import java.lang.reflect.Method;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
 
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
 
/**
 * Java加密解密工具.
 * JavaSE/JavaEE/Android都適用
 * 
 * @author longshu 2016年4月13日
 */
public class EncryptDecrypt {
 // 無需創(chuàng)建對象
 private EncryptDecrypt() {
 }
 
 /**
  * SHA1加密Bit數(shù)據(jù)
  * @param source byte數(shù)組
  * @return 加密后的byte數(shù)組
  */
 public static byte[] SHA1Bit(byte[] source) {
  try {
   MessageDigest sha1Digest = MessageDigest.getInstance("SHA-1");
   sha1Digest.update(source);
   byte targetDigest[] = sha1Digest.digest();
   return targetDigest;
  } catch (NoSuchAlgorithmException e) {
   throw new RuntimeException(e);
  }
 }
 
 /**
  * SHA1加密字符串?dāng)?shù)據(jù)
  * @param source 要加密的字符串
  * @return 加密后的字符串
  */
 public static String SHA1(String source) {
  return byte2HexStr(SHA1Bit(source.getBytes()));
 }
 
 /**
  * MD5加密Bit數(shù)據(jù)
  * @param source byte數(shù)組
  * @return 加密后的byte數(shù)組
  */
 public static byte[] MD5Bit(byte[] source) {
  try {
   // 獲得MD5摘要算法的 MessageDigest對象
   MessageDigest md5Digest = MessageDigest.getInstance("MD5");
   // 使用指定的字節(jié)更新摘要
   md5Digest.update(source);
   // 獲得密文
   return md5Digest.digest();
  } catch (NoSuchAlgorithmException e) {
   throw new RuntimeException(e);
  }
 }
 
 /**
  * MD5加密字符串,32位長
  * @param source 要加密的內(nèi)容
  * @return 加密后的內(nèi)容
  */
 public static String MD5(String source) {
  return byte2HexStr(MD5Bit(source.getBytes()));
 }
 
 /**
  * BASE64編碼
  * @param source 要編碼的字符串
  * @return 編碼過的字符串
  */
 public static String encodeBASE64(String source) {
  Class<?> clazz = null;
  Method encodeMethod = null;
  try {// 優(yōu)先使用第三方庫
   clazz = Class.forName("org.apache.commons.codec.binary.Base64");
   encodeMethod = clazz.getMethod("encodeBase64", byte[].class);
   System.out.println("encodeBASE64-->" + clazz);
   System.out.println("encodeMethod-->" + encodeMethod);
   // 反射方法 靜態(tài)方法執(zhí)行無需對象
   return new String((byte[]) encodeMethod.invoke(null, source.getBytes()));
  } catch (ClassNotFoundException e) {
   String vm = System.getProperty("java.vm.name");
   System.out.println(vm);
   try {
    if ("Dalvik".equals(vm)) {// Android
     clazz = Class.forName("android.util.Base64");
     // byte[] Base64.encode(byte[] input,int flags)
     encodeMethod = clazz.getMethod("encode", byte[].class, int.class);
     System.out.println("encodeBASE64-->" + clazz);
     System.out.println("encodeMethod-->" + encodeMethod);
     return new String((byte[]) encodeMethod.invoke(null, source.getBytes(), 0));
    } else {// JavaSE/JavaEE
     clazz = Class.forName("sun.misc.BASE64Encoder");
     encodeMethod = clazz.getMethod("encode", byte[].class);
     System.out.println("encodeBASE64-->" + clazz);
     System.out.println("encodeMethod-->" + encodeMethod);
     return (String) encodeMethod.invoke(clazz.newInstance(), source.getBytes());
    }
   } catch (ClassNotFoundException e1) {
    return null;
   } catch (Exception e1) {
    return null;
   }
  } catch (Exception e) {
   return null;
  }
  /*
   * Android
   * android.util.Base64
   */
  // return Base64.encodeToString(source, Base64.DEFAULT);
  // return new String(Base64.encode(source.getBytes(), Base64.DEFAULT));
 
  /*
   * JavaSE/JavaEE
   */
  // sun.misc.BASE64Encoder
  // BASE64Encoder encoder = new BASE64Encoder();
  // return encoder.encode(source.getBytes());
 
  // org.apache.commons.codec.binary.Base64
  // return new String(Base64.encodeBase64(source.getBytes()));
 }
 
 /**
  * BASE64解碼
  * @param encodeSource 編碼過的字符串
  * @return 編碼前的字符串
  */
 public static String decodeBASE64(String encodeSource) {
  Class<?> clazz = null;
  Method decodeMethod = null;
 
  try {// 優(yōu)先使用第三方庫
   clazz = Class.forName("org.apache.commons.codec.binary.Base64");
   decodeMethod = clazz.getMethod("decodeBase64", byte[].class);
   System.out.println("decodeBASE64-->" + clazz);
   System.out.println("decodeMethod-->" + decodeMethod);
   // 反射方法 靜態(tài)方法執(zhí)行無需對象
   return new String((byte[]) decodeMethod.invoke(null, encodeSource.getBytes()));
  } catch (ClassNotFoundException e) {
   String vm = System.getProperty("java.vm.name");
   System.out.println(vm);
   try {
    if ("Dalvik".equals(vm)) {// Android
     clazz = Class.forName("android.util.Base64");
     // byte[] Base64.decode(byte[] input, int flags)
     decodeMethod = clazz.getMethod("decode", byte[].class, int.class);
     System.out.println("decodeBASE64-->" + clazz);
     System.out.println("decodeMethod-->" + decodeMethod);
     return new String((byte[]) decodeMethod.invoke(null, encodeSource.getBytes(), 0));
    } else { // JavaSE/JavaEE
     clazz = Class.forName("sun.misc.BASE64Decoder");
     decodeMethod = clazz.getMethod("decodeBuffer", String.class);
     System.out.println("decodeBASE64-->" + clazz);
     System.out.println("decodeMethod-->" + decodeMethod);
     return new String((byte[]) decodeMethod.invoke(clazz.newInstance(), encodeSource));
    }
   } catch (ClassNotFoundException e1) {
    return null;
   } catch (Exception e1) {
    return null;
   }
  } catch (Exception e) {
   return null;
  }
  /*
   * Android
   * android.util.Base64
   */
  // return new
  // String(Base64.decode(encodeSource.getBytes(),Base64.DEFAULT));
 
  /*
   * JavaSE/JavaEE
   */
  // sun.misc.BASE64Decoder
  // try {
  // BASE64Decoder decoder = new BASE64Decoder();
  // return new String(decoder.decodeBuffer(encodeSource));
  // } catch (IOException e) {
  // throw new RuntimeException(e);
  // }
 
  // org.apache.commons.codec.binary.Base64
  // return new String(Base64.decodeBase64(encodeSource.getBytes()));
 }
 
 /**
  * AES加密
  * @param content 待加密的內(nèi)容
  * @param password 加密密碼
  * @return
  */
 public static byte[] encryptBitAES(byte[] content, String password) {
  try {
   Cipher encryptCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");// 創(chuàng)建密碼器
   encryptCipher.init(Cipher.ENCRYPT_MODE, getKey(password));// 初始化
   byte[] result = encryptCipher.doFinal(content);
   return result; // 加密
  } catch (NoSuchAlgorithmException e) {
   e.printStackTrace();
  } catch (NoSuchPaddingException e) {
   e.printStackTrace();
  } catch (InvalidKeyException e) {
   e.printStackTrace();
  } catch (IllegalBlockSizeException e) {
   e.printStackTrace();
  } catch (BadPaddingException e) {
   e.printStackTrace();
  }
  return null;
 }
 
 /**
  * AES解密
  * @param content 待解密內(nèi)容
  * @param password 解密密鑰
  * @return
  */
 public static byte[] decryptBitAES(byte[] content, String password) {
  try {
   Cipher decryptCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");// 創(chuàng)建密碼器
   decryptCipher.init(Cipher.DECRYPT_MODE, getKey(password));// 初始化
   byte[] result = decryptCipher.doFinal(content);
   return result; // 加密結(jié)果
  } catch (InvalidKeyException e) {
   e.printStackTrace();
  } catch (NoSuchAlgorithmException e) {
   e.printStackTrace();
  } catch (NoSuchPaddingException e) {
   e.printStackTrace();
  } catch (IllegalBlockSizeException e) {
   e.printStackTrace();
  } catch (BadPaddingException e) {
   e.printStackTrace();
  }
  return null;
 }
 
 /**
  * AES字符串加密
  * @param content 待加密的內(nèi)容
  * @param password 加密密碼
  * @return
  */
 public static String encryptAES(String content, String password) {
  return byte2HexStr(encryptBitAES(content.getBytes(), password));
 }
 
 /**
  * AES字符串解密
  * @param content 待解密內(nèi)容
  * @param password 解密密鑰
  * @return
  */
 public static String decryptAES(String content, String password) {
  return new String(decryptBitAES(hexStr2Bytes(content), password));
 }
 
 /**
  * 從指定字符串生成密鑰
  * @param password 構(gòu)成該秘鑰的字符串
  * @return 生成的密鑰
  * @throws NoSuchAlgorithmException
  */
 private static Key getKey(String password) throws NoSuchAlgorithmException {
  SecureRandom secureRandom = new SecureRandom(password.getBytes());
  // 生成KEY
  KeyGenerator kgen = KeyGenerator.getInstance("AES");
  kgen.init(128, secureRandom);
  SecretKey secretKey = kgen.generateKey();
  byte[] enCodeFormat = secretKey.getEncoded();
  // 轉(zhuǎn)換KEY
  SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
  return key;
 }
 
 /**
  * 將byte數(shù)組轉(zhuǎn)換為表示16進(jìn)制值的字符串.
  * 如：byte[]{8,18}轉(zhuǎn)換為：0812 
  * 和 byte[] hexStr2Bytes(String strIn) 互為可逆的轉(zhuǎn)換過程.
  * @param bytes 需要轉(zhuǎn)換的byte數(shù)組
  * @return 轉(zhuǎn)換后的字符串
  */
 public static String byte2HexStr(byte[] bytes) {
  int bytesLen = bytes.length;
  // 每個byte用兩個字符才能表示，所以字符串的長度是數(shù)組長度的兩倍
  StringBuffer hexString = new StringBuffer(bytesLen * 2);
  for (int i = 0; i < bytesLen; i++) {
   // 將每個字節(jié)與0xFF進(jìn)行與運算，然后轉(zhuǎn)化為10進(jìn)制，然后借助于Integer再轉(zhuǎn)化為16進(jìn)制
   String hex = Integer.toHexString(bytes[i] & 0xFF);
   if (hex.length() < 2) {
    hexString.append(0);// 如果為1位 前面補個0
   }
   hexString.append(hex);
  }
  return hexString.toString();
 }
 
 /**
  * 將表示16進(jìn)制值的字符串轉(zhuǎn)換為byte數(shù)組,
  * 和 String byte2HexStr(byte[] bytes) 互為可逆的轉(zhuǎn)換過程.
  * @param bytes
  * @return 轉(zhuǎn)換后的byte數(shù)組
  */
 public static byte[] hexStr2Bytes(String strIn) {
  byte[] arrB = strIn.getBytes();
  int iLen = arrB.length;
 
  // 兩個字符表示一個字節(jié)，所以字節(jié)數(shù)組長度是字符串長度除以2
  byte[] arrOut = new byte[iLen / 2];
  for (int i = 0; i < iLen; i = i + 2) {
   String strTmp = new String(arrB, i, 2);
   arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
  }
  return arrOut;
 }
 
}