AlgorithmID ("Entrust Authority Security Toolkit for the Java Platform")

java.lang.Object
- iaik.asn1.structures.AlgorithmID

All Implemented Interfaces:

ASN1Type

Direct Known Subclasses:

AlgorithmIdentifier, CompressionProvider
```
public class AlgorithmID
extends java.lang.Object
implements ASN1Type
```
This class implements the ASN.1 type "AlgorithmIdentifier".
An AlgorithmID object unequivocally identifies some specific algorithm by assigning a particular ObjectID to it. An algorithmID optionally may include algorithm parameters:
```
 
  AlgorithmIdentifier  ::=  SEQUENCE  {
       algorithm               OBJECT IDENTIFIER,
       parameters              ANY DEFINED BY algorithm OPTIONAL  }
  
 
```
An AlgorithmID object may be, for instance, used for specifying the signature algorithm when signing a X509Certificate, e,g.:
```
 
  X509Certificate cert = new X509Certificate();
    ...
  cert.sign(AlgorithmID.md5WithRSAEncryption, issuerPrivateKey);
  
 
```
This class statically registers AlgortihmIDs for several public key, key exchange, symmetric, signature and message digest algorithms. AlgorithmIDs that are already statically registered by this class easily may be obtained by only calling their corresponding parameter names, e.g.:
```
 AlgorithmID algID = AlgorithmID.md5WithRSAEncryption;
 
```
Attention This static registration part of this class only associates one specific object identifier with a particular AlgorithmID. If you intend to use another OID than the registered one, you should call the AlgorithmID(String objectID, String name, String implementation) constructor for registering the OID as alternative OID for the specific algorithm, where objectID indicates the OID in mind, name specifies a name for the OID, and implementationName a string constant to be used for querying for an implementation of the algorithm. This constant may be the specific algorithm's standard name, a registered algorithm alias (but preferably not an OID alias!) (see IAIK provider), or a proper "transformation string" (e.g. "DES/CBC/PKCS5Padding") when dealing with a Cipher algorithm. After registration has been performed, the getSignatureInstance(), getMessageDigestInstance(), getCipherInstance(), getKeyAgreementInstance(), or the getInstance() method may be used to search for an implementation of the corresponding algorithm, whereas getInstance() steps through all the other algorithm types, e.g.:
```
 AlgorithmID algID = AlgorithmID.dsa;Signature dsa = algID.getSignatureInstance();
  //or:
  Signature dsa = (Signature)algID.getInstance();
  
 
```
Unfortunately sometimes there exist multiple object identifiers associated with the same algorithm. Where recognized, the IAIKprovider) registers such object identifiers as aliases for the specific algorithm. Consider, for instance, the two OID strings "1.3.14.3.2.29" and "1.2.840.113549.1.1.5", both identifying the "sha1WithRSAEncryption" signature algorithm. Both OID strings are registered by the IAIK provider as aliases for the "SHA/RSA" algorithm. However the sha1WithRSAEncryption parameter of this class only associates the "1.3.14.3.2.29" object identifier with the "SHA/RSA" algorithm by statically calling
```
 public static AlgorithmID sha1WithRSAEncryption = new AlgorithmID(
      "1.3.14.3.2.29", "sha1WithRSAEncryption", "SHA/RSA");
 
```
Now, if you prefer to use "1.2.840.113549.1.1.5" instead of "1.3.14.3.2.29" you additionally may register this OID by calling:
```
 AlgorithmID algID = new AlgorithmID("1.2.840.113549.1.1.5",
      "sha1WithRSAEncryption", "SHA/RSA");
 
```
Notice, that this will not discard the predefined AlgorithmID.sha1WithRSAEncryption. Accessing AlgorithmID.sha1WithRSAEncryption, again will show 1.3.14.3.2.29. However, you may access your new algorithmID with variable algID you have just created, and when parsing an algorithmID both OIDs will be recognized and handeld properly. Note that proper parsing for "SHA/RSA" with "1.2.840.113549.1.1.5" already is ensured by alias registration in the IAIK provider. However you may wish to create a new "SHA/RSA" AlgorithmID for "1.2.840.113549.1.1.5", or you may know of a object ID which already is not registered as alias). Or you may deal with a cipher where alias registration may not satisfy since padding scheme and cipher mode maybe required. The, for instance, des_CBCcipher algorithmID statically is registered by using the "DES/CBC/PKCS5Padding" transformation string as implementation name:
```
 public static AlgorithmID des_CBC = new AlgorithmID("1.3.14.3.2.7", "DES-CBC",
      "DES/CBC/PKCS5Padding");
 
```
For defining AlgorithmIDs for algorithms not implemented by the IAIK provider, this class uses the AlgorithmID(String objectID, String name) constructor.
If you want to change the object identifier of an already existing AlgorithmID permanently, you may use the changeObjectID(AlgorithmID algID, ObjectID oid) or changeOIDString(AlgorithmID algID, String oidString) method; the latter adopts any existing name or shortName from the old oid. With JDK 1.2 the SUN provider, for instance, has changed the algorithm oid of the DSA algorithm from 1.3.14.3.2.12 to 1.2.840.10040.4.1, whereas IAIK continues to use 1.3.14.3.2.12. An application wishing to use the new OID may allocate it by:
```
 AlgorithmID.changeOIDString(AlgorithmID.dsa, "1.2.840.10040.4.1");
 
```
or
```
 ObjectID oid = new ObjectID("1.2.840.10040.4.1", "DSA", "DSA");
 AlgorithmID.changeObjectID(AlgorithmID.dsa, oid);
 
```
Attention You should clonean algorithmID before adding parameters to avoid unintentional parameter allocation!
See Also:
ASN1Type, ASN1Object, ObjectID

Field Summary

