java常用工具类之DES和Base64加密解密类

时间：2022-03-20 17:26:47

一、DES加密和解密

  1. package com.itjh.javaUtil; 
  2.   
  3. import java.io.UnsupportedEncodingException; 
  4. import java.security.InvalidKeyException; 
  5. import java.security.NoSuchAlgorithmException; 
  6. import java.security.SecureRandom; 
  7. import java.security.spec.InvalidKeySpecException; 
  8.   
  9. import javax.crypto.BadPaddingException; 
  10. import javax.crypto.Cipher; 
  11. import javax.crypto.IllegalBlockSizeException; 
  12. import javax.crypto.KeyGenerator; 
  13. import javax.crypto.NoSuchPaddingException; 
  14. import javax.crypto.SecretKey; 
  15. import javax.crypto.SecretKeyFactory; 
  16. import javax.crypto.spec.DESKeySpec; 
  17.   
  18. /** 
  19.  * DES加密和解密。 
  20.  *  
  21.  * @author 宋立君 
  22.  * @date 2014年07月03日 
  23.  */ 
  24. public class DESUtil { 
  25.   
  26.     /** 安全密钥 */ 
  27.     private String keyData = "ABCDEFGHIJKLMNOPQRSTWXYZabcdefghijklmnopqrstwxyz0123456789-_."; 
  28.   
  29.     /** 
  30.      * 功能：构造 
  31.      *  
  32.      * @author 宋立君 
  33.      * @date 2014年07月03日 
  34.      */ 
  35.     public DESUtil() { 
  36.     } 
  37.   
  38.     /** 
  39.      * 功能：构造 
  40.      *  
  41.      * @author 宋立君 
  42.      * @date 2014年07月03日 
  43.      * @param keyData 
  44.      *  key 
  45.      */ 
  46.     public DESUtil(String key) { 
  47.         this.keyData = key; 
  48.     } 
  49.   
  50.     /** 
  51.      * 功能：加密 (UTF-8) 
  52.      *  
  53.      * @author 宋立君 
  54.      * @date 2014年07月03日 
  55.      * @param source 
  56.      *  源字符串 
  57.      * @param charSet 
  58.      *  编码 
  59.      * @return String 
  60.      * @throws UnsupportedEncodingException 
  61.      *  编码异常 
  62.      */ 
  63.     public String encrypt(String source) throws UnsupportedEncodingException { 
  64.         return encrypt(source, "UTF-8"); 
  65.     } 
  66.   
  67.     /** 
  68.      *  
  69.      * 功能：解密 (UTF-8) 
  70.      *  
  71.      * @author 宋立君 
  72.      * @date 2014年07月03日 
  73.      * @param encryptedData 
  74.      *  被加密后的字符串 
  75.      * @return String 
  76.      * @throws UnsupportedEncodingException 
  77.      *  编码异常 
  78.      */ 
  79.     public String decrypt(String encryptedData) 
  80.             throws UnsupportedEncodingException { 
  81.         return decrypt(encryptedData, "UTF-8"); 
  82.     } 
  83.   
  84.     /** 
  85.      * 功能：加密 
  86.      *  
  87.      * @author 宋立君 
  88.      * @date 2014年07月03日 
  89.      * @param source 
  90.      *  源字符串 
  91.      * @param charSet 
  92.      *  编码 
  93.      * @return String 
  94.      * @throws UnsupportedEncodingException 
  95.      *  编码异常 
  96.      */ 
  97.     public String encrypt(String source, String charSet) 
  98.             throws UnsupportedEncodingException { 
  99.         String encrypt = null; 
  100.         byte[] ret = encrypt(source.getBytes(charSet)); 
  101.         encrypt = new String(Base64.encode(ret)); 
  102.         return encrypt; 
  103.     } 
  104.   
  105.     /** 
  106.      *  
  107.      * 功能：解密 
  108.      *  
  109.      * @author 宋立君 
  110.      * @date 2014年07月03日 
  111.      * @param encryptedData 
  112.      *  被加密后的字符串 
  113.      * @param charSet 
  114.      *  编码 
  115.      * @return String 
  116.      * @throws UnsupportedEncodingException 
  117.      *  编码异常 
  118.      */ 
  119.     public String decrypt(String encryptedData, String charSet) 
  120.             throws UnsupportedEncodingException { 
  121.         String descryptedData = null; 
  122.         byte[] ret = descrypt(Base64.decode(encryptedData.toCharArray())); 
  123.         descryptedData = new String(ret, charSet); 
  124.         return descryptedData; 
  125.     } 
  126.   
  127.     /** 
  128.      * 加密数据 用生成的密钥加密原始数据 
  129.      *  
  130.      * @param primaryData 
  131.      *  原始数据 
  132.      * @return byte[] 
  133.      * @author 宋立君 
  134.      * @date 2014年07月03日 
  135.      */ 
  136.     private byte[] encrypt(byte[] primaryData) { 
  137.   
  138.         /** 取得安全密钥 */ 
  139.         byte rawKeyData[] = getKey(); 
  140.   
  141.         /** DES算法要求有一个可信任的随机数源 */ 
  142.         SecureRandom sr = new SecureRandom(); 
  143.   
  144.         /** 使用原始密钥数据创建DESKeySpec对象 */ 
  145.         DESKeySpec dks = null; 
  146.         try { 
  147.             dks = new DESKeySpec(keyData.getBytes()); 
  148.         } catch (InvalidKeyException e) { 
  149.             e.printStackTrace(); 
  150.         } 
  151.   
  152.         /** 创建一个密钥工厂 */ 
  153.         SecretKeyFactory keyFactory = null; 
  154.         try { 
  155.             keyFactory = SecretKeyFactory.getInstance("DES"); 
  156.         } catch (NoSuchAlgorithmException e) { 
  157.             e.printStackTrace(); 
  158.         } 
  159.   
  160.         /** 用密钥工厂把DESKeySpec转换成一个SecretKey对象 */ 
  161.         SecretKey key = null; 
  162.         try { 
  163.             key = keyFactory.generateSecret(dks); 
  164.         } catch (InvalidKeySpecException e) { 
  165.             e.printStackTrace(); 
  166.         } 
  167.   
  168.         /** Cipher对象实际完成加密操作 */ 
  169.         Cipher cipher = null; 
  170.         try { 
  171.             cipher = Cipher.getInstance("DES"); 
  172.         } catch (NoSuchAlgorithmException e) { 
  173.             e.printStackTrace(); 
  174.         } catch (NoSuchPaddingException e) { 
  175.             e.printStackTrace(); 
  176.         } 
  177.   
  178.         /** 用密钥初始化Cipher对象 */ 
  179.         try { 
  180.             cipher.init(Cipher.ENCRYPT_MODE, key, sr); 
  181.         } catch (InvalidKeyException e) { 
  182.             e.printStackTrace(); 
  183.         } 
  184.   
  185.         /** 正式执行加密操作 */ 
  186.         byte encryptedData[] = null; 
  187.         try { 
  188.             encryptedData = cipher.doFinal(primaryData); 
  189.         } catch (IllegalStateException e) { 
  190.             e.printStackTrace(); 
  191.         } catch (IllegalBlockSizeException e) { 
  192.             e.printStackTrace(); 
  193.         } catch (BadPaddingException e) { 
  194.             e.printStackTrace(); 
  195.         } 
  196.   
  197.         /** 返回加密数据 */ 
  198.         return encryptedData; 
  199.     } 
  200.   
  201.     /** 
  202.      * 用密钥解密数据 
  203.      *  
  204.      * @param encryptedData 
  205.      *  加密后的数据 
  206.      * @return byte[] 
  207.      * @author 宋立君 
  208.      * @date 2014年07月03日 
  209.      */ 
  210.     private byte[] descrypt(byte[] encryptedData) { 
  211.   
  212.         /** DES算法要求有一个可信任的随机数源 */ 
  213.         SecureRandom sr = new SecureRandom(); 
  214.   
  215.         /** 取得安全密钥 */ 
  216.         byte rawKeyData[] = getKey(); 
  217.   
  218.         /** 使用原始密钥数据创建DESKeySpec对象 */ 
  219.         DESKeySpec dks = null; 
  220.         try { 
  221.             dks = new DESKeySpec(keyData.getBytes()); 
  222.         } catch (InvalidKeyException e) { 
  223.             e.printStackTrace(); 
  224.         } 
  225.   
  226.         /** 创建一个密钥工厂 */ 
  227.         SecretKeyFactory keyFactory = null; 
  228.         try { 
  229.             keyFactory = SecretKeyFactory.getInstance("DES"); 
  230.         } catch (NoSuchAlgorithmException e) { 
  231.             e.printStackTrace(); 
  232.         } 
  233.   
  234.         /** 用密钥工厂把DESKeySpec转换成一个SecretKey对象 */ 
  235.         SecretKey key = null; 
  236.         try { 
  237.             key = keyFactory.generateSecret(dks); 
  238.         } catch (InvalidKeySpecException e) { 
  239.             e.printStackTrace(); 
  240.         } 
  241.   
  242.         /** Cipher对象实际完成加密操作 */ 
  243.         Cipher cipher = null; 
  244.         try { 
  245.             cipher = Cipher.getInstance("DES"); 
  246.         } catch (NoSuchAlgorithmException e) { 
  247.             e.printStackTrace(); 
  248.         } catch (NoSuchPaddingException e) { 
  249.             e.printStackTrace(); 
  250.         } 
  251.   
  252.         /** 用密钥初始化Cipher对象 */ 
  253.         try { 
  254.             cipher.init(Cipher.DECRYPT_MODE, key, sr); 
  255.         } catch (InvalidKeyException e) { 
  256.             e.printStackTrace(); 
  257.         } 
  258.   
  259.         /** 正式执行解密操作 */ 
  260.         byte decryptedData[] = null; 
  261.         try { 
  262.             decryptedData = cipher.doFinal(encryptedData); 
  263.         } catch (IllegalStateException e) { 
  264.             e.printStackTrace(); 
  265.         } catch (IllegalBlockSizeException e) { 
  266.             e.printStackTrace(); 
  267.         } catch (BadPaddingException e) { 
  268.             e.printStackTrace(); 
  269.         } 
  270.   
  271.         return decryptedData; 
  272.     } 
  273.   
  274.     /** 
  275.      * 取得安全密钥 此方法作废,因为每次key生成都不一样导致解密加密用的密钥都不一样， 从而导致Given final block not 
  276.      * properly padded错误. 
  277.      *  
  278.      * @return byte数组 
  279.      * @author 宋立君 
  280.      * @date 2014年07月03日 
  281.      */ 
  282.     private byte[] getKey() { 
  283.   
  284.         /** DES算法要求有一个可信任的随机数源 */ 
  285.         SecureRandom sr = new SecureRandom(); 
  286.   
  287.         /** 为我们选择的DES算法生成一个密钥生成器对象 */ 
  288.         KeyGenerator kg = null; 
  289.         try { 
  290.             kg = KeyGenerator.getInstance("DES"); 
  291.         } catch (NoSuchAlgorithmException e) { 
  292.             e.printStackTrace(); 
  293.         } 
  294.         kg.init(sr); 
  295.   
  296.         /** 生成密钥工具类 */ 
  297.         SecretKey key = kg.generateKey(); 
  298.   
  299.         /** 生成密钥byte数组 */ 
  300.         byte rawKeyData[] = key.getEncoded(); 
  301.   
  302.         return rawKeyData; 
  303.     } 
  304.   
  305. } 

