Cipher (Java Platform SE 8 )

java.lang.Object
- javax.crypto.Cipher

已知直接子类：

NullCipher
```
public class Cipher
extends Object
```
这个类提供了一个用于加密和解密的加密密码的功能。它形式的java加密扩展（JCE）框架的核心。
为了创建一个密码的对象，应用程序调用密码的getInstance方法，并通过要求的转型的名字了。可选地，可以指定提供程序的名称。

一个转型是一个字符串，描述操作（或一组操作）进行给定的输入，产生输出。变换总是包括一个加密算法（例如，辅）的名称，并可能随后由一个反馈模式和填充方案。

变换是形式：
- “算法/模式/填充”或
- “算法”
在后一种情况下，使用该模式和填充方案的特定默认值）。例如，下面是一个有效的转换：
```
密码C =密码。getInstance（DES CBC / pkcs5padding /”）；
```
使用模式如 CFB和 OFB，分组密码加密数据的单位小于密码的实际大小的块。当要求这样一种模式，你可以选择指定的比特数是在一个时间处理通过添加该号码模式名称如“ DES/CFB8/NoPadding”和“ DES/OFB32/PKCS5Padding”转变。如果没有指定该数字，则使用提供程序特定的默认值。（例如，sunjce提供者使用默认的64位DES分组密码。）因此，可以变成字节用8位模式如cfb8或ofb8型流密码。
模式如认证加密相关的数据（AEAD）提供机密数据和额外的相关数据真实性的保证（AAD）是不加密的。（请参阅关于失效和失效算法如GCM / CCM的更多信息。 RFC 5116 ）机密的和AAD的数据可以计算认证标签使用时（类似于Mac）。这个标签附加到密文在加密，解密和验证。

AEAD如GCM模式/ CCM执行所有与真实计算开始前的密文的真实性计算。为了避免内部缓冲区和数据密文的实现，都必须提供GCM / CCM实现（通过updateAAD方法）之前密文进行处理（通过update和doFinal方法）。

注意，GCM模式对IVS用于加密一个键的唯一性要求。当IVS是GCM加密重复，这种用法是受伪造攻击。因此，使用GCM模式每个加密操作后，用户应重新GCM参数具有不同的IV值初始化密码的对象。
```
gcmparameterspec =…；密码。init（…，S）；//如果GCM参数由提供程序生成的，它可以/被检索：/ /密码。getparameters()。getparameterspec（gcmparameterspec。类）；密码。updateaad（…）；// AAD密码。更新（…）；/ /多部分更新密码。数组（…）；//结论操作每一个加密使用一个不同的四值字节[] newiv =…；S =新gcmparameterspec（美国gettlen()，newiv）；密码。init（…，S）；…
```
java平台的每种实现都要求支持以下标准 Cipher转换用括号中的keysizes：
- （128）AES/CBC/NoPadding
- （128）AES/CBC/PKCS5Padding
- （128）AES/ECB/NoPadding
- （128）AES/ECB/PKCS5Padding
- （56）DES/CBC/NoPadding
- （56）DES/CBC/PKCS5Padding
- （56）DES/ECB/NoPadding
- （56）DES/ECB/PKCS5Padding
- （168）DESede/CBC/NoPadding
- （168）DESede/CBC/PKCS5Padding
- （168）DESede/ECB/NoPadding
- （168）DESede/ECB/PKCS5Padding
- RSA/ECB/PKCS1Padding（1024，2048）
- RSA/ECB/OAEPWithSHA-1AndMGF1Padding（1024，2048）
- RSA/ECB/OAEPWithSHA-256AndMGF1Padding（1024，2048）
这些变换的java加密体系标准算法的名字 Cipher section描述文件。向您的实现咨询发布文档，以查看是否支持任何其他转换。
从以下版本开始：

一点四

另请参见：

