本文目录一览：
- 1、如何用java实现128位密钥的RSA算法
- 2、￥￥￥￥基于java语言的数字签名￥￥￥￥￥
- 3、如何使用java对密码加密 加密方式aes
- 4、java中怎么获取jks证书文件中的内容
- 5、java中的keystore具体是什么东西，怎么个用法。
如何用java实现128位密钥的RSA算法
import javax.crypto.Cipher;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.Key;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
public class RSA_Encrypt {
/** 指定加密算法为DESede */
private static String ALGORITHM = "RSA";
/** 指定key的大小 */
private static int KEYSIZE = 128;
/** 指定公钥存放文件 */
private static String PUBLIC_KEY_FILE = "PublicKey";
/** 指定私钥存放文件 */
private static String PRIVATE_KEY_FILE = "PrivateKey";
// private static String PUBLIC_KEY_FILE = "D://PublicKey.a";
// private static String PRIVATE_KEY_FILE = "D://PrivateKey.a";
/**
* 生成密钥对
*/
private static void generateKeyPair() throws Exception{
/** RSA算法要求有一个可信任的随机数源 */
SecureRandom sr = new SecureRandom();
/** 为RSA算法创建一个KeyPairGenerator对象 */
KeyPairGenerator kpg = KeyPairGenerator.getInstance(ALGORITHM);
/** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */
kpg.initialize(KEYSIZE, sr);
/** 生成密匙对 */
KeyPair kp = kpg.generateKeyPair();
/** 得到公钥 */
Key publicKey = kp.getPublic();
/** 得到私钥 */
Key privateKey = kp.getPrivate();
/** 用对象流将生成的密钥写入文件 */
ObjectOutputStream oos1 = new ObjectOutputStream(new FileOutputStream(PUBLIC_KEY_FILE));
ObjectOutputStream oos2 = new ObjectOutputStream(new FileOutputStream(PRIVATE_KEY_FILE));
oos1.writeObject(publicKey);
oos2.writeObject(privateKey);
/** 清空缓存，关闭文件输出流 */
oos1.close();
oos2.close();
}
/**
* 加密方法
* source： 源数据
*/
public static String encrypt(String source) throws Exception{
generateKeyPair();
/** 将文件中的公钥对象读出 */
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PUBLIC_KEY_FILE));
Key key = (Key) ois.readObject();
ois.close();
/** 得到Cipher对象来实现对源数据的RSA加密 */
Cipher cipher = Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] b = source.getBytes();
/** 执行加密操作 */
byte[] b1 = cipher.doFinal(b);
BASE64Encoder encoder = new BASE64Encoder();
return encoder.encode(b1);
}
/**
* 解密算法
* cryptograph:密文
*/
public static String decrypt(String cryptograph) throws Exception{
/** 将文件中的私钥对象读出 */
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PRIVATE_KEY_FILE));
Key key = (Key) ois.readObject();
/** 得到Cipher对象对已用公钥加密的数据进行RSA解密 */
Cipher cipher = Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, key);
BASE64Decoder decoder = new BASE64Decoder();
byte[] b1 = decoder.decodeBuffer(cryptograph);
/** 执行解密操作 */
byte[] b = cipher.doFinal(b1);
return new String(b);
}
public static void main(String[] args) {
try {
String source = "Hello World!";//要加密的字符串
String cryptograph = encrypt(source);
System.out.println(cryptograph);
String target = decrypt(cryptograph);//解密密文
System.out.println(target);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}//生成的密文
}
}
￥￥￥￥基于java语言的数字签名￥￥￥￥￥
毕业设计起码也得2个月时间，你现在才开始，不复制粘贴来不及啊~
Java加密和数字签名编程快速入门
本文主要谈一下密码学中的加密和数字签名，以及其在java中如何进行使用。对密码学有兴趣的伙伴，推荐看Bruce Schneier的著作：Applied Crypotography。在jdk1.5的发行版本中安全性方面有了很大的改进，也提供了对RSA算法的直接支持，现在我们从实例入手解决问题（本文仅是作为简单介绍）：
一、密码学上常用的概念
1）消息摘要：
这是一种与消息认证码结合使用以确保消息完整性的技术。主要使用单向散列函数算法，可用于检验消息的完整性，和通过散列密码直接以文本形式保存等，目前广泛使用的算法有MD4、MD5、SHA-1，jdk1.5对上面都提供了支持，在java中进行消息摘要很简单， java.security.MessageDigest提供了一个简易的操作方法：
/**
*MessageDigestExample.java
*Copyright 2005-2-16
*/
import java.security.MessageDigest;
/**
*单一的消息摘要算法，不使用密码.可以用来对明文消息（如：密码）隐藏保存
*/
public class MessageDigestExample{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java MessageDigestExample text");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//使用getInstance("算法")来获得消息摘要,这里使用SHA-1的160位算法
MessageDigest messageDigest=MessageDigest.getInstance("SHA-1");
System.out.println("n"+messageDigest.getProvider().getInfo());
//开始使用算法
messageDigest.update(plainText);
System.out.println("nDigest:");
//输出算法运算结果
System.out.println(new String(messageDigest.digest(),"UTF8"));
}
}
还可以通过消息认证码来进行加密实现，javax.crypto.Mac提供了一个解决方案，有兴趣者可以参考相关API文档，本文只是简单介绍什么是摘要算法。
2）私钥加密：
消息摘要只能检查消息的完整性，但是单向的，对明文消息并不能加密，要加密明文的消息的话，就要使用其他的算法，要确保机密性，我们需要使用私钥密码术来交换私有消息。
这种最好理解，使用对称算法。比如：A用一个密钥对一个文件加密，而B读取这个文件的话，则需要和A一样的密钥，双方共享一个私钥（而在web环境下，私钥在传递时容易被侦听）：
使用私钥加密的话，首先需要一个密钥，可用javax.crypto.KeyGenerator产生一个密钥(java.security.Key),然后传递给一个加密工具(javax.crypto.Cipher),该工具再使用相应的算法来进行加密，主要对称算法有：DES（实际密钥只用到56位），AES（支持三种密钥长度：128、192、256位），通常首先128位，其他的还有DESede等，jdk1.5种也提供了对对称算法的支持，以下例子使用AES算法来加密：
/**
*PrivateExmaple.java
*Copyright 2005-2-16
*/
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import java.security.Key;
/**
*私鈅加密，保证消息机密性
*/
public class PrivateExample{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java PrivateExample text");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//通过KeyGenerator形成一个key
System.out.println("nStart generate AES key");
KeyGenerator keyGen=KeyGenerator.getInstance("AES");
keyGen.init(128);
Key key=keyGen.generateKey();
System.out.println("Finish generating DES key");
//获得一个私鈅加密类Cipher，ECB是加密方式，PKCS5Padding是填充方法
Cipher cipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
System.out.println("n"+cipher.getProvider().getInfo());
//使用私鈅加密
System.out.println("nStart encryption:");
cipher.init(Cipher.ENCRYPT_MODE,key);
byte[] cipherText=cipher.doFinal(plainText);
System.out.println("Finish encryption:");
System.out.println(new String(cipherText,"UTF8"));
System.out.println("nStart decryption:");
cipher.init(Cipher.DECRYPT_MODE,key);
byte[] newPlainText=cipher.doFinal(cipherText);
System.out.println("Finish decryption:");
System.out.println(new String(newPlainText,"UTF8"));
}
}
3）公钥加密：
上面提到，私钥加密需要一个共享的密钥，那么如何传递密钥呢？web环境下，直接传递的话很容易被侦听到，幸好有了公钥加密的出现。公钥加密也叫不对称加密，不对称算法使用一对密钥对，一个公钥，一个私钥，使用公钥加密的数据，只有私钥能解开（可用于加密）；同时，使用私钥加密的数据，只有公钥能解开（签名）。但是速度很慢（比私钥加密慢100到1000倍），公钥的主要算法有RSA，还包括Blowfish,Diffie-Helman等，jdk1.5种提供了对RSA的支持，是一个改进的地方：
/**
*PublicExample.java
*Copyright 2005-2-16
*/
import java.security.Key;
import javax.crypto.Cipher;
import java.security.KeyPairGenerator;
import java.security.KeyPair;
/**
*一个简单的公鈅加密例子,Cipher类使用KeyPairGenerator生成的公鈅和私鈅
*/
public class PublicExample{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java PublicExample text");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//构成一个RSA密钥
System.out.println("nStart generating RSA key");
KeyPairGenerator keyGen=KeyPairGenerator.getInstance("RSA");
keyGen.initialize(1024);
KeyPair key=keyGen.generateKeyPair();
System.out.println("Finish generating RSA key");
//获得一个RSA的Cipher类，使用公鈅加密
Cipher cipher=Cipher.getInstance("RSA/ECB/PKCS1Padding");
System.out.println("n"+cipher.getProvider().getInfo());
System.out.println("nStart encryption");
cipher.init(Cipher.ENCRYPT_MODE,key.getPublic());
byte[] cipherText=cipher.doFinal(plainText);
System.out.println("Finish encryption:");
System.out.println(new String(cipherText,"UTF8"));
//使用私鈅解密
System.out.println("nStart decryption");
cipher.init(Cipher.DECRYPT_MODE,key.getPrivate());
byte[] newPlainText=cipher.doFinal(cipherText);
System.out.println("Finish decryption:");
System.out.println(new String(newPlainText,"UTF8"));
}
}
4）数字签名：
数字签名，它是确定交换消息的通信方身份的第一个级别。上面A通过使用公钥加密数据后发给B，B利用私钥解密就得到了需要的数据，问题来了，由于都是使用公钥加密，那么如何检验是A发过来的消息呢？上面也提到了一点，私钥是唯一的，那么A就可以利用A自己的私钥进行加密，然后B再利用A的公钥来解密，就可以了；数字签名的原理就基于此，而通常为了证明发送数据的真实性，通过利用消息摘要获得简短的消息内容，然后再利用私钥进行加密散列数据和消息一起发送。java中为数字签名提供了良好的支持，java.security.Signature类提供了消息签名：
/**
*DigitalSignature2Example.java
*Copyright 2005-2-16
*/
import java.security.Signature;
import java.security.KeyPairGenerator;
import java.security.KeyPair;
import java.security.SignatureException;
/**
*数字签名，使用RSA私钥对对消息摘要签名，然后使用公鈅验证 测试
*/
public class DigitalSignature2Example{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java DigitalSignature2Example text");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//形成RSA公钥对
System.out.println("nStart generating RSA key");
KeyPairGenerator keyGen=KeyPairGenerator.getInstance("RSA");
keyGen.initialize(1024);
KeyPair key=keyGen.generateKeyPair();
System.out.println("Finish generating RSA key");
//使用私鈅签名
Signature sig=Signature.getInstance("SHA1WithRSA");
sig.initSign(key.getPrivate());
sig.update(plainText);
byte[] signature=sig.sign();
System.out.println(sig.getProvider().getInfo());
System.out.println("nSignature:");
System.out.println(new String(signature,"UTF8"));
//使用公鈅验证
System.out.println("nStart signature verification");
sig.initVerify(key.getPublic());
sig.update(plainText);
try{
if(sig.verify(signature)){
System.out.println("Signature verified");
}else System.out.println("Signature failed");
}catch(SignatureException e){
System.out.println("Signature failed");
}
}
}
5)数字证书。
还有个问题，就是公钥问题，A用私钥加密了，那么B接受到消息后，用A提供的公钥解密；那么现在有个讨厌的C，他把消息拦截了，然后用自己的私钥加密，同时把自己的公钥发给B，并告诉B，那是A的公钥，结果....，这时候就需要一个中间机构出来说话了（相信权威，我是正确的），就出现了Certificate Authority(也即CA），有名的CA机构有Verisign等，目前数字认证的工业标准是：CCITT的X.509：
数字证书：它将一个身份标识连同公钥一起进行封装，并由称为认证中心或 CA 的第三方进行数字签名。
密钥库：java平台为你提供了密钥库，用作密钥和证书的资源库。从物理上讲，密钥库是缺省名称为 .keystore 的文件（有一个选项使它成为加密文件）。密钥和证书可以拥有名称（称为别名），每个别名都由唯一的密码保护。密钥库本身也受密码保护；您可以选择让每个别名密码与主密钥库密码匹配。
使用工具keytool，我们来做一件自我认证的事情吧（相信我的认证）：
1、创建密钥库keytool -genkey -v -alias feiUserKey -keyalg RSA 默认在自己的home目录下（windows系统是c:documents and settings你的用户名 目录下的.keystore文件），创建我们用 RSA 算法生成别名为 feiUserKey 的自签名的证书,如果使用了-keystore mm 就在当前目录下创建一个密钥库mm文件来保存密钥和证书。
2、查看证书：keytool -list 列举了密钥库的所有的证书
也可以在dos下输入keytool -help查看帮助。
二、JAR的签名
我们已经学会了怎样创建自己的证书了，现在可以开始了解怎样对JAR文件签名，JAR文件在Java中相当于 ZIP 文件，允许将多个 Java 类文件打包到一个具有 .jar 扩展名的文件中，然后可以对这个jar文件进行数字签名，以证实其来源和真实性。该 JAR 文件的接收方可以根据发送方的签名决定是否信任该代码，并可以确信该内容在接收之前没有被篡改过。同时在部署中，可以通过在策略文件中放置访问控制语句根据签名者的身份分配对机器资源的访问权。这样，有些Applet的安全检验访问就得以进行。
使用jarsigner工具可以对jar文件进行签名：
现在假设我们有个Test.jar文件（可以使用jar命令行工具生成）：
jarsigner Test.jar feiUserKey (这里我们上面创建了该别名的证书) ，详细信息可以输入jarsigner查看帮助
验证其真实性：jarsigner -verify Test.jar(注意，验证的是jar是否被修改了，但不检验减少的，如果增加了新的内容，也提示，但减少的不会提示。）
使用Applet中：applet code="Test.class" archive="Test.jar" width="150" height="100"/applet然后浏览器就会提示你：准许这个会话-拒绝-始终准许-查看证书等。
三、安全套接字层（SSL Secure Sockets Layer）和传输层安全性（TLS Transport Layer Security）
安全套接字层和传输层安全性是用于在客户机和服务器之间构建安全的通信通道的协议。它也用来为客户机认证服务器，以及（不太常用的）为服务器认证客户机。该协议在浏览器应用程序中比较常见，浏览器窗口底部的锁表明 SSL/TLS 有效：
1）当使用 SSL/TLS（通常使用 https:// URL）向站点进行请求时，从服务器向客户机发送一个证书。客户机使用已安装的公共 CA 证书通过这个证书验证服务器的身份，然后检查 IP 名称（机器名）与客户机连接的机器是否匹配。
2）客户机生成一些可以用来生成对话的私钥（称为会话密钥）的随机信息，然后用服务器的公钥对它加密并将它发送到服务器。服务器用自己的私钥解密消息，然后用该随机信息派生出和客户机一样的私有会话密钥。通常在这个阶段使用 RSA 公钥算法。
3）客户机和服务器使用私有会话密钥和私钥算法（通常是 RC4）进行通信。使用另一个密钥的消息认证码来确保消息的完整性。
java中javax.net.ssl.SSLServerSocketFactory类提供了一个很好的SSLServerSocker的工厂类，熟悉Socket编程的读者可以去练习。当编写完服务器端之后，在浏览器上输入https://主机名:端口 就会通过SSL/TLS进行通话了。注意：运行服务端的时候要带系统环境变量运行：javax.net.ssl.keyStore=密钥库(创建证书时，名字应该为主机名，比如localhost)和javax.net.ssl.keyStorePassword=你的密码
如何使用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中怎么获取jks证书文件中的内容
JavaKeyStore的类型JKS和JCEKS是Java密钥库(KeyStore)的两种比较常见类型(我所知道的共有5种，JKS,JCEKS,PKCS12,BKS，UBER)。JKS的Provider是SUN，在每个版本的JDK中都有，JCEKS的Provider是SUNJCE，1.4后我们都能够直接使用它。JCEKS在安全级别上要比JKS强，使用的Provider是JCEKS(推荐)，尤其在保护KeyStore中的私钥上（使用TripleDes）。PKCS#12是公钥加密标准，它规定了可包含所有私钥、公钥和证书。其以二进制格式存储，也称为PFX文件，在windows中可以直接导入到密钥区，注意，PKCS#12的密钥库保护密码同时也用于保护Key。BKS来自BouncyCastleProvider，它使用的也是TripleDES来保护密钥库中的Key，它能够防止证书库被不小心修改（Keystore的keyentry改掉1个bit都会产生错误），BKS能够跟JKS互操作，读者可以用Keytool去TryTry。UBER比较特别，当密码是通过命令行提供的时候，它只能跟keytool交互。整个keystore是通过PBE/SHA1/Twofish加密，因此keystore能够防止被误改、察看以及校验。以前，SunJDK(提供者为SUN)允许你在不提供密码的情况下直接加载一个Keystore，类似cacerts，UBER不允许这种情况。证书导入Der/Cer证书导入：要从某个文件中导入某个证书，使用keytool工具的-import命令：1keytool-import-filemycert.der-keystoremykeystore.jks如果在-keystore选项中指定了一个并不存在的密钥仓库，则该密钥仓库将被创建。如果不指定-keystore选项，则缺省密钥仓库将是宿主目录中名为.keystore的文件。如果该文件并不存在，则它将被创建。创建密钥仓库时会要求输入访问口令，以后需要使用此口令来访问。可使用-list命令来查看密钥仓库里的内容：1keytool-list-rfc-keystoremykeystore.jksP12格式证书导入：keytool无法直接导入PKCS12文件。第一种方法是使用IE将pfx证书导入，再导出为cert格式文件。使用上面介绍的方法将其导入到密钥仓库中。这样的话仓库里面只包含了证书信息，没有私钥内容。第二种方法是将pfx文件导入到IE浏览器中，再导出为pfx文件。新生成的pfx不能被导入到keystore中，报错：keytool错误：java.lang.Exception:所输入的不是一个X.509认证。新生成的pfx文件可以被当作keystore使用。但会报个错误asunknownattr1.3.6.1.4.1.311.17.1,查了下资料,说IE导出的就会这样,使用Netscape就不会有这个错误.第三种方法是将pfx文件当作一个keystore使用。但是通过微软的证书管理控制台生成的pfx文件不能直接使用。keytool不认此格式，报keytool错误：java.io.IOException:failedtodecryptsafecontentsentry。需要通过OpenSSL转换一下：1opensslpkcs12-inmycerts.pfx-outmycerts.pem2opensslpkcs12-export-inmycerts.pem-outmykeystore.p12通过keytool的-list命令可检查下密钥仓库中的内容：1keytool-rfc-list-keystoremykeystore.p12-storetypepkcs12这里需要指明仓库类型为pkcs12，因为缺省的类型为jks。这样此密钥仓库就即包含证书信息也包含私钥信息。P7B格式证书导入：keytool无法直接导入p7b文件。需要将证书链RootServer.p7b（包含根证书）导出为根rootca.cer和子rootcaserver.cer。将这两个证书导入到可信任的密钥仓库中。1keytool-import-aliasrootca-trustcacerts-filerootca.cer-keystoretestkeytrust.jks遇到是否信任该证书提示时，输入y1keytool-import-aliasrootcaserver-trustcacerts-filerootcaserver.cer-keystoretestkeytrust.jks总结P12格式的证书是不能使用keytool工具导入到keystore中的TheSun'sPKCS12Keystore对从IE和其他的windows程序生成的pfx格式的证书支持不太好.P7B证书链不能直接导入到keystore，需要将里面的证书导出成cer格式，再分别导入到keystore。
java中的keystore具体是什么东西，怎么个用法。
是java的密钥库、用来进行通信加密用的、比如数字签名。keystore就是用来保存密钥对的，比如公钥和私钥。具体用法，在网上搜java数字签名，文件加密就行了、有很多教程的。