二、Base64加密和解密

  1. package com.itjh.javaUtil; 
  2.   
  3. import java.io.*; 
  4.   
  5. /** 
  6.  * Base64 编码和解码。 
  7.  *  
  8.  * @author 宋立君 
  9.  * @date 2014年07月03日 
  10.  */ 
  11. public class Base64 { 
  12.   
  13.     public Base64() { 
  14.     } 
  15.   
  16.     /** 
  17.      * 功能：编码字符串 
  18.      *  
  19.      * @author 宋立君 
  20.      * @date 2014年07月03日 
  21.      * @param data 
  22.      *  源字符串 
  23.      * @return String 
  24.      */ 
  25.     public static String encode(String data) { 
  26.         return new String(encode(data.getBytes())); 
  27.     } 
  28.   
  29.     /** 
  30.      * 功能：解码字符串 
  31.      *  
  32.      * @author 宋立君 
  33.      * @date 2014年07月03日 
  34.      * @param data 
  35.      *  源字符串 
  36.      * @return String 
  37.      */ 
  38.     public static String decode(String data) { 
  39.         return new String(decode(data.toCharArray())); 
  40.     } 
  41.   
  42.     /** 
  43.      * 功能：编码byte[] 
  44.      *  
  45.      * @author 宋立君 
  46.      * @date 2014年07月03日 
  47.      * @param data 
  48.      *  源 
  49.      * @return char[] 
  50.      */ 
  51.     public static char[] encode(byte[] data) { 
  52.         char[] out = new char[((data.length + 2) / 3) * 4]; 
  53.         for (int i = 0, index = 0; i < data.length; i += 3, index += 4) { 
  54.             boolean quad = false; 
  55.             boolean trip = false; 
  56.   
  57.             int val = (0xFF & (int) data[i]); 
  58.             val <<= 8; 
  59.             if ((i + 1) < data.length) { 
  60.                 val |= (0xFF & (int) data[i + 1]); 
  61.                 trip = true; 
  62.             } 
  63.             val <<= 8; 
  64.             if ((i + 2) < data.length) { 
  65.                 val |= (0xFF & (int) data[i + 2]); 
  66.                 quad = true; 
  67.             } 
  68.             out[index + 3] = alphabet[(quad ? (val & 0x3F) : 64)]; 
  69.             val >>= 6; 
  70.             out[index + 2] = alphabet[(trip ? (val & 0x3F) : 64)]; 
  71.             val >>= 6; 
  72.             out[index + 1] = alphabet[val & 0x3F]; 
  73.             val >>= 6; 
  74.             out[index + 0] = alphabet[val & 0x3F]; 
  75.         } 
  76.         return out; 
  77.     } 
  78.   
  79.     /** 
  80.      * 功能：解码 
  81.      *  
  82.      * @author 宋立君 
  83.      * @date 2014年07月03日 
  84.      * @param data 
  85.      *  编码后的字符数组 
  86.      * @return byte[] 
  87.      */ 
  88.     public static byte[] decode(char[] data) { 
  89.   
  90.         int tempLen = data.length; 
  91.         for (int ix = 0; ix < data.length; ix++) { 
  92.             if ((data[ix] > 255) || codes[data[ix]] < 0) { 
  93.                 --tempLen; // ignore non-valid chars and padding 
  94.             } 
  95.         } 
  96.         // calculate required length: 
  97.         // -- 3 bytes for every 4 valid base64 chars 
  98.         // -- plus 2 bytes if there are 3 extra base64 chars, 
  99.         // or plus 1 byte if there are 2 extra. 
  100.   
  101.         int len = (tempLen / 4) * 3; 
  102.         if ((tempLen % 4) == 3) { 
  103.             len += 2; 
  104.         } 
  105.         if ((tempLen % 4) == 2) { 
  106.             len += 1; 
  107.   
  108.         } 
  109.         byte[] out = new byte[len]; 
  110.   
  111.         int shift = 0; // # of excess bits stored in accum 
  112.         int accum = 0; // excess bits 
  113.         int index = 0; 
  114.   
  115.         // we now go through the entire array (NOT using the 'tempLen' value) 
  116.         for (int ix = 0; ix < data.length; ix++) { 
  117.             int value = (data[ix] > 255) ? -1 : codes[data[ix]]; 
  118.   
  119.             if (value >= 0) { // skip over non-code 
  120.                 accum <<= 6; // bits shift up by 6 each time thru 
  121.                 shift += 6; // loop, with new bits being put in 
  122.                 accum |= value; // at the bottom. 
  123.                 if (shift >= 8) { // whenever there are 8 or more shifted in, 
  124.                     shift -= 8; // write them out (from the top, leaving any 
  125.                     out[index++] = // excess at the bottom for next iteration. 
  126.                     (byte) ((accum >> shift) & 0xff); 
  127.                 } 
  128.             } 
  129.         } 
  130.   
  131.         // if there is STILL something wrong we just have to throw up now! 
  132.         if (index != out.length) { 
  133.             throw new Error("Miscalculated data length (wrote " + index 
  134.                     + " instead of " + out.length + ")"); 
  135.         } 
  136.   
  137.         return out; 
  138.     } 
  139.   
  140.     /** 
  141.      * 功能：编码文件 
  142.      *  
  143.      * @author 宋立君 
  144.      * @date 2014年07月03日 
  145.      * @param file 
  146.      *  源文件 
  147.      */ 
  148.     public static void encode(File file) throws IOException { 
  149.         if (!file.exists()) { 
  150.             System.exit(0); 
  151.         } 
  152.   
  153.         else { 
  154.             byte[] decoded = readBytes(file); 
  155.             char[] encoded = encode(decoded); 
  156.             writeChars(file, encoded); 
  157.         } 
  158.         file = null; 
  159.     } 
  160.   
  161.     /** 
  162.      * 功能：解码文件。 
  163.      *  
  164.      * @author 宋立君 
  165.      * @date 2014年07月03日 
  166.      * @param file 
  167.      *  源文件 
  168.      * @throws IOException 
  169.      */ 
  170.     public static void decode(File file) throws IOException { 
  171.         if (!file.exists()) { 
  172.             System.exit(0); 
  173.         } else { 
  174.             char[] encoded = readChars(file); 
  175.             byte[] decoded = decode(encoded); 
  176.             writeBytes(file, decoded); 
  177.         } 
  178.         file = null; 
  179.     } 
  180.   
  181.     // 
  182.     // code characters for values 0..63 
  183.     // 
  184.     private static char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" 
  185.             .toCharArray(); 
  186.   
  187.     // 
  188.     // lookup table for converting base64 characters to value in range 0..63 
  189.     // 
  190.     private static byte[] codes = new byte[256]; 
  191.     static { 
  192.         for (int i = 0; i < 256; i++) { 
  193.             codes[i] = -1; 
  194.             // LoggerUtil.debug(i + "&" + codes[i] + " "); 
  195.         } 
  196.         for (int i = 'A'; i <= 'Z'; i++) { 
  197.             codes[i] = (byte) (i - 'A'); 
  198.             // LoggerUtil.debug(i + "&" + codes[i] + " "); 
  199.         } 
  200.   
  201.         for (int i = 'a'; i <= 'z'; i++) { 
  202.             codes[i] = (byte) (26 + i - 'a'); 
  203.             // LoggerUtil.debug(i + "&" + codes[i] + " "); 
  204.         } 
  205.         for (int i = '0'; i <= '9'; i++) { 
  206.             codes[i] = (byte) (52 + i - '0'); 
  207.             // LoggerUtil.debug(i + "&" + codes[i] + " "); 
  208.         } 
  209.         codes['+'] = 62; 
  210.         codes['/'] = 63; 
  211.     } 
  212.   
  213.     private static byte[] readBytes(File file) throws IOException { 
  214.         ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
  215.         byte[] b = null; 
  216.         InputStream fis = null; 
  217.         InputStream is = null; 
  218.         try { 
  219.             fis = new FileInputStream(file); 
  220.             is = new BufferedInputStream(fis); 
  221.             int count = 0; 
  222.             byte[] buf = new byte[16384]; 
  223.             while ((count = is.read(buf)) != -1) { 
  224.                 if (count > 0) { 
  225.                     baos.write(buf, 0, count); 
  226.                 } 
  227.             } 
  228.             b = baos.toByteArray(); 
  229.   
  230.         } finally { 
  231.             try { 
  232.                 if (fis != null) 
  233.                     fis.close(); 
  234.                 if (is != null) 
  235.                     is.close(); 
  236.                 if (baos != null) 
  237.                     baos.close(); 
  238.             } catch (Exception e) { 
  239.                 System.out.println(e); 
  240.             } 
  241.         } 
  242.   
  243.         return b; 
  244.     } 
  245.   
  246.     private static char[] readChars(File file) throws IOException { 
  247.         CharArrayWriter caw = new CharArrayWriter(); 
  248.         Reader fr = null; 
  249.         Reader in = null; 
  250.         try { 
  251.             fr = new FileReader(file); 
  252.             in = new BufferedReader(fr); 
  253.             int count = 0; 
  254.             char[] buf = new char[16384]; 
  255.             while ((count = in.read(buf)) != -1) { 
  256.                 if (count > 0) { 
  257.                     caw.write(buf, 0, count); 
  258.                 } 
  259.             } 
  260.   
  261.         } finally { 
  262.             try { 
  263.                 if (caw != null) 
  264.                     caw.close(); 
  265.                 if (in != null) 
  266.                     in.close(); 
  267.                 if (fr != null) 
  268.                     fr.close(); 
  269.             } catch (Exception e) { 
  270.                 System.out.println(e); 
  271.             } 
  272.         } 
  273.   
  274.         return caw.toCharArray(); 
  275.     } 
  276.   
  277.     private static void writeBytes(File file, byte[] data) throws IOException { 
  278.         OutputStream fos = null; 
  279.         OutputStream os = null; 
  280.         try { 
  281.             fos = new FileOutputStream(file); 
  282.             os = new BufferedOutputStream(fos); 
  283.             os.write(data); 
  284.   
  285.         } finally { 
  286.             try { 
  287.                 if (os != null) 
  288.                     os.close(); 
  289.                 if (fos != null) 
  290.                     fos.close(); 
  291.             } catch (Exception e) { 
  292.                 System.out.println(e); 
  293.             } 
  294.         } 
  295.     } 
  296.   
  297.     private static void writeChars(File file, char[] data) throws IOException { 
  298.         Writer fos = null; 
  299.         Writer os = null; 
  300.         try { 
  301.             fos = new FileWriter(file); 
  302.             os = new BufferedWriter(fos); 
  303.             os.write(data); 
  304.   
  305.         } finally { 
  306.             try { 
  307.                 if (os != null) 
  308.                     os.close(); 
  309.                 if (fos != null) 
  310.                     fos.close(); 
  311.             } catch (Exception e) { 
  312.                 e.printStackTrace(); 
  313.             } 
  314.         } 
  315.     } 
  316.   
  317.     // ///////////////////////////////////////////////// 
  318.     // end of test code. 
  319.     // ///////////////////////////////////////////////// 
  320.   
  321. } 
 
 

 

标签：

相关文章