`

解决Linux操作系统下AES解密失败的问题

    博客分类:
  • JAVA
阅读更多

现象描述:
windows上加解密正常,linux上加密正常,解密时发生如下异常

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的方法上,如下:
  1. public static SecretKey getKey (String strKey) {  
  2.          try {           
  3.             KeyGenerator _generator = KeyGenerator.getInstance( "AES" );  
  4.             _generator.init(128new SecureRandom(strKey.getBytes()));  
  5.                 return _generator.generateKey();  
  6.         }  catch (Exception e) {  
  7.              throw new RuntimeException( " 初始化密钥出现异常 " );  
  8.         }  
  9.       }   
修改到如下方式,问题解决:

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

原因分析

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;   
	}  


	
}
 


 

分享到:
评论
8 楼 spark_H 2015-03-24  
正好遇到这个问题,多谢楼主。
7 楼 chpn 2013-07-10  
非常感谢,折腾了我一天, 分析了一天的源码,最终在这里找到答案
6 楼 konglx 2013-03-04  
kokojjy 写道
你好,请问你在solaris试过没有?我在10版本上用你的方法试过了不行的啊,怎么回事,有别的办法没?



不好意思,solaris 没有试过
5 楼 zhyun29 2012-05-02  
引用
kgen.init(128, secureRandom);

不过我的程序这里只能填56,128就报错
4 楼 zhyun29 2012-05-02  
我也遇到这个问题,还好看到楼主的这篇文章,获益匪浅
3 楼 youyougulin 2012-02-29  
您好,问一下,加密的时候会有这种问题发生吗?
2 楼 yangeou 2011-12-06  
非常感谢,正好遇到了这个问题.
1 楼 kokojjy 2011-11-29  
你好,请问你在solaris试过没有?我在10版本上用你的方法试过了不行的啊,怎么回事,有别的办法没?

相关推荐

    完美解决Linux操作系统下aes解密失败的问题

    在Linux操作系统中,AES(Advanced Encryption Standard)解密失败是一个常见的问题,特别是在跨平台的环境中。AES是一种广泛使用的块密码,用于数据加密和保护敏感信息。然而,由于各种环境因素,有时在Linux系统中...

    DES加密解密(适用的Windows和Linux系统),防止Linux的下解密失败工具类

    这个DESEncrypt工具类是针对Windows和Linux系统设计的,确保在不同操作系统下都能进行一致的加密和解密操作,避免因环境差异导致的解密失败问题。主要关注点在于如何在不同系统中生成一致的随机数种子,以确保加密...

    AES加密解密源码,解决Linux报错问题

    windows正常,Linux报错。 此.java源码解决此问题。 linux密码随机问题。

    Linux上运行的C语言的AES加密算法

    Linux操作系统上的C语言实现AES加密算法是一个常见的任务,特别是在数据安全和网络安全领域。AES,全称为Advanced Encryption Standard,是目前广泛采用的一种对称加密标准,它提供了强大的数据保护能力。在Linux...

    AES加密算法在Linux文件系统中的设计与研究.pdf

    《AES加密算法在Linux文件系统中的设计与研究》这篇论文主要探讨了如何将先进的AES(高级加密标准)加密算法应用于Linux操作系统中的文件系统,以增强文件系统的安全性,保护用户数据。文章介绍了AES加密算法的基本...

    关于AES加密算法在linux下解密失败的解决办法

    总的来说,解决AES加密算法在Linux下解密失败的问题,关键在于理解和调试加密过程中的各个步骤,包括密钥生成、加密解密模式、编码方式以及潜在的系统差异。通过检查这些方面,可以定位问题并找到相应的解决方案。

    aes.rar_Linux AES_aes linux

    在嵌入式系统中,通常会考虑安全性和性能的平衡,例如通过硬件加速器来提升AES操作的速度,或者在资源受限的情况下采用更轻量级的实现。 总之,这个"aes.rar_Linux AES_aes linux"压缩包提供了在Linux嵌入式系统中...

    AES加密、解密(linux、window加密解密效果一致,支持中文)

    AES具有高效性和安全性,适用于大量数据的加密,尤其在Linux和Windows操作系统中,其加密和解密的效果是一致的,确保了跨平台的数据一致性。 AES的工作模式包括ECB(电子密码本)、CBC(密文块链)、CFB(密文反馈...

    C语言AES加密解密,CBC模式,256(含测试代码且结果与Java一致)

    AES的核心操作是基于替换和置换的混合网络,通过多次迭代来实现数据的加密。它支持128、192和256位的密钥长度,其中256位提供了最高等级的安全性。 **CBC模式:** CBC模式是一种常用的AES工作模式,它通过前一个...

    AES 算法实现(linux) 可移植

    在这个特定的项目中,标题提到的“AES 算法实现(linux) 可移植”表明这是一个在Linux环境下用C语言编写的AES加密库,设计时考虑了跨平台的兼容性。这意味着源代码可能使用了标准C库,并避免了依赖特定操作系统提供的...

    AES在windows下正常加解密,Linux下加密正常,解密异常(javax.crypto.BadPaddingExcepti

    * SecureRandom 实现完全随操作系统本身的內部状态, * 除非调用方在调用 getInstance 方法之后又调用了 setSeed 方法; * 该实现在 windows 上每次生成的 key 都相同, * 但是在 solaris 或部分 linux 系统上则...

    基于AES与SHA-256的Linux内核态数据加密.pdf

    该方案的关键点在于使用AES算法和SHA-256算法对数据进行加密,并使用Linux内核态下的模块实现加密和解密操作,确保了数据的安全性。 首先,本文简介了AES算法的基本原理和特点,包括AES算法的密钥长度可变、迭代...

    Qt-AES-master-linux-QT4.8.rar

    本文将深入探讨如何在Linux操作系统下,利用QT4.8框架实现AES的加密与解密功能。 首先,AES是一种块加密算法,其基本原理是通过一系列复杂的数学运算,如置换、混淆等,将明文转换为密文,然后再通过逆运算将密文...

    AES加密开源库,加解密效率高

    7. **跨平台兼容性**:作为一个开源库,它很可能可以在多种操作系统和编程语言环境下运行,例如Windows、Linux、macOS,以及Java、C++、Python等编程语言。 在实际应用中,这个库可能被用于各种场景,如保护用户...

    AES加解密代码.rar

    这个压缩包文件"AES加解密代码.rar"包含了AES算法的C语言实现,适用于嵌入式系统,且已经在Linux平台上经过验证。 AES的核心是基于替换和置换的操作,包括字节代换、行位移、列混淆和轮密钥添加四个步骤。它使用...

    AESLAZ LAZARUS的AES加解密组件 带DEMO

    10. **跨平台支持**:由于Lazarus的跨平台特性,AESLAZ组件理论上可以在多个操作系统上运行,如Windows、Linux、Mac OS等,使得加密解密功能可以应用于各种环境。 总的来说,AESLAZ Lazarus AES 加解密组件为开发者...

    AES加解密算法编译的so文件及demo

    SO文件是Linux系统下的动态链接库,它们包含了预编译的机器码,可以直接被应用程序加载和执行,无需再次编译。 在本案例中,"AES加解密算法编译的so文件"意味着开发者已经预先将AES算法实现并编译成了SO文件,这有...

    AES加密算法在Linux文件系统中的设计与研究 (1).pdf

    在Linux操作系统和文件系统开发领域,这可能包括关于AES加密算法的研究论文、Linux内核文档、文件系统设计的书籍等。此外,专业指导可能来自于经验丰富的开发者或教授,他们可能在设计和实现过程中提供了关键的建议...

    aes.zip_AES_R67_linux_加密

    总的来说,这个资源提供了一个在Linux系统上实现AES加密算法的C语言源代码,对于学习AES算法、理解其工作原理或在项目中使用AES加密功能的开发者来说非常有价值。通过阅读和分析这个源代码,可以深入理解AES的内部...

Global site tag (gtag.js) - Google Analytics