KeyGenerator， SecretKey

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DECRYPT_MODE` 用于初始化密码到解密模式的常数。
`static int`	`ENCRYPT_MODE` 用于初始化加密到加密模式的常数。
`static int`	`PRIVATE_KEY` 常用来表示将展开，关键是一个“私钥”。
`static int`	`PUBLIC_KEY` 常用来表示将展开，关键是“公钥”。
`static int`	`SECRET_KEY` 常用来表示将展开，关键是一个“秘密钥匙”。
`static int`	`UNWRAP_MODE` 常数用于初始化密钥对密钥展开模式。
`static int`	`WRAP_MODE` 常数用于初始化密钥到密钥的包装模式。

构造方法摘要

构造方法
Modifier	Constructor and Description
`protected`	`Cipher(CipherSpi cipherSpi, Provider provider, String transformation)` 创建一个密码对象。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`byte[]`	`doFinal()` 完成多个部分的加密或解密操作，这取决于该密码是如何初始化的。
`byte[]`	`doFinal(byte[] input)` 在一个单一的部分操作加密或解密数据，或完成一个多部分操作。
`int`	`doFinal(byte[] output, int outputOffset)` 完成多个部分的加密或解密操作，这取决于该密码是如何初始化的。
`byte[]`	`doFinal(byte[] input, int inputOffset, int inputLen)` 在一个单一的部分操作加密或解密数据，或完成一个多部分操作。
`int`	`doFinal(byte[] input, int inputOffset, int inputLen, byte[] output)` 在一个单一的部分操作加密或解密数据，或完成一个多部分操作。
`int`	`doFinal(byte[] input, int inputOffset, int inputLen, byte[] output, int outputOffset)` 在一个单一的部分操作加密或解密数据，或完成一个多部分操作。
`int`	`doFinal(ByteBuffer input, ByteBuffer output)` 在一个单一的部分操作加密或解密数据，或完成一个多部分操作。
`String`	`getAlgorithm()` 返回该对象的算法名称 `Cipher`。
`int`	`getBlockSize()` 返回块大小（以字节为单位）。
`ExemptionMechanism`	`getExemptionMechanism()` 返回此密码的豁免机制对象。
`static Cipher`	`getInstance(String transformation)` 返回一个 `Cipher`对象实现指定的变换。
`static Cipher`	`getInstance(String transformation, Provider provider)` 返回一个 `Cipher`对象实现指定的变换。
`static Cipher`	`getInstance(String transformation, String provider)` 返回一个 `Cipher`对象实现指定的变换。
`byte[]`	`getIV()` 返回一个新的缓冲区中的初始化向量（四）。
`static int`	`getMaxAllowedKeyLength(String transformation)` 返回指定的变换的最大密钥长度根据安装JCE管辖政策文件。
`static AlgorithmParameterSpec`	`getMaxAllowedParameterSpec(String transformation)` 返回一个algorithmparameterspec对象包含的最大密码参数值根据司法政策文件。
`int`	`getOutputSize(int inputLen)` 返回的字节长度，输出缓冲区将需要为了保持结果的下一 `update`或 `doFinal`操作， `inputLen`给定输入长度（以字节为单位）。
`AlgorithmParameters`	`getParameters()` 返回此密码所使用的参数。
`Provider`	`getProvider()` 返回该对象的 `Cipher`提供者。
`void`	`init(int opmode, Certificate certificate)` 从给定证书的公共密钥初始化这个密码。
`void`	`init(int opmode, Certificate certificate, SecureRandom random)` 从给定的证书和一个随机源的公共密钥初始化这个密码。
`void`	`init(int opmode, Key key)` 一个关键的初始化这个密码。
`void`	`init(int opmode, Key key, AlgorithmParameters params)` 用钥匙和一套算法参数初始化这个密码。
`void`	`init(int opmode, Key key, AlgorithmParameterSpec params)` 用钥匙和一套算法参数初始化这个密码。
`void`	`init(int opmode, Key key, AlgorithmParameterSpec params, SecureRandom random)` 一个关键的初始化这个密码，一组算法参数，和一个随机源。
`void`	`init(int opmode, Key key, AlgorithmParameters params, SecureRandom random)` 一个关键的初始化这个密码，一组算法参数，和一个随机源。
`void`	`init(int opmode, Key key, SecureRandom random)` 用钥匙和随机源初始化这个密码。
`Key`	`unwrap(byte[] wrappedKey, String wrappedKeyAlgorithm, int wrappedKeyType)` 打开先前包的关键。
`byte[]`	`update(byte[] input)` 继续一个多部分加密或解密操作（取决于这个密码是如何初始化的），处理另一个数据部分。
`byte[]`	`update(byte[] input, int inputOffset, int inputLen)` 继续一个多部分加密或解密操作（取决于这个密码是如何初始化的），处理另一个数据部分。
`int`	`update(byte[] input, int inputOffset, int inputLen, byte[] output)` 继续一个多部分加密或解密操作（取决于这个密码是如何初始化的），处理另一个数据部分。
`int`	`update(byte[] input, int inputOffset, int inputLen, byte[] output, int outputOffset)` 继续一个多部分加密或解密操作（取决于这个密码是如何初始化的），处理另一个数据部分。
`int`	`update(ByteBuffer input, ByteBuffer output)` 继续一个多部分加密或解密操作（取决于这个密码是如何初始化的），处理另一个数据部分。
`void`	`updateAAD(byte[] src)` 继续一个附加的认证数据的多部分更新（AAD）。
`void`	`updateAAD(byte[] src, int offset, int len)` 继续一个附加的认证数据的多部分更新（AAD），使用所提供的缓冲区的一个子集。
`void`	`updateAAD(ByteBuffer src)` 继续一个附加的认证数据的多部分更新（AAD）。
`byte[]`	`wrap(Key key)` 包钥匙。

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - ENCRYPT_MODE
```
public static final int ENCRYPT_MODE
```
    用于初始化加密到加密模式的常数。
    
    另请参见：
    
    Constant Field Values
  - DECRYPT_MODE
```
public static final int DECRYPT_MODE
```
    用于初始化密码到解密模式的常数。
    
    另请参见：
    
    Constant Field Values
  - WRAP_MODE
```
public static final int WRAP_MODE
```
    常数用于初始化密钥到密钥的包装模式。
    
    另请参见：
    
    Constant Field Values
  - UNWRAP_MODE
```
public static final int UNWRAP_MODE
```
    常数用于初始化密钥对密钥展开模式。
    
    另请参见：
    
    Constant Field Values
  - PUBLIC_KEY
```
public static final int PUBLIC_KEY
```
    常用来表示将展开，关键是“公钥”。
    
    另请参见：
    
    Constant Field Values
  - PRIVATE_KEY
```
public static final int PRIVATE_KEY
```
    常用来表示将展开，关键是一个“私钥”。
    
    另请参见：
    
    Constant Field Values
  - SECRET_KEY
```
public static final int SECRET_KEY
```
    常用来表示将展开，关键是一个“秘密钥匙”。
    
    另请参见：
    
    Constant Field Values
- Constructor Detail
  - Cipher
```
protected Cipher(CipherSpi cipherSpi,
                 Provider provider,
                 String transformation)
```
    创建一个密码对象。
    
    参数
    
    cipherSpi -代表
    
    provider -供应商
    
    transformation -改造
- 方法详细信息
  - getInstance
```
public static final Cipher getInstance(String transformation)
                                throws NoSuchAlgorithmException,
                                       NoSuchPaddingException
```
    返回一个实现指定转换 Cipher对象。
    该方法通过注册安全提供商列表，从最开始的首选供应商。一个新的密码cipherspi对象封装实现，支持指定算法的第一供应商返回。
    
    注意，注册商的列表可以通过Security.getProviders()检索方法。
    
    参数
    
    transformation的变换，如：名字，DES CBC / pkcs5padding /。看到有关规范变换名称的信息在 Java Cryptography Architecture Standard Algorithm Name Documentation密码部分。
    
    结果
    
    实现请求的转换的密码。
    
    异常
    
    NoSuchAlgorithmException -如果 transformation是空的，空的，无效的格式，或者如果没有供应商的支持cipherspi为指定的算法实现。
    
    NoSuchPaddingException -如果 transformation包含填充方案不可用。
    
    另请参见：
    
    Provider
  - getInstance
```
public static final Cipher getInstance(String transformation,
                                       String provider)
                                throws NoSuchAlgorithmException,
                                       NoSuchProviderException,
                                       NoSuchPaddingException
```
    返回一个 Cipher对象实现指定的变换。
    新密码的对象封装cipherspi实现从指定的提供程序返回。指定的提供程序必须在安全提供程序列表中注册。
    
    注意，注册商的列表可以通过Security.getProviders()检索方法。
    
    参数
    
    transformation的变换，如：名字，DES CBC / pkcs5padding /。看到有关规范变换名称的信息在 Java Cryptography Architecture Standard Algorithm Name Documentation密码部分。
    
    provider -提供者的名称。
    
    结果
    
    实现请求的转换的密码。
    
    异常
    
    NoSuchAlgorithmException -如果 transformation是空的，空的，无效的格式，或者如果一个指定的算法cipherspi执行不可从指定的供应商。
    
    NoSuchProviderException -如果指定的供应商不在安全提供商注册名单。
    
    NoSuchPaddingException -如果 transformation包含填充方案不可用。
    
    IllegalArgumentException -如果 provider是null或空。
    
    另请参见：
    
    Provider
  - getInstance
```
public static final Cipher getInstance(String transformation,
                                       Provider provider)
                                throws NoSuchAlgorithmException,
                                       NoSuchPaddingException