Fields
Modifier and Type	Field and Description
`static AlgorithmID`	`aes_128_CBC` Creates an AlgorithmID for the `AES` symmetric block cipher used with a 128-bit key in CBC mode.
`static AlgorithmID`	`aes_128_ECB` Creates an AlgorithmID for the `AES` symmetric block cipher used with a 128-bit key in ECB mode.
`static AlgorithmID`	`aes_128_wrap` Creates an AlgorithmID for the `AesKeyWrap` key wrap algorithm for wrapping 128-bit AES content encryption keys with 128-bit AES key encryption keys (RFC 3394).
`static AlgorithmID`	`aes_192_CBC` Creates an AlgorithmID for the `AES` symmetric block cipher used with a 192-bit key in CBC mode.
`static AlgorithmID`	`aes_192_ECB` Creates an AlgorithmID for the `AES` symmetric block cipher used with a 192-bit key in ECB mode.
`static AlgorithmID`	`aes_192_wrap` Creates an AlgorithmID for the `AesKeyWrap` key wrap algorithm for wrapping 192-bit AES content encryption keys with 192-bit AES key encryption keys (RFC 3394).
`static AlgorithmID`	`aes_256_CBC` Creates an AlgorithmID for the `AES` symmetric block cipher used with a 256-bit key in CBC mode.
`static AlgorithmID`	`aes_256_ECB` Creates an AlgorithmID for the `AES` symmetric block cipher used with a 256-bit key in ECB mode.
`static AlgorithmID`	`aes_256_wrap` Creates an AlgorithmID for the `AesKeyWrap` key wrap algorithm for wrapping 256-bit AES content encryption keys with 256-bit AES key encryption keys (RFC 3394).
`static AlgorithmID`	`cast3_CBC` Creates an AlgorithmID for the `CAST3` symmetric block cipher used in CBC mode.
`static AlgorithmID`	`cast5_CBC` Creates an AlgorithmID for the `CAST5` symmetric block cipher used in CBC mode.
`static AlgorithmID`	`cms_3DES_wrap` Creates an AlgorithmID for the `CMS3DESwrap` key wrap algorithm for wrapping DESede content encryption keys with DESede key encryption keys (RFC 2630).
`static AlgorithmID`	`cms_cast_wrap` Creates an AlgorithmID for the `CMSCAST128wrap` key wrap algorithm for wrapping CAST128 content encryption keys with CAST128 key encryption keys (RFC 2984).
`static AlgorithmID`	`cms_cast5_wrap` Creates an AlgorithmID for the `CMSCAST128wrap` key wrap algorithm for wrapping CAST128 content encryption keys with CAST128 key encryption keys (RFC 2984).
`static AlgorithmID`	`cms_idea_wrap` Creates an AlgorithmID for the `CMSIDEAwrap` key wrap algorithm for wrapping IDEA content encryption keys with IDEA key encryption keys (RFC 3058).
`static AlgorithmID`	`cms_pwri_kek` Creates an AlgorithmID for the key wrap algorithm for wrapping a Password Recipient Info content encryption key a Key Encryption Key derived from a password (RFC 3231).
`static AlgorithmID`	`cms_rc2_wrap` Creates an AlgorithmID for the `CMSRC2wrap` key wrap algorithm for wrapping RC2 content encryption keys with RC2 key encryption keys (RFC 2630).
`static AlgorithmID`	`des_CBC` Creates an AlgorithmID for the `DES` symmetric block cipher used in CBC mode.
`static AlgorithmID`	`des_EDE3_CBC` Creates an AlgorithmID for the `Triple DES` symmetric block cipher used in CBC mode.
`static AlgorithmID`	`dhKeyAgreement` Creates an AlgorithmID for the `Diffie-Hellman` key exchange algorithm.
`static AlgorithmID`	`dhSinglePass_cofactorDH_sha1kdf_scheme` Creates an AlgorithmID for the `1-Pass Diffie Hellman` scheme that uses the modified (aka: cofactor) Diffie-Hellman primitive and the key derivation function based on SHA-1 (ANSI X9.63).
`static AlgorithmID`	`dhSinglePass_cofactorDH_sha224kdf_scheme` To support some new KARI Algorithms for ECC CMC RFC#5753
`static AlgorithmID`	`dhSinglePass_cofactorDH_sha256kdf_scheme`
`static AlgorithmID`	`dhSinglePass_cofactorDH_sha384kdf_scheme`
`static AlgorithmID`	`dhSinglePass_cofactorDH_sha512kdf_scheme`
`static AlgorithmID`	`dhSinglePass_stdDH_sha1kdf_scheme` Creates an AlgorithmID for the `1-Pass Diffie Hellman` scheme that uses the standard Diffie-Hellman primitive and the key derivation function based on SHA-1 (ANSI X9.63).
`static AlgorithmID`	`dhSinglePass_stdDH_sha224kdf_scheme`
`static AlgorithmID`	`dhSinglePass_stdDH_sha256kdf_scheme` To support some new KARI Algorithms for ECC CMC RFC#5753
`static AlgorithmID`	`dhSinglePass_stdDH_sha384kdf_scheme`
`static AlgorithmID`	`dhSinglePass_stdDH_sha512kdf_scheme`
`static AlgorithmID`	`dsa` Creates an AlgorithmID for the `DSA` signature algorithm.
`static AlgorithmID`	`dsa_With_SHA1` Creates an alternative AlgorithmID for the `dsaWithSHA1` signature algorithm.
`static AlgorithmID`	`dsaWithSHA` Creates an AlgorithmID for the `dsaWithSHA` signature algorithm.
`static AlgorithmID`	`dsaWithSHA1` Creates an AlgorithmID for the `dsaWithSHA1` signature algorithm.
`static AlgorithmID`	`dsaX957` Creates an AlgorithmID for the `DSA` signature algorithm, using the OID defined in the X.957 standard.
`static AlgorithmID`	`ecdsa_with_Recommended` Creates an AlgorithmID for the `ecdsa-with-Recommended` signature algorithm.
`static AlgorithmID`	`ecdsa_with_Sha224` Creates an AlgorithmID for the `ecdsa-with-Sha224` signature algorithm.
`static AlgorithmID`	`ecdsa_with_Sha256` Creates an AlgorithmID for the `ecdsa-with-Sha256` signature algorithm.
`static AlgorithmID`	`ecdsa_with_Sha384` Creates an AlgorithmID for the `ecdsa-with-Sha384` signature algorithm.
`static AlgorithmID`	`ecdsa_with_Sha512` Creates an AlgorithmID for the `ecdsa-with-Sha512` signature algorithm.
`static AlgorithmID`	`ecdsa_with_Specified` Creates an AlgorithmID for the `ecdsa-with-Specified` signature algorithm.
`static AlgorithmID`	`ecdsaWithSHA1` Creates an AlgorithmID for the `ecdsaWithSHA1` signature algorithm.
`static AlgorithmID`	`esdh` Creates an AlgorithmID for identifying public `Ephemeral-Static Diffie-Hellman` keys.
`static AlgorithmID`	`esdhKeyAgreement` Creates an AlgorithmID for the `Ephemeral-Static Diffie-Hellman` key agreement algorithm (RFC 2631).
`static AlgorithmID`	`id_ecPublicKey` Creates an AlgorithmID that represents an `EC` public key (ANSI X9.62).
`static AlgorithmID`	`id_RSASAA_PSS` An AlgorithmID for the RSA-PSS signature algorithm.
`static AlgorithmID`	`idea_CBC` Creates an AlgorithmID for the `IDEA` symmetric block cipher used in CBC mode.
`protected static java.util.Hashtable`	`implementations` Implementation repository.
`static AlgorithmID`	`md2` Creates an AlgorithmID for the `MD2` message digest algorithm.
`static AlgorithmID`	`md2WithRSAEncryption` Creates an AlgorithmID for the `md2WithRSAEncryption` signature algorithm.
`static AlgorithmID`	`md4` Creates an AlgorithmID for the `MD4` message digest algorithm.
`static AlgorithmID`	`md4WithRSAEncryption` Creates an AlgorithmID for the `md4WithRSAEncryption` signature algorithm.
`static AlgorithmID`	`md5` Creates an AlgorithmID for the `MD5` message digest algorithm.
`static AlgorithmID`	`md5WithRSAEncryption` Creates an AlgorithmID for the `md5WithRSAEncryption` signature algorithm.
`static AlgorithmID`	`mgf1` Creates an AlgorithmID for the `MGF1` mask generation algorithm used in PKCS-1 v2.0.
`static AlgorithmID`	`pbeWithMD5AndDES_CBC` Creates an AlgorithmID for the `pbeWithMD5AndDES_CBC` key-encryption algorithm as defined by PKCS#5.
`static AlgorithmID`	`pbeWithSHAAnd128BitRC2_CBC` Creates an AlgorithmID for the `pbeWithSHAAnd128BitRC2_CBC` key-encryption algorithm as defined by PKCS#12.
`static AlgorithmID`	`pbeWithSHAAnd128BitRC4` Creates an AlgorithmID for the `pbeWithSHAAnd128BitRC4` key-encryption algorithm as defined by PKCS#12.
`static AlgorithmID`	`pbeWithSHAAnd2_KeyTripleDES_CBC` Creates an AlgorithmID for the `pbeWithSHAAnd2_KeyTripleDES_CBC` key-encryption algorithm as defined by PKCS#12.
`static AlgorithmID`	`pbeWithSHAAnd3_KeyTripleDES_CBC` Creates an AlgorithmID for the `pbeWithSHAAnd3_KeyTripleDES_CBC` key-encryption algorithm as defined by PKCS#12.
`static AlgorithmID`	`pbeWithSHAAnd40BitRC2_CBC` Creates an AlgorithmID for the `pbeWithSHAAnd40BitRC2_CBC` key-encryption algorithm as defined by PKCS#12.
`static AlgorithmID`	`pbeWithSHAAnd40BitRC4` Creates an AlgorithmID for the `pbeWithSHAAnd40BitRC4` key-encryption algorithm as defined by PKCS#12.
`static AlgorithmID`	`pbkdf2` Creates an AlgorithmID for the `PBKDF2` key-generator algorithm as defined by RFC 2298.
`static AlgorithmID`	`rc2_CBC` Creates an AlgorithmID for the `RC2` symmetric block cipher used in CBC mode.
`static AlgorithmID`	`rc4` Creates an AlgorithmID for the `RC4` stream cipher.
`static AlgorithmID`	`rc5_CBC` Creates an AlgorithmID for the `RC5` symmetric block cipher used in CBC mode.
`static AlgorithmID`	`rsa` Creates an AlgorithmID for the `RSA` public key algorithm.
`static AlgorithmID`	`rsaEncryption` Creates an AlgorithmID for the `RSA encryption` signature algorithm.
`static AlgorithmID`	`rsaESOAEP` Creates an AlgorithmID for the `RSA encryption` signature algorithm, using the OAEP encoding scheme defined in PKCS-1 v2.0 ObjectID = "1.2.840.113549.1.1.7" name = "rsaESOAEP" implementationName = "RSA-OAEP" For addressing it, use `AlgorithmID.rsaESOAEP`.
`static AlgorithmID`	`sha` Creates an AlgorithmID for the `SHA` message digest algorithm.
`static AlgorithmID`	`sha1` Creates an AlgorithmID for the `SHA1` message digest algorithm which is the same as `SHA`.
`static AlgorithmID`	`sha1WithRSAEncryption` Creates an AlgorithmID for the `sha1WithRSAEncryption` signature algorithm.
`static AlgorithmID`	`sha224` Creates an AlgorithmID for the `SHA224` message digest algorithm.
`static AlgorithmID`	`sha224WithRSAEncryption` Creates an AlgorithmID for the `sha224WithRSAEncryption` signature algorithm.
`static AlgorithmID`	`sha256` Creates an AlgorithmID for the `SHA256` message digest algorithm.
`static AlgorithmID`	`sha256WithRSAEncryption` Creates an AlgorithmID for the `sha256WithRSAEncryption` signature algorithm.
`static AlgorithmID`	`sha384` Creates an AlgorithmID for the `SHA384` message digest algorithm.
`static AlgorithmID`	`sha384WithRSAEncryption` Creates an AlgorithmID for the `sha384WithRSAEncryption` signature algorithm.
`static AlgorithmID`	`sha512` Creates an AlgorithmID for the `SHA512` message digest algorithm.
`static AlgorithmID`	`sha512WithRSAEncryption` Creates an AlgorithmID for the `sha512WithRSAEncryption` signature algorithm.

Constructor Summary

Constructors
Constructor and Description
`AlgorithmID()` Default constructor.
`AlgorithmID(ASN1Object algorithmID)` Creates a new AlgorithmID from an ASN1Object.
`AlgorithmID(DerInputStream is)` Decodes an AlgorithmID from a DerInputStream.
`AlgorithmID(ObjectID algorithm)` Creates a new AlgorithmID from an ObjectID.
`AlgorithmID(ObjectID algorithm, ASN1Object parameter)` Creates a new AlgorithmID from an ObjectID and algorithm parameters.
`AlgorithmID(ObjectID algorithm, java.lang.String implementationName)` Creates a new AlgorithmID from an ObjectID and an implementation.
`AlgorithmID(java.lang.String objectID, java.lang.String name)` Creates a new AlgorithmID from an object identifier and a name.
`AlgorithmID(java.lang.String objectID, java.lang.String name, java.lang.String implementationName)` Creates a new AlgorithmID from an object identifier, a name and an implementation.

Method Summary

