javaaes文件加密

Ⅰ java如何用Aes加密和解密

你解密的key必須是加密的key啊
你看看，你解密的時候又KeyGenerator.getInstance("AES").generateKey();這是重新搞了一個key啊，當然解不出來了
我估計你這代碼人家原先是寫在一起的吧，加密完了再直接解密給你看，人家只generateKey一次，自然很順利，你分成了兩個例子，居然分別generateKey，自然失敗

Ⅱ JAVA實現AES加密疑問么

和加密沒關系，SecureRandom是生成安全隨機數序列，password.getBytes()是種子，只要種子相同，序列就一樣，所以解密只要有password就行，可以復原這個序列

Ⅲ java實現aes加密或者解密，不用工具包的怎麼做

importjava.security.InvalidKeyException;
importjava.security.Key;
importjava.security.NoSuchAlgorithmException;

importjavax.crypto.*;
importjavax.crypto.spec.*;

/**
*
*@authorwchun
*
*AES128演算法，加密模式為ECB，填充模式為pkcs7（實際就是pkcs5）
*
*
*/
publicclassAES{
	
	staticfinalStringalgorithmStr="AES/ECB/PKCS5Padding";
	
	;
	
	staticprivateCiphercipher;
	
	staticbooleanisInited=false;
	
	//初始化
	staticprivatevoidinit()
	{
		
		//初始化keyGen
		try{
			keyGen=KeyGenerator.getInstance("AES");
		}catch(NoSuchAlgorithmExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		keyGen.init(128);
		
		//初始化cipher
		try{
			cipher=Cipher.getInstance(algorithmStr);
		}catch(NoSuchAlgorithmExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}catch(NoSuchPaddingExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		isInited=true;
	}
	
	publicstaticbyte[]GenKey()
	{
		if(!isInited)//如果沒有初始化過,則初始化
		{
			init();
		}
		returnkeyGen.generateKey().getEncoded();
	}
	
	publicstaticbyte[]Encrypt(byte[]content,byte[]keyBytes)
	{
		byte[]encryptedText=null;
		
		if(!isInited)//為初始化
		{
			init();
		}
		
		Keykey=newSecretKeySpec(keyBytes,"AES");
		
		try{
			cipher.init(Cipher.ENCRYPT_MODE,key);
		}catch(InvalidKeyExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		try{
			encryptedText=cipher.doFinal(content);
		}catch(IllegalBlockSizeExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}catch(BadPaddingExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		returnencryptedText;
	}
	
	//解密為byte[]
	publicstaticbyte[]DecryptToBytes(byte[]content,byte[]keyBytes)
	{
		byte[]originBytes=null;
		if(!isInited)
		{
			init();
		}
		
		Keykey=newSecretKeySpec(keyBytes,"AES");
		
		try{
			cipher.init(Cipher.DECRYPT_MODE,key);
		}catch(InvalidKeyExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		//解密
		try{
			originBytes=cipher.doFinal(content);
		}catch(IllegalBlockSizeExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}catch(BadPaddingExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		returnoriginBytes;
	}
}

Ⅳ JAVA如何AES和DES加密

publicclassDESCoder{
publicstaticbyte[]decodeBase64(Stringdata)throwsException{
returnnewBASE64Decoder().decodeBuffer(data);
}
(byte[]key)throwsException{
returnnewBASE64Encoder().encodeBuffer(key);
}
/**
*生成密鑰
*@paramseed
*@return
*@throwsException
*/
publicstaticStringinitKey(Stringseed)throwsException{
SecureRandomsecureRandom=null;
if(seed!=null){
secureRandom=newSecureRandom(decodeBase64(seed));
}else{
secureRandom=newSecureRandom();
}
KeyGeneratorkg=KeyGenerator.getInstance("DES");
kg.init(secureRandom);
SecretKeykey=kg.generateKey();
returnencodeBase64(key.getEncoded());
}
/**
*轉換成密鑰
*@paramkey
*@return
*@throwsException
*/
publicstaticKeytoKey(byte[]key)throwsException{
DESKeySpecdks=newDESKeySpec(key);
SecretKeyFactorykeyFactory=SecretKeyFactory.getInstance("DES");
SecretKeysecretKey=keyFactory.generateSecret(dks);
//當使用其他對稱加密演算法時，如AES、Blowfish等演算法時，用下述代碼替換上述三行代碼
//SecretKeysecretKey=newSecretKeySpec(key,"AES");
returnsecretKey;
}
/**
*加密
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]encrypt(byte[]data,Stringkey)throwsException{
Keyk=toKey(decodeBase64(key));
Ciphercipher=Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE,k);
returncipher.doFinal(data);
}
/***
*解密
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]decrypt(byte[]data,Stringkey)throwsException{
Keyk=toKey(decodeBase64(key));
Ciphercipher=Cipher.getInstance("DES");
cipher.init(Cipher.DECRYPT_MODE,k);
returncipher.doFinal(data);
}
publicstaticvoidmain(String[]args)throwsException{
System.out.println(initKey(null));
Stringtxt="abc";
Stringkey=initKey(null);
byte[]data=encrypt(txt.getBytes(),key);
System.out.println(newString(encodeBase64(data)));
byte[]output=decrypt(data,key);
System.out.println(newString(output));
}
}

Ⅳ 關於Java的AES加密問題

使用AES加密時，當密鑰大於128時，代碼會拋出java.security.InvalidKeyException: Illegal key size or default parameters

Illegal key size or default parameters是指密鑰長度是受限制的，java運行時環境讀到的是受限的policy文件。文件位於${java_home}/jre/lib/security

這種限制是因為美國對軟體出口的控制。

解決辦法：
去掉這種限制需要下載Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files.網址如下。

下載包的readme.txt 有安裝說明。就是替換${java_home}/jre/lib/security/ 下面的local_policy.jar和US_export_policy.jar
jdk 5: http://www.oracle.com/technetwork/java/javasebusiness/downloads/java-archive-downloads-java-plat-419418.html#jce_policy-1.5.0-oth-JPR

Ⅵ 請教個關於Java實現AES加解密的問題

JDK對DESede演算法的支持

密鑰長度：128位
工作模式：ECB/CBC/PCBC/CTR/CTS/CFB/CFB8 to CFB128/OFB/OBF8 to OFB128
填充方式：Nopadding/PKCS5Padding/ISO10126Padding/

AES加密解密的java實現：

package com.kongxincai.encanddec;import java.security.Key;import java.security.NoSuchAlgorithmException;import javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import javax.crypto.spec.SecretKeySpec;public class AESCoder { private static final String KEY_ALGORITHM = "AES"; private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";//默認的加密演算法

public static byte[] initSecretKey() { //返回生成指定演算法密鑰生成器的 KeyGenerator 對象
KeyGenerator kg = null; try {
kg = KeyGenerator.getInstance(KEY_ALGORITHM);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace(); return new byte[0];
} //初始化此密鑰生成器，使其具有確定的密鑰大小 //AES 要求密鑰長度為 128
kg.init(128); //生成一個密鑰
SecretKey secretKey = kg.generateKey(); return secretKey.getEncoded();
} private static Key toKey(byte[] key){ //生成密鑰
return new SecretKeySpec(key, KEY_ALGORITHM);
} public static byte[] encrypt(byte[] data,Key key) throws Exception{ return encrypt(data, key,DEFAULT_CIPHER_ALGORITHM);
} public static byte[] encrypt(byte[] data,byte[] key) throws Exception{ return encrypt(data, key,DEFAULT_CIPHER_ALGORITHM);
} public static byte[] encrypt(byte[] data,byte[] key,String cipherAlgorithm) throws Exception{ //還原密鑰
Key k = toKey(key); return encrypt(data, k, cipherAlgorithm);
} public static byte[] encrypt(byte[] data,Key key,String cipherAlgorithm) throws Exception{ //實例化
Cipher cipher = Cipher.getInstance(cipherAlgorithm); //使用密鑰初始化，設置為加密模式 cipher.init(Cipher.ENCRYPT_MODE, key); //執行操作
return cipher.doFinal(data);
} public static byte[] decrypt(byte[] data,byte[] key) throws Exception{ return decrypt(data, key,DEFAULT_CIPHER_ALGORITHM);
} public static byte[] decrypt(byte[] data,Key key) throws Exception{ return decrypt(data, key,DEFAULT_CIPHER_ALGORITHM);
} public static byte[] decrypt(byte[] data,byte[] key,String cipherAlgorithm) throws Exception{ //還原密鑰
Key k = toKey(key); return decrypt(data, k, cipherAlgorithm);
} public static byte[] decrypt(byte[] data,Key key,String cipherAlgorithm) throws Exception{ //實例化
Cipher cipher = Cipher.getInstance(cipherAlgorithm); //使用密鑰初始化，設置為解密模式 cipher.init(Cipher.DECRYPT_MODE, key); //執行操作
return cipher.doFinal(data);
} private static String showByteArray(byte[] data){ if(null == data){ return null;
}
StringBuilder sb = new StringBuilder("{"); for(byte b:data){
sb.append(b).append(",");
}
sb.deleteCharAt(sb.length()-1);
sb.append("}"); return sb.toString();
} public static void main(String[] args) throws Exception { byte[] key = initSecretKey();
System.out.println("key："+showByteArray(key));
Key k = toKey(key); //生成秘鑰
String data ="AES數據";
System.out.println("加密前數據: string:"+data);
System.out.println("加密前數據: byte[]:"+showByteArray(data.getBytes()));
System.out.println(); byte[] encryptData = encrypt(data.getBytes(), k);//數據加密
System.out.println("加密後數據: byte[]:"+showByteArray(encryptData));// System.out.println("加密後數據: hexStr:"+Hex.encodeHexStr(encryptData)); System.out.println(); byte[] decryptData = decrypt(encryptData, k);//數據解密
System.out.println("解密後數據: byte[]:"+showByteArray(decryptData));
System.out.println("解密後數據: string:"+new String(decryptData));
}
}

Ⅶ JAVA AES加密

這篇文章有詳細的AES演算法的使用講解，希望可以幫助到你，https://blog.csdn.net/xingkong_hdc/article/details/79413462

Ⅷ 通過Java如何實現AES密碼演算法

1. AES加密字元串

public static byte[] encrypt(String content, String password) {
try {
KeyGenerator kgen = KeyGenerator.getInstance("AES");// 創建AES的Key生產者

kgen.init(128, new SecureRandom(password.getBytes()));// 利用用戶密碼作為隨機數初始化出
// 128位的key生產者
//加密沒關系，SecureRandom是生成安全隨機數序列，password.getBytes()是種子，只要種子相同，序列就一樣，所以解密只要有password就行

SecretKey secretKey = kgen.generateKey();// 根據用戶密碼，生成一個密鑰

byte[] enCodeFormat = secretKey.getEncoded();// 返回基本編碼格式的密鑰，如果此密鑰不支持編碼，則返回
// null。

SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");// 轉換為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 (NoSuchPaddingException e) {
e.printStackTrace();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
return null;
}
2. AES解密
public static byte[] decrypt(byte[] content, String password) {
try {
KeyGenerator kgen = KeyGenerator.getInstance("AES");// 創建AES的Key生產者
kgen.init(128, new SecureRandom(password.getBytes()));
SecretKey secretKey = kgen.generateKey();// 根據用戶密碼，生成一個密鑰
byte[] enCodeFormat = secretKey.getEncoded();// 返回基本編碼格式的密鑰
SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");// 轉換為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;
}

Ⅸ 為什麼沒有Java實現的Aes加密演算法

需要依賴Java加密擴展的支持才能實現。
用Java實現AES需要依賴Java加密擴展TheJavaCryptographyExtension，簡稱JCE的支持主要是在javax下面的一些包。根據描述需要使用的演算法為AESCBCNoPadding。
Java語言的語法與C語言和C加加語言很接近，使得大多數程序員很容易學習和使用。另一方面，Java丟棄了C加加中很少使用的、很難理解的、令人迷惑的那些特性，如操作符重載、多繼承、自動的強制類型轉換。特別地，Java語言不使用指針，而是引用。並提供了自動分配和回收內存空間，使得程序員不必為內存管理而擔憂。

Ⅹ java的aes加密成多少位數

深圳遠標幫你：
1.默認 Java 中僅支持 128 位密鑰，當使用 256 位密鑰的時候，會報告密鑰長度錯誤
Invalid AES key length

你需要下載一個支持更長密鑰的包。這個包叫做 Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 6
看一下你的 JRE 環境，將 JRE 環境中 lib\lib\security 中的同名包替換掉。
2. Base64 問題
// 編碼
String asB64 = new Base64().encodeToString("some string".getBytes("utf-8"));
System.out.println(asB64); // 輸出為: c29tZSBzdHJpbmc=

解碼
// 解碼
byte[] asBytes = new Base64().getDecoder().decode("c29tZSBzdHJpbmc=");
System.out.println(new String(asBytes, "utf-8")); // 輸出為: some string

如果你已經使用 Java 8，那麼就不需要再選用第三方的實現了，在 java.util 包中已經包含了 Base64 的處理。
編碼的方式
// 編碼
String asB64 = Base64.getEncoder().encodeToString("some string".getBytes("utf-8"));
System.out.println(asB64); // 輸出為: c29tZSBzdHJpbmc=

解碼處理
// 解碼
byte[] asBytes = Base64.getDecoder().decode("c29tZSBzdHJpbmc=");
System.out.println(new String(asBytes, "utf-8")); // 輸出為: some string

3. 關於 PKCS5 和 PKCS7 填充問題
PKCS #7 填充字元串由一個位元組序列組成，每個位元組填充該填充位元組序列的長度。
假定塊長度為 8，數據長度為 9，
數據： FF FF FF FF FF FF FF FF FF
PKCS7 填充： FF FF FF FF FF FF FF FF FF 07 07 07 07 07 07 07
簡單地說, PKCS5, PKCS7和SSL3, 以及CMS(Cryptographic Message Syntax)
有如下相同的特點:
1)填充的位元組都是一個相同的位元組
2)該位元組的值,就是要填充的位元組的個數
如果要填充8個位元組,那麼填充的位元組的值就是0×8;
要填充7個位元組,那麼填入的值就是0×7;
…
如果只填充1個位元組，那麼填入的值就是0×1;
這種填充方法也叫PKCS5, 恰好8個位元組時還要補8個位元組的0×08
正是這種即使恰好是8個位元組也需要再補充位元組的規定，可以讓解密的數據很確定無誤的移除多餘的位元組。

比如, Java中
Cipher.getInstance(「AES/CBC/PKCS5Padding」)
這個加密模式
跟C#中的
RijndaelManaged cipher = new RijndaelManaged();
cipher.KeySize = 128;
cipher.BlockSize = 128;
cipher.Mode = CipherMode.CBC;
cipher.Padding = PaddingMode.PKCS7;
的加密模式是一樣的
因為AES並沒有64位的塊, 如果採用PKCS5, 那麼實質上就是採用PKCS7