```
    返回一个 Cipher对象实现指定的变换。
    新密码的对象封装cipherspi实现从指定的提供程序对象返回。请注意，指定的提供程序对象不必在提供者列表中注册。
    
    参数
    
    transformation的变换，如：名字，DES CBC / pkcs5padding /。看到有关规范变换名称的信息在 Java Cryptography Architecture Standard Algorithm Name Documentation密码部分。
    
    provider -供应商。
    
    结果
    
    实现请求的转换的密码。
    
    异常
    
    NoSuchAlgorithmException -如果 transformation是空的，空的，无效的格式，或者如果一个指定的算法cipherspi执行不可从指定的提供程序对象。
    
    NoSuchPaddingException -如果 transformation包含填充方案不可用。
    
    IllegalArgumentException -如果 provider是空的。
    
    另请参见：
    
    Provider
  - getProvider
```
public final Provider getProvider()
```
    返回该对象的 Cipher提供者。
    
    结果
    
    这 Cipher对象的提供者
  - getAlgorithm
```
public final String getAlgorithm()
```
    返回该对象的算法名称 Cipher。
    这是相同的名字，是在一个Cipher创建这个对象。getInstance调用指定的
    
    结果
    
    这 Cipher对象的算法名称。
  - getBlockSize
```
public final int getBlockSize()
```
    返回块大小（以字节为单位）。
    
    结果
    
    块大小（以字节为单位），或0，如果底层的算法不是一个块密码
  - getOutputSize
```
public final int getOutputSize(int inputLen)
```
    返回的字节长度，输出缓冲区将需要为了保持结果的下一 update或 doFinal操作， inputLen给定输入长度（以字节为单位）。
    这叫考虑任何未处理（缓冲）从以前的update电话，数据填充，和AEAD标注。
    
    第二update或doFinal称实际输出的长度可以小于由该方法返回的长度。
    
    参数
    
    inputLen -输入长度（以字节为单位）
    
    结果
    
    所需的输出缓冲区大小（以字节为单位）
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）
  - getIV
```
public final byte[] getIV()
```
    返回一个新的缓冲区中的初始化向量（四）。
    这是有用的情况下，一个随机的四被创建，或在基于密码的加密或解密的上下文中，其中的第四是来自用户提供的密码。
    
    结果
    
    在一个新的缓冲区中的初始化向量，或空，如果底层的算法不使用一个四，或如果第四尚未被设置。
  - getParameters
```
public final AlgorithmParameters getParameters()
```
    返回此密码所使用的参数。
    返回的参数可能是相同的，用于初始化这个密码，或可能包含默认值和随机参数值的组合使用的基本密码实现，如果这个密码需要算法参数，但没有初始化。
    
    结果
    
    此密码使用的参数，或为空，如果这个密码不使用任何参数。
  - getExemptionMechanism
```
public final ExemptionMechanism getExemptionMechanism()
```
    返回此密码的豁免机制对象。
    
    结果
    
    使用此密码的豁免机制对象，或为空，如果此密码不使用任何豁免机制。
  - init
```
public final void init(int opmode,
                       Key key)
                throws InvalidKeyException
```
    一个关键的初始化这个密码。
    密码是以下四个操作：加密、解密、密钥初始化包装或重点展开，根据opmode价值。
    
    如果这个密码要求任何算法的参数不能被来自给定的key，底层的密码体制的实现应该是生成所需的参数本身（使用提供程序特定的默认或随机值）如果被加密或钥匙包初始化，和提高InvalidKeyException如果它被初始化为解密或重点展开。生成的参数可以使用getParameters或getIV检索（如果该参数是一个四）。
    
    如果这个密码需要算法参数，不能来自输入参数，有没有合理的供应商特定的默认值，初始化将必然失败。
    
    如果这个密码（包括其潜在的反馈或填充方案）要求任意字节（例如，参数生成），这会让他们使用SecureRandom执行优先级最高的供应商作为随机源。（如果没有安装供应商提供的供应，实现一个系统提供的随机源将被使用。）
    
    请注意，当一个密码对象被初始化时，它会丢失所有先前获得的状态。换句话说，初始化密码相当于创建密码和初始化一个新的实例。
    
    参数
    
    opmode -这个密码的操作模式（这是下列之一： ENCRYPT_MODE， DECRYPT_MODE， WRAP_MODE或 UNWRAP_MODE）
    
    key的关键
    
    异常
    
    InvalidKeyException -如果给定的关键是初始化这个密码不合适，或者要求算法参数无法确定从给定的键，或如果它的键有一个超过最大允许指定密钥长度的密钥大小（从配置文件作为确定管辖权的政策）。
    
    UnsupportedOperationException如果（@代码OpMode }是 WRAP_MODE或 UNWRAP_MODE但模式不受潜在的 CipherSpi实施。
  - init
```
public final void init(int opmode,
                       Key key,
                       SecureRandom random)
                throws InvalidKeyException
```
    用钥匙和随机源初始化这个密码。
    密码是以下四个操作：加密、解密、密钥初始化包装或重点展开，根据opmode价值。
    
    如果这个密码要求任何算法的参数不能被来自给定的key，底层的密码体制的实现应该是生成所需的参数本身（使用提供程序特定的默认或随机值）如果被加密或钥匙包初始化，和提高InvalidKeyException如果它被初始化为解密或重点展开。生成的参数可以使用getParameters或getIV检索（如果该参数是一个四）。
    
    如果这个密码需要算法参数，不能来自输入参数，有没有合理的供应商特定的默认值，初始化将必然失败。
    
    如果这个密码（包括其潜在的反馈或填充方案）要求任意字节（例如，参数代），它将从random让他们。
    
    请注意，当一个密码对象被初始化时，它会丢失所有先前获得的状态。换句话说，初始化密码相当于创建密码和初始化一个新的实例。
    
    参数
    
    opmode -这个密码的操作模式（这是下列之一： ENCRYPT_MODE， DECRYPT_MODE， WRAP_MODE或 UNWRAP_MODE）
    
    key -加密密钥
    
    random -随机源
    
    异常
    
    InvalidKeyException -如果给定的关键是初始化这个密码不合适，或者要求算法参数无法确定从给定的键，或如果它的键有一个超过最大允许指定密钥长度的密钥大小（从配置文件作为确定管辖权的政策）。
    
    UnsupportedOperationException如果（@代码OpMode }是 WRAP_MODE或 UNWRAP_MODE但模式不受潜在的 CipherSpi实施。
  - init
```
public final void init(int opmode,
                       Key key,
                       AlgorithmParameterSpec params)
                throws InvalidKeyException,
                       InvalidAlgorithmParameterException