Methods
Modifier and Type	Method and Description
`static boolean`	`changeObjectID(AlgorithmID algID, ObjectID oid)` Changes the object identifier of the given AlgorithmID object.
`static boolean`	`changeOIDString(AlgorithmID algID, java.lang.String oidString)` Changes the object identifier string of the given AlgorithmID object.
`java.lang.Object`	`clone()` Returns a clone of this AlgorithmID.
`void`	`decode(ASN1Object algorithmID)` Decodes an AlgorithmID from the given ASN1Object.
`void`	`encodeAbsentParametersAsNull(boolean useNULLForAbsentParameters)` Decide whether to encode absent parameters as NULL or omit the parameters field.
`boolean`	`equals(java.lang.Object obj)` Compares this AlgorithmID with the given AlgorithmID.
`ObjectID`	`getAlgorithm()` Returns the ObjectID of the algorithm.
`java.security.AlgorithmParameters`	`getAlgorithmParameters()` Returns the parameters of the algorithm as `java.security.AlgorithmParameters` object.
`java.security.AlgorithmParameters`	`getAlgorithmParameters(java.lang.String algorithm)` Returns the parameters of the algorithm as `java.security.AlgorithmParameters` object.
`java.security.AlgorithmParameters`	`getAlgorithmParameters(java.lang.String algorithm, java.lang.String provider)` Returns the parameters of the algorithm as `java.security.AlgorithmParameters` object.
`javax.crypto.Cipher`	`getCipherInstance()` Tries to find a Cipher implementation for this AlgorithmIdentifier.
`javax.crypto.Cipher`	`getCipherInstance(java.lang.String provider)` Tries to find a provider-specific Cipher implementation for this AlgorithmIdentifier.
`boolean`	`getDecodedAbsentParameters()` This method is used to determine if the ASN1 Encoded version of the parameters were absent when this structure was decoded.
`java.lang.String`	`getImplementationName()` Returns the name for an implementation of this algorithm.
`java.lang.Object`	`getInstance()` Tries to find an implementation for this AlgorithmIdentifier.
`java.lang.Object`	`getInstance(java.lang.String provider)` Tries to find a provider specific implementation for this AlgorithmIdentifier.
`javax.crypto.KeyAgreement`	`getKeyAgreementInstance()` Tries to find a KeyAgreement implementation for this AlgorithmIdentifier.
`javax.crypto.KeyAgreement`	`getKeyAgreementInstance(java.lang.String provider)` Tries to find a provider-specific KeyAgreement implementation for this AlgorithmIdentifier.
`java.security.KeyFactory`	`getKeyFactoryInstance()` Tries to find a KeyFactory implementation for this AlgorithmIdentifier.
`java.security.KeyFactory`	`getKeyFactoryInstance(java.lang.String provider)` Tries to find a provider-specific KeyFactory implementation for this AlgorithmIdentifier.
`javax.crypto.KeyGenerator`	`getKeyGeneratorInstance()` Tries to find a KeyGenerator implementation for this AlgorithmIdentifier.
`javax.crypto.KeyGenerator`	`getKeyGeneratorInstance(java.lang.String provider)` Tries to find a provider-specific KeyGenerator implementation for this AlgorithmID.
`java.security.KeyPairGenerator`	`getKeyPairGeneratorInstance()` Tries to find a KeyPairGenerator implementation for this AlgorithmIdentifier.
`java.security.KeyPairGenerator`	`getKeyPairGeneratorInstance(java.lang.String provider)` Tries to find a provider-specific KeyPairGenerator implementation for this AlgorithmID.
`java.security.MessageDigest`	`getMessageDigestInstance()` Tries to find a `MessageDigest` implementation for this `AlgorithmIdentifier`.
`java.security.MessageDigest`	`getMessageDigestInstance(java.lang.String provider)` Tries to find a `MessageDigest` implementation for this `AlgorithmIdentifier`.
`java.lang.String`	`getName()` Returns the name registered for this AlgorithmID or the object identifier string if there is no name registered.
`ASN1Object`	`getParameter()` Returns the parameters of the algorithm as ASN1Object.
`java.lang.String`	`getRawImplementationName()` Tries to get the raw inplementation name of the algorithm this AlgorithmID represents.
`javax.crypto.SecretKeyFactory`	`getSecretKeyFactoryInstance()` Tries to find a SecretKeyFactory implementation for this AlgorithmIdentifier.
`javax.crypto.SecretKeyFactory`	`getSecretKeyFactoryInstance(java.lang.String provider)` Tries to find a provider-specific SecretKeyFactory implementation for this AlgorithmID.
`java.security.Signature`	`getSignatureInstance()` Tries to find a Signature implementation for this AlgorithmIdentifier.
`java.security.Signature`	`getSignatureInstance(java.lang.String provider)` Tries to find a provider-specific Signature implementation for this AlgorithmIdentifier.
`void`	`initSignatureSign(java.security.Signature signatureAlg, java.security.PrivateKey signingKey)` Initializes a `Signature` algorithm instance for signing with the specified signing private key and algorithm parameters from the Algorithm Identifier.
`void`	`initSignatureVerify(java.security.Signature signatureAlg, java.security.PublicKey verificationKey)` Initializes a `Signature` algorithm instance for verification with the specified verification public key and algorithm parameters from the Algorithm Identifier.
`void`	`setAlgorithmParameters(java.security.AlgorithmParameters parameters)` Sets the parameters of the algorithm.
`void`	`setParameter(ASN1Object parameters)` Sets the parameters of the algorithm.
`ASN1Object`	`toASN1Object()` Returns the AlgorithmID as an (SEQUENCE) ASN1Object.
`ASN1Object`	`toASN1Object(boolean useNULLForAbsentParameters)` Returns the AlgorithmID as an (SEQUENCE) ASN1Object.
`AlgorithmID`	`toEntrustAlgorithmID()` Converts an IAIK Algorithm Identifier to an Entrust Algorithm Identifier.
`java.lang.String`	`toString()` Returns a string that represents this AlgorithmIdentifier.

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

- Field Detail
  - implementations
```
protected static java.util.Hashtable implementations
```
    Implementation repository.
  - dhKeyAgreement
```
public static AlgorithmID dhKeyAgreement
```
    Creates an AlgorithmID for the Diffie-Hellman key exchange algorithm.
    - ObjectID = "1.2.840.113549.1.3.1"
    - name = "DH Key Agreement"
    - implementationName = "DH"
    For addressing it, use AlgorithmID.dhKeyAgreement.
  - esdhKeyAgreement
```
public static AlgorithmID esdhKeyAgreement
```
    Creates an AlgorithmID for the Ephemeral-Static Diffie-Hellman key agreement algorithm (RFC 2631).
    - ObjectID = "1.2.840.113549.1.9.16.3.5"
    - name = "ESDH Key Agreement"
    - implementationName = "ESDH"
    For addressing it, use AlgorithmID.esdhKeyAgreement.
  - esdh
```
public static AlgorithmID esdh
```
    Creates an AlgorithmID for identifying public Ephemeral-Static Diffie-Hellman keys.
    - ObjectID = "1.2.840.10046.2.1"
    - name = "ESDH"
    - implementationName = "ESDH"
    For addressing it, use AlgorithmID.esdh.
  - rsaEncryption
```
public static AlgorithmID rsaEncryption
```
    Creates an AlgorithmID for the RSA encryption signature algorithm.
    - ObjectID = "1.2.840.113549.1.1.1"
    - name = "rsaEncryption"
    - implementationName = "RSA"
    For addressing it, use AlgorithmID.rsaEncryption.
  - rsaESOAEP
```
public static AlgorithmID rsaESOAEP
```
    Creates an AlgorithmID for the RSA encryption signature algorithm, using the OAEP encoding scheme defined in PKCS-1 v2.0
    - ObjectID = "1.2.840.113549.1.1.7"
    - name = "rsaESOAEP"
    - implementationName = "RSA-OAEP"
    For addressing it, use AlgorithmID.rsaESOAEP.
  - mgf1
```
public static AlgorithmID mgf1
```
    Creates an AlgorithmID for the MGF1 mask generation algorithm used in PKCS-1 v2.0.
    - ObjectID = "1.2.840.113549.1.1.8"
    - name = "MGF1"
    - implementationName = "MGF1"
    For addressing it, use AlgorithmID.mgf1.
  - md2WithRSAEncryption
```
public static AlgorithmID md2WithRSAEncryption
```
    Creates an AlgorithmID for the md2WithRSAEncryption signature algorithm.
    - ObjectID = "1.2.840.113549.1.1.2"
    - name = "md2WithRSAEncryption"
    - implementationName = "MD2/RSA"
    For addressing it, use AlgorithmID.md2WithRSAEncryption.
  - md4WithRSAEncryption
```
public static AlgorithmID md4WithRSAEncryption
```
    Creates an AlgorithmID for the md4WithRSAEncryption signature algorithm.
    - ObjectID = "1.2.840.113549.1.1.3"
    - name = "md4WithRSAEncryption"
    - implementationName = - (not implemented by the IAIK provider)
    For addressing it, use AlgorithmID.md4WithRSAEncryption.
  - md5WithRSAEncryption
```
public static AlgorithmID md5WithRSAEncryption
```
    Creates an AlgorithmID for the md5WithRSAEncryption signature algorithm.
    - ObjectID = "1.2.840.113549.1.1.4"
    - name = "md5WithRSAEncryption"
    - implementationName = "MD5/RSA"
    For addressing it, use AlgorithmID.md5WithRSAEncryption.
  - sha1WithRSAEncryption
```
public static AlgorithmID sha1WithRSAEncryption
```
    Creates an AlgorithmID for the sha1WithRSAEncryption signature algorithm.
    - ObjectID = "1.2.840.113549.1.1.5"
    - name = "sha1WithRSAEncryption"
    - implementationName = "SHA/RSA"
    For addressing it, use AlgorithmID.sha1WithRSAEncryption.
  - sha512WithRSAEncryption
```
public static AlgorithmID sha512WithRSAEncryption
```
    Creates an AlgorithmID for the sha512WithRSAEncryption signature algorithm.
    - ObjectID = "1.2.840.113549.1.1.13"
    - name = "sha512WithRSAEncryption"
    - implementationName = "SHA512/RSA"
    For addressing it, use AlgorithmID.sha512WithRSAEncryption.
  - sha384WithRSAEncryption
```
public static AlgorithmID sha384WithRSAEncryption
```
    Creates an AlgorithmID for the sha384WithRSAEncryption signature algorithm.
    - ObjectID = "1.2.840.113549.1.1.12"
    - name = "sha384WithRSAEncryption"
    - implementationName = "SHA384/RSA"
    For addressing it, use AlgorithmID.sha384WithRSAEncryption.
  - sha256WithRSAEncryption
```
public static AlgorithmID sha256WithRSAEncryption
```
    Creates an AlgorithmID for the sha256WithRSAEncryption signature algorithm.
    - ObjectID = "1.2.840.113549.1.1.11"
    - name = "sha256WithRSAEncryption"
    - implementationName = "SHA256/RSA"
    For addressing it, use AlgorithmID.sha256WithRSAEncryption.
  - sha224WithRSAEncryption
```
public static AlgorithmID sha224WithRSAEncryption
```
    Creates an AlgorithmID for the sha224WithRSAEncryption signature algorithm.
    - ObjectID = "1.2.840.113549.1.1.14"
    - name = "sha224WithRSAEncryption"
    - implementationName = "SHA224/RSA"
    For addressing it, use AlgorithmID.sha224WithRSAEncryption.
  - dsa
```
public static AlgorithmID dsa
```
    Creates an AlgorithmID for the DSA signature algorithm.
    - ObjectID = "1.3.14.3.2.12"
    - name = "DSA"
    - implementationName = "DSA"
    For addressing it, use AlgorithmID.dsa.
  - dsaX957
```
public static AlgorithmID dsaX957
```
    Creates an AlgorithmID for the DSA signature algorithm, using the OID defined in the X.957 standard.
    - ObjectID="1.2.840.10040.4.1"
    - name="DSA"
    - implementationName="DSA"
    For addressing it, use AlgorithmID.dsaX957.
  - dsaWithSHA
```
public static AlgorithmID dsaWithSHA
```
    Creates an AlgorithmID for the dsaWithSHA signature algorithm.
    - ObjectID = "1.3.14.3.2.13"
    - name = "dsaWithSHA"
    - implementationName = "DSA"
    For addressing it, use AlgorithmID.dsaWithSHA.
  - dsaWithSHA1
```
public static AlgorithmID dsaWithSHA1
```
    Creates an AlgorithmID for the dsaWithSHA1 signature algorithm.
    - ObjectID = "1.3.14.3.2.27"
    - name = "dsaWithSHA1"
    - implementationName = "DSA"
    For addressing it, use AlgorithmID.dsaWithSHA1.
  - dsa_With_SHA1
