des解密失败 linux_linux des解密 - CSDN
  • 转自:http://blog.csdn.net/jerry_bj/article/details/8276552 package com.lasun.util; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io....import java.io.Ou...

    转自:http://blog.csdn.net/jerry_bj/article/details/8276552

    package com.lasun.util;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.security.Key;
    import java.security.SecureRandom;
    
    import javax.crypto.Cipher;
    import javax.crypto.CipherInputStream;
    import javax.crypto.CipherOutputStream;
    import javax.crypto.KeyGenerator;
    
    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    
    import com.lasun.core.services.ParameterManager;
    
    public class DESUtil {
        Key key;
    
        public DESUtil() {
    
        }
    
        public DESUtil(String str) {
            setKey(str); // 生成密匙
        }
    
        public Key getKey() {
            return key;
        }
    
        public void setKey(Key key) {
            this.key = key;
        }
    
       <span style="color:#FF0000;"> /**
         * 根据参数生成 KEY  
        */
        public void setKey (String strKey) {
            try {
                KeyGenerator _generator = KeyGenerator.getInstance("DES");
                //防止linux下 随机生成key 
                SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG" );
                secureRandom.setSeed(strKey.getBytes());
                
                _generator.init(56,secureRandom);
                this.key = _generator.generateKey();
                _generator = null;
            } catch (Exception e) {
                throw new RuntimeException(
                        "Error initializing SqlMap class. Cause: " + e);
            }
        }</span>
    
        <span style="color:#3366FF;">/**
         * 根据参数生成 KEY     
         */
        /*public void setKey(String strKey) {
            try {
                KeyGenerator _generator = KeyGenerator.getInstance("DES");
                _generator.init(new SecureRandom(strKey.getBytes()));
                this.key = _generator.generateKey();
                _generator = null;
            } catch (Exception e) {
                throw new RuntimeException(
                        "Error initializing SqlMap class. Cause: " + e);
            }
        }*/</span>
    
        /**
         * 加密 String 明文输入 ,String 密文输出
         */
        public String encryptStr(String strMing) {
            byte[] byteMi = null;
            byte[] byteMing = null;
            String strMi = "";
            BASE64Encoder base64en = new BASE64Encoder();
            try {
                byteMing = strMing.getBytes("UTF8");
                byteMi = this.encryptByte(byteMing);
                strMi = base64en.encode(byteMi);
            } catch (Exception e) {
                throw new RuntimeException(
                        "Error initializing SqlMap class. Cause: " + e);
            } finally {
                base64en = null;
                byteMing = null;
                byteMi = null;
            }
            return strMi;
        }
    
        /**
         * 解密 以 String 密文输入 ,String 明文输出
         *
         * @param strMi
         * @return
         */
        public String decryptStr(String strMi) {
            BASE64Decoder base64De = new BASE64Decoder();
            byte[] byteMing = null;
            byte[] byteMi = null;
            String strMing = "";
            try {
                byteMi = base64De.decodeBuffer(strMi);
                byteMing = this.decryptByte(byteMi);
                strMing = new String(byteMing, "UTF8");
            } catch (Exception e) {
                throw new RuntimeException(
                        "Error initializing SqlMap class. Cause: " + e);
            } finally {
                base64De = null;
                byteMing = null;
                byteMi = null;
            }
            return strMing;
        }
    
        /**
         * 加密以 byte[] 明文输入 ,byte[] 密文输出
         *
         * @param byteS
         * @return
         */
        private byte[] encryptByte(byte[] byteS) {
            byte[] byteFina = null;
            Cipher cipher;
            try {
                cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
                cipher.init(Cipher.ENCRYPT_MODE, key);
                byteFina = cipher.doFinal(byteS);
            } catch (Exception e) {
                throw new RuntimeException(
                        "Error initializing SqlMap class. Cause: " + e);
            } finally {
                cipher = null;
            }
            return byteFina;
        }
    
        /**
         * 解密以 byte[] 密文输入 , 以 byte[] 明文输出
         *
         * @param byteD
         * @return
         */
        private byte[] decryptByte(byte[] byteD) {
            Cipher cipher;
            byte[] byteFina = null;
            try {
                cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
                cipher.init(Cipher.DECRYPT_MODE, key);
                byteFina = cipher.doFinal(byteD);
            } catch (Exception e) {
                throw new RuntimeException(
                        "Error initializing SqlMap class. Cause: " + e);
            } finally {
                cipher = null;
            }
            return byteFina;
        }
     
        public static void main(String[] args) throws Exception {
            DESUtil des = new DESUtil("123456");
            // DES 加密文件
            // des.encryptFile("G:/test.doc", "G:/ 加密 test.doc");
            // DES 解密文件
            // des.decryptFile("G:/ 加密 test.doc", "G:/ 解密 test.doc");
            String str1 = "jui8qayuh7yhqwsh";
            // DES 加密字符串
            String str2 = des.encryptStr(str1);
            // DES 解密字符串
            String deStr = des.decryptStr(str2);
            System.out.println(" 加密前: " + str1);
            System.out.println(" 加密后: " + str2);
            System.out.println(" 加密后长度: " + str2.length());
            System.out.println(" 解密后: " + deStr);
        }
     }

    说明:蓝色部分(注释掉的)代码 在windows下面好使,但是在linux下面会导致每次生成的key不一样、也就是说加密之后再解密就会保存,网上说由于两个操作系统处理补充字节默认补齐的方式不同,所以出现这样的情况;

    红色部分代码防止在linux下随机生成key,在两个操作系统下通用。

    展开全文
  • DES java源代码如下: [java] view plaincopy import java.security.InvalidKeyException;  import java.security.NoSuchAlgorithmException;  import java.security.SecureRandom; ...

    DES java源代码如下:

    [java] view plaincopy
    1. import java.security.InvalidKeyException;  
    2. import java.security.NoSuchAlgorithmException;  
    3. import java.security.SecureRandom;  
    4. import java.security.spec.InvalidKeySpecException;  
    5.   
    6. import javax.crypto.BadPaddingException;  
    7. import javax.crypto.Cipher;  
    8. import javax.crypto.IllegalBlockSizeException;  
    9. import javax.crypto.KeyGenerator;  
    10. import javax.crypto.NoSuchPaddingException;  
    11. import javax.crypto.SecretKey;  
    12. import javax.crypto.SecretKeyFactory;  
    13. import javax.crypto.spec.DESKeySpec;  
    14.   
    15. public class DESEncryptTest {  
    16. private static final String DES_ALGORITHM = "DES";  
    17.           
    18.     /** 
    19.      * DES加密 
    20.      * @param plainData 
    21.      * @param secretKey 
    22.      * @return 
    23.      * @throws Exception 
    24.      */  
    25.     public String encryption(String plainData, String secretKey) throws Exception{  
    26.   
    27.         Cipher cipher = null;  
    28.         try {  
    29.             cipher = Cipher.getInstance(DES_ALGORITHM);  
    30.             cipher.init(Cipher.ENCRYPT_MODE, generateKey(secretKey));  
    31.               
    32.         } catch (NoSuchAlgorithmException e) {  
    33.             e.printStackTrace();  
    34.         } catch (NoSuchPaddingException e) {  
    35.             e.printStackTrace();  
    36.         }catch(InvalidKeyException e){  
    37.               
    38.         }  
    39.           
    40.         try {  
    41.             // 为了防止解密时报javax.crypto.IllegalBlockSizeException: Input length must be multiple of 8 when decrypting with padded cipher异常,  
    42.             // 不能把加密后的字节数组直接转换成字符串  
    43.             byte[] buf = cipher.doFinal(plainData.getBytes());  
    44.               
    45.             return Base64Utils.encode(buf);  
    46.               
    47.         } catch (IllegalBlockSizeException e) {  
    48.             e.printStackTrace();  
    49.             throw new Exception("IllegalBlockSizeException", e);  
    50.         } catch (BadPaddingException e) {  
    51.             e.printStackTrace();  
    52.             throw new Exception("BadPaddingException", e);  
    53.         }  
    54.           
    55.     }  
    56.   
    57.     /** 
    58.      * DES解密 
    59.      * @param secretData 
    60.      * @param secretKey 
    61.      * @return 
    62.      * @throws Exception 
    63.      */  
    64.     public String decryption(String secretData, String secretKey) throws Exception{  
    65.           
    66.         Cipher cipher = null;  
    67.         try {  
    68.             cipher = Cipher.getInstance(DES_ALGORITHM);  
    69.             cipher.init(Cipher.DECRYPT_MODE, generateKey(secretKey));  
    70.               
    71.         } catch (NoSuchAlgorithmException e) {  
    72.             e.printStackTrace();  
    73.             throw new Exception("NoSuchAlgorithmException", e);  
    74.         } catch (NoSuchPaddingException e) {  
    75.             e.printStackTrace();  
    76.             throw new Exception("NoSuchPaddingException", e);  
    77.         }catch(InvalidKeyException e){  
    78.             e.printStackTrace();  
    79.             throw new Exception("InvalidKeyException", e);  
    80.               
    81.         }  
    82.           
    83.         try {  
    84.               
    85.             byte[] buf = cipher.doFinal(Base64Utils.decode(secretData.toCharArray()));  
    86.               
    87.             return new String(buf);  
    88.               
    89.         } catch (IllegalBlockSizeException e) {  
    90.             e.printStackTrace();  
    91.             throw new Exception("IllegalBlockSizeException", e);  
    92.         } catch (BadPaddingException e) {  
    93.             e.printStackTrace();  
    94.             throw new Exception("BadPaddingException", e);  
    95.         }  
    96.     }  
    97.       
    98.       
    99.     /** 
    100.      * 获得秘密密钥 
    101.      *  
    102.      * @param secretKey 
    103.      * @return 
    104.      * @throws NoSuchAlgorithmException  
    105.      */  
    106.     private SecretKey generateKey(String secretKey) throws NoSuchAlgorithmException{  
    107.         SecureRandom secureRandom = new SecureRandom(secretKey.getBytes());  
    108.                   
    109.         // 为我们选择的DES算法生成一个KeyGenerator对象  
    110.         KeyGenerator kg = null;  
    111.         try {  
    112.             kg = KeyGenerator.getInstance(DES_ALGORITHM);  
    113.         } catch (NoSuchAlgorithmException e) {  
    114.         }  
    115.         kg.init(secureRandom);  
    116.         //kg.init(56, secureRandom);  
    117.           
    118.         // 生成密钥  
    119.         return kg.generateKey();  
    120.     }  
    121.               
    122.     public static void main(String[] a) throws Exception{  
    123.         String input = "cy11Xlbrmzyh:604:301:1353064296";  
    124.         String key = "37d5aed075525d4fa0fe635231cba447";  
    125.           
    126.         DESEncryptTest des = new DESEncryptTest();  
    127.           
    128.         String result = des.encryption(input, key);  
    129.         System.out.println(result);  
    130.           
    131.         System.out.println(des.decryption(result, key));  
    132.               
    133.     }  
    134.           
    135.     static class Base64Utils {  
    136.   
    137.         static private char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".toCharArray();  
    138.         static private byte[] codes = new byte[256];  
    139.         static {  
    140.             for (int i = 0; i < 256; i++)  
    141.                 codes[i] = -1;  
    142.             for (int i = 'A'; i <= 'Z'; i++)  
    143.                 codes[i] = (byte) (i - 'A');  
    144.             for (int i = 'a'; i <= 'z'; i++)  
    145.                 codes[i] = (byte) (26 + i - 'a');  
    146.             for (int i = '0'; i <= '9'; i++)  
    147.                 codes[i] = (byte) (52 + i - '0');  
    148.             codes['+'] = 62;  
    149.             codes['/'] = 63;  
    150.         }  
    151.           
    152.         /** 
    153.          * 将原始数据编码为base64编码 
    154.          */  
    155.         static public String encode(byte[] data) {  
    156.             char[] out = new char[((data.length + 2) / 3) * 4];  
    157.             for (int i = 0, index = 0; i < data.length; i += 3, index += 4) {  
    158.                 boolean quad = false;  
    159.                 boolean trip = false;  
    160.                 int val = (0xFF & (int) data[i]);  
    161.                 val <<= 8;  
    162.                 if ((i + 1) < data.length) {  
    163.                     val |= (0xFF & (int) data[i + 1]);  
    164.                     trip = true;  
    165.                 }  
    166.                 val <<= 8;  
    167.                 if ((i + 2) < data.length) {  
    168.                     val |= (0xFF & (int) data[i + 2]);  
    169.                     quad = true;  
    170.                 }  
    171.                 out[index + 3] = alphabet[(quad ? (val & 0x3F) : 64)];  
    172.                 val >>= 6;  
    173.                 out[index + 2] = alphabet[(trip ? (val & 0x3F) : 64)];  
    174.                 val >>= 6;  
    175.                 out[index + 1] = alphabet[val & 0x3F];  
    176.                 val >>= 6;  
    177.                 out[index + 0] = alphabet[val & 0x3F];  
    178.             }  
    179.               
    180.             return new String(out);  
    181.         }  
    182.   
    183.         /** 
    184.          * 将base64编码的数据解码成原始数据 
    185.          */  
    186.         static public byte[] decode(char[] data) {  
    187.             int len = ((data.length + 3) / 4) * 3;  
    188.             if (data.length > 0 && data[data.length - 1] == '=')  
    189.                 --len;  
    190.             if (data.length > 1 && data[data.length - 2] == '=')  
    191.                 --len;  
    192.             byte[] out = new byte[len];  
    193.             int shift = 0;  
    194.             int accum = 0;  
    195.             int index = 0;  
    196.             for (int ix = 0; ix < data.length; ix++) {  
    197.                 int value = codes[data[ix] & 0xFF];  
    198.                 if (value >= 0) {  
    199.                     accum <<= 6;  
    200.                     shift += 6;  
    201.                     accum |= value;  
    202.                     if (shift >= 8) {  
    203.                         shift -= 8;  
    204.                         out[index++] = (byte) ((accum >> shift) & 0xff);  
    205.                     }  
    206.                 }  
    207.             }  
    208.             if (index != out.length)  
    209.                 throw new Error("miscalculated data length!");  
    210.             return out;  
    211.         }  
    212.     }  
    213. }  


    此代码在windows下运行正常,对加密后的密文可以正常解密。运行结果如下:

    xl1nEww4mm09EvMy3tETBNg8HSfTFeBoilhNT7uBKBg=
    cy11Xlbrmzyh:604:301:1353064296

    但是放到linux上运行,则报错,错误信息如下图:

    通过图片可以看到,对相同的明文(cy11Xlbrmzyh:604:301:1353064296)进行加密,在linux上加密后的结果和在windows上是不同的;而且在linux上不能对加密之后的密文进行解密,并抛出异常。

     

    原因:
    经过检查之后,定位在生成KEY的方法上,即如下红色代码:
    [java] view plaincopy
    1. /** 
    2.      * 获得秘密密钥 
    3.      *  
    4.      * @param secretKey 
    5.      * @return 
    6.      * @throws NoSuchAlgorithmException  
    7.      */  
    8.     private SecretKey generateKey(String secretKey) throws NoSuchAlgorithmException{  
    9.         <span style="color:#ff0000;">SecureRandom secureRandom = new SecureRandom(secretKey.getBytes()); //主要是此处代码  
    10. </span>               
    11.         // 为我们选择的DES算法生成一个KeyGenerator对象  
    12.         KeyGenerator kg = null;  
    13.         try {  
    14.             kg = KeyGenerator.getInstance(DES_ALGORITHM);  
    15.         } catch (NoSuchAlgorithmException e) {  
    16.         }  
    17.         kg.init(secureRandom);  
    18.         //kg.init(56, secureRandom);  
    19.           
    20.         // 生成密钥  
    21.         return kg.generateKey();  
    22.     }  

    SecureRandom 实现完全随操作系统本身的內部状态,除非调用方在 getInstance 方法,然后调用 setSeed 方法;该实现在 windows 上每次生成的 key 都相同,但是在 solaris 或部分 linux 系统上则不同。关于SecureRandom类的详细介绍,见 http://yangzb.iteye.com/blog/325264

     

    解决办法

     方法1:把原来的generateKey方法中红色如下的红色部分:

    [java] view plaincopy
    1. /** 
    2.  * 获得秘密密钥 
    3.  *  
    4.  * @param secretKey 
    5.  * @return 
    6.  * @throws NoSuchAlgorithmException  
    7.  */  
    8. private SecretKey generateKey(String secretKey) throws NoSuchAlgorithmException{  
    9.     <span style="color:#ff0000;"><span><code class="comments">//防止linux下 随机生成key</code></span>  
    10.     SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");  
    11.     secureRandom.setSeed(secretKey.getBytes());  
    12. /span>        
    13.     // 为我们选择的DES算法生成一个KeyGenerator对象  
    14.     KeyGenerator kg = null;  
    15.     try {  
    16.         kg = KeyGenerator.getInstance(DES_ALGORITHM);  
    17.     } catch (NoSuchAlgorithmException e) {  
    18.     }  
    19.     kg.init(secureRandom);  
    20.     //kg.init(56, secureRandom);  
    21.       
    22.     // 生成密钥  
    23.     return kg.generateKey();  
    24. }  


    方法2:不使用SecureRandom生成SecretKey,而是使用SecretKeyFactory;重新实现方法generateKey,代码如下

    [java] view plaincopy
    1. /** 
    2.  * 获得密钥 
    3.  *  
    4.  * @param secretKey 
    5.  * @return 
    6.  * @throws NoSuchAlgorithmException  
    7.  * @throws InvalidKeyException  
    8.  * @throws InvalidKeySpecException  
    9.  */  
    10. private SecretKey generateKey(String secretKey) throws NoSuchAlgorithmException,InvalidKeyException,InvalidKeySpecException{  
    11.       
    12.     SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES_ALGORITHM);  
    13.     DESKeySpec keySpec = new DESKeySpec(secretKey.getBytes());  
    14.     keyFactory.generateSecret(keySpec);  
    15.     return keyFactory.generateSecret(keySpec);  
    16. }  
    展开全文
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
    现象描述:

    windows上加解密正常,linux上加密正常,解密时发生 如下异常

    Des修改方式如下


     public void getKey(String strKey) {
    		try {
    			KeyGenerator _generator = KeyGenerator.getInstance("DES");
    			SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
    			secureRandom.setSeed(strKey.getBytes());
    			_generator.init(secureRandom);
    			this.key = _generator.generateKey();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}



    AES修改方式如下:
    javax.crypto.BadPaddingException: Given final block not properly padded

           at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)
           at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)
           at com.sun.crypto.provider.AESCipher.engineDoFinal(DashoA13*..)
           at javax.crypto.Cipher.doFinal(DashoA13*..)
           at chb.test.crypto.AESUtils.crypt(AESUtils.java:386)
           at chb.test.crypto.AESUtils.AesDecrypt(AESUtils.java:254)
           at chb.test.crypto.AESUtils.main(AESUtils.java:40) 

    解决方法:
    经过检查之后,定位在生成KEY的方法上,如下:
    public static SecretKey getKey (String strKey) {            try {                        KeyGenerator _generator = KeyGenerator.getInstance( "AES" );               _generator.init(128new SecureRandom(strKey.getBytes()));                   return _generator.generateKey();           }  catch (Exception e) {                throw new RuntimeException( " 初始化密钥出现异常 " );           }         }   
    修改到如下方式,问题解决:

    public static SecretKey getKey(String strKey) {          try {                      KeyGenerator _generator = KeyGenerator.getInstance( "AES" );              SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG" );             secureRandom.setSeed(strKey.getBytes());             _generator.init(128,secureRandom);                 return _generator.generateKey();         }  catch (Exception e) {              throw new RuntimeException( " 初始化密钥出现异常 " );         }       }   

    原因分析

    SecureRandom 实现完全隨操作系统本身的內部狀態,除非調用方在調用 getInstance 方法之後又調用了 setSeed 方法;该实现在 windows 上每次生成的 key 都相同,但是在 solaris 或部分 linux 系统上则不同。

    原因二:

    1、加密完byte[] 后,需要将加密了的byte[] 转换成base64保存,如: 
    BASE64Encoder base64encoder = new BASE64Encoder(); 
    String encode=base64encoder.encode(bytes); 

    2、解密前,需要将加密后的字符串从base64转回来再解密,如: 
    BASE64Decoder base64decoder = new BASE64Decoder(); 
    byte[] encodeByte = base64decoder.decodeBuffer(str); 

    完整例子:

    package com.travelsky.tdp.pkgStock.util;
    
    import java.io.IOException;
    import java.io.UnsupportedEncodingException;
    import java.security.InvalidKeyException;
    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;
    
    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    
    public class SecurityAES {
    	private final static String encoding = "UTF-8"; 
    	/**
    	 * AES加密
    	 * 
    	 * @param content
    	 * @param password
    	 * @return
    	 */
    	public static String encryptAES(String content, String password) {
    		byte[] encryptResult = encrypt(content, password);
    		String encryptResultStr = parseByte2HexStr(encryptResult);
    		// BASE64位加密
    		encryptResultStr = ebotongEncrypto(encryptResultStr);
    		return encryptResultStr;
    	}
    
    	/**
    	 * AES解密
    	 * 
    	 * @param encryptResultStr
    	 * @param password
    	 * @return
    	 */
    	public static String decrypt(String encryptResultStr, String password) {
    		// BASE64位解密
    		String decrpt = ebotongDecrypto(encryptResultStr);
    		byte[] decryptFrom = parseHexStr2Byte(decrpt);
    		byte[] decryptResult = decrypt(decryptFrom, password);
    		return new String(decryptResult);
    	}
    
    		/**
    	 * 加密字符串
    	 */
    	public static String ebotongEncrypto(String str) {
    		BASE64Encoder base64encoder = new BASE64Encoder();
    		String result = str;
    		if (str != null && str.length() > 0) {
    			try {
    				byte[] encodeByte = str.getBytes(encoding);
    				result = base64encoder.encode(encodeByte);
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		}
    		//base64加密超过一定长度会自动换行 需要去除换行符
    		return result.replaceAll("\r\n", "").replaceAll("\r", "").replaceAll("\n", "");
    	}
    
    	/**
    	 * 解密字符串
    	 */
    	public static String ebotongDecrypto(String str) {
    		BASE64Decoder base64decoder = new BASE64Decoder();
    		try {
    			byte[] encodeByte = base64decoder.decodeBuffer(str);
    			return new String(encodeByte);
    		} catch (IOException e) {
    			e.printStackTrace();
    			return str;
    		}
    	}
    	/**  
    	 * 加密  
    	 *   
    	 * @param content 需要加密的内容  
    	 * @param password  加密密码  
    	 * @return  
    	 */  
    	private static byte[] encrypt(String content, String password) {   
    	        try {              
    	                KeyGenerator kgen = KeyGenerator.getInstance("AES"); 
    	                //防止linux下 随机生成key
    	                SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG" );   
    	                secureRandom.setSeed(password.getBytes());   
    	                kgen.init(128, secureRandom);
    	                //kgen.init(128, new SecureRandom(password.getBytes()));   
    	                SecretKey secretKey = kgen.generateKey();   
    	                byte[] enCodeFormat = secretKey.getEncoded();   
    	                SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");   
    	                Cipher cipher = Cipher.getInstance("AES");// 创建密码器   
    	                byte[] byteContent = content.getBytes("utf-8");   
    	                cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化   
    	                byte[] result = cipher.doFinal(byteContent);   
    	                return result; // 加密   
    	        } catch (NoSuchAlgorithmException e) {   
    	                e.printStackTrace();   
    	        } catch (NoSuchPaddingException e) {   
    	                e.printStackTrace();   
    	        } catch (InvalidKeyException e) {   
    	                e.printStackTrace();   
    	        } catch (UnsupportedEncodingException e) {   
    	                e.printStackTrace();   
    	        } catch (IllegalBlockSizeException e) {   
    	                e.printStackTrace();   
    	        } catch (BadPaddingException e) {   
    	                e.printStackTrace();   
    	        }   
    	        return null;   
    	}  
    
    
    	/**解密  
    	 * @param content  待解密内容  
    	 * @param password 解密密钥  
    	 * @return  
    	 */  
    	private static byte[] decrypt(byte[] content, String password) {   
    	        try {   
    	                 KeyGenerator kgen = KeyGenerator.getInstance("AES"); 
    	               //防止linux下 随机生成key
    		             SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG" );   
    		             secureRandom.setSeed(password.getBytes());   
    		             kgen.init(128, secureRandom);
    	                 //kgen.init(128, new SecureRandom(password.getBytes()));   
    	                 SecretKey secretKey = kgen.generateKey();   
    	                 byte[] enCodeFormat = secretKey.getEncoded();   
    	                 SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");               
    	                 Cipher cipher = Cipher.getInstance("AES");// 创建密码器   
    	                cipher.init(Cipher.DECRYPT_MODE, key);// 初始化   
    	                byte[] result = cipher.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;   
    	}  
    
    	/**将二进制转换成16进制  
    	 * @param buf  
    	 * @return  
    	 */  
    	public static String parseByte2HexStr(byte buf[]) {   
    	        StringBuffer sb = new StringBuffer();   
    	        for (int i = 0; i < buf.length; i++) {   
    	                String hex = Integer.toHexString(buf[i] & 0xFF);   
    	                if (hex.length() == 1) {   
    	                        hex = '0' + hex;   
    	                }   
    	                sb.append(hex.toUpperCase());   
    	        }   
    	        return sb.toString();   
    	}  
    
    
    	/**将16进制转换为二进制  
    	 * @param hexStr  
    	 * @return  
    	 */  
    	public static byte[] parseHexStr2Byte(String hexStr) {   
    	        if (hexStr.length() < 1)   
    	                return null;   
    	        byte[] result = new byte[hexStr.length()/2];   
    	        for (int i = 0;i< hexStr.length()/2; i++) {   
    	                int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);   
    	                int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);   
    	                result[i] = (byte) (high * 16 + low);   
    	        }   
    	        return result;   
    	}  
    
    
    	
    }

    转载于:https://my.oschina.net/skyfree/blog/62370

    展开全文
  • DES加密解密(适用Windows和Linux系统)防止linux解密失败,主要是SecureRandom 实现完全随操作系统本身的內部状态
  • package com.abc.core.utils... import java.io.UnsupportedEncodingException; import java.security.InvalidKeyException; import java.security.Key; import java.security.NoSuchAlgorithmException;...import ja...

    package com.abc.core.utils;


    import java.io.UnsupportedEncodingException;
    import java.security.InvalidKeyException;
    import java.security.Key;
    import java.security.NoSuchAlgorithmException;

    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.ShortBufferException;
    import javax.crypto.spec.SecretKeySpec;

    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;


    /**
     * 将数据使用DES算法加密,再进行base64编码,方便进行网络传输,支持中文。
     * @author Administrator
     */
    public class CipherBase64 {
        @SuppressWarnings("unused")
        private static Logger logger =LogManager.getLogger(CipherBase64.class);
        
        private Key key;
        private Cipher cipher;
        private static CipherBase64 singltonEncrypt = null;
        private static CipherBase64 singltonDecrypt = null;
        
        @SuppressWarnings("unused")
        private char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
            .toCharArray();

        private byte[] codes = new byte[256];    
        
        /**
         * 
         * 初始化,由于消耗内存过多,所以设置为private,只能用getInstance()方法生成一个对象
         * 
         */
        private CipherBase64(String model) {
            for (int i = 0; i < 256; i++)
                codes[i] = -1;
            for (int i = 'A'; i <= 'Z'; i++)
                codes[i] = (byte) (i - 'A');
            for (int i = 'a'; i <= 'z'; i++)
                codes[i] = (byte) (26 + i - 'a');
            for (int i = '0'; i <= '9'; i++)
                codes[i] = (byte) (52 + i - '0');
            codes['+'] = 62;
            codes['/'] = 63;
            try {
                cipher = Cipher.getInstance(model);
            } catch (NoSuchAlgorithmException e) {
                singltonEncrypt = null;
                singltonDecrypt = null;
                logger.error(e.getMessage(), e);
            } catch (NoSuchPaddingException e) {
                singltonEncrypt = null;
                singltonDecrypt = null;
                logger.error(e.getMessage(), e);
            }
        }

        public static CipherBase64 getSingltonDecryptInstance() throws InvalidKeyException {
               if (singltonDecrypt == null) {
                    synchronized (CipherBase64.class) {
                        if (singltonDecrypt == null) {
                            CipherBase64 cipherBase = new CipherBase64("DES/ECB/NoPadding");
                            cipherBase.setKey(SystemParaUtil.SECRET_KEY);
                            cipherBase.initDecrypt();
                            singltonDecrypt = cipherBase;
                        }
                    }
                }

            return singltonDecrypt;
        }

        public static CipherBase64 getSingltonEncryptInstance() throws InvalidKeyException {
               if (singltonEncrypt == null) {
                    synchronized (CipherBase64.class) {
                        if (singltonEncrypt == null) {
                            CipherBase64 cipherBase = new CipherBase64("DES");
                            cipherBase.setKey(SystemParaUtil.SECRET_KEY);
                            cipherBase.initEncrypt();
                            singltonEncrypt = cipherBase;
                        }
                    }
                }
               
            
            return singltonEncrypt;
        }
        /**
         * 
         * 
         * 加密
         * @param sourceString
         * @return
         * @throws InvalidKeyException
         * @throws UnsupportedEncodingException
         * @throws IllegalStateException
         * @throws IllegalBlockSizeException
         * @throws BadPaddingException
         */
        private String encrpt(String sourceString) throws InvalidKeyException,
                UnsupportedEncodingException, IllegalStateException,
                IllegalBlockSizeException, BadPaddingException {
            String cryptedString = null;
            int cypheredBytes = 0;
            byte[] inputBytes = sourceString.getBytes("GBK");
            byte[] outputBytes = new byte[256];
            while (true) {
                try {
                    cypheredBytes = cipher.doFinal(inputBytes, 0,
                            inputBytes.length, outputBytes, 0);
                    break;
                } catch (ShortBufferException e) {
                    outputBytes = new byte[outputBytes.length * 2];
                }
            }
            cryptedString = new String(outputBytes, 0, cypheredBytes, "iso-8859-1");
            return cryptedString;
        }

        /**
         * 
         * 解密
         * @param sourcebyte
         * @return
         * @throws InvalidKeyException
         * @throws UnsupportedEncodingException
         * @throws IllegalStateException
         * @throws IllegalBlockSizeException
         * @throws BadPaddingException
         */
        private String decrypt(byte[] sourcebyte) throws InvalidKeyException,
                UnsupportedEncodingException, IllegalStateException,
                IllegalBlockSizeException, BadPaddingException{
            if(sourcebyte == null || sourcebyte.length == 0){
                throw new IllegalBlockSizeException("sourcebyte length equals 0");
            }
            String cryptedString = null;
            int cypheredBytes = 0;
            byte[] inputBytes = sourcebyte;
            byte[] outputBytes = new byte[256];
            while (true) {
                try {
                    cypheredBytes = cipher.doFinal(inputBytes, 0,
                            inputBytes.length, outputBytes, 0);
                    break;
                } catch (ShortBufferException e) {
                    outputBytes = new byte[outputBytes.length * 2];
                }
            }
            cryptedString = new String(outputBytes, 0, cypheredBytes, "GBK");
            return cryptedString;
        }
        
        public String encrpts(String string) throws InvalidKeyException,
                UnsupportedEncodingException, IllegalStateException,
                IllegalBlockSizeException, BadPaddingException {        
            return SimpleCrypto.toHex(encrpt(string));
        }

        public String decrypts(String string) throws InvalidKeyException,
                UnsupportedEncodingException, IllegalStateException,
                IllegalBlockSizeException, BadPaddingException, Exception {
            return decrypt(SimpleCrypto.toByte(string));
        }
        
        /**
         * 设置密钥
         * @param keyString
         */
        private void setKey(String keyString) {
            byte[] keyData = keyString.getBytes();
            key = new SecretKeySpec(keyData, 0, keyData.length, "DES");
        }

        private void initDecrypt() throws InvalidKeyException {
            cipher.init(Cipher.DECRYPT_MODE, key);
        }

        private void initEncrypt() throws InvalidKeyException {
            cipher.init(Cipher.ENCRYPT_MODE, key);
        }
    }
    注意点:
    (1)加密获取实例:DES,因为DES就是:DES/ECB/PKCS5Padding,默认的加密算法
    (2)解密获取实例:DES/ECB/NoPadding
    (3)加密前,会使用默认的空格填充,解密的时候要去空格。

    展开全文
  • 但是在linux中,des加密解密生成的密钥,是在变化的,所以加密后,解密失败, 代码修改如下: 生成密钥方法: public static String getSecretKey(String key) throws Exception { KeyGenerator keyGen...
  • AES、DES、RSA等加密出现解密失败原因 我们在用微信支付或者其他第三方接口用对称或者非对称加密时经常会遇到明明公钥私钥都正确,可是第三方服务端还是返回解密失败 解密错误原因 1.本地字符串编码和加密后字节编码...
  • 1,DES加密解密(适用Windows和Linux系统)防止linux解密失败 2, 解决Linux操作系统下AES解密失败的问题   原因分析:   SecureRandom 实现完全随操作系统本身的內部状态,除非调用方在调用 ...
  • windows上加解密正常,linux上加密正常,解密时发生如下异常,异常信息如下: [ERROR] 2018-10-15 09:30:35,998 method:com.iscas.ippc.common.utils.RandomPwd.decrypt(RandomPwd.java:120)decrypt Exception is ...
  • Exception in thread "main" javax.crypto.BadPaddingException: Given final block not properly padded at com.sun.crypto.provider.CipherCore.doFinal(CipherCore.java:811) at com.sun.crypto.provider.Ciphe
  • Android DES加密解密

    千次阅读 2013-08-02 21:26:11
    就是加密的结果不一样,更不要说Android平台的加密输入作为java DES解密输出了。这样的话,客户端和服务器端就不能进行通信了。我网上之前也发帖子问了不少人,但是回答都不满意。 今天部门的另外一个同事跟我说了...
  • 不同则关于的SecureRandom的类的详细介绍,见 http://yangzb.iteye.com/blog/325264  package ... import java.net.URLEncoder; import java.security.InvalidKeyException; import jav...
  • 解密的时候报错:  javax.crypto.BadPaddingException: Given final block not properly padded  该异常是在解密的时候抛出的,加密的方法没有问题。 但是两个方法的唯一差别是Cipher对象的模式不一样,...
  • 为什么80%的码农都做不了架构师?>>> ...
  • Android Des加密解密

    2019-06-29 08:39:36
    算法转自:http://www.linuxidc.com/Linux/2011-08/41866.htm import java.security.Key; import java.security.spec.AlgorithmParameterSpec; import javax.crypto.Cipher; import javax.crypto....
1 2 3 4 5 ... 20
收藏数 1,336
精华内容 534
关键字:

des解密失败 linux