看雪论坛追加加密解密

java中的Cipher类

该类位于javax.crypto包下，声明为 public class Cipher extends Object 此类为加密和解密提供密码功能。它构成了 Java Cryptographic Extension (JCE) 框架的核心。为创建 Cipher 对象，应用程序调用 Cipher 的 getInstance 方法并将所请求转换的名称传递给它。还可以指定提供者的名称（可选）。转换是一个字符串，它描述为产生某种输出而在给定的输入上执行的操作（或一组操作）。转换始终包括加密算法的名称（例如，DES），后面可能跟有一个反馈模式和填充方案。
转换具有以下形式：
算法/模式/填充”或算法”
（后一种情况下，使用模式和填充方案特定于提供者的默认值）。例如，以下是有效的转换：
Cipher c = Cipher.getInstance(“DES/CB/PKCS5Padding“);

使用 CFB 和 OFB 之类的模式，Cipher 块可以加密单元中小于该 Cipher 的实际块大小的数据。请求这样一个模式时，可以指定一次处理的位数（可选）：将此数添加到模式名称中，正如 “DES/CFB8/NoPadding” 和 “DES/OFB32/PKCS5Padding” 转换所示。如果未指定该数，则将使用特定于提供者的默认值。（例如，SunJCE 提供者对 DES 使用默认的 64 位）。因此，通过使用如 CFB8 或 OFB8 的 8 位模式，Cipher 块可以被转换为面向字节的 Cipher 流。

1、字段
public static final int ENCRYPT_MODE 用于将 Cipher 初始化为加密模式的常量。

public static final int DECRYPT_MODE 用于将 Cipher 初始化为解密模式的常量。

public static final int WRAP_MODE 用于将 Cipher 初始化为密钥包装模式的常量。

public static final int UNWRAP_MODE 用于将 Cipher 初始化为密钥解包模式的常量。

public static final int PUBLIC_KEY 用于表示要解包的密钥为“公钥”的常量。

public static final int PRIVATE_KEY 用于表示要解包的密钥为“私钥”的常量。

public static final int SECRET_KEY 用于表示要解包的密钥为“秘密密钥”的常量。

2、构造方法

protected Cipher(CipherSpi cipherSpi, Provider provider, String transformation)
参数：cipherSpi - 代理 provider - 提供者 transformation - 转换

3、方法摘要

①public static final Cipher getInstance(String transformation) 返回实现指定转换的 Cipher 对象。transformation - 转换的名称，例如 DES/CBC/PKCS5Padding

②public static final Cipher getInstance(String transformation, String provider) 返回实现指定转换的 Cipher 对象

③public static final Cipher getInstance(String transformation, Provider provider) 返回实现指定转换的 Cipher 对象。

④public final Provider getProvider() 返回此 Cipher 对象的提供者。

⑤public final String getAlgorithm() 返回此 Cipher 对象的算法名称。

⑥public final int getBlockSize() 返回块的大小（以字节为单位）。

⑦public final int getOutputSize(int inputLen)

根据给定的输入长度 inputLen（以字节为单位），返回保存下一个 update 或 doFinal 操作结果所需的输出缓冲区长度（以字节为单位）。

此调用还考虑到任何取自上一个 update 调用的未处理（已缓存）数据和填充。

下一个 update 或 doFinal 调用的实际输出长度可能小于此方法返回的长度。

参数： nputLen - 输入长度（以字节为单位）

返回：所需的输出缓冲区大小（以字节为单位）

⑧public final byte[] getIV() 返回新缓冲区中的初始化向量 (IV)。

⑨public final AlgorithmParameters getParameters() 返回此 Cipher 使用的参数。返回的参数可能与初始化此 Cipher 所使用的参数相同；如果此 Cipher 需要算法参数但却未使用任何参数进行初始化，则返回的参数将由默认值和底层 Cipher 实现所使用的随机参数值组成。