```
public static AlgorithmID dsa_With_SHA1
```
    Creates an alternative AlgorithmID for the dsaWithSHA1 signature algorithm.
    - ObjectID = "1.2.840.10040.4.3"
    - name = "DSAWithSHA1"
    - implementationName = "DSA"
    For addressing it, use AlgorithmID.dsa_With_SHA1.
  - ecdsaWithSHA1
```
public static AlgorithmID ecdsaWithSHA1
```
    Creates an AlgorithmID for the ecdsaWithSHA1 signature algorithm.
    - ObjectID = "1.2.840.10045.4.1"
    - name = "ecdsaWithSHA1"
    - implementationName = "SHA1withECDSA"
    For addressing it, use AlgorithmID.ecdsaWithSHA1.
  - ecdsa_with_Recommended
```
public static AlgorithmID ecdsa_with_Recommended
```
    Creates an AlgorithmID for the ecdsa-with-Recommended signature algorithm.
    - ObjectID = "1.2.840.10045.4.2"
    - name = "ecdsa-with-Recommended"
    - implementationName = (not implemented by the Entrust or IAIK provider)
    For addressing it, use AlgorithmID.ecdsaWithRecommended.
    Since:
    
    7.2 SP1
  - ecdsa_with_Specified
```
public static AlgorithmID ecdsa_with_Specified
```
    Creates an AlgorithmID for the ecdsa-with-Specified signature algorithm.
    - ObjectID = "1.2.840.10045.4.3"
    - name = "ecdsa-with-Specified"
    - implementationName = (not implemented by the Entrust or IAIK provider)
    For addressing it, use AlgorithmID.ecdsaWithSpecified.
    Since:
    
    7.2 SP1
  - ecdsa_with_Sha224
```
public static AlgorithmID ecdsa_with_Sha224
```
    Creates an AlgorithmID for the ecdsa-with-Sha224 signature algorithm.
    - ObjectID = "1.2.840.10045.4.3.1"
    - name = "ecdsa-with-Sha224"
    - implementationName = "SHA224withECDSA"
    For addressing it, use AlgorithmID.ecdsaWithSHA224.
    Since:
    
    7.2 SP1
  - ecdsa_with_Sha256
```
public static AlgorithmID ecdsa_with_Sha256
```
    Creates an AlgorithmID for the ecdsa-with-Sha256 signature algorithm.
    - ObjectID = "1.2.840.10045.4.3.2"
    - name = "ecdsa-with-Sha256"
    - implementationName = "SHA256withECDSA"
    For addressing it, use AlgorithmID.ecdsaWithSHA256.
    Since:
    
    7.2 SP1
  - ecdsa_with_Sha384
```
public static AlgorithmID ecdsa_with_Sha384
```
    Creates an AlgorithmID for the ecdsa-with-Sha384 signature algorithm.
    - ObjectID = "1.2.840.10045.4.3.3"
    - name = "ecdsa-with-Sha384"
    - implementationName = "SHA384withECDSA"
    For addressing it, use AlgorithmID.ecdsaWithSHA384.
    Since:
    
    7.2 SP1
  - ecdsa_with_Sha512
```
public static AlgorithmID ecdsa_with_Sha512
```
    Creates an AlgorithmID for the ecdsa-with-Sha512 signature algorithm.
    - ObjectID = "1.2.840.10045.4.3.4"
    - name = "ecdsa-with-Sha512"
    - implementationName = "SHA512withECDSA"
    For addressing it, use AlgorithmID.ecdsaWithSHA512.
    Since:
    
    7.2 SP1
  - pbeWithMD5AndDES_CBC
```
public static AlgorithmID pbeWithMD5AndDES_CBC
```
    Creates an AlgorithmID for the pbeWithMD5AndDES_CBC key-encryption algorithm as defined by PKCS#5.
    - ObjectID = "1.2.840.113549.1.5.3"
    - name = "PbeWithMD5AndDES-CBC"
    - implementationName = "PbeWithMD5AndDES_CBC"
    For addressing it, use AlgorithmID.pbeWithMD5AndDES_CBC.
  - pbkdf2
```
public static AlgorithmID pbkdf2
```
    Creates an AlgorithmID for the PBKDF2 key-generator algorithm as defined by RFC 2298.
    - ObjectID = "1.2.840.113549.1.5.12"
    - name = "PBKDF2"
    - implementationName = "PBKDF2"
    For addressing it, use AlgorithmID.pbkdf2.
  - pbeWithSHAAnd128BitRC4
```
public static AlgorithmID pbeWithSHAAnd128BitRC4
```
    Creates an AlgorithmID for the pbeWithSHAAnd128BitRC4 key-encryption algorithm as defined by PKCS#12.
    - ObjectID = "1.2.840.113549.1.12.1.1"
    - name = "PbeWithSHAAnd128BitRC4"
    - implementationName = - (not implemented by the IAIK provider)
    For addressing it, use AlgorithmID.pbeWithSHAAnd128BitRC4.
  - pbeWithSHAAnd40BitRC4
```
public static AlgorithmID pbeWithSHAAnd40BitRC4
```
    Creates an AlgorithmID for the pbeWithSHAAnd40BitRC4 key-encryption algorithm as defined by PKCS#12.
    - ObjectID = "1.2.840.113549.1.12.1.2"
    - name = "PbeWithSHAAnd40BitRC4"
    - implementationName = - (not implemented by the IAIK provider)
    For addressing it, use AlgorithmID.pbeWithSHAAnd40BitRC4.
  - pbeWithSHAAnd3_KeyTripleDES_CBC
```
public static AlgorithmID pbeWithSHAAnd3_KeyTripleDES_CBC
```
    Creates an AlgorithmID for the pbeWithSHAAnd3_KeyTripleDES_CBC key-encryption algorithm as defined by PKCS#12.
    - ObjectID = "1.2.840.113549.1.12.1.3"
    - name = "PbeWithSHAAnd3-KeyTripleDES-CBC"
    - implementationName = "PbeWithSHAAnd3_KeyTripleDES_CBC"
    For addressing it, use AlgorithmID.pbeWithSHAAnd3_KeyTripleDES_CBC.
  - pbeWithSHAAnd2_KeyTripleDES_CBC
```
public static AlgorithmID pbeWithSHAAnd2_KeyTripleDES_CBC
```
    Creates an AlgorithmID for the pbeWithSHAAnd2_KeyTripleDES_CBC key-encryption algorithm as defined by PKCS#12.
    - ObjectID = "1.2.840.113549.1.12.1.4"
    - name = "PbeWithSHAAnd2-KeyTripleDES-CBC"
    - implementationName = - (not implemented by the IAIK provider)
    For addressing it, use AlgorithmID.pbeWithSHAAnd2_KeyTripleDES_CBC.
  - pbeWithSHAAnd128BitRC2_CBC
```
public static AlgorithmID pbeWithSHAAnd128BitRC2_CBC
```
    Creates an AlgorithmID for the pbeWithSHAAnd128BitRC2_CBC key-encryption algorithm as defined by PKCS#12.
    - ObjectID = "1.2.840.113549.1.12.1.5"
    - name = "PbeWithSHAAnd128BitRC2-CBC"
    - implementationName = - (not implemented by the IAIK provider)
    For addressing it, use AlgorithmID.pbeWithSHAAnd128BitRC2_CBC.
  - pbeWithSHAAnd40BitRC2_CBC
```
public static AlgorithmID pbeWithSHAAnd40BitRC2_CBC
```
    Creates an AlgorithmID for the pbeWithSHAAnd40BitRC2_CBC key-encryption algorithm as defined by PKCS#12.
    - ObjectID = "1.2.840.113549.1.12.1.6"
    - name = "PbeWithSHAAnd40BitRC2-CBC"
    - implementationName = "PbeWithSHAAnd40BitRC2_CBC"
    For addressing it, use AlgorithmID.pbeWithSHAAnd40BitRC2_CBC.
  - rsa
```
public static AlgorithmID rsa
```
    Creates an AlgorithmID for the RSA public key algorithm.
    - ObjectID = "2.5.8.1.1"
    - name = "RSA"
    - implementationName = "RSA"
    For addressing it, use AlgorithmID.rsa.
  - rc2_CBC
```
public static AlgorithmID rc2_CBC
```
    Creates an AlgorithmID for the RC2 symmetric block cipher used in CBC mode.
    - ObjectID = "1.2.840.113549.3.2"
    - name = "RC2-CBC"
    - implementationName = "RC2/CBC/PKCS5Padding"
    For addressing it, use AlgorithmID.rc2_CBC.
  - rc4
```
public static AlgorithmID rc4
```
    Creates an AlgorithmID for the RC4 stream cipher.
    - ObjectID = "1.2.840.113549.3.4"
    - name = "RC4"
    - implementationName = "RC4/ECB/NoPadding"
    For addressing it, use AlgorithmID.rc4.
  - des_EDE3_CBC
```
public static AlgorithmID des_EDE3_CBC
```
    Creates an AlgorithmID for the Triple DES symmetric block cipher used in CBC mode.
    - ObjectID = "1.2.840.113549.3.7"
    - name = "DES-EDE3-CBC"
    - implementationName = "DESede/CBC/PKCS5Padding"
    For addressing it, use AlgorithmID.des_EDE3_CBC.
  - des_CBC
```
public static AlgorithmID des_CBC
```
    Creates an AlgorithmID for the DES symmetric block cipher used in CBC mode.
    - ObjectID = "1.3.14.3.2.7"
    - name = "DES-CBC"
    - implementationName = "DES/CBC/PKCS5Padding"
    For addressing it, use AlgorithmID.des_CBC.
  - idea_CBC
```
public static AlgorithmID idea_CBC
```
    Creates an AlgorithmID for the IDEA symmetric block cipher used in CBC mode.
    - ObjectID = "1.3.6.1.4.1.188.7.1.1.2"
    - name = "IDEA-CBC"
    - implementationName = "IDEA/CBC/PKCS5Padding"
    For addressing it, use AlgorithmID.idea_CBC.
  - cast5_CBC
```
public static AlgorithmID cast5_CBC
```
    Creates an AlgorithmID for the CAST5 symmetric block cipher used in CBC mode.
    - ObjectID = "1.2.840.113533.7.66.10"
    - name = "CAST5-CBC"
    - implementationName = "CAST5/CBC/PKCS5Padding"
    For addressing it, use AlgorithmID.cast5_CBC.
  - cast3_CBC
```
public static AlgorithmID cast3_CBC
```
    Creates an AlgorithmID for the CAST3 symmetric block cipher used in CBC mode.
    - ObjectID = "1.2.840.113533.7.66.3"
    - name = "CAST3-CBC"
    - implementationName = "CAST3/CBC/PKCS5Padding"
    For addressing it, use AlgorithmID.cast3_CBC.
    Since:
    
    Entrust 7.0
  - rc5_CBC