```
    用钥匙和一套算法参数初始化这个密码。
    密码是以下四个操作：加密、解密、密钥初始化包装或重点展开，根据opmode价值。
    
    如果需要任何密码算法参数和params是空的，底层的密码体制的实现应该是生成所需的参数本身（使用提供程序特定的默认或随机值）如果被加密或钥匙包初始化，和提高InvalidAlgorithmParameterException如果它被初始化为解密或重点展开。生成的参数可以使用getParameters或getIV检索（如果该参数是一个四）。
    
    如果这个密码需要算法参数，不能来自输入参数，有没有合理的供应商特定的默认值，初始化将必然失败。
    
    如果这个密码（包括其潜在的反馈或填充方案）要求任意字节（例如，参数生成），这会让他们使用SecureRandom执行优先级最高的供应商作为随机源。（如果没有安装供应商提供的供应，实现一个系统提供的随机源将被使用。）
    
    请注意，当一个密码对象被初始化时，它会丢失所有先前获得的状态。换句话说，初始化密码相当于创建密码和初始化一个新的实例。
    
    参数
    
    opmode -这个密码的操作模式（这是下列之一： ENCRYPT_MODE， DECRYPT_MODE， WRAP_MODE或 UNWRAP_MODE）
    
    key -加密密钥
    
    params -算法参数
    
    异常
    
    InvalidKeyException -如果给定的关键是初始化这个密码不合适，或其指定密钥长度超过最大允许的密钥大小（从配置文件作为确定管辖权的政策）。
    
    InvalidAlgorithmParameterException -如果给定的算法参数，这个密码是不适当的，或者这个密码需要算法参数和 params为空，或给定的算法参数意味着加密强度将超过法律限制（从配置文件作为确定管辖权的政策）。
    
    UnsupportedOperationException如果（@代码OpMode }是 WRAP_MODE或 UNWRAP_MODE但模式不受潜在的 CipherSpi实施。
  - init
```
public final void init(int opmode,
                       Key key,
                       AlgorithmParameterSpec params,
                       SecureRandom random)
                throws InvalidKeyException,
                       InvalidAlgorithmParameterException
```
    一个关键的初始化这个密码，一组算法参数，和一个随机源。
    密码是以下四个操作：加密、解密、密钥初始化包装或重点展开，根据opmode价值。
    
    如果需要任何密码算法参数和params是空的，底层的密码体制的实现应该是生成所需的参数本身（使用提供程序特定的默认或随机值）如果被加密或钥匙包初始化，和提高InvalidAlgorithmParameterException如果它被初始化为解密或重点展开。生成的参数可以使用getParameters或getIV检索（如果该参数是一个四）。
    
    如果这个密码需要算法参数，不能来自输入参数，有没有合理的供应商特定的默认值，初始化将必然失败。
    
    如果这个密码（包括其潜在的反馈或填充方案）要求任意字节（例如，参数代），它将从random让他们。
    
    请注意，当一个密码对象被初始化时，它会丢失所有先前获得的状态。换句话说，初始化密码相当于创建密码和初始化一个新的实例。
    
    参数
    
    opmode -这个密码的操作模式（这是下列之一： ENCRYPT_MODE， DECRYPT_MODE， WRAP_MODE或 UNWRAP_MODE）
    
    key -加密密钥
    
    params -算法参数
    
    random -随机源
    
    异常
    
    InvalidKeyException -如果给定的关键是初始化这个密码不合适，或其指定密钥长度超过最大允许的密钥大小（从配置文件作为确定管辖权的政策）。
    
    InvalidAlgorithmParameterException -如果给定的算法参数，这个密码是不适当的，或者这个密码需要算法参数和 params为空，或给定的算法参数意味着加密强度将超过法律限制（从配置文件作为确定管辖权的政策）。
    
    UnsupportedOperationException如果（@代码OpMode }是 WRAP_MODE或 UNWRAP_MODE但模式不受潜在的 CipherSpi实施。
  - init
```
public final void init(int opmode,
                       Key key,
                       AlgorithmParameters params)
                throws InvalidKeyException,
                       InvalidAlgorithmParameterException
```
    用钥匙和一套算法参数初始化这个密码。
    密码是以下四个操作：加密、解密、密钥初始化包装或重点展开，根据opmode价值。
    
    如果需要任何密码算法参数和params是空的，底层的密码体制的实现应该是生成所需的参数本身（使用提供程序特定的默认或随机值）如果被加密或钥匙包初始化，和提高InvalidAlgorithmParameterException如果它被初始化为解密或重点展开。生成的参数可以使用getParameters或getIV检索（如果该参数是一个四）。
    
    如果这个密码需要算法参数，不能来自输入参数，有没有合理的供应商特定的默认值，初始化将必然失败。
    
    如果这个密码（包括其潜在的反馈或填充方案）要求任意字节（例如，参数生成），这会让他们使用SecureRandom执行优先级最高的供应商作为随机源。（如果没有安装供应商提供的供应，实现一个系统提供的随机源将被使用。）
    
    请注意，当一个密码对象被初始化时，它会丢失所有先前获得的状态。换句话说，初始化密码相当于创建密码和初始化一个新的实例。
    
    参数
    
    opmode -这个密码的操作模式（这是下列之一： ENCRYPT_MODE， DECRYPT_MODE， WRAP_MODE或 UNWRAP_MODE）
    
    key -加密密钥
    
    params -算法参数
    
    异常
    
    InvalidKeyException -如果给定的关键是初始化这个密码不合适，或其指定密钥长度超过最大允许的密钥大小（从配置文件作为确定管辖权的政策）。
    
    InvalidAlgorithmParameterException -如果给定的算法参数，这个密码是不适当的，或者这个密码需要算法参数和 params为空，或给定的算法参数意味着加密强度将超过法律限制（从配置文件作为确定管辖权的政策）。
    
    UnsupportedOperationException如果（@代码OpMode }是 WRAP_MODE或 UNWRAP_MODE但模式不受潜在的 CipherSpi实施。
  - init
```
public final void init(int opmode,
                       Key key,
                       AlgorithmParameters params,
                       SecureRandom random)
                throws InvalidKeyException,
                       InvalidAlgorithmParameterException
```
    一个关键的初始化这个密码，一组算法参数，和一个随机源。
    密码是以下四个操作：加密、解密、密钥初始化包装或重点展开，根据opmode价值。
    
    如果需要任何密码算法参数和params是空的，底层的密码体制的实现应该是生成所需的参数本身（使用提供程序特定的默认或随机值）如果被加密或钥匙包初始化，和提高InvalidAlgorithmParameterException如果它被初始化为解密或重点展开。生成的参数可以使用getParameters或getIV检索（如果该参数是一个四）。
    
    如果这个密码需要算法参数，不能来自输入参数，有没有合理的供应商特定的默认值，初始化将必然失败。
    
    如果这个密码（包括其潜在的反馈或填充方案）要求任意字节（例如，参数代），它将从random让他们。
    
    请注意，当一个密码对象被初始化时，它会丢失所有先前获得的状态。换句话说，初始化密码相当于创建密码和初始化一个新的实例。
    
    参数
    
    opmode -这个密码的操作模式（这是下列之一： ENCRYPT_MODE， DECRYPT_MODE， WRAP_MODE或 UNWRAP_MODE）
    
    key -加密密钥
    
    params -算法参数
    
    random -随机源
    
    异常
    
    InvalidKeyException -如果给定的关键是初始化这个密码不合适，或其指定密钥长度超过最大允许的密钥大小（从配置文件作为确定管辖权的政策）。
    
    InvalidAlgorithmParameterException -如果给定的算法参数，这个密码是不适当的，或者这个密码需要算法参数和 params为空，或给定的算法参数意味着加密强度将超过法律限制（从配置文件作为确定管辖权的政策）。
    
    UnsupportedOperationException如果（@代码OpMode }是 WRAP_MODE或 UNWRAP_MODE但模式不受潜在的 CipherSpi实施。
  - init
```
public final void init(int opmode,
                       Certificate certificate)
                throws InvalidKeyException