⑩public final ExemptionMechanism getExemptionMechanism() 返回此 Cipher 使用的豁免 (exemption) 机制对象。

11、public final void init(int opmode, Key key) 用密钥初始化此 Cipher。

为以下 4 种操作之一初始化该 Cipher：加密、解密、密钥包装或密钥解包，具体取决于 opmode 的值。

如果此 Cipher 需要任何无法从给定 key 派生的算法参数，则在为加密或密钥包装初始化时，底层 Cipher 实现应自己生成所需的参数（使用特定于提供者的默认值或随机值）；在为解密或密钥解包初始化时，将引发 InvalidKeyException。可以用 getParameters 或 getIV 获取生成的参数（如果该参数为 IV）。

如果此 Cipher（包括其底层反馈或填充方案）需要随机字节（例如，用于参数生成），那么它将使用具有最高优先级的已安装提供者的 SecureRandom 实现作为随机源获取这些字节。（如果已安装的提供者都不提供 SecureRandom 实现，则将使用系统提供的随机源）。

注意，初始化 Cipher 对象时，它将失去所有以前获得的状态。换句话说，初始化 Cipher 相当于创建该 Cipher 的一个新实例并将其初始化。

参数： opmode - 此 Cipher 的操作模式（为以下之一：ENCRYPT_MODE、DECRYPT_MODE、WRAP_MODE 或 UNWRAP_MODE）

key - 密钥

抛出： InvalidKeyException- 如果给定的 key 不适合初始化此 Cipher；如果此 Cipher 为解密初始化，并且所需算法参数无法从给定的 key 确定；如果给定 key 的键大小超出所允许的最大值（由已配置的仲裁策略文件确定）。

12、public final void init(int opmode, Key key, SecureRandom random) 用密钥和随机源初始化此 Cipher。

13、public final void init(int opmode, Key key, AlgorithmParameterSpec params) 用密钥和一组算法参数初始化此 Cipher。

14、public final void init(int opmode, Key key, AlgorithmParameterSpec params, SecureRandom random) 用一个密钥、一组算法参数和一个随机源初始化此 Cipher。

15、public final void init(int opmode, Key key, AlgorithmParameters params) 用密钥和一组算法参数初始化此 Cipher。

16、public final void init(int opmode, Key key, AlgorithmParameters params, SecureRandom random) 用一个密钥、一组算法参数和一个随机源初始化此 Cipher。

17、public final void init(int opmode, Certificate certificate) 用取自给定证书的公钥初始化此 Cipher。

18、public final void init(int opmode, Certificate certificate, SecureRandom random) 用取自给定证书的公钥和随机源初始化此 Cipher。

19、public final byte[] update(byte[] input) 继续多部分加密或解密操作（具体取决于此 Cipher 的初始化方式），以处理其他数据部分。处理 input 缓冲区中的字节，并将结果存储在新的缓冲区中。如果 input 长度为 0，则此方法返回 null。

20、public final byte[] update(byte[] input, int inputOffset,int inputLen) 继续多部分加密或解密操作（具体取决于此 Cipher 的初始化方式），以处理其他数据部分。

21、public final int update(byte[] input, int inputOffset, int inputLen, byte[] output) 继续多部分加密或解密操作（具体取决于此 Cipher 的初始化方式），以处理其他数据部分。处理 input 缓冲区中从 inputOffset 开始（包含）的前 inputLen 个字节，并将结果存储在 output 缓冲区中。

如果 output 缓冲区太小无法保存该结果，则抛出 ShortBufferException。这种情况下，使用一个稍大的缓冲区再次调用。使用 getOutputSize 确定输出缓冲区应为多大。如果 inputLen 为 0，则此方法返回的长度为 0。

注：此方法应该是复制安全 (copy-safe) 的，这意味着 input 和 output 缓冲区可引用相同的 byte 数组，并且在将结果复制到输出缓冲区时，不会覆盖任何未处理的输入数据。