```
public static AlgorithmID rc5_CBC
```
    Creates an AlgorithmID for the RC5 symmetric block cipher used in CBC mode.
    - ObjectID = "1.2.840.113549.3.8"
    - name = "RC5-CBC"
    - implementationName = "RC5/CBC/PKCS5Padding"
    For addressing it, use AlgorithmID.rc5_CBC.
  - aes_128_ECB
```
public static AlgorithmID aes_128_ECB
```
    Creates an AlgorithmID for the AES symmetric block cipher used with a 128-bit key in ECB mode.
    - ObjectID = "2.16.840.1.101.3.4.1.1"
    - name = "AES-128-ECB"
    - implementationName = "AES/ECB/PKCS5Padding"
    For addressing it, use AlgorithmID.aes_128_ECB.
  - aes_128_CBC
```
public static AlgorithmID aes_128_CBC
```
    Creates an AlgorithmID for the AES symmetric block cipher used with a 128-bit key in CBC mode.
    - ObjectID = "2.16.840.1.101.3.4.1.2"
    - name = "AES-128-CBC"
    - implementationName = "AES/CBC/PKCS5Padding"
    For addressing it, use AlgorithmID.aes_128_CBC.
  - aes_192_ECB
```
public static AlgorithmID aes_192_ECB
```
    Creates an AlgorithmID for the AES symmetric block cipher used with a 192-bit key in ECB mode.
    - ObjectID = "2.16.840.1.101.3.4.1.21"
    - name = "AES-192-ECB"
    - implementationName = "AES/ECB/PKCS5Padding"
    For addressing it, use AlgorithmID.aes_192_ECB.
  - aes_192_CBC
```
public static AlgorithmID aes_192_CBC
```
    Creates an AlgorithmID for the AES symmetric block cipher used with a 192-bit key in CBC mode.
    - ObjectID = "2.16.840.1.101.3.4.1.22"
    - name = "AES-192-CBC"
    - implementationName = "AES/CBC/PKCS5Padding"
    For addressing it, use AlgorithmID.aes_192_CBC.
  - aes_256_ECB
```
public static AlgorithmID aes_256_ECB
```
    Creates an AlgorithmID for the AES symmetric block cipher used with a 256-bit key in ECB mode.
    - ObjectID = "2.16.840.1.101.3.4.1.41"
    - name = "AES-256-ECB"
    - implementationName = "AES/ECB/PKCS5Padding"
    For addressing it, use AlgorithmID.aes_256_ECB.
  - aes_256_CBC
```
public static AlgorithmID aes_256_CBC
```
    Creates an AlgorithmID for the AES symmetric block cipher used with a 256-bit key in CBC mode.
    - ObjectID = "2.16.840.1.101.3.4.1.42"
    - name = "AES-256-CBC"
    - implementationName = "AES/CBC/PKCS5Padding"
    For addressing it, use AlgorithmID.aes_256_CBC.
  - md2
```
public static AlgorithmID md2
```
    Creates an AlgorithmID for the MD2 message digest algorithm.
    - ObjectID = "1.2.840.113549.2.2"
    - name = "MD2"
    - implementationName = "MD2"
    For addressing it, use AlgorithmID.md2.
  - md4
```
public static AlgorithmID md4
```
    Creates an AlgorithmID for the MD4 message digest algorithm.
    - ObjectID = "1.2.840.113549.2.4"
    - name = "MD4"
    - implementationName = - (not implemented by the IAIK provider)
    For addressing it, use AlgorithmID.md4.
  - md5
```
public static AlgorithmID md5
```
    Creates an AlgorithmID for the MD5 message digest algorithm.
    - ObjectID = "1.2.840.113549.2.5"
    - name = "MD5"
    - implementationName = "MD5"
    For addressing it, use AlgorithmID.md5.
  - sha
```
public static AlgorithmID sha
```
    Creates an AlgorithmID for the SHA message digest algorithm.
    - ObjectID = "1.3.14.3.2.26"
    - name = "SHA"
    - implementationName = "SHA"
    For addressing it, use AlgorithmID.sha.
  - sha1
```
public static AlgorithmID sha1
```
    Creates an AlgorithmID for the SHA1 message digest algorithm which is the same as SHA.
    - ObjectID = "1.3.14.3.2.26"
    - name = "SHA"
    - implementationName = "SHA"
    For addressing it, use AlgorithmID.sha1.
  - sha224
```
public static AlgorithmID sha224
```
    Creates an AlgorithmID for the SHA224 message digest algorithm.
    - ObjectID = "2.16.840.1.101.3.4.2.4"
    - name = "id_sha224"
    - implementationName = "SHA224"
    For addressing it, use AlgorithmID.sha224.
    Since:
    
    7.2 SP1
  - sha256
```
public static AlgorithmID sha256
```
    Creates an AlgorithmID for the SHA256 message digest algorithm.
    - ObjectID = "2.16.840.1.101.3.4.2.1"
    - name = "id_sha256"
    - implementationName = "SHA256"
    For addressing it, use AlgorithmID.sha256.
    Since:
    
    Entrust 7.0
  - sha384
```
public static AlgorithmID sha384
```
    Creates an AlgorithmID for the SHA384 message digest algorithm.
    - ObjectID = "2.16.840.1.101.3.4.2.2"
    - name = "id_sha384"
    - implementationName = "SHA384"
    For addressing it, use AlgorithmID.sha384.
    Since:
    
    Entrust 7.0
  - sha512
```
public static AlgorithmID sha512
```
    Creates an AlgorithmID for the SHA512 message digest algorithm.
    - ObjectID = "2.16.840.1.101.3.4.2.3"
    - name = "id_sha512"
    - implementationName = "SHA512"
    For addressing it, use AlgorithmID.sha512.
    Since:
    
    Entrust 7.0
  - cms_3DES_wrap
```
public static AlgorithmID cms_3DES_wrap
```
    Creates an AlgorithmID for the CMS3DESwrap key wrap algorithm for wrapping DESede content encryption keys with DESede key encryption keys (RFC 2630).
    - ObjectID = "1.2.840.113549.1.9.16.3.6"
    - name = "CMS-3DES-Wrap"
    - implementationName = "DESedeWrapDESede"
    For addressing it, use AlgorithmID.cms_3DES_wrap.
  - cms_rc2_wrap
```
public static AlgorithmID cms_rc2_wrap
```
    Creates an AlgorithmID for the CMSRC2wrap key wrap algorithm for wrapping RC2 content encryption keys with RC2 key encryption keys (RFC 2630).
    - ObjectID = "1.2.840.113549.1.9.16.3.7"
    - name = "CMS-RC2-Wrap"
    - implementationName = "RC2WrapRC2"
    For addressing it, use AlgorithmID.cms_rc2_wrap.
  - cms_pwri_kek
```
public static AlgorithmID cms_pwri_kek
```
    Creates an AlgorithmID for the key wrap algorithm for wrapping a Password Recipient Info content encryption key a Key Encryption Key derived from a password (RFC 3231).
    - ObjectID = "1.2.840.113549.1.9.16.3.9"
    - name = "CMS-PWRI-KEK"
    - implementationName = "PWRIKek" (Not implemented)
    For addressing it, use AlgorithmID.cms_pwri_kek.
  - cms_idea_wrap
```
public static AlgorithmID cms_idea_wrap
```
    Creates an AlgorithmID for the CMSIDEAwrap key wrap algorithm for wrapping IDEA content encryption keys with IDEA key encryption keys (RFC 3058).
    - ObjectID = "1.3.6.1.4.1.188.7.1.1.6"
    - name = "CMS-IDEA-Wrap"
    - implementationName = "IDEAWrapIDEA"
    For addressing it, use AlgorithmID.cms_idea_wrap.
  - cms_cast5_wrap
```
public static AlgorithmID cms_cast5_wrap
```
    Creates an AlgorithmID for the CMSCAST128wrap key wrap algorithm for wrapping CAST128 content encryption keys with CAST128 key encryption keys (RFC 2984).
    - ObjectID = "1.2.840.113533.7.66.15"
    - name = "CMS-CAST-Wrap"
    - implementationName = "CASTWrapCAST"
    For addressing it, use AlgorithmID.cms_cast5_wrap.
  - cms_cast_wrap
```
public static AlgorithmID cms_cast_wrap
```
    Creates an AlgorithmID for the CMSCAST128wrap key wrap algorithm for wrapping CAST128 content encryption keys with CAST128 key encryption keys (RFC 2984).
    - ObjectID = "1.2.840.113533.7.66.15"
    - name = "CMS-CAST-Wrap"
    - implementationName = "CASTWrapCAST"
    For addressing it, use AlgorithmID.cms_cast_wrap.
  - id_ecPublicKey
```
public static AlgorithmID id_ecPublicKey
```
    Creates an AlgorithmID that represents an EC public key (ANSI X9.62).
    - ObjectID = "1.2.840.10045.2.1"
    - name = "id-ecPublicKey"
    - implementationName = EC
    For addressing it, use AlgorithmID.id_ecPublicKey.
    Since:
    
    7.2 SP1
  - dhSinglePass_stdDH_sha1kdf_scheme
```
public static AlgorithmID dhSinglePass_stdDH_sha1kdf_scheme
```
    Creates an AlgorithmID for the 1-Pass Diffie Hellman scheme that uses the standard Diffie-Hellman primitive and the key derivation function based on SHA-1 (ANSI X9.63).
    - ObjectID = "1.3.133.16.840.63.0.2"
    - name = "dhSinglePass-stdDH-sha1kdf-scheme"
    - implementationName = None
    For addressing it, use AlgorithmID.dhSinglePass_stdDH_sha1kdf_scheme.
    Since:
    
    7.2 SP1
  - dhSinglePass_stdDH_sha256kdf_scheme
```
public static AlgorithmID dhSinglePass_stdDH_sha256kdf_scheme
```
    To support some new KARI Algorithms for ECC CMC RFC#5753
  - dhSinglePass_stdDH_sha224kdf_scheme
```
public static AlgorithmID dhSinglePass_stdDH_sha224kdf_scheme
```
  - dhSinglePass_stdDH_sha384kdf_scheme
```
public static AlgorithmID dhSinglePass_stdDH_sha384kdf_scheme
```
  - dhSinglePass_stdDH_sha512kdf_scheme
```
public static AlgorithmID dhSinglePass_stdDH_sha512kdf_scheme
```
  - dhSinglePass_cofactorDH_sha1kdf_scheme
