--- a/jdk/src/java.base/share/classes/javax/crypto/Cipher.java Tue Aug 25 18:40:32 2015 +0300
+++ b/jdk/src/java.base/share/classes/javax/crypto/Cipher.java Tue Aug 25 18:45:09 2015 +0300
@@ -52,7 +52,7 @@
* Extension (JCE) framework.
*
* <p>In order to create a Cipher object, the application calls the
- * Cipher's <code>getInstance</code> method, and passes the name of the
+ * Cipher's {@code getInstance} method, and passes the name of the
* requested <i>transformation</i> to it. Optionally, the name of a provider
* may be specified.
*
@@ -78,12 +78,12 @@
* Cipher c = Cipher.getInstance("<i>DES/CBC/PKCS5Padding</i>");
* </pre>
*
- * Using modes such as <code>CFB</code> and <code>OFB</code>, block
+ * Using modes such as {@code CFB} and {@code OFB}, block
* ciphers can encrypt data in units smaller than the cipher's actual
* block size. When requesting such a mode, you may optionally specify
* the number of bits to be processed at a time by appending this number
- * to the mode name as shown in the "<code>DES/CFB8/NoPadding</code>" and
- * "<code>DES/OFB32/PKCS5Padding</code>" transformations. If no such
+ * to the mode name as shown in the "{@code DES/CFB8/NoPadding}" and
+ * "{@code DES/OFB32/PKCS5Padding}" transformations. If no such
* number is specified, a provider-specific default is used. (For
* example, the SunJCE provider uses a default of 64 bits for DES.)
* Thus, block ciphers can be turned into byte-oriented stream ciphers by
@@ -101,8 +101,8 @@
* AEAD modes such as GCM/CCM perform all AAD authenticity calculations
* before starting the ciphertext authenticity calculations. To avoid
* implementations having to internally buffer ciphertext, all AAD data
- * must be supplied to GCM/CCM implementations (via the {@code
- * updateAAD} methods) <b>before</b> the ciphertext is processed (via
+ * must be supplied to GCM/CCM implementations (via the {@code updateAAD}
+ * methods) <b>before</b> the ciphertext is processed (via
* the {@code update} and {@code doFinal} methods).
* <p>
* Note that GCM mode has a uniqueness requirement on IVs used in
@@ -130,24 +130,24 @@
*
* </pre>
* Every implementation of the Java platform is required to support
- * the following standard <code>Cipher</code> transformations with the keysizes
+ * the following standard {@code Cipher} transformations with the keysizes
* in parentheses:
* <ul>
- * <li><tt>AES/CBC/NoPadding</tt> (128)</li>
- * <li><tt>AES/CBC/PKCS5Padding</tt> (128)</li>
- * <li><tt>AES/ECB/NoPadding</tt> (128)</li>
- * <li><tt>AES/ECB/PKCS5Padding</tt> (128)</li>
- * <li><tt>DES/CBC/NoPadding</tt> (56)</li>
- * <li><tt>DES/CBC/PKCS5Padding</tt> (56)</li>
- * <li><tt>DES/ECB/NoPadding</tt> (56)</li>
- * <li><tt>DES/ECB/PKCS5Padding</tt> (56)</li>
- * <li><tt>DESede/CBC/NoPadding</tt> (168)</li>
- * <li><tt>DESede/CBC/PKCS5Padding</tt> (168)</li>
- * <li><tt>DESede/ECB/NoPadding</tt> (168)</li>
- * <li><tt>DESede/ECB/PKCS5Padding</tt> (168)</li>
- * <li><tt>RSA/ECB/PKCS1Padding</tt> (1024, 2048)</li>
- * <li><tt>RSA/ECB/OAEPWithSHA-1AndMGF1Padding</tt> (1024, 2048)</li>
- * <li><tt>RSA/ECB/OAEPWithSHA-256AndMGF1Padding</tt> (1024, 2048)</li>
+ * <li>{@code AES/CBC/NoPadding} (128)</li>
+ * <li>{@code AES/CBC/PKCS5Padding} (128)</li>
+ * <li>{@code AES/ECB/NoPadding} (128)</li>
+ * <li>{@code AES/ECB/PKCS5Padding} (128)</li>
+ * <li>{@code DES/CBC/NoPadding} (56)</li>
+ * <li>{@code DES/CBC/PKCS5Padding} (56)</li>
+ * <li>{@code DES/ECB/NoPadding} (56)</li>
+ * <li>{@code DES/ECB/PKCS5Padding} (56)</li>
+ * <li>{@code DESede/CBC/NoPadding} (168)</li>
+ * <li>{@code DESede/CBC/PKCS5Padding} (168)</li>
+ * <li>{@code DESede/ECB/NoPadding} (168)</li>
+ * <li>{@code DESede/ECB/PKCS5Padding} (168)</li>
+ * <li>{@code RSA/ECB/PKCS1Padding} (1024, 2048)</li>
+ * <li>{@code RSA/ECB/OAEPWithSHA-1AndMGF1Padding} (1024, 2048)</li>
+ * <li>{@code RSA/ECB/OAEPWithSHA-256AndMGF1Padding} (1024, 2048)</li>
* </ul>
* These transformations are described in the
* <a href="{@docRoot}/../technotes/guides/security/StandardNames.html#Cipher">
@@ -466,7 +466,7 @@
}
/**
- * Returns a <code>Cipher</code> object that implements the specified
+ * Returns a {@code Cipher} object that implements the specified
* transformation.
*
* <p> This method traverses the list of registered security Providers,
@@ -487,12 +487,12 @@
*
* @return a cipher that implements the requested transformation.
*
- * @exception NoSuchAlgorithmException if <code>transformation</code>
+ * @exception NoSuchAlgorithmException if {@code transformation}
* is null, empty, in an invalid format,
* or if no Provider supports a CipherSpi implementation for the
* specified algorithm.
*
- * @exception NoSuchPaddingException if <code>transformation</code>
+ * @exception NoSuchPaddingException if {@code transformation}
* contains a padding scheme that is not available.
*
* @see java.security.Provider
@@ -542,7 +542,7 @@
}
/**
- * Returns a <code>Cipher</code> object that implements the specified
+ * Returns a {@code Cipher} object that implements the specified
* transformation.
*
* <p> A new Cipher object encapsulating the
@@ -564,7 +564,7 @@
*
* @return a cipher that implements the requested transformation.
*
- * @exception NoSuchAlgorithmException if <code>transformation</code>
+ * @exception NoSuchAlgorithmException if {@code transformation}
* is null, empty, in an invalid format,
* or if a CipherSpi implementation for the specified algorithm
* is not available from the specified provider.
@@ -572,10 +572,10 @@
* @exception NoSuchProviderException if the specified provider is not
* registered in the security provider list.
*
- * @exception NoSuchPaddingException if <code>transformation</code>
+ * @exception NoSuchPaddingException if {@code transformation}
* contains a padding scheme that is not available.
*
- * @exception IllegalArgumentException if the <code>provider</code>
+ * @exception IllegalArgumentException if the {@code provider}
* is null or empty.
*
* @see java.security.Provider
@@ -597,7 +597,7 @@
}
/**
- * Returns a <code>Cipher</code> object that implements the specified
+ * Returns a {@code Cipher} object that implements the specified
* transformation.
*
* <p> A new Cipher object encapsulating the
@@ -616,15 +616,15 @@
*
* @return a cipher that implements the requested transformation.
*
- * @exception NoSuchAlgorithmException if <code>transformation</code>
+ * @exception NoSuchAlgorithmException if {@code transformation}
* is null, empty, in an invalid format,
* or if a CipherSpi implementation for the specified algorithm
* is not available from the specified Provider object.
*
- * @exception NoSuchPaddingException if <code>transformation</code>
+ * @exception NoSuchPaddingException if {@code transformation}
* contains a padding scheme that is not available.
*
- * @exception IllegalArgumentException if the <code>provider</code>
+ * @exception IllegalArgumentException if the {@code provider}
* is null.
*
* @see java.security.Provider
@@ -897,9 +897,9 @@
}
/**
- * Returns the provider of this <code>Cipher</code> object.
+ * Returns the provider of this {@code Cipher} object.
*
- * @return the provider of this <code>Cipher</code> object
+ * @return the provider of this {@code Cipher} object
*/
public final Provider getProvider() {
chooseFirstProvider();
@@ -907,13 +907,13 @@
}
/**
- * Returns the algorithm name of this <code>Cipher</code> object.
+ * Returns the algorithm name of this {@code Cipher} object.
*
* <p>This is the same name that was specified in one of the
- * <code>getInstance</code> calls that created this <code>Cipher</code>
+ * {@code getInstance} calls that created this {@code Cipher}
* object..
*
- * @return the algorithm name of this <code>Cipher</code> object.
+ * @return the algorithm name of this {@code Cipher} object.
*/
public final String getAlgorithm() {
return this.transformation;
@@ -932,15 +932,15 @@
/**
* Returns the length in bytes that an output buffer would need to be in
- * order to hold the result of the next <code>update</code> or
- * <code>doFinal</code> operation, given the input length
- * <code>inputLen</code> (in bytes).
+ * order to hold the result of the next {@code update} or
+ * {@code doFinal} operation, given the input length
+ * {@code inputLen} (in bytes).
*
* <p>This call takes into account any unprocessed (buffered) data from a
- * previous <code>update</code> call, padding, and AEAD tagging.
+ * previous {@code update} call, padding, and AEAD tagging.
*
- * <p>The actual output length of the next <code>update</code> or
- * <code>doFinal</code> call may be smaller than the length returned by
+ * <p>The actual output length of the next {@code update} or
+ * {@code doFinal} call may be smaller than the length returned by
* this method.
*
* @param inputLen the input length (in bytes)
@@ -1135,14 +1135,14 @@
*
* <p>The cipher is initialized for one of the following four operations:
* encryption, decryption, key wrapping or key unwrapping, depending
- * on the value of <code>opmode</code>.
+ * on the value of {@code opmode}.
*
* <p>If this cipher requires any algorithm parameters that cannot be
- * derived from the given <code>key</code>, the underlying cipher
+ * derived from the given {@code key}, the underlying cipher
* implementation is supposed to generate the required parameters itself
* (using provider-specific default or random values) if it is being
* initialized for encryption or key wrapping, and raise an
- * <code>InvalidKeyException</code> if it is being
+ * {@code InvalidKeyException} if it is being
* initialized for decryption or key unwrapping.
* The generated parameters can be retrieved using
* {@link #getParameters() getParameters} or
@@ -1168,8 +1168,8 @@
*
* @param opmode the operation mode of this cipher (this is one of
* the following:
- * <code>ENCRYPT_MODE</code>, <code>DECRYPT_MODE</code>,
- * <code>WRAP_MODE</code> or <code>UNWRAP_MODE</code>)
+ * {@code ENCRYPT_MODE}, {@code DECRYPT_MODE},
+ * {@code WRAP_MODE} or {@code UNWRAP_MODE})
* @param key the key
*
* @exception InvalidKeyException if the given key is inappropriate for
@@ -1191,14 +1191,14 @@
*
* <p>The cipher is initialized for one of the following four operations:
* encryption, decryption, key wrapping or key unwrapping, depending
- * on the value of <code>opmode</code>.
+ * on the value of {@code opmode}.
*
* <p>If this cipher requires any algorithm parameters that cannot be
- * derived from the given <code>key</code>, the underlying cipher
+ * derived from the given {@code key}, the underlying cipher
* implementation is supposed to generate the required parameters itself
* (using provider-specific default or random values) if it is being
* initialized for encryption or key wrapping, and raise an
- * <code>InvalidKeyException</code> if it is being
+ * {@code InvalidKeyException} if it is being
* initialized for decryption or key unwrapping.
* The generated parameters can be retrieved using
* {@link #getParameters() getParameters} or
@@ -1211,7 +1211,7 @@
*
* <p>If this cipher (including its underlying feedback or padding scheme)
* requires any random bytes (e.g., for parameter generation), it will get
- * them from <code>random</code>.
+ * them from {@code random}.
*
* <p>Note that when a Cipher object is initialized, it loses all
* previously-acquired state. In other words, initializing a Cipher is
@@ -1220,8 +1220,8 @@
*
* @param opmode the operation mode of this cipher (this is one of the
* following:
- * <code>ENCRYPT_MODE</code>, <code>DECRYPT_MODE</code>,
- * <code>WRAP_MODE</code> or <code>UNWRAP_MODE</code>)
+ * {@code ENCRYPT_MODE}, {@code DECRYPT_MODE},
+ * {@code WRAP_MODE} or {@code UNWRAP_MODE})
* @param key the encryption key
* @param random the source of randomness
*
@@ -1269,14 +1269,14 @@
*
* <p>The cipher is initialized for one of the following four operations:
* encryption, decryption, key wrapping or key unwrapping, depending
- * on the value of <code>opmode</code>.
+ * on the value of {@code opmode}.
*
* <p>If this cipher requires any algorithm parameters and
- * <code>params</code> is null, the underlying cipher implementation is
+ * {@code params} is null, the underlying cipher implementation is
* supposed to generate the required parameters itself (using
* provider-specific default or random values) if it is being
* initialized for encryption or key wrapping, and raise an
- * <code>InvalidAlgorithmParameterException</code> if it is being
+ * {@code InvalidAlgorithmParameterException} if it is being
* initialized for decryption or key unwrapping.
* The generated parameters can be retrieved using
* {@link #getParameters() getParameters} or
@@ -1302,8 +1302,8 @@
*
* @param opmode the operation mode of this cipher (this is one of the
* following:
- * <code>ENCRYPT_MODE</code>, <code>DECRYPT_MODE</code>,
- * <code>WRAP_MODE</code> or <code>UNWRAP_MODE</code>)
+ * {@code ENCRYPT_MODE}, {@code DECRYPT_MODE},
+ * {@code WRAP_MODE} or {@code UNWRAP_MODE})
* @param key the encryption key
* @param params the algorithm parameters
*
@@ -1313,7 +1313,7 @@
* @exception InvalidAlgorithmParameterException if the given algorithm
* parameters are inappropriate for this cipher,
* or this cipher requires
- * algorithm parameters and <code>params</code> is null, or the given
+ * algorithm parameters and {@code params} is null, or the given
* algorithm parameters imply a cryptographic strength that would exceed
* the legal limits (as determined from the configured jurisdiction
* policy files).
@@ -1333,14 +1333,14 @@
*
* <p>The cipher is initialized for one of the following four operations:
* encryption, decryption, key wrapping or key unwrapping, depending
- * on the value of <code>opmode</code>.
+ * on the value of {@code opmode}.
*
* <p>If this cipher requires any algorithm parameters and
- * <code>params</code> is null, the underlying cipher implementation is
+ * {@code params} is null, the underlying cipher implementation is
* supposed to generate the required parameters itself (using
* provider-specific default or random values) if it is being
* initialized for encryption or key wrapping, and raise an
- * <code>InvalidAlgorithmParameterException</code> if it is being
+ * {@code InvalidAlgorithmParameterException} if it is being
* initialized for decryption or key unwrapping.
* The generated parameters can be retrieved using
* {@link #getParameters() getParameters} or
@@ -1353,7 +1353,7 @@
*
* <p>If this cipher (including its underlying feedback or padding scheme)
* requires any random bytes (e.g., for parameter generation), it will get
- * them from <code>random</code>.
+ * them from {@code random}.
*
* <p>Note that when a Cipher object is initialized, it loses all
* previously-acquired state. In other words, initializing a Cipher is
@@ -1362,8 +1362,8 @@
*
* @param opmode the operation mode of this cipher (this is one of the
* following:
- * <code>ENCRYPT_MODE</code>, <code>DECRYPT_MODE</code>,
- * <code>WRAP_MODE</code> or <code>UNWRAP_MODE</code>)
+ * {@code ENCRYPT_MODE}, {@code DECRYPT_MODE},
+ * {@code WRAP_MODE} or {@code UNWRAP_MODE})
* @param key the encryption key
* @param params the algorithm parameters
* @param random the source of randomness
@@ -1374,7 +1374,7 @@
* @exception InvalidAlgorithmParameterException if the given algorithm
* parameters are inappropriate for this cipher,
* or this cipher requires
- * algorithm parameters and <code>params</code> is null, or the given
+ * algorithm parameters and {@code params} is null, or the given
* algorithm parameters imply a cryptographic strength that would exceed
* the legal limits (as determined from the configured jurisdiction
* policy files).
@@ -1412,14 +1412,14 @@
*
* <p>The cipher is initialized for one of the following four operations:
* encryption, decryption, key wrapping or key unwrapping, depending
- * on the value of <code>opmode</code>.
+ * on the value of {@code opmode}.
*
* <p>If this cipher requires any algorithm parameters and
- * <code>params</code> is null, the underlying cipher implementation is
+ * {@code params} is null, the underlying cipher implementation is
* supposed to generate the required parameters itself (using
* provider-specific default or random values) if it is being
* initialized for encryption or key wrapping, and raise an
- * <code>InvalidAlgorithmParameterException</code> if it is being
+ * {@code InvalidAlgorithmParameterException} if it is being
* initialized for decryption or key unwrapping.
* The generated parameters can be retrieved using
* {@link #getParameters() getParameters} or
@@ -1444,9 +1444,9 @@
* it.
*
* @param opmode the operation mode of this cipher (this is one of the
- * following: <code>ENCRYPT_MODE</code>,
- * <code>DECRYPT_MODE</code>, <code>WRAP_MODE</code>
- * or <code>UNWRAP_MODE</code>)
+ * following: {@code ENCRYPT_MODE},
+ * {@code DECRYPT_MODE}, {@code WRAP_MODE}
+ * or {@code UNWRAP_MODE})
* @param key the encryption key
* @param params the algorithm parameters
*
@@ -1456,7 +1456,7 @@
* @exception InvalidAlgorithmParameterException if the given algorithm
* parameters are inappropriate for this cipher,
* or this cipher requires
- * algorithm parameters and <code>params</code> is null, or the given
+ * algorithm parameters and {@code params} is null, or the given
* algorithm parameters imply a cryptographic strength that would exceed
* the legal limits (as determined from the configured jurisdiction
* policy files).
@@ -1476,14 +1476,14 @@
*
* <p>The cipher is initialized for one of the following four operations:
* encryption, decryption, key wrapping or key unwrapping, depending
- * on the value of <code>opmode</code>.
+ * on the value of {@code opmode}.
*
* <p>If this cipher requires any algorithm parameters and
- * <code>params</code> is null, the underlying cipher implementation is
+ * {@code params} is null, the underlying cipher implementation is
* supposed to generate the required parameters itself (using
* provider-specific default or random values) if it is being
* initialized for encryption or key wrapping, and raise an
- * <code>InvalidAlgorithmParameterException</code> if it is being
+ * {@code InvalidAlgorithmParameterException} if it is being
* initialized for decryption or key unwrapping.
* The generated parameters can be retrieved using
* {@link #getParameters() getParameters} or
@@ -1496,7 +1496,7 @@
*
* <p>If this cipher (including its underlying feedback or padding scheme)
* requires any random bytes (e.g., for parameter generation), it will get
- * them from <code>random</code>.
+ * them from {@code random}.
*
* <p>Note that when a Cipher object is initialized, it loses all
* previously-acquired state. In other words, initializing a Cipher is
@@ -1504,9 +1504,9 @@
* it.
*
* @param opmode the operation mode of this cipher (this is one of the
- * following: <code>ENCRYPT_MODE</code>,
- * <code>DECRYPT_MODE</code>, <code>WRAP_MODE</code>
- * or <code>UNWRAP_MODE</code>)
+ * following: {@code ENCRYPT_MODE},
+ * {@code DECRYPT_MODE}, {@code WRAP_MODE}
+ * or {@code UNWRAP_MODE})
* @param key the encryption key
* @param params the algorithm parameters
* @param random the source of randomness
@@ -1517,7 +1517,7 @@
* @exception InvalidAlgorithmParameterException if the given algorithm
* parameters are inappropriate for this cipher,
* or this cipher requires
- * algorithm parameters and <code>params</code> is null, or the given
+ * algorithm parameters and {@code params} is null, or the given
* algorithm parameters imply a cryptographic strength that would exceed
* the legal limits (as determined from the configured jurisdiction
* policy files).
@@ -1553,15 +1553,15 @@
* Initializes this cipher with the public key from the given certificate.
* <p> The cipher is initialized for one of the following four operations:
* encryption, decryption, key wrapping or key unwrapping, depending
- * on the value of <code>opmode</code>.
+ * on the value of {@code opmode}.
*
* <p>If the certificate is of type X.509 and has a <i>key usage</i>
* extension field marked as critical, and the value of the <i>key usage</i>
* extension field implies that the public key in
* the certificate and its corresponding private key are not
* supposed to be used for the operation represented by the value
- * of <code>opmode</code>,
- * an <code>InvalidKeyException</code>
+ * of {@code opmode},
+ * an {@code InvalidKeyException}
* is thrown.
*
* <p> If this cipher requires any algorithm parameters that cannot be
@@ -1569,8 +1569,8 @@
* cipher
* implementation is supposed to generate the required parameters itself
* (using provider-specific default or random values) if it is being
- * initialized for encryption or key wrapping, and raise an <code>
- * InvalidKeyException</code> if it is being initialized for decryption or
+ * initialized for encryption or key wrapping, and raise an
+ * {@code InvalidKeyException} if it is being initialized for decryption or
* key unwrapping.
* The generated parameters can be retrieved using
* {@link #getParameters() getParameters} or
@@ -1584,7 +1584,7 @@
* <p>If this cipher (including its underlying feedback or padding scheme)
* requires any random bytes (e.g., for parameter generation), it will get
* them using the
- * <code>SecureRandom</code>
+ * {@code SecureRandom}
* implementation of the highest-priority
* installed provider as the source of randomness.
* (If none of the installed providers supply an implementation of
@@ -1597,8 +1597,8 @@
*
* @param opmode the operation mode of this cipher (this is one of the
* following:
- * <code>ENCRYPT_MODE</code>, <code>DECRYPT_MODE</code>,
- * <code>WRAP_MODE</code> or <code>UNWRAP_MODE</code>)
+ * {@code ENCRYPT_MODE}, {@code DECRYPT_MODE},
+ * {@code WRAP_MODE} or {@code UNWRAP_MODE})
* @param certificate the certificate
*
* @exception InvalidKeyException if the public key in the given
@@ -1626,24 +1626,24 @@
* <p>The cipher is initialized for one of the following four operations:
* encryption, decryption, key wrapping
* or key unwrapping, depending on
- * the value of <code>opmode</code>.
+ * the value of {@code opmode}.
*
* <p>If the certificate is of type X.509 and has a <i>key usage</i>
* extension field marked as critical, and the value of the <i>key usage</i>
* extension field implies that the public key in
* the certificate and its corresponding private key are not
* supposed to be used for the operation represented by the value of
- * <code>opmode</code>,
- * an <code>InvalidKeyException</code>
+ * {@code opmode},
+ * an {@code InvalidKeyException}
* is thrown.
*
* <p>If this cipher requires any algorithm parameters that cannot be
- * derived from the public key in the given <code>certificate</code>,
+ * derived from the public key in the given {@code certificate},
* the underlying cipher
* implementation is supposed to generate the required parameters itself
* (using provider-specific default or random values) if it is being
* initialized for encryption or key wrapping, and raise an
- * <code>InvalidKeyException</code> if it is being
+ * {@code InvalidKeyException} if it is being
* initialized for decryption or key unwrapping.
* The generated parameters can be retrieved using
* {@link #getParameters() getParameters} or
@@ -1656,7 +1656,7 @@
*
* <p>If this cipher (including its underlying feedback or padding scheme)
* requires any random bytes (e.g., for parameter generation), it will get
- * them from <code>random</code>.
+ * them from {@code random}.
*
* <p>Note that when a Cipher object is initialized, it loses all
* previously-acquired state. In other words, initializing a Cipher is
@@ -1665,8 +1665,8 @@
*
* @param opmode the operation mode of this cipher (this is one of the
* following:
- * <code>ENCRYPT_MODE</code>, <code>DECRYPT_MODE</code>,
- * <code>WRAP_MODE</code> or <code>UNWRAP_MODE</code>)
+ * {@code ENCRYPT_MODE}, {@code DECRYPT_MODE},
+ * {@code WRAP_MODE} or {@code UNWRAP_MODE})
* @param certificate the certificate
* @param random the source of randomness
*
@@ -1762,11 +1762,11 @@
* (depending on how this cipher was initialized), processing another data
* part.
*
- * <p>The bytes in the <code>input</code> buffer are processed, and the
+ * <p>The bytes in the {@code input} buffer are processed, and the
* result is stored in a new buffer.
*
- * <p>If <code>input</code> has a length of zero, this method returns
- * <code>null</code>.
+ * <p>If {@code input} has a length of zero, this method returns
+ * {@code null}.
*
* @param input the input buffer
*
@@ -1797,15 +1797,15 @@
* (depending on how this cipher was initialized), processing another data
* part.
*
- * <p>The first <code>inputLen</code> bytes in the <code>input</code>
- * buffer, starting at <code>inputOffset</code> inclusive, are processed,
+ * <p>The first {@code inputLen} bytes in the {@code input}
+ * buffer, starting at {@code inputOffset} inclusive, are processed,
* and the result is stored in a new buffer.
*
- * <p>If <code>inputLen</code> is zero, this method returns
- * <code>null</code>.
+ * <p>If {@code inputLen} is zero, this method returns
+ * {@code null}.
*
* @param input the input buffer
- * @param inputOffset the offset in <code>input</code> where the input
+ * @param inputOffset the offset in {@code input} where the input
* starts
* @param inputLen the input length
*
@@ -1837,31 +1837,31 @@
* (depending on how this cipher was initialized), processing another data
* part.
*
- * <p>The first <code>inputLen</code> bytes in the <code>input</code>
- * buffer, starting at <code>inputOffset</code> inclusive, are processed,
- * and the result is stored in the <code>output</code> buffer.
+ * <p>The first {@code inputLen} bytes in the {@code input}
+ * buffer, starting at {@code inputOffset} inclusive, are processed,
+ * and the result is stored in the {@code output} buffer.
*
- * <p>If the <code>output</code> buffer is too small to hold the result,
- * a <code>ShortBufferException</code> is thrown. In this case, repeat this
+ * <p>If the {@code output} buffer is too small to hold the result,
+ * a {@code ShortBufferException} is thrown. In this case, repeat this
* call with a larger output buffer. Use
* {@link #getOutputSize(int) getOutputSize} to determine how big
* the output buffer should be.
*
- * <p>If <code>inputLen</code> is zero, this method returns
+ * <p>If {@code inputLen} is zero, this method returns
* a length of zero.
*
* <p>Note: this method should be copy-safe, which means the
- * <code>input</code> and <code>output</code> buffers can reference
+ * {@code input} and {@code output} buffers can reference
* the same byte array and no unprocessed input data is overwritten
* when the result is copied into the output buffer.
*
* @param input the input buffer
- * @param inputOffset the offset in <code>input</code> where the input
+ * @param inputOffset the offset in {@code input} where the input
* starts
* @param inputLen the input length
* @param output the buffer for the result
*
- * @return the number of bytes stored in <code>output</code>
+ * @return the number of bytes stored in {@code output}
*
* @exception IllegalStateException if this cipher is in a wrong state
* (e.g., has not been initialized)
@@ -1892,34 +1892,34 @@
* (depending on how this cipher was initialized), processing another data
* part.
*
- * <p>The first <code>inputLen</code> bytes in the <code>input</code>
- * buffer, starting at <code>inputOffset</code> inclusive, are processed,
- * and the result is stored in the <code>output</code> buffer, starting at
- * <code>outputOffset</code> inclusive.
+ * <p>The first {@code inputLen} bytes in the {@code input}
+ * buffer, starting at {@code inputOffset} inclusive, are processed,
+ * and the result is stored in the {@code output} buffer, starting at
+ * {@code outputOffset} inclusive.
*
- * <p>If the <code>output</code> buffer is too small to hold the result,
- * a <code>ShortBufferException</code> is thrown. In this case, repeat this
+ * <p>If the {@code output} buffer is too small to hold the result,
+ * a {@code ShortBufferException} is thrown. In this case, repeat this
* call with a larger output buffer. Use
* {@link #getOutputSize(int) getOutputSize} to determine how big
* the output buffer should be.
*
- * <p>If <code>inputLen</code> is zero, this method returns
+ * <p>If {@code inputLen} is zero, this method returns
* a length of zero.
*
* <p>Note: this method should be copy-safe, which means the
- * <code>input</code> and <code>output</code> buffers can reference
+ * {@code input} and {@code output} buffers can reference
* the same byte array and no unprocessed input data is overwritten
* when the result is copied into the output buffer.
*
* @param input the input buffer
- * @param inputOffset the offset in <code>input</code> where the input
+ * @param inputOffset the offset in {@code input} where the input
* starts
* @param inputLen the input length
* @param output the buffer for the result
- * @param outputOffset the offset in <code>output</code> where the result
+ * @param outputOffset the offset in {@code output} where the result
* is stored
*
- * @return the number of bytes stored in <code>output</code>
+ * @return the number of bytes stored in {@code output}
*
* @exception IllegalStateException if this cipher is in a wrong state
* (e.g., has not been initialized)
@@ -1951,29 +1951,29 @@
* (depending on how this cipher was initialized), processing another data
* part.
*
- * <p>All <code>input.remaining()</code> bytes starting at
- * <code>input.position()</code> are processed. The result is stored
+ * <p>All {@code input.remaining()} bytes starting at
+ * {@code input.position()} are processed. The result is stored
* in the output buffer.
* Upon return, the input buffer's position will be equal
* to its limit; its limit will not have changed. The output buffer's
* position will have advanced by n, where n is the value returned
* by this method; the output buffer's limit will not have changed.
*
- * <p>If <code>output.remaining()</code> bytes are insufficient to
- * hold the result, a <code>ShortBufferException</code> is thrown.
+ * <p>If {@code output.remaining()} bytes are insufficient to
+ * hold the result, a {@code ShortBufferException} is thrown.
* In this case, repeat this call with a larger output buffer. Use
* {@link #getOutputSize(int) getOutputSize} to determine how big
* the output buffer should be.
*
* <p>Note: this method should be copy-safe, which means the
- * <code>input</code> and <code>output</code> buffers can reference
+ * {@code input} and {@code output} buffers can reference
* the same block of memory and no unprocessed input data is overwritten
* when the result is copied into the output buffer.
*
* @param input the input ByteBuffer
* @param output the output ByteByffer
*
- * @return the number of bytes stored in <code>output</code>
+ * @return the number of bytes stored in {@code output}
*
* @exception IllegalStateException if this cipher is in a wrong state
* (e.g., has not been initialized)
@@ -2008,7 +2008,7 @@
* on how this cipher was initialized.
*
* <p>Input data that may have been buffered during a previous
- * <code>update</code> operation is processed, with padding (if requested)
+ * {@code update} operation is processed, with padding (if requested)
* being applied.
* If an AEAD mode such as GCM/CCM is being used, the authentication
* tag is appended in the case of encryption, or verified in the
@@ -2016,10 +2016,10 @@
* The result is stored in a new buffer.
*
* <p>Upon finishing, this method resets this cipher object to the state
- * it was in when previously initialized via a call to <code>init</code>.
+ * it was in when previously initialized via a call to {@code init}.
* That is, the object is reset and available to encrypt or decrypt
* (depending on the operation mode that was specified in the call to
- * <code>init</code>) more data.
+ * {@code init}) more data.
*
* <p>Note: if any exception is thrown, this cipher object may need to
* be reset before it can be used again.
@@ -2053,34 +2053,34 @@
* on how this cipher was initialized.
*
* <p>Input data that may have been buffered during a previous
- * <code>update</code> operation is processed, with padding (if requested)
+ * {@code update} operation is processed, with padding (if requested)
* being applied.
* If an AEAD mode such as GCM/CCM is being used, the authentication
* tag is appended in the case of encryption, or verified in the
* case of decryption.
- * The result is stored in the <code>output</code> buffer, starting at
- * <code>outputOffset</code> inclusive.
+ * The result is stored in the {@code output} buffer, starting at
+ * {@code outputOffset} inclusive.
*
- * <p>If the <code>output</code> buffer is too small to hold the result,
- * a <code>ShortBufferException</code> is thrown. In this case, repeat this
+ * <p>If the {@code output} buffer is too small to hold the result,
+ * a {@code ShortBufferException} is thrown. In this case, repeat this
* call with a larger output buffer. Use
* {@link #getOutputSize(int) getOutputSize} to determine how big
* the output buffer should be.
*
* <p>Upon finishing, this method resets this cipher object to the state
- * it was in when previously initialized via a call to <code>init</code>.
+ * it was in when previously initialized via a call to {@code init}.
* That is, the object is reset and available to encrypt or decrypt
* (depending on the operation mode that was specified in the call to
- * <code>init</code>) more data.
+ * {@code init}) more data.
*
* <p>Note: if any exception is thrown, this cipher object may need to
* be reset before it can be used again.
*
* @param output the buffer for the result
- * @param outputOffset the offset in <code>output</code> where the result
+ * @param outputOffset the offset in {@code output} where the result
* is stored
*
- * @return the number of bytes stored in <code>output</code>
+ * @return the number of bytes stored in {@code output}
*
* @exception IllegalStateException if this cipher is in a wrong state
* (e.g., has not been initialized)
@@ -2117,8 +2117,8 @@
* multiple-part operation. The data is encrypted or decrypted,
* depending on how this cipher was initialized.
*
- * <p>The bytes in the <code>input</code> buffer, and any input bytes that
- * may have been buffered during a previous <code>update</code> operation,
+ * <p>The bytes in the {@code input} buffer, and any input bytes that
+ * may have been buffered during a previous {@code update} operation,
* are processed, with padding (if requested) being applied.
* If an AEAD mode such as GCM/CCM is being used, the authentication
* tag is appended in the case of encryption, or verified in the
@@ -2126,10 +2126,10 @@
* The result is stored in a new buffer.
*
* <p>Upon finishing, this method resets this cipher object to the state
- * it was in when previously initialized via a call to <code>init</code>.
+ * it was in when previously initialized via a call to {@code init}.
* That is, the object is reset and available to encrypt or decrypt
* (depending on the operation mode that was specified in the call to
- * <code>init</code>) more data.
+ * {@code init}) more data.
*
* <p>Note: if any exception is thrown, this cipher object may need to
* be reset before it can be used again.
@@ -2170,9 +2170,9 @@
* multiple-part operation. The data is encrypted or decrypted,
* depending on how this cipher was initialized.
*
- * <p>The first <code>inputLen</code> bytes in the <code>input</code>
- * buffer, starting at <code>inputOffset</code> inclusive, and any input
- * bytes that may have been buffered during a previous <code>update</code>
+ * <p>The first {@code inputLen} bytes in the {@code input}
+ * buffer, starting at {@code inputOffset} inclusive, and any input
+ * bytes that may have been buffered during a previous {@code update}
* operation, are processed, with padding (if requested) being applied.
* If an AEAD mode such as GCM/CCM is being used, the authentication
* tag is appended in the case of encryption, or verified in the
@@ -2180,16 +2180,16 @@
* The result is stored in a new buffer.
*
* <p>Upon finishing, this method resets this cipher object to the state
- * it was in when previously initialized via a call to <code>init</code>.
+ * it was in when previously initialized via a call to {@code init}.
* That is, the object is reset and available to encrypt or decrypt
* (depending on the operation mode that was specified in the call to
- * <code>init</code>) more data.
+ * {@code init}) more data.
*
* <p>Note: if any exception is thrown, this cipher object may need to
* be reset before it can be used again.
*
* @param input the input buffer
- * @param inputOffset the offset in <code>input</code> where the input
+ * @param inputOffset the offset in {@code input} where the input
* starts
* @param inputLen the input length
*
@@ -2228,42 +2228,42 @@
* multiple-part operation. The data is encrypted or decrypted,
* depending on how this cipher was initialized.
*
- * <p>The first <code>inputLen</code> bytes in the <code>input</code>
- * buffer, starting at <code>inputOffset</code> inclusive, and any input
- * bytes that may have been buffered during a previous <code>update</code>
+ * <p>The first {@code inputLen} bytes in the {@code input}
+ * buffer, starting at {@code inputOffset} inclusive, and any input
+ * bytes that may have been buffered during a previous {@code update}
* operation, are processed, with padding (if requested) being applied.
* If an AEAD mode such as GCM/CCM is being used, the authentication
* tag is appended in the case of encryption, or verified in the
* case of decryption.
- * The result is stored in the <code>output</code> buffer.
+ * The result is stored in the {@code output} buffer.
*
- * <p>If the <code>output</code> buffer is too small to hold the result,
- * a <code>ShortBufferException</code> is thrown. In this case, repeat this
+ * <p>If the {@code output} buffer is too small to hold the result,
+ * a {@code ShortBufferException} is thrown. In this case, repeat this
* call with a larger output buffer. Use
* {@link #getOutputSize(int) getOutputSize} to determine how big
* the output buffer should be.
*
* <p>Upon finishing, this method resets this cipher object to the state
- * it was in when previously initialized via a call to <code>init</code>.
+ * it was in when previously initialized via a call to {@code init}.
* That is, the object is reset and available to encrypt or decrypt
* (depending on the operation mode that was specified in the call to
- * <code>init</code>) more data.
+ * {@code init}) more data.
*
* <p>Note: if any exception is thrown, this cipher object may need to
* be reset before it can be used again.
*
* <p>Note: this method should be copy-safe, which means the
- * <code>input</code> and <code>output</code> buffers can reference
+ * {@code input} and {@code output} buffers can reference
* the same byte array and no unprocessed input data is overwritten
* when the result is copied into the output buffer.
*
* @param input the input buffer
- * @param inputOffset the offset in <code>input</code> where the input
+ * @param inputOffset the offset in {@code input} where the input
* starts
* @param inputLen the input length
* @param output the buffer for the result
*
- * @return the number of bytes stored in <code>output</code>
+ * @return the number of bytes stored in {@code output}
*
* @exception IllegalStateException if this cipher is in a wrong state
* (e.g., has not been initialized)
@@ -2303,46 +2303,46 @@
* multiple-part operation. The data is encrypted or decrypted,
* depending on how this cipher was initialized.
*
- * <p>The first <code>inputLen</code> bytes in the <code>input</code>
- * buffer, starting at <code>inputOffset</code> inclusive, and any input
+ * <p>The first {@code inputLen} bytes in the {@code input}
+ * buffer, starting at {@code inputOffset} inclusive, and any input
* bytes that may have been buffered during a previous
- * <code>update</code> operation, are processed, with padding
+ * {@code update} operation, are processed, with padding
* (if requested) being applied.
* If an AEAD mode such as GCM/CCM is being used, the authentication
* tag is appended in the case of encryption, or verified in the
* case of decryption.
- * The result is stored in the <code>output</code> buffer, starting at
- * <code>outputOffset</code> inclusive.
+ * The result is stored in the {@code output} buffer, starting at
+ * {@code outputOffset} inclusive.
*
- * <p>If the <code>output</code> buffer is too small to hold the result,
- * a <code>ShortBufferException</code> is thrown. In this case, repeat this
+ * <p>If the {@code output} buffer is too small to hold the result,
+ * a {@code ShortBufferException} is thrown. In this case, repeat this
* call with a larger output buffer. Use
* {@link #getOutputSize(int) getOutputSize} to determine how big
* the output buffer should be.
*
* <p>Upon finishing, this method resets this cipher object to the state
- * it was in when previously initialized via a call to <code>init</code>.
+ * it was in when previously initialized via a call to {@code init}.
* That is, the object is reset and available to encrypt or decrypt
* (depending on the operation mode that was specified in the call to
- * <code>init</code>) more data.
+ * {@code init}) more data.
*
* <p>Note: if any exception is thrown, this cipher object may need to
* be reset before it can be used again.
*
* <p>Note: this method should be copy-safe, which means the
- * <code>input</code> and <code>output</code> buffers can reference
+ * {@code input} and {@code output} buffers can reference
* the same byte array and no unprocessed input data is overwritten
* when the result is copied into the output buffer.
*
* @param input the input buffer
- * @param inputOffset the offset in <code>input</code> where the input
+ * @param inputOffset the offset in {@code input} where the input
* starts
* @param inputLen the input length
* @param output the buffer for the result
- * @param outputOffset the offset in <code>output</code> where the result
+ * @param outputOffset the offset in {@code output} where the result
* is stored
*
- * @return the number of bytes stored in <code>output</code>
+ * @return the number of bytes stored in {@code output}
*
* @exception IllegalStateException if this cipher is in a wrong state
* (e.g., has not been initialized)
@@ -2383,8 +2383,8 @@
* multiple-part operation. The data is encrypted or decrypted,
* depending on how this cipher was initialized.
*
- * <p>All <code>input.remaining()</code> bytes starting at
- * <code>input.position()</code> are processed.
+ * <p>All {@code input.remaining()} bytes starting at
+ * {@code input.position()} are processed.
* If an AEAD mode such as GCM/CCM is being used, the authentication
* tag is appended in the case of encryption, or verified in the
* case of decryption.
@@ -2394,30 +2394,30 @@
* position will have advanced by n, where n is the value returned
* by this method; the output buffer's limit will not have changed.
*
- * <p>If <code>output.remaining()</code> bytes are insufficient to
- * hold the result, a <code>ShortBufferException</code> is thrown.
+ * <p>If {@code output.remaining()} bytes are insufficient to
+ * hold the result, a {@code ShortBufferException} is thrown.
* In this case, repeat this call with a larger output buffer. Use
* {@link #getOutputSize(int) getOutputSize} to determine how big
* the output buffer should be.
*
* <p>Upon finishing, this method resets this cipher object to the state
- * it was in when previously initialized via a call to <code>init</code>.
+ * it was in when previously initialized via a call to {@code init}.
* That is, the object is reset and available to encrypt or decrypt
* (depending on the operation mode that was specified in the call to
- * <code>init</code>) more data.
+ * {@code init}) more data.
*
* <p>Note: if any exception is thrown, this cipher object may need to
* be reset before it can be used again.
*
* <p>Note: this method should be copy-safe, which means the
- * <code>input</code> and <code>output</code> buffers can reference
+ * {@code input} and {@code output} buffers can reference
* the same byte array and no unprocessed input data is overwritten
* when the result is copied into the output buffer.
*
* @param input the input ByteBuffer
* @param output the output ByteBuffer
*
- * @return the number of bytes stored in <code>output</code>
+ * @return the number of bytes stored in {@code output}
*
* @exception IllegalStateException if this cipher is in a wrong state
* (e.g., has not been initialized)
@@ -2507,8 +2507,8 @@
* key.
*
* @param wrappedKeyType the type of the wrapped key. This must be one of
- * <code>SECRET_KEY</code>, <code>PRIVATE_KEY</code>, or
- * <code>PUBLIC_KEY</code>.
+ * {@code SECRET_KEY}, {@code PRIVATE_KEY}, or
+ * {@code PUBLIC_KEY}.
*
* @return the unwrapped key.
*
@@ -2516,12 +2516,12 @@
* (e.g., has not been initialized).
*
* @exception NoSuchAlgorithmException if no installed providers
- * can create keys of type <code>wrappedKeyType</code> for the
- * <code>wrappedKeyAlgorithm</code>.
+ * can create keys of type {@code wrappedKeyType} for the
+ * {@code wrappedKeyAlgorithm}.
*
- * @exception InvalidKeyException if <code>wrappedKey</code> does not
- * represent a wrapped key of type <code>wrappedKeyType</code> for
- * the <code>wrappedKeyAlgorithm</code>.
+ * @exception InvalidKeyException if {@code wrappedKey} does not
+ * represent a wrapped key of type {@code wrappedKeyType} for
+ * the {@code wrappedKeyAlgorithm}.
*
* @throws UnsupportedOperationException if the corresponding method in the
* {@code CipherSpi} is not supported.
@@ -2600,8 +2600,8 @@
*
* @param transformation the cipher transformation.
* @return the maximum key length in bits or Integer.MAX_VALUE.
- * @exception NullPointerException if <code>transformation</code> is null.
- * @exception NoSuchAlgorithmException if <code>transformation</code>
+ * @exception NullPointerException if {@code transformation} is null.
+ * @exception NoSuchAlgorithmException if {@code transformation}
* is not a valid transformation, i.e. in the form of "algorithm" or
* "algorithm/mode/padding".
* @since 1.5
@@ -2623,9 +2623,9 @@
* @param transformation the cipher transformation.
* @return an AlgorithmParameterSpec which holds the maximum
* value or null.
- * @exception NullPointerException if <code>transformation</code>
+ * @exception NullPointerException if {@code transformation}
* is null.
- * @exception NoSuchAlgorithmException if <code>transformation</code>
+ * @exception NoSuchAlgorithmException if {@code transformation}
* is not a valid transformation, i.e. in the form of "algorithm" or
* "algorithm/mode/padding".
* @since 1.5
@@ -2643,8 +2643,8 @@
* Calls to this method provide AAD to the cipher when operating in
* modes such as AEAD (GCM/CCM). If this cipher is operating in
* either GCM or CCM mode, all AAD must be supplied before beginning
- * operations on the ciphertext (via the {@code update} and {@code
- * doFinal} methods).
+ * operations on the ciphertext (via the {@code update} and
+ * {@code doFinal} methods).
*
* @param src the buffer containing the Additional Authentication Data
*
@@ -2676,8 +2676,8 @@
* Calls to this method provide AAD to the cipher when operating in
* modes such as AEAD (GCM/CCM). If this cipher is operating in
* either GCM or CCM mode, all AAD must be supplied before beginning
- * operations on the ciphertext (via the {@code update} and {@code
- * doFinal} methods).
+ * operations on the ciphertext (via the {@code update}
+ * and {@code doFinal} methods).
*
* @param src the buffer containing the AAD
* @param offset the offset in {@code src} where the AAD input starts
@@ -2722,8 +2722,8 @@
* Calls to this method provide AAD to the cipher when operating in
* modes such as AEAD (GCM/CCM). If this cipher is operating in
* either GCM or CCM mode, all AAD must be supplied before beginning
- * operations on the ciphertext (via the {@code update} and {@code
- * doFinal} methods).
+ * operations on the ciphertext (via the {@code update}
+ * and {@code doFinal} methods).
* <p>
* All {@code src.remaining()} bytes starting at
* {@code src.position()} are processed.