```
    从给定证书的公共密钥初始化这个密码。
    密码是以下四个操作：加密、解密、密钥初始化包装或重点展开，根据opmode价值。
    
    如果证书的类型是X.509和有密钥用法扩展字段标记为关键，对密钥用法扩展字段的值意味着在证书和对应的私钥公钥不应该用opmode价值为代表的操作，一个InvalidKeyException抛出。
    
    如果这个密码要求任何算法的参数不能被来自公共密钥的加密机制实现了证书，用来生成所需的参数本身（使用提供程序特定的默认或随机值）如果被加密或钥匙包初始化，和提高 InvalidKeyException如果它被初始化为解密或重点展开。生成的参数可以使用getParameters或getIV检索（如果该参数是一个四）。
    
    如果这个密码需要算法参数，不能来自输入参数，有没有合理的供应商特定的默认值，初始化将必然失败。
    
    如果这个密码（包括其潜在的反馈或填充方案）要求任意字节（例如，参数生成），这会让他们使用SecureRandom执行优先级最高的供应商作为随机源。（如果没有安装供应商提供的供应，实现一个系统提供的随机源将被使用。）
    
    请注意，当一个密码对象被初始化时，它会丢失所有先前获得的状态。换句话说，初始化密码相当于创建密码和初始化一个新的实例。
    
    参数
    
    opmode -这个密码的操作模式（这是下列之一： ENCRYPT_MODE， DECRYPT_MODE， WRAP_MODE或 UNWRAP_MODE）
    
    certificate -证书
    
    异常
    
    InvalidKeyException -如果在给定证书的公共密钥初始化这个密码不合适，或者需要这个密码算法参数不能确定在给定的公钥证书，或在给定证书的公钥密钥大小有超过最大允许指定密钥长度的密钥大小（由配置文件的权限政策确定）。
    
    UnsupportedOperationException如果（@代码OpMode }是 WRAP_MODE或 UNWRAP_MODE但模式不受潜在的 CipherSpi实施。
  - init
```
public final void init(int opmode,
                       Certificate certificate,
                       SecureRandom random)
                throws InvalidKeyException
```
    从给定的证书和一个随机源的公共密钥初始化这个密码。
    密码是以下四个操作：加密、解密、密钥初始化包装或重点展开，根据opmode价值。
    
    如果证书的类型是X.509和有密钥用法扩展字段标记为关键，对密钥用法扩展字段的值意味着在证书和对应的私钥公钥不应该用opmode价值为代表的操作，一个InvalidKeyException抛出。
    
    如果这个密码要求任何算法的参数不能被来自公共密钥的加密机制实现了certificate，用来生成所需的参数本身（使用提供程序特定的默认或随机值）如果被加密或钥匙包初始化，和提高InvalidKeyException如果它被初始化为解密或重点展开。生成的参数可以使用getParameters或getIV检索（如果该参数是一个四）。
    
    如果这个密码需要算法参数，不能来自输入参数，有没有合理的供应商特定的默认值，初始化将必然失败。
    
    如果这个密码（包括其潜在的反馈或填充方案）要求任意字节（例如，参数代），它将从random让他们。
    
    请注意，当一个密码对象被初始化时，它会丢失所有先前获得的状态。换句话说，初始化密码相当于创建密码和初始化一个新的实例。
    
    参数
    
    opmode -这个密码的操作模式（这是下列之一： ENCRYPT_MODE， DECRYPT_MODE， WRAP_MODE或 UNWRAP_MODE）
    
    certificate -证书
    
    random -随机源
    
    异常
    
    InvalidKeyException -如果在给定证书的公共密钥初始化这个密码不合适，或者需要这个密码算法参数不能确定在给定的公钥证书，或在给定证书的公钥密钥大小有超过最大允许指定密钥长度的密钥大小（由配置文件的权限政策确定）。
    
    UnsupportedOperationException如果（@代码OpMode }是 WRAP_MODE或 UNWRAP_MODE但模式不受潜在的 CipherSpi实施。
  - update
```
public final byte[] update(byte[] input)
```
    继续一个多部分加密或解密操作（取决于这个密码是如何初始化的），处理另一个数据部分。
    在input缓冲字节进行处理，其结果是存储在一个新的缓冲区。
    
    如果input长度为零，此方法返回null。
    
    参数
    
    input -输入缓冲区
    
    结果
    
    新的缓冲区的结果，或无效，如果底层的密码是一个块密码和输入数据太短，导致在一个新的块。
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）
  - update
```
public final byte[] update(byte[] input,
                           int inputOffset,
                           int inputLen)
```
    继续一个多部分加密或解密操作（取决于这个密码是如何初始化的），处理另一个数据部分。
    在input缓冲第一inputLen字节，从inputOffset包容，进行处理，其结果是存储在一个新的缓冲区。
    
    如果inputLen为零，此方法返回null。
    
    参数
    
    input -输入缓冲区
    
    inputOffset - input那里开始输入偏移
    
    inputLen -输入长度
    
    结果
    
    新的缓冲区的结果，或无效，如果底层的密码是一个块密码和输入数据太短，导致在一个新的块。
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）
  - update
```
public final int update(byte[] input,
                        int inputOffset,
                        int inputLen,
                        byte[] output)
                 throws ShortBufferException
```
    继续一个多部分加密或解密操作（取决于这个密码是如何初始化的），处理另一个数据部分。
    在input缓冲第一inputLen字节，从inputOffset包容，进行处理，并将结果存储在output缓冲。
    
    如果output缓冲太小装不下的结果，一个ShortBufferException抛出。在这种情况下，重复此调用具有较大的输出缓冲区。使用getOutputSize确定多大的输出缓冲区应。
    
    如果inputLen为零，此方法返回一个长度为零。
    
    注意：这个方法应该复制安全的，这意味着input和output缓冲器可以引用相同的字节数组和未经加工的输入数据将被覆盖，当结果复制到输出缓冲区。
    
    参数
    
    input -输入缓冲区
    
    在 input那里开始输入偏移 inputOffset -
    
    inputLen -输入长度
    
    output -结果缓冲区
    
    结果
    
    存储在 output字节数
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）
    
    ShortBufferException如果给定的输出缓冲区太小，保存结果
  - update
```
public final int update(byte[] input,
                        int inputOffset,
                        int inputLen,
                        byte[] output,
                        int outputOffset)
                 throws ShortBufferException