```
public static AlgorithmID dhSinglePass_cofactorDH_sha1kdf_scheme
```
    Creates an AlgorithmID for the 1-Pass Diffie Hellman scheme that uses the modified (aka: cofactor) Diffie-Hellman primitive and the key derivation function based on SHA-1 (ANSI X9.63).
    - ObjectID = "1.3.133.16.840.63.0.3"
    - name = "dhSinglePass-cofactorDH-sha1kdf-scheme"
    - implementationName = None
    For addressing it, use AlgorithmID.dhSinglePass_cofactorDH_sha1kdf_scheme.
    Since:
    
    8.0
  - dhSinglePass_cofactorDH_sha224kdf_scheme
```
public static AlgorithmID dhSinglePass_cofactorDH_sha224kdf_scheme
```
    To support some new KARI Algorithms for ECC CMC RFC#5753
  - dhSinglePass_cofactorDH_sha256kdf_scheme
```
public static AlgorithmID dhSinglePass_cofactorDH_sha256kdf_scheme
```
  - dhSinglePass_cofactorDH_sha384kdf_scheme
```
public static AlgorithmID dhSinglePass_cofactorDH_sha384kdf_scheme
```
  - dhSinglePass_cofactorDH_sha512kdf_scheme
```
public static AlgorithmID dhSinglePass_cofactorDH_sha512kdf_scheme
```
  - aes_128_wrap
```
public static AlgorithmID aes_128_wrap
```
    Creates an AlgorithmID for the AesKeyWrap key wrap algorithm for wrapping 128-bit AES content encryption keys with 128-bit AES key encryption keys (RFC 3394).
    - ObjectID = "2.16.840.1.101.3.4.1.5"
    - name = "id-aes128-wrap"
    - implementationName = "AesKeyWrap"
    For addressing it, use AlgorithmID.aes_128_wrap.
    Since:
    
    7.2 SP1
  - aes_192_wrap
```
public static AlgorithmID aes_192_wrap
```
    Creates an AlgorithmID for the AesKeyWrap key wrap algorithm for wrapping 192-bit AES content encryption keys with 192-bit AES key encryption keys (RFC 3394).
    - ObjectID = "2.16.840.1.101.3.4.1.25"
    - name = "id-aes192-wrap"
    - implementationName = "AesKeyWrap"
    For addressing it, use AlgorithmID.aes_192_wrap.
    Since:
    
    7.2 SP1
  - aes_256_wrap
```
public static AlgorithmID aes_256_wrap
```
    Creates an AlgorithmID for the AesKeyWrap key wrap algorithm for wrapping 256-bit AES content encryption keys with 256-bit AES key encryption keys (RFC 3394).
    - ObjectID = "2.16.840.1.101.3.4.1.45"
    - name = "id-aes256-wrap"
    - implementationName = "AesKeyWrap"
    For addressing it, use AlgorithmID.aes_256_wrap.
    Since:
    
    7.2 SP1
  - id_RSASAA_PSS
```
public static final AlgorithmID id_RSASAA_PSS
```
    An AlgorithmID for the RSA-PSS signature algorithm.
    - ObjectID = "1.2.840.113549.1.1.10"
    - name = id-RSASAA-PSS
    - implementationName = "RSA-PSS"
    Since:
    
    7.2 SP2
- Constructor Detail
  - AlgorithmID
```
public AlgorithmID()
```
    Default constructor. Creates an AlgorithmID object with null ObjectID and null parameters.
  - AlgorithmID
```
public AlgorithmID(java.lang.String objectID,
           java.lang.String name)
```
    Creates a new AlgorithmID from an object identifier and a name. The AlgorithmID parameters are set to NULL.
    
    Parameters:
    objectID - the object identifier of the algorithm as a string; e.g. "2.5.8.1.1"
    name - the name for this object identifier; e.g "rsa"
  - AlgorithmID
```
public AlgorithmID(java.lang.String objectID,
           java.lang.String name,
           java.lang.String implementationName)
```
    Creates a new AlgorithmID from an object identifier, a name and an implementation. The AlgorithmID parameters are set to NULL.
    
    Parameters:
    objectID - the object identifier of the algorithm as a string; e.g. "1.2.840.113549.3.7"
    name - the name for this object identifier; e.g "DES-EDE3-CBC"
    implementationName - the internal implementation name; e.g. "DESede/CBC/PKCS5Padding"
  - AlgorithmID
```
public AlgorithmID(ObjectID algorithm,
           java.lang.String implementationName)
```
    Creates a new AlgorithmID from an ObjectID and an implementation. The AlgorithmID parameters are set to NULL.
    
    Parameters:
    algorithm - the ObjectID of the algorithm
    implementationName - the internal implementation name; e.g. "DESede/CBC/PKCS5Padding"
    Since:
    
    Entrust 7.0
  - AlgorithmID
```
public AlgorithmID(ObjectID algorithm)
```
    Creates a new AlgorithmID from an ObjectID. The parameters are set to NULL.
    
    Parameters:
    algorithm - the ObjectID of the algorithm
  - AlgorithmID
```
public AlgorithmID(ObjectID algorithm,
           ASN1Object parameter)
```
    Creates a new AlgorithmID from an ObjectID and algorithm parameters.
    
    Parameters:
    algorithm - the ObjectID of the algorithm
    parameter - the algorithm parameters
  - AlgorithmID
```
public AlgorithmID(ASN1Object algorithmID)
            throws CodingException
```
    Creates a new AlgorithmID from an ASN1Object. The supplied ASN1Object represents an already existing AlgorithmID that may have been created by means of the toASN1Object()method.
    
    Parameters:
    algorithmID - the AlgorithmID as ASN1Object
    
    Throws:
    
    CodingException - if the ASN1Object is no AlgorithmID
  - AlgorithmID
```
public AlgorithmID(DerInputStream is)
            throws java.io.IOException
```
    Decodes an AlgorithmID from a DerInputStream.
    The given DerInputStreamsupplies DER encoded data that represents an already existing AlgorithmID.
    Note: This method will decode Algorithm parameters which have been encoded with a Null algorithm parameter as well as Algorithm parameters which have been omitted from the sequence. See RFC 3274 section 2.1.
    
    Parameters:
    is - the DerInputStream supplying the DER encoded ASN1Object
    
    Throws:
    
    java.io.IOException - if an I/O or decoding error occurs
- Method Detail
  - changeObjectID
```
public static boolean changeObjectID(AlgorithmID algID,
                     ObjectID oid)
```
    Changes the object identifier of the given AlgorithmID object.
    This method may be used to allocate a new object identifier to an already existing AlgorithmID. With JDK 1.2 the SUN provider, for instance, has changed the algorithm oid of the DSA algorithm from 1.3.14.3.2.12 to 1.2.840.10040.4.1, whereas IAIK continues to use 1.3.14.3.2.12. An application wishing to use the new OID, can allocate it by using this method, e.g.:
```
 ObjectID oid = new ObjectID("1.2.840.10040.4.1", "DSA");
 AlgorithmID.changeObjectID(AlgorithmID.dsa, oid);
 
```
    If you only want to change the OID string, but keep name and shortName, you may use method changeOIDString(AlgorithmID algID, String oidString).
    Parameters:
    algID - the AlgorithmID to which a new OID shall be allocated
    oid - the new object identifier
    
    Returns:
    true if the OID successfully has been changed, false otherwise
  - changeOIDString
```
public static boolean changeOIDString(AlgorithmID algID,
                      java.lang.String oidString)
```
    Changes the object identifier string of the given AlgorithmID object.
    This method may be used to allocate a new object identifier to an already existing AlgorithmID. With JDK 1.2 the SUN provider, for instance, has changed the algorithm oid of the DSA algorithm from 1.3.14.3.2.12 to 1.2.840.10040.4.1, whereas IAIK continues to use 1.3.14.3.2.12. An application wishing to use the new OID, can allocate it by using this method, e.g.:
```
 AlgorithmID.changeOIDString(AlgorithmID.dsa, "1.2.840.10040.4.1");
 
```
    This method adopts any registered name and shortName from the old object identifier; and only changes the OID string. To set an entire new object identifier, use method changeObjectID(AlgorithmID, ObjectID).
    Parameters:
    algID - the AlgorithmID to which a new OID shall be allocated
    oidString - the new object identifier
    
    Returns:
    true if the OID successfully has been changed, false otherwise
  - decode
```
public void decode(ASN1Object algorithmID)
            throws CodingException
```
    Decodes an AlgorithmID from the given ASN1Object.
    The supplied ASN1Object represents an already existing AlgorithmID that may have been created by means of the toASN1Object()method.
    
    Specified by:
    
    decode in interface ASN1Type
    
    Parameters:
    algorithmID - the AlgorithmID as ASN1Object
    
    Throws:
    
    CodingException - if the ASN1Object is no AlgorithmID
  - encodeAbsentParametersAsNull
```
public void encodeAbsentParametersAsNull(boolean useNULLForAbsentParameters)
```
    Decide whether to encode absent parameters as NULL or omit the parameters field.
    An application (e.g. X.509) may require to omit the parameters field in the AlgorihmID encoding of some specific algorithm (e.g. dsaWithSHA1, ecdsaWithSHA1) if no parameters are set. This method may be used to decide whether absent parameters shall be encoded as ASN.1 NULL object or shall be omitted from the encoding at all. Note that per default absent parameters are encoded as NULL by the static registered AlgorithmIDs of this class, except for those algorithms (like dsaWithSHA1, ecdsaWithSHA1) where it is explicitly announced by the Javadoc that absent parameters are omitted.
    
    Parameters:
    useNULLForAbsentParameters - true if absent parameters shall be encoded as NULL, false if absent parameters shall be omitted from the encoding
  - toASN1Object
```
public ASN1Object toASN1Object()
```
    Returns the AlgorithmID as an (SEQUENCE) ASN1Object.
    
    Specified by:
    
    toASN1Object in interface ASN1Type
    
    Returns:
    the AlgorithmID as ASN1Object
    See Also:
    SEQUENCE
  - toASN1Object
```
public ASN1Object toASN1Object(boolean useNULLForAbsentParameters)
```
    Returns the AlgorithmID as an (SEQUENCE) ASN1Object.
    
    Returns:
    the AlgorithmID as ASN1Object
  - getImplementationName
```
public java.lang.String getImplementationName()
                                       throws java.security.NoSuchAlgorithmException
```
    Returns the name for an implementation of this algorithm.
    
    Returns:
    the name for an implementation e.g. "DES/CBC"
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no name for the implementation
  - getInstance
```
public java.lang.Object getInstance()
                             throws java.security.NoSuchAlgorithmException
```
    Tries to find an implementation for this AlgorithmIdentifier. This method calls the getInstance() methods in the following order:
    - MessageDigest
    - Signature
    - Cipher
    - KeyAgreement
    - KeyFactory
    Returns:
    an instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no implementation
  - getInstance
