Java Security Standard Algorithm Names

The Java SE Security API requires and uses a set of standard names for algorithms, certificate and keystore types. You can find a list of standard algorithm names in this document.

Note that an SE implementation may support additional algorithms that are not defined in this specification. As a best practice, if an algorithm is defined in a subsequent version of this specification and an implementation of an earlier specification supports that algorithm, the implementation should use the standard name of the algorithm that is defined in the subsequent specification. Each SE implementation should also document the algorithms that it supports or adds support for in subsequent update releases. The algorithms may be documented in release notes or in a separate document such as the JDK Providers Documentation.

In some cases naming conventions are given for forming names that are not explicitly listed, to facilitate name consistency across provider implementations. Items in angle brackets (such as <digest> and <encryption>) are placeholders to be replaced by a specific message digest, encryption algorithm, or other name.

Note: Standard names are not case-sensitive.

Note: The JDK Providers Documentation contains specific provider and algorithm information.

AlgorithmParameterGenerator Algorithms

The algorithm names in this section can be specified when generating an instance of AlgorithmParameterGenerator.

AlgorithmParameters Algorithms

The algorithm names in this section can be specified when generating an instance of AlgorithmParameters.

CertificateFactory Types

The type in this section can be specified when generating an instance of CertificateFactory.

CertPath Encodings

The following encodings may be passed to the getEncoded method of CertPath or the generateCertPath(InputStream inStream, String encoding) method of CertificateFactory.

CertPathBuilder Algorithms

The algorithm in this section can be specified when generating an instance of CertPathBuilder.

CertPathValidator Algorithms

The algorithm in this section can be specified when generating an instance of CertPathValidator.

CertStore Types

The types in this section can be specified when generating an instance of CertStore.

Cipher Algorithm Names

The following names can be specified as the algorithm component in a transformation when requesting an instance of Cipher.

Note: It is recommended to use a transformation that fully specifies the algorithm, mode, and padding. By not doing so, the provider will use a default for the mode and padding which may not meet the security requirements of your application.

Cipher Algorithm Modes

The following names can be specified as the mode component in a transformation when requesting an instance of Cipher.

Cipher Algorithm Paddings

The following names can be specified as the padding component in a transformation when requesting an instance of Cipher.

Configuration Types

The type in this section can be specified when generating an instance of javax.security.auth.login.Configuration.

Exemption Mechanisms

The following exemption mechanism names can be specified in the permission policy file that accompanies an application considered "exempt" from cryptographic restrictions.

GSSAPI Mechanisms

The following mechanisms can be specified when using GSSAPI. Note that Object Identifiers (OIDs) are specified instead of names to be consistent with the GSSAPI standard.

KeyAgreement Algorithms

The following algorithm names can be specified when requesting an instance of KeyAgreement.

KeyFactory Algorithms

The algorithm names in this section can be specified when generating an instance of KeyFactory.

(Except as noted, these classes create keys for which Key.getAlgorithm() returns the standard algorithm name.)

KeyGenerator Algorithms

The following algorithm names can be specified when requesting an instance of KeyGenerator.

(These classes generate keys for which Key.getAlgorithm() returns the standard algorithm name.)

KeyManagerFactory Algorithms

The algorithm names that can be specified when generating an instance of KeyManagerFactory.

KeyPairGenerator Algorithms

The algorithm names that can be specified when generating an instance of KeyPairGenerator.

(Except as noted, these classes create keys for which Key.getAlgorithm() returns the standard algorithm name.)

KeyStore Types

The types in this section can be specified when generating an instance of KeyStore.

Mac Algorithms

The following algorithm names can be specified when requesting an instance of Mac.

MessageDigest Algorithms

Algorithm names that can be specified when generating an instance of MessageDigest.

ParameterSpec Names

The NamedParameterSpec class in the java.security.spec package may be used to specify a set of parameters using the following names.

The ECGenParameterSpec class in the java.security.spec package may be used to specify a set of elliptic curve parameters using the following names.

Policy Types

The type in this section can be specified when generating an instance of Policy.

SaslClient Mechanisms

The mechanisms in this section can be specified when generating an instance of SaslClient.

SaslServer Mechanisms

The mechanisms in this section can be specified when generating an instance of SaslServer.

SecretKeyFactory Algorithms

The following algorithm names can be specified when requesting an instance of SecretKeyFactory.

(These classes create keys for which Key.getAlgorithm() returns the standard algorithm name.)