```
    继续一个多部分加密或解密操作（取决于这个密码是如何初始化的），处理另一个数据部分。
    在input缓冲第一inputLen字节，从inputOffset包容，进行处理，并将结果存储在output缓冲，从outputOffset包容。
    
    如果output缓冲太小装不下的结果，一个ShortBufferException抛出。在这种情况下，重复此调用具有较大的输出缓冲区。使用getOutputSize确定多大的输出缓冲区应。
    
    如果inputLen为零，此方法返回一个长度为零。
    
    注意：这个方法应该复制安全的，这意味着input和output缓冲器可以引用相同的字节数组和未经加工的输入数据将被覆盖，当结果复制到输出缓冲区。
    
    参数
    
    input -输入缓冲区
    
    inputOffset - input那里开始输入偏移
    
    inputLen -输入长度
    
    output -结果缓冲区
    
    outputOffset -抵消 output哪里结果存储
    
    结果
    
    存储在 output字节数
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）
    
    ShortBufferException如果给定的输出缓冲区太小，保存结果
  - update
```
public final int update(ByteBuffer input,
                        ByteBuffer output)
                 throws ShortBufferException
```
    继续一个多部分加密或解密操作（取决于这个密码是如何初始化的），处理另一个数据部分。
    所有的input.remaining()字节开始input.position()处理。结果存储在输出缓冲区中。返回时，输入缓冲区的位置将等于它的极限，它的限制将不会改变。输出缓冲区的位置将有先进的N，其中N是通过这种方法返回的值，输出缓冲区的限制将不会改变。
    
    如果output.remaining()字节不够坚持的结果，一个ShortBufferException抛出。在这种情况下，重复此调用具有较大的输出缓冲区。使用getOutputSize确定多大的输出缓冲区应。
    
    注意：这个方法应该复制安全的，这意味着input和output缓冲器可以引用相同的内存块和未经加工的输入数据将被覆盖，当结果复制到输出缓冲区。
    
    参数
    
    input -输入ByteBuffer
    
    output -输出ByteByffer
    
    结果
    
    存储在 output字节数
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）
    
    IllegalArgumentException如果输入和输出是同一个对象
    
    ReadOnlyBufferException如果输出缓冲区是只读的
    
    ShortBufferException -如果在输出缓冲区没有足够的空间
    
    从以下版本开始：
    
    一点五
  - doFinal
```
public final byte[] doFinal()
                     throws IllegalBlockSizeException,
                            BadPaddingException
```
    完成多个部分的加密或解密操作，这取决于该密码是如何初始化的。
    输入的数据可能已经被以前的update缓冲过程中处理，与填充（如果要求）的应用。如果一个失效模式如GCM / CCM正在使用，认证标签附加在加密的情况下，或在解密的情况下验证。结果存储在一个新的缓冲区中。
    
    完成，这个方式将这个密码对象时的状态通过电话init先前初始化。那就是，对象是复位和可加密或解密（取决于被指定在调用init运营模式）更多的数据。
    
    注：如果抛出任何异常，这个密码对象可能需要重置之前，它可以再次使用。
    
    结果
    
    新的缓冲区的结果
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）
    
    IllegalBlockSizeException -如果这密码是一种分组密码，无填料已要求（仅在加密模式），以及数据处理的这一密码输入总长度不是块大小的倍数；或如果该加密算法无法处理输入数据的提供。
    
    BadPaddingException -如果这密码解密模式，和（联合国）填充已提出要求，但解密后的数据不通过适当的填充字节界
    
    AEADBadTagException -如果这密码解密的失效模式（如GCM / CCM），和接收的认证标签计算值不匹配
  - doFinal
```
public final int doFinal(byte[] output,
                         int outputOffset)
                  throws IllegalBlockSizeException,
                         ShortBufferException,
                         BadPaddingException
```
    完成多个部分的加密或解密操作，这取决于该密码是如何初始化的。
    输入的数据可能已经被以前的update缓冲过程中处理，与填充（如果要求）的应用。如果一个失效模式如GCM / CCM正在使用，认证标签附加在加密的情况下，或在解密的情况下验证。结果存储在output缓冲，从outputOffset包容。
    
    如果output缓冲太小装不下的结果，一个ShortBufferException抛出。在这种情况下，重复此调用具有较大的输出缓冲区。使用getOutputSize确定多大的输出缓冲区应。
    
    完成，这个方式将这个密码对象时的状态通过电话init先前初始化。那就是，对象是复位和可加密或解密（取决于被指定在调用init运营模式）更多的数据。
    
    注：如果抛出任何异常，这个密码对象可能需要重置之前，它可以再次使用。
    
    参数
    
    output -结果缓冲区
    
    outputOffset -抵消 output哪里结果存储
    
    结果
    
    存储在 output字节数
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）
    
    IllegalBlockSizeException -如果这密码是一种分组密码，无填料已要求（仅在加密模式），以及数据处理的这一密码输入总长度不是块大小的倍数；或如果该加密算法无法处理输入数据的提供。
    
    ShortBufferException如果给定的输出缓冲区太小，保存结果
    
    BadPaddingException -如果这密码解密模式，和（联合国）填充已提出要求，但解密后的数据不通过适当的填充字节界
    
    AEADBadTagException -如果这密码解密的失效模式（如GCM / CCM），和接收的认证标签计算值不匹配
  - doFinal
```
public final byte[] doFinal(byte[] input)
                     throws IllegalBlockSizeException,
                            BadPaddingException
```
    在一个单一的部分操作加密或解密数据，或完成一个多部分操作。对数据进行加密或解密，根据这个密码初始化。
    在input缓冲的字节，这可能是一update缓冲操作，在任何输入的字节处理，与填充（如果要求）的应用。如果一个失效模式如GCM / CCM正在使用，认证标签附加在加密的情况下，或在解密的情况下验证。结果存储在一个新的缓冲区中。
    
    完成，这个方式将这个密码对象时的状态通过电话init先前初始化。那就是，对象是复位和可加密或解密（取决于被指定在调用init运营模式）更多的数据。
    
    注：如果抛出任何异常，这个密码对象可能需要重置之前，它可以再次使用。
    
    参数
    
    input -输入缓冲区
    
    结果
    
    新的缓冲区的结果
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）
    
    IllegalBlockSizeException -如果这密码是一种分组密码，无填料已要求（仅在加密模式），以及数据处理的这一密码输入总长度不是块大小的倍数；或如果该加密算法无法处理输入数据的提供。
    
    BadPaddingException -如果这密码解密模式，和（联合国）填充已提出要求，但解密后的数据不通过适当的填充字节界
    
    AEADBadTagException -如果这密码解密的失效模式（如GCM / CCM），和接收的认证标签计算值不匹配
  - doFinal
```
public final byte[] doFinal(byte[] input,
                            int inputOffset,
                            int inputLen)
                     throws IllegalBlockSizeException,
                            BadPaddingException
