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