SecureRandom Number Generation Algorithms

The algorithm names in this section can be specified when generating an instance of SecureRandom.

Service Attributes

The attributes in this section are for cryptographic services. The service attributes can be used as filters for selecting providers.

A cryptographic service is always associated with a particular algorithm or type. For example, a digital signature service is always associated with a particular algorithm (for example, DSA), and a CertificateFactory service is always associated with a particular certificate type (for example, X.509).

Note: The attribute name and value are case-insensitive.

For example,

    map.put("KeyPairGenerator.DSA",
            "sun.security.provider.DSAKeyPairGenerator");
    map.put("KeyPairGenerator.DSA KeySize", "2048");
    map.put("KeyPairGenerator.DSA ImplementedIn", "Software");

Signature Algorithms

The algorithm names in this section can be specified when generating an instance of Signature.

SSLContext Algorithms

The algorithm names in this section can be specified when generating an instance of SSLContext.

TrustManagerFactory Algorithms

The algorithm name in this section can be specified when generating an instance of TrustManagerFactory.

XML Signature (XMLSignatureFactory/KeyInfoFactory/TransformService) Mechanisms

The mechanism that can be specified when generating an instance of XMLSignatureFactory, KeyInfoFactory, or TransformService.

The mechanism identifies the XML processing mechanism that an implementation uses internally to parse and generate XML signature and KeyInfo structures. Also, note that each TransformService instance supports a specific transform algorithm in addition to a mechanism. The standard names for the transform algorithms are defined in the next section.

XML Signature Transform (TransformService) Algorithms

The algorithms in this section can be specified when generating an instance of TransformService.

Note: The URIs are specified instead of names to be consistent with the XML Signature standard. API constants have been defined for each URI, and are listed in parentheses after each URI in the following table.

JSSE Cipher Suite Names

The following table contains the standard JSSE cipher suite names. Over time, various groups have added additional cipher suites to the SSL/TLS/DTLS namespace.

Some JSSE cipher suite names were defined before TLSv1.0 was finalized, and were therefore given the SSL_ prefix. The names mentioned in the TLS RFCs prefixed with TLS_ are functionally equivalent to the JSSE cipher suites prefixed with SSL_.

Additional JSSE Standard Names

Key Types

The keyType parameter passed to the chooseClientAlias, chooseServerAlias, getClientAliases, and getServerAliases methods of X509KeyManager specifies the public key types.

Each row of the table that follows lists the standard name that should be used for keyType, given the specified certificate type.

Protocols

The protocols parameter passed to the setEnabledProtocols method of SSLSocket and SSLEngine specifies the protocol versions to be enabled for use on the connection. The table that follows lists the standard names that can be passed to the setEnabledProtocols method or that may be returned by the getSupportedProtocols and getEnabledProtocols methods of SSLSocket and SSLEngine.

These names also apply to the protocol parameter returned from the getProtocol method of SSLSession, and the protocols parameter passed to the setProtocols method or that may be returned by the getProtocols method of SSLParameters.

Authentication Types

The authType parameter passed to the checkClientTrusted and checkServerTrusted methods of X509TrustManager indicates the authentication type. The table that follows specifies what standard names should be used for the client or server certificate chains.

Endpoint Identification Algorithms

The endpoint identification algorithm indicates the endpoint identification or verification procedures during SSL/TLS/DTLS handshaking. The algorithm name can be passed to the setEndpointIdentificationAlgorithm method of javax.net.ssl.SSLParameters.

The following table shows the standard endpoint identification names.

Signature Schemes

The following table contains the standard signature scheme names, which are the algorithms used in the digital signatures of TLS connections and are also defined in the SignatureScheme section of the IANA TLS Registry.

Named Groups

The following table contains the standard group names, which are the named groups used in key exchange algorithms of TLS connections and are also defined in the Supported Groups section of the IANA TLS Registry.

Security Algorithm Specification

This section specifies details concerning some of the algorithms defined in this document. Any provider supplying an implementation of the listed algorithms must comply with the specifications in this section.

Specification Template

The following table shows the fields of the algorithm specifications.

Algorithm Specifications

The following are the parameter values for keysizes of 512, 768, and 1024 bits:

512-bit Key Parameters

 SEED =
     b869c82b 35d70e1b 1ff91b28 e37a62ec dc34409b
 counter = 123
 p =
     fca682ce 8e12caba 26efccf7 110e526d b078b05e decbcd1e b4a208f3
     ae1617ae 01f35b91 a47e6df6 3413c5e1 2ed0899b cd132acd 50d99151
     bdc43ee7 37592e17
 q =
     962eddcc 369cba8e bb260ee6 b6a126d9 346e38c5
 g =
     678471b2 7a9cf44e e91a49c5 147db1a9 aaf244f0 5a434d64 86931d2d
     14271b9e 35030b71 fd73da17 9069b32e 2935630e 1c206235 4d0da20a
     6c416e50 be794ca4

768-bit key parameters

 SEED =
     77d0f8c4 dad15eb8 c4f2f8d6 726cefd9 6d5bb399
 counter = 263
 p =
     e9e64259 9d355f37 c97ffd35 67120b8e 25c9cd43 e927b3a9 670fbec5
     d8901419 22d2c3b3 ad248009 3799869d 1e846aab 49fab0ad 26d2ce6a
     22219d47 0bce7d77 7d4a21fb e9c270b5 7f607002 f3cef839 3694cf45
     ee3688c1 1a8c56ab 127a3daf
 q =
     9cdbd84c 9f1ac2f3 8d0f80f4 2ab952e7 338bf511
 g =
     30470ad5 a005fb14 ce2d9dcd 87e38bc7 d1b1c5fa cbaecbe9 5f190aa7
     a31d23c4 dbbcbe06 17454440 1a5b2c02 0965d8c2 bd2171d3 66844577
     1f74ba08 4d2029d8 3c1c1585 47f3a9f1 a2715be2 3d51ae4d 3e5a1f6a
     7064f316 933a346d 3f529252

1024-bit key parameters

 SEED =
     8d515589 4229d5e6 89ee01e6 018a237e 2cae64cd
 counter = 92
 p =
     fd7f5381 1d751229 52df4a9c 2eece4e7 f611b752 3cef4400 c31e3f80
     b6512669 455d4022 51fb593d 8d58fabf c5f5ba30 f6cb9b55 6cd7813b
     801d346f f26660b7 6b9950a5 a49f9fe8 047b1022 c24fbba9 d7feb7c6
     1bf83b57 e7c6a8a6 150f04fb 83f6d3c5 1ec30235 54135a16 9132f675
     f3ae2b61 d72aeff2 2203199d d14801c7
 q =
     9760508f 15230bcc b292b982 a2eb840b f0581cf5
 g =
     f7e1a085 d69b3dde cbbcab5c 36b857b9 7994afbb fa3aea82 f9574c0b
     3d078267 5159578e bad4594f e6710710 8180b449 167123e8 4c281613
     b7cf0932 8cc8a6e1 3c167a8b 547c8d28 e0a3ae1e 2bb3a675 916ea37f
     0bfa2135 62f1fb62 7a01243b cca4f1be a8519089 a883dfe1 5ae59f06
     928b665e 807b5525 64014c3b fecf492a

The following are the default values for larger DSA key sizes identified by (L,N) pairs:

(L,N) = (2048, 256)

 SEED =
     b0b44176 01b59cbc 9d8ac8f9 35cadaec 4f5fbb2f 23785609 ae466748
     d9b5a536
 counter = 497
 p =
     95475cf5 d93e596c 3fcd1d90 2add02f4 27f5f3c7 210313bb 45fb4d5b
     b2e5fe1c bd678cd4 bbdd84c9 836be1f3 1c077772 5aeb6c2f c38b85f4
     8076fa76 bcd8146c c89a6fb2 f706dd71 9898c208 3dc8d896 f84062e2
     c9c94d13 7b054a8d 8096adb8 d5195239 8eeca852 a0af12df 83e475aa
     65d4ec0c 38a9560d 5661186f f98b9fc9 eb60eee8 b030376b 236bc73b
     e3acdbd7 4fd61c1d 2475fa30 77b8f080 467881ff 7e1ca56f ee066d79
     506ade51 edbb5443 a563927d bc4ba520 08674617 5c888592 5ebc64c6
     14790677 3496990c b714ec66 7304e261 faee33b3 cbdf008e 0c3fa906
     50d97d39 09c9275b f4ac86ff cb3d03e6 dfc8ada5 934242dd 6d3bcca2
     a406cb0b
 q =
     f8183668 ba5fc5bb 06b5981e 6d8b795d 30b8978d 43ca0ec5 72e37e09
     939a9773
 g =
     42debb9d a5b3d88c c956e087 87ec3f3a 09bba5f4 8b889a74 aaf53174
     aa0fbe7e 3c5b8fcd 7a53bef5 63b0e985 60328960 a9517f40 14d3325f
     c7962bf1 e049370d 76d1314a 76137e79 2f3f0db8 59d095e4 a5b93202
     4f079ecf 2ef09c79 7452b077 0e135078 2ed57ddf 794979dc ef23cb96
     f1830619 65c4ebc9 3c9c71c5 6b925955 a75f94cc cf1449ac 43d586d0
     beee4325 1b0b2287 349d68de 0d144403 f13e802f 4146d882 e057af19
     b6f6275c 6676c8fa 0e3ca271 3a3257fd 1b27d063 9f695e34 7d8d1cf9
     ac819a26 ca9b04cb 0eb9b7b0 35988d15 bbac6521 2a55239c fc7e58fa
     e38d7250 ab9991ff bc971340 25fe8ce0 4c4399ad 96569be9 1a546f49
     78693c7a

