当前位置：首页 » 编程语言 » java的aes加密

java的aes加密

发布时间: 2021-03-25 16:43:34

Ⅰ java如何用Aes加密和解密

你解密的key必须是加密的key啊
你看看，你解密的时候又KeyGenerator.getInstance("AES").generateKey();这是重新搞了一个key啊，当然解不出来了
我估计你这代码人家原先是写在一起的吧，加密完了再直接解密给你看，人家只generateKey一次，自然很顺利，你分成了两个例子，居然分别generateKey，自然失败

Ⅱ 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和C之间通用的AES加密标准是什么

public static byte[] encrypt(String content, String password) {
try {
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");

SecretKeySpec secretKey = new SecretKeySpec(password.getBytes(),
"AES");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] byteContent = content.getBytes("utf-8");
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;
}

public static byte[] decrypt(byte[] content, String password) {
try {
Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");

SecretKeySpec secretKey = new SecretKeySpec(password.getBytes(),
"AES");
cipher.init(Cipher.DECRYPT_MODE, secretKey);
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;
}
这个和Linux里面的OpenSSL加解密兼容

Ⅳ 通过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 AES256加密怎么实现啊

java.security.InvalidKeyException: Illegal key

package com.jlins;

import java.io.UnsupportedEncodingException;

import javax.crypto.Cipher;

import javax.crypto.spec.IvParameterSpec;

import javax.crypto.spec.SecretKeySpec;

import com.jlins.util.Hex;

/**

* java Aes256 加密

*

* @author jlins

*

*/

public class Aes256Encryptor {

// 说明 key 需要大家自己去设定加密解密的key，key牵涉到安全信息,所以这里无法公布

private static final byte[] key = {};

private static final String transform = "AES/CBC/NoPadding";

private static final String algorithm = "AES";

private static final SecretKeySpec keySpec = new SecretKeySpec(key, algorithm);

public static void main(String[] args) throws Exception {

String pwds[] = { "123", "0123456789012345", "01234567890123456", "123", "123", "0123456789012345678",

"", "b", "0123456789012345", "01234567890123456", "012345678901234567" };

String ivss[] = { "test", "test", "test", "test0123456789012", "test01234567890123", "test", "test", "a",

"test", "test", "test" };

String rr[] = new String[ivss.length];

for (int i = 0; i < ivss.length; i++) {

String en = encrypt(pwds[i], ivss[i]);

String decy = decrypt(en, ivss[i]);

rr[i] = "[" + ivss[i] + "],[" + decy + "]-->[" + en + "]";

System.out.println(rr[i]);

}

System.out.println("---------");

for (int i = 0; i < rr.length; i++) {

System.out.println(rr[i]);

}

}

/**

*/

public static String decrypt(String pHexText, String pIv) throws Exception {

Cipher cipher = Cipher.getInstance(transform);

byte[] encryptedBytes = Hex.decode(pHexText);

byte[] iv = createIV(pIv);

cipher.init(Cipher.DECRYPT_MODE, keySpec, new IvParameterSpec(iv));

byte[] decryptedBytes = cipher.doFinal(encryptedBytes);

System.array(decryptedBytes, 0, encryptedBytes, 0, encryptedBytes.length);

String result = new String(encryptedBytes);

return result.trim();

}

/**

*/

public static String encrypt(String pData, String pIv) throws Exception {

Cipher cipher = Cipher.getInstance(transform);

byte[] iv = createIV(pIv);

cipher.init(Cipher.ENCRYPT_MODE, keySpec, new IvParameterSpec(iv));

byte[] output = cipher.doFinal(paddingData(pData));

byte[] encryptedContent = new byte[output.length];

System.array(output, 0, encryptedContent, 0, encryptedContent.length);

String result = new String(Hex.encode(encryptedContent)).toUpperCase();

return result;

}

/**

* 补齐的16位的整数倍

*

* @param pData

* @return

*/

private static byte[] paddingData(String pData) {

byte[] bytes = pData.getBytes();

int length = bytes.length / 16;

if (length * 16 < bytes.length) {

length++;

}

byte[] result = new byte[length * 16];

System.array(bytes, 0, result, 0, bytes.length);

for (int i = bytes.length; i < result.length; i++) {

result[i] = 0x00;

}

return result;

}

/**

* 初始化向量到16位

* */

private static byte[] createIV(String pIv) throws UnsupportedEncodingException {

byte[] bytes = pIv.getBytes("US-ASCII");

int length = bytes.length / 16;

if (length * 16 < bytes.length) {

length++;

}

byte[] result = new byte[16];

System.array(bytes, 0, result, 0, bytes.length > 16 ? 16 : bytes.length);

for (int i = bytes.length; i < result.length; i++) {

result[i] = 0x00;

}

return result;

}

}

Ⅵ 如何使用java对密码加密加密方式aes

Java有相关的实现类：具体原理如下
对于任意长度的明文，AES首先对其进行分组，每组的长度为128位。分组之后将分别对每个128位的明文分组进行加密。
对于每个128位长度的明文分组的加密过程如下：
（1）将128位AES明文分组放入状态矩阵中。
（2）AddRoundKey变换：对状态矩阵进行AddRoundKey变换，与膨胀后的密钥进行异或操作（密钥膨胀将在实验原理七中详细讨论）。
（3）10轮循环：AES对状态矩阵进行了10轮类似的子加密过程。前9轮子加密过程中，每一轮子加密过程包括4种不同的变换，而最后一轮只有3种变换，前9轮的子加密步骤如下：
● SubBytes变换：SubBytes变换是一个对状态矩阵非线性的变换；
● ShiftRows变换：ShiftRows变换对状态矩阵的行进行循环移位；
● MixColumns变换：MixColumns变换对状态矩阵的列进行变换；
● AddRoundKey变换：AddRoundKey变换对状态矩阵和膨胀后的密钥进行异或操作。
最后一轮的子加密步骤如下：
● SubBytes变换：SubBytes变换是一个对状态矩阵非线性的变换；
● ShiftRows变换：ShiftRows变换对状态矩阵的行进行循环移位；
● AddRoundKey变换：AddRoundKey变换对状态矩阵和膨胀后的密钥进行异或操作；
（4）经过10轮循环的状态矩阵中的内容就是加密后的密文。
AES的加密算法的伪代码如下。

在AES算法中，AddRoundKey变换需要使用膨胀后的密钥，原始的128位密钥经过膨胀会产生44个字（每个字为32位）的膨胀后的密钥，这44个字的膨胀后的密钥供11次AddRoundKey变换使用，一次AddRoundKey使用4个字（128位）的膨胀后的密钥。
三．AES的分组过程
对于任意长度的明文，AES首先对其进行分组，分组的方法与DES相同，即对长度不足的明文分组后面补充0即可，只是每一组的长度为128位。
AES的密钥长度有128比特，192比特和256比特三种标准，其他长度的密钥并没有列入到AES联邦标准中，在下面的介绍中，我们将以128位密钥为例。
四．状态矩阵
状态矩阵是一个4行、4列的字节矩阵，所谓字节矩阵就是指矩阵中的每个元素都是一个1字节长度的数据。我们将状态矩阵记为State，State中的元素记为Sij，表示状态矩阵中第i行第j列的元素。128比特的明文分组按字节分成16块，第一块记为“块0”，第二块记为“块1”，依此类推，最后一块记为“块15”，然后将这16块明文数据放入到状态矩阵中，将这16块明文数据放入到状态矩阵中的方法如图2-2-1所示。

块0

块4

块8

块12

块1

块5

块9

块13

块2

块6

块10

块14

块3

块7

块11

块15

图2-2-1 将明文块放入状态矩阵中
五．AddRoundKey变换
状态矩阵生成以后，首先要进行AddRoundKey变换，AddRoundKey变换将状态矩阵与膨胀后的密钥进行按位异或运算，如下所示。

其中，c表示列数，数组W为膨胀后的密钥，round为加密轮数，Nb为状态矩阵的列数。
它的过程如图2-2-2所示。

图2-2-2 AES算法AddRoundKey变换
六．10轮循环
经过AddRoundKey的状态矩阵要继续进行10轮类似的子加密过程。前9轮子加密过程中，每一轮要经过4种不同的变换，即SubBytes变换、ShiftRows变换、MixColumns变换和AddRoundKey变换，而最后一轮只有3种变换，即SubBytes变换、ShiftRows变换和AddRoundKey变换。AddRoundKey变换已经讨论过，下面分别讨论余下的三种变换。
1．SubBytes变换
SubBytes是一个独立作用于状态字节的非线性变换，它由以下两个步骤组成：
（1）在GF（28）域，求乘法的逆运算，即对于α∈GF（28）求β∈GF（28），使αβ =βα = 1mod（x8 + x4 + x3 + x + 1）。
（2）在GF（28）域做变换，变换使用矩阵乘法，如下所示：

由于所有的运算都在GF（28）域上进行，所以最后的结果都在GF（28）上。若g∈GF（28）是GF（28）的本原元素，则对于α∈GF（28），α≠0，则存在
β ∈ GF（28），使得：
β = gαmod（x8 + x4 + x3 + x + 1）
由于g255 = 1mod（x8 + x4 + x3 + x + 1）
所以g255-α = β-1mod（x8 + x4 + x3 + x + 1）
根据SubBytes变换算法，可以得出SubBytes的置换表，如表2-2-1所示，这个表也叫做AES的S盒。该表的使用方法如下：状态矩阵中每个元素都要经过该表替换，每个元素为8比特，前4比特决定了行号，后4比特决定了列号，例如求SubBytes(0C)查表的0行C列得FE。
表2-2-1 AES的SubBytes置换表

它的变换过程如图2-2-3所示。

图2-2-3 SubBytes变换
AES加密过程需要用到一些数学基础，其中包括GF(2)域上的多项式、GF（28）域上的多项式的计算和矩阵乘法运算等，有兴趣的同学请参考相关的数学书籍。
2．ShiftRows变换
ShiftRows变换比较简单，状态矩阵的第1行不发生改变，第2行循环左移1字节，第3行循环左移2字节，第4行循环左移3字节。ShiftRows变换的过程如图2-2-4所示。

图2-2-4 AES的ShiftRows变换
3．MixColumns变换
在MixColumns变换中，状态矩阵的列看作是域GF（28）的多项式，模(x4＋1)乘以c（x）的结果：
c(x)＝(03)x3＋(01)x2+(01)x+(02)
这里(03)为十六进制表示，依此类推。c(x)与x4＋1互质，故存在逆：
d(x)=(0B)x3＋(0D)x2＋(0G)x＋(0E)使c(x)•d(x) = (D1)mod(x4＋1)。
设有：

它的过程如图2-2-5所示。

图2-2-5 AES算法MixColumns变换
七．密钥膨胀
在AES算法中，AddRoundKey变换需要使用膨胀后的密钥，膨胀后的密钥记为子密钥，原始的128位密钥经过膨胀会产生44个字（每个字为32位）的子密钥，这44个字的子密钥供11次AddRoundKey变换使用，一次AddRoundKey使用4个字（128位）的膨胀后的密钥。
密钥膨胀算法是以字为基础的（一个字由4个字节组成，即32比特）。128比特的原始密钥经过膨胀后将产生44个字的子密钥，我们将这44个密钥保存在一个字数组中，记为W[44]。128比特的原始密钥分成16份，存放在一个字节的数组：Key[0]，Key[1]……Key[15]中。
在密钥膨胀算法中，Rcon是一个10个字的数组，在数组中保存着算法定义的常数，分别为：
Rcon[0] = 0x01000000
Rcon[1] = 0x02000000
Rcon[2] = 0x04000000
Rcon[3] = 0x08000000
Rcon[4] = 0x10000000
Rcon[5] = 0x20000000
Rcon[6] = 0x40000000
Rcon[7] = 0x80000000
Rcon[8] = 0x1b000000
Rcon[9] = 0x36000000
另外，在密钥膨胀中包括其他两个操作RotWord和SubWord，下面对这两个操作做说明：
RotWord( B0,B1,B2,B3 )对4个字节B0,B1,B2,B3进行循环移位，即
RotWord( B0,B1,B2,B3 ) = ( B1,B2,B3,B0 )
SubWord( B0,B1,B2,B3 )对4个字节B0,B1,B2,B3使用AES的S盒，即
SubWord( B0,B1,B2,B3 ) = ( B’0,B’1,B’2,B’3 )
其中，B’i = SubBytes（Bi），i = 0,1,2,3。
密钥膨胀的算法如下：

八．解密过程
AES的加密和解密过程并不相同，首先密文按128位分组，分组方法和加密时的分组方法相同，然后进行轮变换。
AES的解密过程可以看成是加密过程的逆过程，它也由10轮循环组成，每一轮循环包括四个变换分别为InvShiftRows变换、InvSubBytes变换、InvMixColumns变换和AddRoundKey变换；
这个过程可以描述为如下代码片段所示：

九．InvShiftRows变换
InvShiftRows变换是ShiftRows变换的逆过程，十分简单，指定InvShiftRows的变换如下。
Sr,(c+shift(r,Nb))modNb= Sr,c for 0 < r< 4 and 0 ≤ c < Nb
图2-2-6演示了这个过程。

图2-2-6 AES算法InvShiftRows变换
十．InvSubBytes变换
InvSubBytes变换是SubBytes变换的逆变换，利用AES的S盒的逆作字节置换，表2-2-2为InvSubBytes变换的置换表。
表2-2-2 InvSubBytes置换表

十一．InvMixColumns变换
InvMixColumns变换与MixColumns变换类似，每列乘以d(x)
d(x) = (OB)x3 + (0D)x2 + (0G)x + (0E)
下列等式成立：
( (03)x3 + (01)x2 + (01)x + (02) )⊙d(x) = (01)
上面的内容可以描述为以下的矩阵乘法：

十二．AddRoundKey变换
AES解密过程的AddRoundKey变换与加密过程中的AddRoundKey变换一样，都是按位与子密钥做异或操作。解密过程的密钥膨胀算法也与加密的密钥膨胀算法相同。最后状态矩阵中的数据就是明文。

Ⅶ 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加密与网上在线加密不同。谁能告诉我为什么求个正确的例子，谢谢了！

Cipher.getInstance("AES/ECB/PKCS5Padding");
就是这个东西有很多标准的，你得看下线上用的是什么标准

AES/CBC/NoPadding (128)
AES/CBC/PKCS5Padding (128)
AES/ECB/NoPadding (128)
AES/ECB/PKCS5Padding (128)
DES/CBC/NoPadding (56)
DES/CBC/PKCS5Padding (56)
DES/ECB/NoPadding (56)
DES/ECB/PKCS5Padding (56)
DESede/CBC/NoPadding (168)
DESede/CBC/PKCS5Padding (168)
DESede/ECB/NoPadding (168)
DESede/ECB/PKCS5Padding (168)
RSA/ECB/PKCS1Padding (1024, 2048)
RSA/ECB/OAEPWithSHA-1AndMGF1Padding (1024, 2048)
RSA/ECB/OAEPWithSHA-256AndMGF1Padding (1024, 2048)

Ⅸ 求一款java的AES加密解密的软件源代码（完整）

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#define JIA_SIZE 1024
#define M_S 25
//加密菜单
void menu()
{
puts("(1)加密");
puts("(2)解密");
puts("(3)退出");
}

//加密
void jiami(const char *path/*加密路径*/)
{
int i;
int fp,len;
char buffer[1024];

puts("正在加密... ...");
fp = open(path,O_RDWR); //open以读写方式打开

len=read(fp,buffer,1024);

puts("将要加密的数据");
puts(buffer);
printf("字符一共有: %d\n",len);
puts("准备加密");

for(i=0;i<len;i++)
{
buffer[i] ^= M_S;
}
lseek(fp,0,SEEK_SET);
write(fp,buffer,len);
close(fp); //关闭文件
}

int main(int argc,char *argv[])
{
FILE *fp;
char buffer[JIA_SIZE];
char ch;

if(argc <2){ //如果没有输入路径就错误
puts("请输入正确的参数比如: ./jiami /home/long/bin/123.txt");
return 0;
}
else{//显示加密或者解密路径
printf("你加密或者解密的路径:");
puts(argv[1]);
}

menu(); //显示菜单
switch(ch=getchar())
{
case '1'://加密
jiami(argv[1]);
break;
case '2'://解密
jiami(argv[1]);
break;
case '3'://退出
return 0;
break;
defualt:
puts("请输入正确的菜单参数(1-3)");
}
return 0;
}

Ⅹ JAVA AES加密和解密

你需要看看你数据库部分JAVA操作的程序了，这个跟AES加密没有什么关系。

阅读全文

java的aes加密

与java的aes加密相关的阅读推荐