22、public final int update(byte[] input, int inputOffset, int inputLen, byte[] output, int outputOffset) 继续多部分加密或解密操作（具体取决于此 Cipher 的初始化方式），以处理其他数据部分。

23、public final int update(ByteBuffer input, ByteBuffer output) 继续多部分加密或解密操作（具体取决于此 Cipher 的初始化方式），以处理其他数据部分。

24、public final byte[] doFinal() throws IllegalBlockSizeException, BadPaddingException 结束多部分加密或解密操作（具体取决于此 Cipher 的初始化方式）。

处理在上一次 update 操作中缓存的输入数据，其中应用了填充（如果请求）。结果将存储在新缓冲区中。结束时，此方法将此 Cipher 对象重置为上一次调用 init 初始化得到的状态。即该对象被重置，并可用于加密或解密（具体取决于调用 init 时指定的操作模式）更多的数据。

注：如果抛出了任何异常，则再次使用此 Cipher 对象前需要将其重置。
返回：包含结果的新缓冲区抛出： IllegalStateException - 如果此 Cipher 处于错误状态（例如，尚未初始化） IllegalBlockSizeException - 如果此 Cipher 为 Cipher 块，未请求任何填充（只针对加密模式），并且由此 Cipher 处理的数据总输入长度不是块大小的倍数；如果此加密算法无法处理所提供的输入数据。 BadPaddingException - 如果此 Cipher 为解密模式，并且未请求填充（或不填充），但解密的数据没有用适当的填充字节进行限制

25、public final int doFinal(byte[] output, int outputOffset) 结束多部分加密或解密操作（具体取决于此 Cipher 的初始化方式）。

26、public final byte[] doFinal(byte[] input) 按单部分操作加密或解密数据，或者结束一个多部分操作。数据将被加密或解密（具体取决于此 Cipher 的初始化方式）。

27、public final byte[] doFinal(byte[] input, int inputOffset, int inputLen) 按单部分操作加密或解密数据，或者结束一个多部分操作。数据将被加密或解密（具体取决于此 Cipher 的初始化方式）。

28、public final int doFinal(byte[] input, int inputOffset, int inputLen, byte[] output) 按单部分操作加密或解密数据，或者结束一个多部分操作。数据将被加密或解密（具体取决于此 Cipher 的初始化方式）。

29、public final int doFinal(byte[] input, int inputOffset, int inputLen, byte[] output, int outputOffset) 按单部分操作加密或解密数据，或者结束一个多部分操作。数据将被加密或解密（具体取决于此 Cipher 的初始化方式）。

30、public final int doFinal(ByteBuffer input, ByteBuffer output) 按单部分操作加密或解密数据，或者结束一个多部分操作。数据将被加密或解密（具体取决于此 Cipher 的初始化方式）。

31、public final byte[] wrap(Keykey) throws IllegalBlockSizeException, InvalidKeyException 包装密钥。
抛出：IllegalStateException - 如果此 Cipher 处于错误状态（例如，尚未初始化） IllegalBlockSizeException - 如果此 Cipher 为 Cipher 块，未请求填充，并且要包装的密钥的编码长度不是块大小的倍数。 InvalidKeyException - 如果不能用此 Cipher 包装该密钥，或者这样做不安全（例如，将一个硬件保护的密钥传给只能用于软件保护的 Cipher）。

32、
?
1

public final Key unwrap(byte[] wrappedKey, String wrappedKeyAlgorithm,int wrappedKeyType)throws InvalidKeyException,NoSuchAlgorithmException 解包一个以前包装的密钥。
参数： wrappedKey - 要解包的密钥。 wrappedKeyAlgorithm - 与此包装密钥关联的算法。 wrappedKeyType - 已包装密钥的类型。此类型必须为 SECRET_KEY、PRIVATE_KEY 或 PUBLIC_KEY 之一。返回：解包的密钥。抛出： IllegalStateException - 如果此 Cipher 处于错误状态（例如，尚未初始化） NoSuchAlgorithmException - 如果没有一个已安装的提供者能够针对 wrappedKeyAlgorithm 创建类型为 wrappedKeyType 的密钥。 InvalidKeyException - 如果 wrappedKey 不表示针对 wrappedKeyAlgorithm 的类型为 wrappedKeyType 的已包装密钥。