```
public java.lang.Object getInstance(java.lang.String provider)
                             throws java.security.NoSuchAlgorithmException
```
    Tries to find a provider specific implementation for this AlgorithmIdentifier. This method calls the getInstance() methods in the following order:
    - MessageDigest
    - Signature
    - Cipher
    - KeyAgreement
    - KeyFactory
    Parameters:
    provider - the name of the requested provider
    
    Returns:
    an instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no implementation
  - getCipherInstance
```
public javax.crypto.Cipher getCipherInstance()
                                      throws java.security.NoSuchAlgorithmException
```
    Tries to find a Cipher implementation for this AlgorithmIdentifier. This method calls Cipher.getInstance(algorithm) by substituting the algorithmID's
    - implementationName
    - OID name
    - OID string
    for the algorithm parameter in Cipher.getInstance(algorithm).
    Returns:
    an Cipher instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no Cipher implementation
  - getCipherInstance
```
public javax.crypto.Cipher getCipherInstance(java.lang.String provider)
                                      throws java.security.NoSuchAlgorithmException
```
    Tries to find a provider-specific Cipher implementation for this AlgorithmIdentifier. This method calls Cipher.getInstance(algorithm, provider) by substituting the algorithmID's
    - implementationName
    - OID name
    - OID string
    for the algorithm parameter in Cipher.getInstance(algorithm, provider).
    Parameters:
    provider - the name of the requested provider
    
    Returns:
    an Cipher instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no Cipher implementation
  - getSignatureInstance
```
public java.security.Signature getSignatureInstance()
                                             throws java.security.NoSuchAlgorithmException
```
    Tries to find a Signature implementation for this AlgorithmIdentifier. This method calls Signature.getInstance(algorithm) by substituting the algorithmID's
    - OID string
    - OID name
    - implementationName
    for the algorithm parameter in Signature.getInstance(algorithm).
    Returns:
    a Signature instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no Signature implementation
  - getSignatureInstance
```
public java.security.Signature getSignatureInstance(java.lang.String provider)
                                             throws java.security.NoSuchAlgorithmException
```
    Tries to find a provider-specific Signature implementation for this AlgorithmIdentifier. This method calls Signature.getInstance(algorithm,provider) by substituting the algorithmID's
    - OID string
    - OID name
    - implementationName
    for the algorithm parameter in Signature.getInstance(algorithm,provider).
    Parameters:
    provider - the name of the requested provider
    
    Returns:
    a Signature instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no Signature implementation
  - initSignatureVerify
```
public void initSignatureVerify(java.security.Signature signatureAlg,
                       java.security.PublicKey verificationKey)
                         throws java.security.InvalidAlgorithmParameterException,
                                java.security.InvalidKeyException
```
    Initializes a Signature algorithm instance for verification with the specified verification public key and algorithm parameters from the Algorithm Identifier.
    For an Algorithm Identifier that contains algorithms parameters, these parameters are extracted, decoded, and set in the Signature algorithm instance prior to initialization. This ensures that the algorithm parameters specified inside an Algorithm Identifier are actually used during signature verification; some signature algorithms require algorithm parameters (ex: RSA-PSS).
    
    This API was introduced to provide better support for the RSA-PSS signature algorithm, which requires algorithm parameters. It is used throughout the Toolkit for signature verification purposes. It should be used in conjunction with the getSignatureInstance() or getSignatureInstance(String) APIs to instantiate and then initialize a Signature algorithm instance.
    
    Important:
    
    The JCA Signature class was not designed to allow algorithm parameters to be set in a provider independent manner; the Signature class only accepts algorithm parameters in AlgorithmParameterSpec format. This API extracts the algorithm parameters from the Algorithm Identifier in DER encoded ASN.1 format and then converts them to one of Entrust's AlgorithmParameterSpec implementations. (The actual AlgorithmParameterSpec used are registered in Entrust's AlgorithmID class, for more details refer to AlgorithmID.getAlgorithmParameterSpec()). These implementations will most likely only be compatible with Entrust's Signature algorithm implementations. For this reason, when using this API to instantiate and initialize a Signature algorithm instance from a non-Entrust JCA/JCE cryptographic service provider, and algorithm parameters are specified in the Algorithm Identifier, an InvalidAlgorithmParameterException may result.
    
    Parameters:
    signatureAlg - the Signature algorithm implementation to be initialized for verification
    verificationKey - the public verification key
    
    Throws:
    
    java.security.InvalidKeyException - if the public verification key is not appropriate for the Signature algorithm implementation
    
    java.security.InvalidAlgorithmParameterException - if the algorithm parameters are not supported by the Signature algorithm implementation or the algorithm parameters could not be converted from DER encoded ASN.1 format to AlgorithmParameterSpec format
    Since:
    
    7.2 patch
  - initSignatureSign
```
public void initSignatureSign(java.security.Signature signatureAlg,
                     java.security.PrivateKey signingKey)
                       throws java.security.InvalidAlgorithmParameterException,
                              java.security.InvalidKeyException
```
    Initializes a Signature algorithm instance for signing with the specified signing private key and algorithm parameters from the Algorithm Identifier.
    For an Algorithm Identifier that contains algorithms parameters, these parameters are extracted, decoded, and set in the Signature algorithm instance prior to initialization. This ensures that the algorithm parameters specified inside an Algorithm Identifier are actually used during signature generation (some signature algorithms require algorithm parameters).
    
    After the Signature algorithm instance has been initialized, the algorithm parameters it is configured to use are extracted, encoded, and stored back in Algorithm Identifier. This ensures that the algorithm parameters that are actually used by the Signature algorithm implementation are not discarded. This is important for signature algorithms that automatically generate their own default parameters when none are provided (ex: RSA-PSS).
    
    This API was introduced to provide better support for the RSA-PSS signature algorithm, which requires algorithm parameters. It is used throughout the Toolkit for signature generation purposes. It should be used in conjunction with the getSignatureInstance() or getSignatureInstance(String) APIs to instantiate and then initialize a Signature algorithm instance.
    
    Important:
    
    The JCA Signature class was not designed to allow algorithm parameters to be set in a provider independent manner; the Signature class only accepts algorithm parameters in AlgorithmParameterSpec format. This API extracts the algorithm parameters from the Algorithm Identifier in DER encoded ASN.1 format and then converts them to one of Entrust's AlgorithmParameterSpec implementations. (The actual AlgorithmParameterSpec used are registered in Entrust's AlgorithmID class, for more details refer to AlgorithmID.getAlgorithmParameterSpec()). These implementations will most likely only be compatible with Entrust's Signature algorithm implementations. For this reason, when using this API to instantiate and initialize a Signature algorithm instance from a non-Entrust JCA/JCE cryptographic service provider, and algorithm parameters are specified in the Algorithm Identifier, an InvalidAlgorithmParameterException may result.
    
    Parameters:
    signatureAlg - the Signature algorithm implementation to be initialized for signing
    signingKey - the private signing key
    
    Throws:
    
    java.security.InvalidKeyException - if the private signing key is not appropriate for the Signature algorithm implementation
    
    java.security.InvalidAlgorithmParameterException - if the algorithm parameters are not supported by the Signature algorithm implementation or the algorithm parameters could not be converted from DER encoded ASN.1 format to AlgorithmParameterSpec format
    Since:
    
    7.2 patch
  - toEntrustAlgorithmID
```
public AlgorithmID toEntrustAlgorithmID()
```
    Converts an IAIK Algorithm Identifier to an Entrust Algorithm Identifier.
    The Algorithm Identifier components (identifier and parameters) are passed by reference (a deep copy of the elements is not done).
    
    Returns:
    the Entrust Algorithm Identifier
    Since:
    
    7.2 patch
  - getMessageDigestInstance
```
public java.security.MessageDigest getMessageDigestInstance()
                                                     throws java.security.NoSuchAlgorithmException
```
    Tries to find a MessageDigest implementation for this AlgorithmIdentifier.
    This method requests a MessageDigest instance from the JCA/JCE; it attempts each of the following algorithm name representations using the following providers in order (the first implementation that is found is returned):
    Algorithm Name Order
    - implementation name
    - OID name
    - OID string
    Provider Order
    - Entrust
    - IAIK
    - default provider order
    Returns:
    the message digest implementation for the requested algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if an implementation of the message digest algorithm could not be obtained from any of the installed providers
  - getMessageDigestInstance
```
public java.security.MessageDigest getMessageDigestInstance(java.lang.String provider)
                                                     throws java.security.NoSuchAlgorithmException
```
    Tries to find a MessageDigest implementation for this AlgorithmIdentifier.
    This method requests a MessageDigest instance from the JCA/JCE; it attempts each of the following algorithm name representations using the specifeid provider in order (the first implementation that is found is returned):
    Algorithm Name Order
    - implementation name
    - OID name
    - OID string
    Parameters:
    provider - the name of the requested provider
    
    Returns:
    the message digest implementation for the requested algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if an implementation of the message digest algorithm could not be obtained from the specified provider
  - getKeyAgreementInstance
```
public javax.crypto.KeyAgreement getKeyAgreementInstance()
                                                  throws java.security.NoSuchAlgorithmException
```
    Tries to find a KeyAgreement implementation for this AlgorithmIdentifier. This method calls KeyAgreement.getInstance(algorithm) by substituting the algorithmID´s
    - implementationName
    - OID name
    - OID string
    for the algorithm parameter in KeyAgreement.getInstance(algorithm).
    Returns:
    a KeyAgreement instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no KeyAgreement implementation
  - getKeyAgreementInstance
```
public javax.crypto.KeyAgreement getKeyAgreementInstance(java.lang.String provider)
                                                  throws java.security.NoSuchAlgorithmException
```
    Tries to find a provider-specific KeyAgreement implementation for this AlgorithmIdentifier. This method calls KeyAgreement.getInstance(algorithm,provider) by substituting the algorithmID´s
    - implementationName
    - OID name
    - OID string
    for the algorithm parameter in KeyAgreement.getInstance(algorithm,provider).
    Parameters:
    provider - the name of the requested provider
    
    Returns:
    a KeyAgreement instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no KeyAgreement implementation
  - getKeyFactoryInstance
```
public java.security.KeyFactory getKeyFactoryInstance()
                                               throws java.security.NoSuchAlgorithmException
```
    Tries to find a KeyFactory implementation for this AlgorithmIdentifier. This method calls KeyFactory.getInstance(algorithm) by substituting the algorithmID´s
    - implementationName
    - OID name
    - OID string
    for the algorithm parameter in KeyFactory.getInstance(algorithm).
    Returns:
    a KeyFactory instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no KeyFactory implementation
  - getKeyFactoryInstance