(L,N) = (2048, 224)

 SEED =
     58423608 0cfa43c0 9b023541 35f4cc51 98a19efa da08bd86 6d601ba4
 counter = 2666
 p =
     8f7935d9 b9aae9bf abed887a cf4951b6 f32ec59e 3baf3718 e8eac496
     1f3efd36 06e74351 a9c41833 39b809e7 c2ae1c53 9ba7475b 85d011ad
     b8b47987 75498469 5cac0e8f 14b33608 28a22ffa 27110a3d 62a99345
     3409a0fe 696c4658 f84bdd20 819c3709 a01057b1 95adcd00 233dba54
     84b6291f 9d648ef8 83448677 979cec04 b434a6ac 2e75e998 5de23db0
     292fc111 8c9ffa9d 8181e733 8db792b7 30d7b9e3 49592f68 09987215
     3915ea3d 6b8b4653 c633458f 803b32a4 c2e0f272 90256e4e 3f8a3b08
     38a1c450 e4e18c1a 29a37ddf 5ea143de 4b66ff04 903ed5cf 1623e158
     d487c608 e97f211c d81dca23 cb6e3807 65f822e3 42be484c 05763939
     601cd667
 q =
     baf696a6 8578f7df dee7fa67 c977c785 ef32b233 bae580c0 bcd5695d
 g =
     16a65c58 20485070 4e7502a3 9757040d 34da3a34 78c154d4 e4a5c02d
     242ee04f 96e61e4b d0904abd ac8f37ee b1e09f31 82d23c90 43cb642f
     88004160 edf9ca09 b32076a7 9c32a627 f2473e91 879ba2c4 e744bd20
     81544cb5 5b802c36 8d1fa83e d489e94e 0fa0688e 32428a5c 78c478c6
     8d0527b7 1c9a3abb 0b0be12c 44689639 e7d3ce74 db101a65 aa2b87f6
     4c6826db 3ec72f4b 5599834b b4edb02f 7c90e9a4 96d3a55d 535bebfc
     45d4f619 f63f3ded bb873925 c2f224e0 7731296d a887ec1e 4748f87e
     fb5fdeb7 5484316b 2232dee5 53ddaf02 112b0d1f 02da3097 3224fe27
     aeda8b9d 4b2922d9 ba8be39e d9e103a6 3c52810b c688b7e2 ed4316e1
     ef17dbde

Security Algorithm Implementation Requirements

This section defines the security algorithm requirements for Java SE implementations. The security algorithm requirements are intended to improve the interoperability of Java SE implementations and applications that use these algorithms.

Note: The requirements in this section are not a measure of the strength or security of the algorithm. For example, recent advances in cryptanalysis have found weaknesses in the strength of the DESede (Triple DES) cipher algorithm. It is your responsibility to determine whether the algorithm meets the security requirements of your application.

Every implementation of this version of the Java SE platform must support the specified algorithms in the table that follows. These requirements do not apply to 3rd party providers. Consult the release documentation for your implementation to see if any other algorithms are supported.

[1] No specific Configuration type, Policy type or SecureRandom algorithm is required; however, an implementation-specific default must be provided.

XML Signature Algorithms

Every implementation of this version of the Java SE platform must support the specified XML Signature algorithms in the table that follows. These requirements do not apply to 3rd party providers. Consult the release documentation for your implementation to see if any other algorithms are supported.