33、public static final int getMaxAllowedKeyLength(String transformation) throws NoSuchAlgorithmException 根据所安装的 JCE 仲裁策略文件，返回指定转换的最大密钥长度。如果安装了 JCE 无限制强度仲裁策略文件，则返回 Integer.MAX_VALUE
参数： transformation - Cipher 转换。返回：最大密钥长度（以位为单位）或 Integer.MAX_VALUE。抛出： NullPointerException - 如果 transformation 为 null。 NoSuchAlgorithmException - 如果 transformation 不是有效的转换，即格式不为“算法”或“算法/模式/填充”。

34、public static final AlgorithmParameterSpec getMaxAllowedParameterSpec(String transformation) throws NoSuchAlgorithmException
根据仲裁策略文件，返回包含最大 Cipher 参数值的 AlgorithmParameterSpec 对象。如果安装了 JCE 无限制强度仲裁策略文件，或者策略文件中对用于指定转换的参数没有最大限制，则返回 null。

参数： transformation - Cipher 转换。返回：保存最大值的 AlgorithmParameterSpec，或者返回 null。
抛出： NullPointerException - 如果 transformation 为 null。 NoSuchAlgorithmException - 如果 transformation 不是有效的转换，即格式不为“算法”或“算法/模式/填充”。

2. Java中的SecretKeyFactory类

SecretKeyFactory表示秘密密钥的工厂。类声明：public class SecretKeyFactory extends Object
密钥工厂用来将密钥（类型 Key 的不透明加密密钥）转换为密钥规范（底层密钥材料的透明表示形式），反之亦然。秘密密钥工厂只对秘密（对称）密钥进行操作。

密钥工厂为双工模式，即其允许根据给定密钥规范（密钥材料）构建不透明密钥对象，或以适当格式获取密钥对象的底层密钥材料。

应用程序开发人员应参阅其提供者文档，找出 generateSecret和 getKeySpec方法所支持的密钥规范。例如，”SunJCE” 提供者提供的 DES 秘密密钥工厂支持 DESKeySpec 作为 DES 密钥的透明表示形式，并且该提供者的 Triple DES 密钥的秘密密钥工厂支持 DESedeKeySpec 作为 Triple DES 密钥的透明表示形式。

1、构造方法：protected SecretKeyFactory(SecretKeyFactorySpi keyFacSpi, Provider provider, String algorithm) 用来创建一个 SecretKeyFactory 对象。
参数：

keyFacSpi - 委托

provider - 提供者

algorithm - 秘密密钥算法

2、方法详细：

①public static final SecretKeyFactory getInstance(String algorithm) throws NoSuchAlgorithmException

返回转换指定算法的秘密密钥的 SecretKeyFactory 对象

此方法从首选 Provider 开始遍历已注册安全提供者列表。返回一个封装 SecretKeyFactorySpi 实现的新 SecretKeyFactory 对象，该实现取自支持指定算法的第一个 Provider。

注意，可以通过 Security.getProviders() 方法获取已注册提供者列表。
参数：

algorithm - 所请求的秘密密钥算法的标准名称。有关标准算法名称的信息，请参阅 java Cryptography Architecture Reference Guide中的附录 A

抛出：NoSuchAlgorithmException - 如果没有任何 Provider 支持指定算法的 SecretKeyFactorySpi 实现。

②public static final SecretKeyFactory getInstance(String algorithm, String provider) throws NoSuchAlgorithmException, NoSuchProviderException

返回转换指定算法的秘密密钥的 SecretKeyFactory 对象。

返回一个封装 SecretKeyFactorySpi 实现的新 SecretKeyFactory 对象，该实现取自指定的提供者。指定提供者必须在安全提供者列表中注册。