```
public java.security.KeyFactory getKeyFactoryInstance(java.lang.String provider)
                                               throws java.security.NoSuchAlgorithmException
```
    Tries to find a provider-specific KeyFactory implementation for this AlgorithmIdentifier. This method calls KeyFactory.getInstance(algorithm,provider) by substituting the algorithmID´s
    - implementationName
    - OID name
    - OID string
    for the algorithm parameter in KeyFactory.getInstance(algorithm,provider).
    Parameters:
    provider - the name of the requested provider
    
    Returns:
    a KeyFactory instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no KeyFactory implementation
  - getKeyPairGeneratorInstance
```
public java.security.KeyPairGenerator getKeyPairGeneratorInstance()
                                                           throws java.security.NoSuchAlgorithmException
```
    Tries to find a KeyPairGenerator implementation for this AlgorithmIdentifier. This method calls KeyPairGenerator.getInstance(algorithm) by substituting the algorithmID´s
    - implementationName
    - OID name
    - OID string
    for the algorithm parameter in KeyPairGenerator.getInstance(algorithm).
    Returns:
    a KeyPairGenerator instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no KeyPairGenerator implementation
  - getKeyPairGeneratorInstance
```
public java.security.KeyPairGenerator getKeyPairGeneratorInstance(java.lang.String provider)
                                                           throws java.security.NoSuchAlgorithmException
```
    Tries to find a provider-specific KeyPairGenerator implementation for this AlgorithmID.
    This method calls KeyPairGenerator.getInstance(algorithm,provider) by substituting the algorithmID´s
    - implementationName
    - OID name
    - OID string
    for the algorithm parameter in KeyPairGenerator.getInstance(algorithm,provider).
    Parameters:
    provider - the name of the requested provider
    
    Returns:
    a KeyPairGenerator instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no KeyPairGenerator implementation
  - getKeyGeneratorInstance
```
public javax.crypto.KeyGenerator getKeyGeneratorInstance()
                                                  throws java.security.NoSuchAlgorithmException
```
    Tries to find a KeyGenerator implementation for this AlgorithmIdentifier. This method calls KeyGenerator.getInstance(algorithm) by substituting the algorithmID´s
    - raw implementationName
    - OID name
    - OID string
    - implementationName
    for the algorithm parameter in KeyGenerator.getInstance(algorithm).
    Returns:
    a KeyGenerator instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no KeyGenerator implementation
  - getKeyGeneratorInstance
```
public javax.crypto.KeyGenerator getKeyGeneratorInstance(java.lang.String provider)
                                                  throws java.security.NoSuchAlgorithmException
```
    Tries to find a provider-specific KeyGenerator implementation for this AlgorithmID.
    This method calls KeyGenerator.getInstance(algorithm,provider) by substituting the algorithmID´s
    - raw implementationName
    - OID name
    - OID string
    - implementationName
    for the algorithm parameter in KeyGenerator.getInstance(algorithm,provider).
    Parameters:
    provider - the name of the requested provider
    
    Returns:
    a KeyGenerator instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no KeyGenerator implementation
  - getSecretKeyFactoryInstance
```
public javax.crypto.SecretKeyFactory getSecretKeyFactoryInstance()
                                                          throws java.security.NoSuchAlgorithmException
```
    Tries to find a SecretKeyFactory implementation for this AlgorithmIdentifier. This method calls SecretKeyFactory.getInstance(algorithm) by substituting the algorithmID´s
    - raw implementationName
    - OID name
    - OID string
    - implementationName
    for the algorithm parameter in SecretKeyFactory.getInstance(algorithm).
    Returns:
    a SecretKeyFactory instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no SecretKeyFactory implementation
  - getSecretKeyFactoryInstance
```
public javax.crypto.SecretKeyFactory getSecretKeyFactoryInstance(java.lang.String provider)
                                                          throws java.security.NoSuchAlgorithmException
```
    Tries to find a provider-specific SecretKeyFactory implementation for this AlgorithmID.
    This method calls SecretKeyFactory.getInstance(algorithm,provider) by substituting the algorithmID´s
    - raw implementationName
    - OID name
    - OID string
    - implementationName
    for the algorithm parameter in SecretKeyFactory.getInstance(algorithm,provider).
    Parameters:
    provider - the name of the requested provider
    
    Returns:
    a SecretKeyFactory instance of the object which implements this algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there is no SecretKeyFactory implementation
  - getRawImplementationName
```
public java.lang.String getRawImplementationName()
                                          throws java.security.NoSuchAlgorithmException
```
    Tries to get the raw inplementation name of the algorithm this AlgorithmID represents.
    In some situations (e.g. for instantiating a KeyGenerator,...) it might be useful to know the implementation name of the algorithm only and not whole the implementation name which -- in the case of ciphers -- may represent the whole transformation string required when creating the corresponding Cipher object. The, for instance, implementation name for DES-CBC may be "DES/CBC/PKC5Padding" which may be suitable for creating a Cipher object, but not for creating a key generator where only "DES" is required as returned by this method.
    
    Returns:
    the raw implementation name of the algorithm this AlgorithmID represents
    
    Throws:
    
    java.security.NoSuchAlgorithmException
  - clone
```
public java.lang.Object clone()
```
    Returns a clone of this AlgorithmID. Shall be used when setting an algorithm parameter to an already defined AlgorithmID (e.g. AlgorithmID.rsa).
    
    Overrides:
    
    clone in class java.lang.Object
    
    Returns:
    a clone of this AlgorithmID
  - getAlgorithm
```
public ObjectID getAlgorithm()
```
    Returns the ObjectID of the algorithm.
    
    Returns:
    the ObjectID of the algorithm
    See Also:
    ObjectID
  - getParameter
```
public ASN1Object getParameter()
```
    Returns the parameters of the algorithm as ASN1Object.
    
    Returns:
    the parameters of the algorithm
  - getDecodedAbsentParameters
```
public boolean getDecodedAbsentParameters()
```
    This method is used to determine if the ASN1 Encoded version of the parameters were absent when this structure was decoded. If this value is set to true, the parameters were absent. If this value is false, the parameters were present. This parameter is only set when the AlgorithmID is constructed from an ASN1Object. The default is false.
  - getAlgorithmParameters
```
public java.security.AlgorithmParameters getAlgorithmParameters(java.lang.String algorithm)
                                                         throws java.security.NoSuchAlgorithmException
```
    Returns the parameters of the algorithm as java.security.AlgorithmParameters object.
    
    Parameters:
    algorithm - the name of the algorithm the parameters belong to
    
    Returns:
    the parameter of the algorithm
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there are no parameters to return
  - getAlgorithmParameters
```
public java.security.AlgorithmParameters getAlgorithmParameters(java.lang.String algorithm,
                                                       java.lang.String provider)
                                                         throws java.security.NoSuchAlgorithmException
```
    Returns the parameters of the algorithm as java.security.AlgorithmParameters object.
    
    Parameters:
    algorithm - the name of the algorithm the parameters belong to
    provider - the name of the cryptography provider from which the AlgorithmParameters object should be created
    
    Returns:
    the algorithm parameters
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there are no parameters to return
  - getAlgorithmParameters
```
public java.security.AlgorithmParameters getAlgorithmParameters()
                                                         throws java.security.NoSuchAlgorithmException
```
    Returns the parameters of the algorithm as java.security.AlgorithmParameters object.
    In contrast to method getAlgorithmParameters(String algorithm) where the name used for instantiating the required AlgorithmParameters engine has to be supplied, this method tries to get the name from the raw implementation name.
    
    Returns:
    the algorithm parameters or null if no parameters are included
    
    Throws:
    
    java.security.NoSuchAlgorithmException - if there are no parameters to return
  - setAlgorithmParameters
```
public void setAlgorithmParameters(java.security.AlgorithmParameters parameters)
```
    Sets the parameters of the algorithm. The parameters have to be specified as java.security.AlgorithmParameters object.
    
    Parameters:
    parameters - the parameters of the algorithm
  - setParameter
```
public void setParameter(ASN1Object parameters)
```
    Sets the parameters of the algorithm. The parameters have to be specified as ASN1Object.
    
    Parameters:
    parameters - the parameters of the algorithm
  - getName
```
public java.lang.String getName()
```
    Returns the name registered for this AlgorithmID or the object identifier string if there is no name registered.
    
    Returns:
    the name of this AlgorithmID or the ObjectID string if no name is registered.
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Compares this AlgorithmID with the given AlgorithmID.
    
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    obj - the other AlgorithmID
    
    Returns:
    true, if the two AlgorithmIDs are equal, false otherwise
  - toString
```
public java.lang.String toString()
```
    Returns a string that represents this AlgorithmIdentifier.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    the string representation

Class AlgorithmID

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

implementations

dhKeyAgreement

esdhKeyAgreement

esdh

rsaEncryption

rsaESOAEP

mgf1

md2WithRSAEncryption

md4WithRSAEncryption

md5WithRSAEncryption

sha1WithRSAEncryption

sha512WithRSAEncryption

sha384WithRSAEncryption

sha256WithRSAEncryption

sha224WithRSAEncryption

dsa

dsaX957

dsaWithSHA

dsaWithSHA1

dsa_With_SHA1

ecdsaWithSHA1

ecdsa_with_Recommended

ecdsa_with_Specified

ecdsa_with_Sha224

ecdsa_with_Sha256

ecdsa_with_Sha384

ecdsa_with_Sha512

pbeWithMD5AndDES_CBC

pbkdf2

pbeWithSHAAnd128BitRC4

pbeWithSHAAnd40BitRC4

pbeWithSHAAnd3_KeyTripleDES_CBC

pbeWithSHAAnd2_KeyTripleDES_CBC

pbeWithSHAAnd128BitRC2_CBC

pbeWithSHAAnd40BitRC2_CBC

rsa

rc2_CBC

rc4

des_EDE3_CBC

des_CBC

idea_CBC

cast5_CBC

cast3_CBC

rc5_CBC

aes_128_ECB

aes_128_CBC

aes_192_ECB

aes_192_CBC

aes_256_ECB

aes_256_CBC

md2

md4

md5

sha

sha1

sha224

sha256

sha384

sha512

cms_3DES_wrap

cms_rc2_wrap

cms_pwri_kek

cms_idea_wrap

cms_cast5_wrap

cms_cast_wrap

id_ecPublicKey

dhSinglePass_stdDH_sha1kdf_scheme

dhSinglePass_stdDH_sha256kdf_scheme

dhSinglePass_stdDH_sha224kdf_scheme

dhSinglePass_stdDH_sha384kdf_scheme

dhSinglePass_stdDH_sha512kdf_scheme

dhSinglePass_cofactorDH_sha1kdf_scheme

dhSinglePass_cofactorDH_sha224kdf_scheme

dhSinglePass_cofactorDH_sha256kdf_scheme