```
    在一个单一的部分操作加密或解密数据，或完成一个多部分操作。对数据进行加密或解密，根据这个密码初始化。
    在input缓冲第一inputLen字节，从inputOffset包容，这可能是一update缓冲操作，在任何输入的字节处理，与填充（如果要求）的应用。如果一个失效模式如GCM / CCM正在使用，认证标签附加在加密的情况下，或在解密的情况下验证。结果存储在一个新的缓冲区中。
    
    完成，这个方式将这个密码对象时的状态通过电话init先前初始化，对象是复位和可加密或解密（取决于被指定在调用init运营模式）更多的数据。
    
    注：如果抛出任何异常，这个密码对象可能需要重置之前，它可以再次使用。
    
    参数
    
    input -输入缓冲区
    
    inputOffset - input那里开始输入偏移
    
    inputLen -输入长度
    
    结果
    
    新的缓冲区的结果
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）
    
    IllegalBlockSizeException -如果这密码是一种分组密码，无填料已要求（仅在加密模式），以及数据处理的这一密码输入总长度不是块大小的倍数；或如果该加密算法无法处理输入数据的提供。
    
    BadPaddingException -如果这密码解密模式，和（联合国）填充已提出要求，但解密后的数据不通过适当的填充字节界
    
    AEADBadTagException -如果这密码解密的失效模式（如GCM / CCM），和接收的认证标签计算值不匹配
  - doFinal
```
public final int doFinal(byte[] input,
                         int inputOffset,
                         int inputLen,
                         byte[] output)
                  throws ShortBufferException,
                         IllegalBlockSizeException,
                         BadPaddingException
```
    在一个单一的部分操作加密或解密数据，或完成一个多部分操作。对数据进行加密或解密，根据这个密码初始化。
    在input缓冲第一inputLen字节，从inputOffset包容，这可能是一update缓冲操作，在任何输入的字节处理，与填充（如果要求）的应用。如果一个失效模式如GCM / CCM正在使用，认证标签附加在加密的情况下，或在解密的情况下验证。结果存储在output缓冲。
    
    如果output缓冲太小装不下的结果，一个ShortBufferException抛出。在这种情况下，重复此调用具有较大的输出缓冲区。使用getOutputSize确定多大的输出缓冲区应。
    
    完成，这个方式将这个密码对象时的状态通过电话init先前初始化。那就是，对象是复位和可加密或解密（取决于被指定在调用init运营模式）更多的数据。
    
    注：如果抛出任何异常，这个密码对象可能需要重置之前，它可以再次使用。
    
    注意：这个方法应该复制安全的，这意味着input和output缓冲器可以引用相同的字节数组和未经加工的输入数据将被覆盖，当结果复制到输出缓冲区。
    
    参数
    
    input -输入缓冲区
    
    inputOffset - input那里开始输入偏移
    
    inputLen -输入长度
    
    output -结果缓冲区
    
    结果
    
    存储在 output字节数
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）
    
    IllegalBlockSizeException -如果这密码是一种分组密码，无填料已要求（仅在加密模式），以及数据处理的这一密码输入总长度不是块大小的倍数；或如果该加密算法无法处理输入数据的提供。
    
    ShortBufferException如果给定的输出缓冲区太小，保存结果
    
    BadPaddingException -如果这密码解密模式，和（联合国）填充已提出要求，但解密后的数据不通过适当的填充字节界
    
    AEADBadTagException -如果这密码解密的失效模式（如GCM / CCM），和接收的认证标签计算值不匹配
  - doFinal
```
public final int doFinal(byte[] input,
                         int inputOffset,
                         int inputLen,
                         byte[] output,
                         int outputOffset)
                  throws ShortBufferException,
                         IllegalBlockSizeException,
                         BadPaddingException
```
    在一个单一的部分操作加密或解密数据，或完成一个多部分操作。对数据进行加密或解密，根据这个密码初始化。
    在input缓冲第一inputLen字节，从inputOffset包容，这可能是一update缓冲操作，在任何输入的字节处理，与填充（如果要求）的应用。如果一个失效模式如GCM / CCM正在使用，认证标签附加在加密的情况下，或在解密的情况下验证。结果存储在output缓冲，从outputOffset包容。
    
    如果output缓冲太小装不下的结果，一个ShortBufferException抛出。在这种情况下，重复此调用具有较大的输出缓冲区。使用getOutputSize确定多大的输出缓冲区应。
    
    完成，这个方式将这个密码对象时的状态通过电话init先前初始化，对象是复位和可加密或解密（取决于被指定在调用init运营模式）更多的数据。
    
    注：如果抛出任何异常，这个密码对象可能需要重置之前，它可以再次使用。
    
    注意：这个方法应该复制安全的，这意味着input和output缓冲器可以引用相同的字节数组和未经加工的输入数据将被覆盖，当结果复制到输出缓冲区。
    
    参数
    
    input -输入缓冲区
    
    inputOffset - input那里开始输入偏移
    
    inputLen -输入长度
    
    output -结果缓冲区
    
    outputOffset -抵消 output哪里结果存储
    
    结果
    
    存储在 output字节数
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）
    
    IllegalBlockSizeException -如果这密码是一种分组密码，无填料已要求（仅在加密模式），以及数据处理的这一密码输入总长度不是块大小的倍数；或如果该加密算法无法处理输入数据的提供。
    
    ShortBufferException如果给定的输出缓冲区太小，保存结果
    
    BadPaddingException -如果这密码解密模式，和（联合国）填充已提出要求，但解密后的数据不通过适当的填充字节界
    
    AEADBadTagException -如果这密码解密的失效模式（如GCM / CCM），和接收的认证标签计算值不匹配
  - doFinal
```
public final int doFinal(ByteBuffer input,
                         ByteBuffer output)
                  throws ShortBufferException,
                         IllegalBlockSizeException,
                         BadPaddingException
```
    在一个单一的部分操作加密或解密数据，或完成一个多部分操作。对数据进行加密或解密，根据这个密码初始化。
    所有的input.remaining()字节开始input.position()处理。如果一个失效模式如GCM / CCM正在使用，认证标签附加在加密的情况下，或在解密的情况下验证。结果存储在输出缓冲区中。返回时，输入缓冲区的位置将等于它的极限，它的限制将不会改变。输出缓冲区的位置将有先进的N，其中N是通过这种方法返回的值，输出缓冲区的限制将不会改变。
    
    如果output.remaining()字节不够坚持的结果，一个ShortBufferException抛出。在这种情况下，重复此调用具有较大的输出缓冲区。使用getOutputSize确定多大的输出缓冲区应。
    
    完成，这个方式将这个密码对象时的状态通过电话init先前初始化。那就是，对象是复位和可加密或解密（取决于被指定在调用init运营模式）更多的数据。
    
    注：如果抛出任何异常，这个密码对象可能需要重置之前，它可以再次使用。
    
    注意：这个方法应该复制安全的，这意味着input和output缓冲器可以引用相同的字节数组和未经加工的输入数据将被覆盖，当结果复制到输出缓冲区。
    
    参数
    
    input -输入ByteBuffer
    
    output -输出ByteBuffer
    
    结果
    
    存储在 output字节数
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）
    
    IllegalArgumentException如果输入和输出是同一个对象
    
    ReadOnlyBufferException如果输出缓冲区是只读的
    
    IllegalBlockSizeException -如果这密码是一种分组密码，无填料已要求（仅在加密模式），以及数据处理的这一密码输入总长度不是块大小的倍数；或如果该加密算法无法处理输入数据的提供。
    
    ShortBufferException -如果在输出缓冲区没有足够的空间
    
    BadPaddingException -如果这密码解密模式，和（联合国）填充已提出要求，但解密后的数据不通过适当的填充字节界
    
    AEADBadTagException -如果这密码解密的失效模式（如GCM / CCM），和接收的认证标签计算值不匹配
    
    从以下版本开始：
    
    一点五
  - wrap
```
public final byte[] wrap(Key key)
                  throws IllegalBlockSizeException,
                         InvalidKeyException