抛出异常：
NoSuchAlgorithmException - 如果不能从指定提供者获得指定算法的 SecretKeyFactorySpi 实现。 NullPointerException - 如果指定的算法为 null。 NoSuchProviderException - 如果指定提供者未在安全提供者列表中注册。 IllegalArgumentException - 如果 provider 为 null 或空。

③public static final SecretKeyFactory getInstance(String algorithm, Provider provider) throws NoSuchAlgorithmException

返回转换指定算法的秘密密钥的 SecretKeyFactory 对象。

返回一个封装 SecretKeyFactorySpi 实现的新 SecretKeyFactory 对象，该实现取自指定的 Provider 对象。注意，指定 Provider 对象无需在提供者列表中注册。

抛出异常：
NullPointerException - 如果指定的算法为 null。 NoSuchAlgorithmException - 如果不能从指定的 Provider 对象获得指定算法的 SecretKeyFactorySpi 实现。 IllegalArgumentException - 如果 provider 为 null。

④public final Provider getProvider() 返回此 SecretKeyFactory 对象的提供者。

⑤public final String getAlgorithm()

返回此 SecretKeyFactory 对象的算法名称。此名称与在某个创建此 SecretKeyFactory 对象的 getInstance 调用中指定的名称相同。

⑥public final SecretKey generateSecret(KeySpec keySpec) throws InvalidKeySpecException 根据提供的密钥规范（密钥材料）生成 SecretKey 对象。

参数：keySpec - 秘密密钥的规范（密钥材料）
返回：秘密密钥抛出： InvalidKeySpecException - 如果给定密钥规范不适合生成秘密密钥的秘密密钥工厂。
⑦public final KeySpec getKeySpec(SecretKey key, Class keySpec) throws InvalidKeySpecException 以请求的格式返回给定密钥对象的规范（密钥材料）。参数：key - 密钥 keySpec - 所请求的格式，密钥材料将以此格式返回返回：所请求格式的底层密钥规范（密钥材料）抛出：InvalidKeySpecException - 如果所请求的密钥规范不适合给定的密钥（例如，与 key 和 keySpec 关联的算法不匹配，或者 key 在加密硬件设备上引用一个密钥而 keySpec 是基于软件的密钥规范），或者无法处理给定的密钥（例如，给定的密钥具有此秘密密钥工厂不支持的算法或格式）。
⑧public final SecretKey translateKey(SecretKey key) throws InvalidKeyException将一个密钥对象（其提供者未知或可能不受信任）转换为此秘密密钥工厂的相应密钥对象。参数：key - 其提供者未知或不受信任的密钥返回：已转换的密钥

抛出：InvalidKeyException - 如果此秘密密钥工厂无法处理给定的密钥。

例如下面例子：

        try {// 获取密钥工厂类对象SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");byte[] DESkey = "abcdefghijk".getBytes("UTF-8");// 设置密钥DESKeySpec keySpec = new DESKeySpec(DESkey);// 设置密钥参数Key key = keyFactory.generateSecret(keySpec);// 得到密钥对象
} catch (Exception e) {e.printStackTrace();
}

3.类PBEKeySpec

所有已实现的接口：
KeySpec

public class PBEKeySpec extends Object implements KeySpec

可随同基于密码的加密法 (PBE) 使用的供用户选择的密码。

可以将密码视为某种原始密钥内容，由此加密机制使用其导出一个密钥。

不同的 PBE 机制可能对每一个密码字符使用不同的位数。例如，在 PKCS #5 中定义的 PEB 机制仅仅关注每一个字符的低 8 位，而 PKCS #12 关注每一个字符的全 16 位。

通过创建一个合适的密钥工厂实例来将密码转换成为一个 PBE 密钥。例如，PKCS #5 的密钥工厂仅根据每个密码字符的低 8 位来构造 PBE 密钥，而 PKCS #12 的密钥工厂将使用每个字符的全 16 位。

