This class specifies a DES-EDE (`triple-DES`) key.

This class specifies a DES key.

This class specifies the set of parameters used for generating
Diffie-Hellman (system) parameters for use in Diffie-Hellman key
agreement. This is typically done by a central
authority.

 The central authority, after computing the parameters, must send this
information to the parties looking to agree on a secret key.

This class specifies the set of parameters used with the Diffie-Hellman
algorithm, as specified in PKCS #3: Diffie-Hellman Key-Agreement
Standard.

A central authority generates parameters and gives them to the two
entities seeking to generate a secret key. The parameters are a prime
p, a base g, and optionally the length
in bits of the private value, l.

It is possible that more than one instance of parameters may be
generated by a given central authority, and that there may be more than
one central authority. Indeed, each individual may be its own central
authority, with different entities having different parameters.

Note that this class does not perform any validation on specified
parameters. Thus, the specified values are returned directly even
if they are null.

This class specifies a Diffie-Hellman private key with its associated
parameters.

Note that this class does not perform any validation on specified
parameters. Thus, the specified values are returned directly even
if they are null.

This class specifies a Diffie-Hellman public key with its associated
parameters.

Note that this class does not perform any validation on specified
parameters. Thus, the specified values are returned directly even
if they are null.

Specifies the set of parameters required by a Cipher using the Galois/Counter Mode (GCM) mode.

Simple block cipher modes (such as CBC) generally require only an
initialization vector (such as IvParameterSpec),
but GCM needs these parameters:

IV: Initialization Vector (IV)
tLen: length (in bits) of authentication tag T


In addition to the parameters described here, other GCM inputs/output
(Additional Authenticated Data (AAD), Keys, block ciphers,
plain/ciphertext and authentication tags) are handled in the Cipher class.

Please see  RFC 5116
 for more information on the Authenticated Encryption with
Associated Data (AEAD) algorithm, and
NIST Special Publication 800-38D, `NIST Recommendation for Block
Cipher Modes of Operation:  Galois/Counter Mode (GCM) and GMAC.`

The GCM specification states that tLen may only have the
values {128, 120, 112, 104, 96}, or {64, 32} for certain
applications.  Other values can be specified for this class, but not
all CSP implementations will support them.

This class specifies an initialization vector (IV).
Examples which use IVs are ciphers in feedback mode,
e.g., DES in CBC mode and RSA ciphers with OAEP encoding
operation.

This class specifies the set of parameters used with OAEP Padding,
as defined in the
PKCS #1
standard.

Its ASN.1 definition in PKCS#1 standard is described below:


RSAES-OAEP-params ::= SEQUENCE {
  hashAlgorithm      [0] OAEP-PSSDigestAlgorithms     DEFAULT sha1,
  maskGenAlgorithm   [1] PKCS1MGFAlgorithms  DEFAULT mgf1SHA1,
  pSourceAlgorithm   [2] PKCS1PSourceAlgorithms  DEFAULT pSpecifiedEmpty
}
where


OAEP-PSSDigestAlgorithms    ALGORITHM-IDENTIFIER ::= {
  { OID id-sha1 PARAMETERS NULL   }|
  { OID id-sha256 PARAMETERS NULL }|
  { OID id-sha384 PARAMETERS NULL }|
  { OID id-sha512 PARAMETERS NULL },
  ...  -- Allows for future expansion --
}
PKCS1MGFAlgorithms    ALGORITHM-IDENTIFIER ::= {
  { OID id-mgf1 PARAMETERS OAEP-PSSDigestAlgorithms },
  ...  -- Allows for future expansion --
}
PKCS1PSourceAlgorithms    ALGORITHM-IDENTIFIER ::= {
  { OID id-pSpecified PARAMETERS OCTET STRING },
  ...  -- Allows for future expansion --
}
Note: the OAEPParameterSpec.DEFAULT uses the following:
    message digest  -- `SHA-1`
    mask generation function (mgf) -- `MGF1`
    parameters for mgf -- MGF1ParameterSpec.SHA1
    source of encoding input -- PSource.PSpecified.DEFAULT

A user-chosen password that can be used with password-based encryption
(PBE).

The password can be viewed as some kind of raw key material, from which
the encryption mechanism that uses it derives a cryptographic key.

Different PBE mechanisms may consume different bits of each password
character. For example, the PBE mechanism defined in

PKCS #5 looks at only the low order 8 bits of each character, whereas
PKCS #12 looks at all 16 bits of each character.

You convert the password characters to a PBE key by creating an
instance of the appropriate secret-key factory. For example, a secret-key
factory for PKCS #5 will construct a PBE key from only the low order 8 bits
of each password character, whereas a secret-key factory for PKCS #12 will
take all 16 bits of each character.

Also note that this class stores passwords as char arrays instead of
String objects (which would seem more logical), because the
String class is immutable and there is no way to overwrite its
internal value when the password stored in it is no longer needed. Hence,
this class requests the password as a char array, so it can be overwritten
when done.

This class specifies the set of parameters used with password-based
encryption (PBE), as defined in the
PKCS #5
standard.

This class specifies the source for encoding input P in OAEP Padding,
as defined in the
PKCS #1
standard.


PKCS1PSourceAlgorithms    ALGORITHM-IDENTIFIER ::= {
  { OID id-pSpecified PARAMETERS OCTET STRING },
  ...  -- Allows for future expansion --
}

This class is used to explicitly specify the value for
encoding input P in OAEP Padding.

This class specifies the parameters used with the
RC2
algorithm.

 The parameters consist of an effective key size and optionally
an 8-byte initialization vector (IV) (only in feedback mode).

 This class can be used to initialize a Cipher object that
implements the RC2 algorithm.

This class specifies the parameters used with the
RC5
algorithm.

 The parameters consist of a version number, a rounds count, a word
size, and optionally an initialization vector (IV) (only in feedback mode).

 This class can be used to initialize a Cipher object that
implements the RC5 algorithm as supplied by
RSA Security Inc.,
or any parties authorized by RSA Security.

This class specifies a secret key in a provider-independent fashion.

It can be used to construct a SecretKey from a byte array,
without having to go through a (provider-based)
SecretKeyFactory.

This class is only useful for raw secret keys that can be represented as
a byte array and have no key parameters associated with them, e.g., DES or
Triple DES keys.