```
    包钥匙。
    
    参数
    
    key -被包裹的关键。
    
    结果
    
    包裹钥匙。
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）。
    
    IllegalBlockSizeException -如果这密码是一种分组密码，无填料一直要求和编码的关键是包的长度不是块大小的倍数。
    
    InvalidKeyException -如果它与这个密码将密钥是不可能的或不安全的（例如，一个硬件保护的关键是通过一个软件密码）。
    
    UnsupportedOperationException -如果在 CipherSpi相应的方法不受支持。
  - unwrap
```
public final Key unwrap(byte[] wrappedKey,
                        String wrappedKeyAlgorithm,
                        int wrappedKeyType)
                 throws InvalidKeyException,
                        NoSuchAlgorithmException
```
    打开先前包的关键。
    
    参数
    
    wrappedKey -被解开的关键。
    
    wrappedKeyAlgorithm与包裹键相关的算法。
    
    wrappedKeyType -包装的主要类型。这必须是一个 SECRET_KEY， PRIVATE_KEY，或 PUBLIC_KEY。
    
    结果
    
    展开的关键。
    
    异常
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化）。
    
    NoSuchAlgorithmException -如果没有安装商可以创建的 wrappedKeyAlgorithm型 wrappedKeyType键。
    
    InvalidKeyException -如果 wrappedKey并不代表包重点为 wrappedKeyAlgorithm型 wrappedKeyType。
    
    UnsupportedOperationException -如果在 CipherSpi相应的方法不受支持。
  - getMaxAllowedKeyLength
```
public static final int getMaxAllowedKeyLength(String transformation)
                                        throws NoSuchAlgorithmException
```
    返回指定的变换的最大密钥长度根据安装JCE管辖政策文件。如果安装了JCE的无限力量管辖的政策文件，integer.max_value将返回。在JCE的司法政策文件在默认的密钥大小的更多信息，请参见在 Java Cryptography Architecture Reference Guide附录E。
    
    参数
    
    transformation -密码变换。
    
    结果
    
    位或integer.max_value最大键长度。
    
    异常
    
    NullPointerException -如果 transformation是空的。
    
    NoSuchAlgorithmException -如果 transformation不是有效的转化，即在形式的“算法”或“算法/模式/填充”。
    
    从以下版本开始：
    
    一点五
  - getMaxAllowedParameterSpec
```
public static final AlgorithmParameterSpec getMaxAllowedParameterSpec(String transformation)
                                                               throws NoSuchAlgorithmException
```
    返回一个algorithmparameterspec对象包含的最大密码参数值根据司法政策文件。如果JCE的无限力量管辖政策文件安装或没有最大限度的参数在策略文件中指定的转换，将会返回null。
    
    参数
    
    transformation -密码变换。
    
    结果
    
    一个algorithmparameterspec持有最大值或空。
    
    异常
    
    NullPointerException -如果 transformation是空的。
    
    NoSuchAlgorithmException -如果 transformation不是有效的转化，即在形式的“算法”或“算法/模式/填充”。
    
    从以下版本开始：
    
    一点五
  - updateAAD
```
public final void updateAAD(byte[] src)
```
    继续一个附加的认证数据的多部分更新（AAD）。
    调用此方法提供、密码等方式认证加密操作时（GCM / CCM）。如果这个密码是在GCM和CCM模式操作，必须提供所有与在开始操作的密文（通过update和doFinal方法）。
    
    参数
    
    src含有额外的身份验证数据的缓冲区
    
    异常
    
    IllegalArgumentException -如果 src字节数组是空的
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化），不接受AAD，或者如果在GCM和CCM模式的一个 update方法已被称为主动的加密/解密操作
    
    UnsupportedOperationException -如果在 CipherSpi对应的方法没有被重写的实现
    
    从以下版本开始：
    
    一点七
  - updateAAD
```
public final void updateAAD(byte[] src,
                            int offset,
                            int len)
```
    继续一个附加的认证数据的多部分更新（AAD），使用所提供的缓冲区的一个子集。
    调用此方法提供、密码等方式认证加密操作时（GCM / CCM）。如果这个密码是在GCM和CCM模式操作，必须提供所有与在开始操作的密文（通过update和doFinal方法）。
    
    参数
    
    含 src AAD的缓冲
    
    offset - src在AAD开始输入偏移
    
    len - AAD的字节数
    
    异常
    
    IllegalArgumentException -如果 src字节数组为空，或 offset或 length小于0，或对 offset和 len总和大于的 src字节数组的长度
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化），不接受AAD，或者如果在GCM和CCM模式的一个 update方法已被称为主动的加密/解密操作
    
    UnsupportedOperationException -如果在 CipherSpi对应的方法没有被重写的实现
    
    从以下版本开始：
    
    一点七
  - updateAAD
```
public final void updateAAD(ByteBuffer src)
```
    继续一个附加的认证数据的多部分更新（AAD）。
    调用此方法提供、密码等方式认证加密操作时（GCM / CCM）。如果这个密码是在GCM和CCM模式操作，必须提供所有与在开始操作的密文（通过update和doFinal方法）。
    
    所有的src.remaining()字节开始src.position()处理。返回时，输入缓冲区的位置将等于它的极限，它的限制将不会改变。
    
    参数
    
    含 src AAD的缓冲
    
    异常
    
    IllegalArgumentException -如果 src ByteBuffer是空的
    
    IllegalStateException -如果这个密码是错误的状态（例如，尚未初始化），不接受AAD，或者如果在GCM和CCM模式的一个 update方法已被称为主动的加密/解密操作
    
    UnsupportedOperationException -如果在 CipherSpi对应的方法没有被重写的实现
    
    从以下版本开始：
    
    一点七

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class Cipher

Field Summary

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Field Detail

ENCRYPT_MODE

DECRYPT_MODE

WRAP_MODE

UNWRAP_MODE

PUBLIC_KEY

PRIVATE_KEY

SECRET_KEY

Constructor Detail

Cipher

方法详细信息

getInstance

getInstance

getInstance

getProvider

getAlgorithm

getBlockSize

getOutputSize

getIV

getParameters

getExemptionMechanism

init

init

init

init

init

init

init

init

update

update

update

update

update

doFinal

doFinal

doFinal

doFinal

doFinal

doFinal

doFinal

wrap

unwrap

getMaxAllowedKeyLength

getMaxAllowedParameterSpec

updateAAD

updateAAD

updateAAD