还要注意，此类以 char 数组而不是 String 对象的形式存储密码（这可能更具逻辑性），因为 String 类是不可变的，当不再需要存储在其中的密码时没有任何途径来重写其内部值。因此，此类需要以 char 数组作密码，以便在完成后进行重写。详细的见Java的文档：http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/javax/crypto/spec/PBEKeySpec.html

4.一个完整的例子

package cn.date20150908.com;import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;
import javax.management.PersistentMBean;public class MyPbe {public static void main(String[] args)throws Exception{//定义需要进行加密的数据 String pass="liyanhao";System.out.println("加密前的数据："+pass);//对数据进行加密  secretEncrypt(pass);//对数据进行解密  secretDecrypt("c:/PBencrypted.data","c:/PBsecret.key");  }public static  void secretEncrypt(String data) throws Exception{//使用PBEWithMD5AndDES算法获取Cipher实例Cipher cipher=Cipher.getInstance("PBEWithMD5AndDES");//初始化密钥(跟cipher的初始化的参数是相同的)SecretKeyFactory keyFactory=SecretKeyFactory.getInstance("PBEWithMD5AndDES");PBEKeySpec pbeKeySpec=new PBEKeySpec("password".toCharArray());SecretKey secretKey = keyFactory.generateSecret(pbeKeySpec);//初始化Cipher为加密器 /*PBEParameterSpecpublic PBEParameterSpec(byte[] salt,int iterationCount)为 PKCS #5 标准中所定义的基于密码的加密法构造一个参数集合。参数：salt - salt。复制该 salt 的内容来防止后续修改。iterationCount - 迭代计数。 抛出：NullPointerException - 如果 salt 为 null。*/PBEParameterSpec parameterSpec=new PBEParameterSpec(new byte[]{1,2,3,4,5,6,7,8}, 1000);cipher.init(Cipher.ENCRYPT_MODE, secretKey,parameterSpec);//对数据进行加密byte[] encryptedData =cipher.doFinal(data.getBytes());System.out.println("加密后的数据"+new String (encryptedData));//将密钥进行持久化和序列化FileOutputStream keyFos=new FileOutputStream("c:/PBsecret.key");ObjectOutputStream keyOos=new ObjectOutputStream(keyFos);keyOos.writeObject(secretKey);keyOos.close();keyOos.close();//将加密后的数据进行持久化 FileOutputStream encryptedDataFos=new FileOutputStream("c:/PBencrypted.data");encryptedDataFos.write(encryptedData);encryptedDataFos.close();}public static  void secretDecrypt(String dataPath,String keypath)throws Exception{//通过IO流获得密钥和加密数据FileInputStream keyFis=new FileInputStream(keypath);ObjectInputStream keyois=new ObjectInputStream(keyFis);//使用PBEWithMD5AndDES算法获取Cipher实例Cipher cipher=Cipher.getInstance("PBEWithMD5AndDES");//初始化密钥SecretKey secretKey=(SecretKey)keyois.readObject();keyois.close();//初始化Cipher为解密器PBEParameterSpec pbeParameterSpec=new PBEParameterSpec(new byte[]{1,2,3,4,5,6,7,8},1000 );cipher.init(Cipher.DECRYPT_MODE, secretKey,pbeParameterSpec);//获得加密后的数据FileInputStream encryptedDataFis=new FileInputStream(dataPath);ByteArrayOutputStream bos=new ByteArrayOutputStream();copyStream(encryptedDataFis,bos);//获得解密后的数据 byte[] decryptedData =cipher.doFinal(bos.toByteArray());bos.close();encryptedDataFis.close();System.out.println("解密后的数据"+new String(decryptedData));}public static void copyStream(FileInputStream fis ,ByteArrayOutputStream bos) throws Exception{  byte[] buf = new byte[1024];  int len = -1;  while((len=fis.read(buf))!=-1){  bos.write(buf,0,len);  }  }
}