The following pages contain documentation, example code, and ancillary files relating to IBM's SDKs. The documentation covers IBM-specific features of IBM's offerings. A platform-specific Security User Guide is included in each download. For information about the SDK for z/OS product and security components specific to that platform, see this Web site.
The Security API is a core API of the Java programming language, built around the java.security package (and its subpackages). This API is designed to allow developers to incorporate both low-level and high-level security functionality into their programs.
The first release of Security API in JDK 1.1 introduced the Java Cryptography Architecture (JCA), a framework for accessing and developing cryptographic functionality for the Java platform. In JDK 1.1, the JCA included APIs for digital signatures and message digests.
In subsequent releases, the Java 2 SDK significantly extended the Java Cryptography Architecture, as described in this document. It also upgraded the certificate management infrastructure to support X.509 v3 certificates, and introduced a new Java Security Architecture for fine-grain, highly configurable, flexible, and extensible access control.
The Java Cryptography Architecture encompasses the parts of the Java 2 SDK Security API related to cryptography, as well as a set of conventions and specifications provided in this document. It includes a "provider" architecture that allows for multiple and interoperable cryptography implementations.
The Java Cryptography Extension (JCE) extends the JCA API to include APIs for encryption, key exchange, and Message Authentication Code (MAC). Together, the JCE and the cryptography aspects of the SDK provide a complete, platform-independent cryptography API. JCE was previously an optional package (extension) to the Java 2 SDK, Standard Edition, versions 1.2.x and 1.3.x. JCE has now been integrated into the Java 2 SDK, v 1.4.
The Java Cryptography Architecture (JCA) was designed around these principles:
Implementation independence and interoperability
Algorithm independence and extensibility
Implementation independence and algorithm independence are complementary; you can use cryptographic services, such as digital signatures and message digests, without worrying about the implementation details or even the algorithms that form the basis for these concepts. When complete algorithm-independence is not possible, the JCA provides standardized, algorithm-specific APIs. When implementation-independence is not desirable, the JCA lets developers indicate a specific implementation.
Algorithm independence is achieved by defining types of cryptographic "engines" (services), and defining classes that provide the functionality of these cryptographic engines. These classes are called engine classes, and examples are the MessageDigest, Signature, KeyFactory, and KeyPairGenerator classes.
Implementation independence is achieved using a "provider"-based architecture. The term Cryptographic Service Provider (used interchangeably with "provider" in this document) refers to a package or set of packages that implement one or more cryptographic services, such as digital signature algorithms, message digest algorithms, and key conversion services. A program can simply request a particular type of object (such as a Signature object) that is implementing a particular service (such as the DSA signature algorithm) and get an implementation from one of the installed providers. If desired, a program can instead request an implementation from a specific provider. Providers can be updated transparently to the application, for example when faster or more secure versions are available.
Implementation interoperability means that various implementations can work with each other, use each other's keys, or verify each other's signatures. This interoperability would mean, for example, that for the same algorithms, a key generated by one provider would be usable by another, and a signature generated by one provider would be verifiable by another.
Algorithm extensibility means that new algorithms that fit in one of the supported engine classes can be added easily.
Architecture
Cryptographic Service Providers
The Java Cryptography Architecture introduced the notion of a Cryptographic Service Provider. This term refers to a package (or a set of packages) that supplies a concrete implementation of a subset of the cryptography aspects of the Security API.
For example, in JDK 1.1 a provider could contain an implementation of one or more digital signature algorithms, message digest algorithms, and key generation algorithms. Java 2 SDK adds five additional types of services: key factories, keystore creation and management, algorithm parameter management, algorithm parameter generation, and certificate factories. It also enables a provider to supply a random number generation (RNG) algorithm. Previously, RNGs were not provider-based; a particular algorithm was hard-coded in the JDK.
As previously noted, a program can simply request a particular type of object (such as a Signature object) for a particular service (such as the DSA signature algorithm) and get an implementation from one of the installed providers. Alternatively, the program can request the objects from a specific provider. (Each provider has a name used to refer to it.)
Previous versions of the Java runtime environment (1.2.x and 1.3.x) came with a default provider, named SUN. The 1.4 environment has replaced this provider with a number of new providers, including IBMJCE. The IBMJCE provider package includes:
An implementation of the Digital Signature Algorithm (DSA), described in NIST FIPS 186-2.
An implementation of the MD2, MD5 (RFC 1321), SHA-1 (FIPS 180-2), SHA-256, SHA-384, SHA-512 message digest algorithms.
A DSA key pair generator for generating a pair of public and private keys suitable for the DSA algorithm.
A DSA algorithm parameter generator.
A DSA algorithm parameter manager.
A DSA key factory providing bidirectional conversions between (opaque) DSA private and public key objects and their underlying key material.
An implementation of the proprietary "IBMSecureRandom" random number generation algorithm.
A keystore implementation for the proprietary keystore type named JKS.
Each SDK installation has one or more provider packages installed. New providers can be added statically or dynamically (see the Provider and Security classes). The Java Cryptography Architecture offers a set of APIs that allow users to query which providers are installed and what services they support.
Clients can configure their runtime with different providers, and specify a preference order for each of them. The preference order is the order in which providers are searched for requested services when no specific provider is requested.
Key Management
A database called a "keystore" can be used to manage a repository of keys and certificates. A keystore is available to applications that need it for authentication or signing purposes.
Applications can access a keystore via an implementation of the KeyStore class, which is in the java.security package. A default KeyStore implementation, called "JKS", is provided. It implements the keystore as a file, using a proprietary keystore type (format).
Applications can choose different types of keystore implementations from different providers, using the getInstance factory method supplied in the KeyStore class.
An engine class defines a cryptographic service in an abstract fashion (without a concrete implementation).
A cryptographic service is always associated with a particular algorithm or type, and it either provides cryptographic operations (such as those for digital signatures or message digests), generates or supplies the cryptographic material (keys or parameters) required for cryptographic operations, or generates data objects (keystores or certificates) that encapsulate cryptographic keys (that can be used in a cryptographic operation) in a secure fashion. For example, two of the engine classes are the Signature and KeyFactory classes. The Signature class provides access to the functionality of a digital signature algorithm. A DSA KeyFactory supplies a DSA private or public key (from its encoding or transparent specification) in a format usable by the initSign or initVerify methods, respectively, of a DSA Signature object.
The Java Cryptography Architecture encompasses the classes of the Java 2 SDK Security package related to cryptography, including the engine classes. Users of the API request and use instances of the engine classes to carry out corresponding operations. The following engine classes are defined in the Java 2 SDK:
MessageDigest: used to calculate the message digest (hash) of specified data.
Signature: used to sign data and verify digital signatures.
KeyPairGenerator: used to generate a pair of public and private keys suitable for a specified algorithm.
KeyFactory: used to convert opaque cryptographic keys of type Key into key specifications (transparent representations of the underlying key material), and vice versa.
CertificateFactory: used to create public key certificates and Certificate Revocation Lists (CRLs).
KeyStore: used to create and manage a keystore. A keystore is a database of keys. Private keys in a keystore have a certificate chain associated with them, that authenticates the corresponding public key. A keystore also contains certificates from trusted entities.
AlgorithmParameters: used to manage the parameters for a particular algorithm, including parameter encoding and decoding.
CertStore: used to retrieve Certificate objects and CRL objects from a repository.
Note: A generator creates objects with brand-new contents, whereas a factory creates objects from existing material (for example, an encoding).
An engine class provides the interface to the functionality of a specific type of cryptographic service (independent of a particular cryptographic algorithm). It defines Application Programming Interface (API) methods that allow applications to access the specific type of cryptographic service it provides. The actual implementations (from one or more providers) are those for specific algorithms. The Signature engine class, for example, provides access to the functionality of a digital signature algorithm. The actual implementation supplied in a SignatureSpi subclass would be that for a specific kind of signature algorithm, such as SHA-1 with DSA, SHA-1 with RSA, or MD5 with RSA.
The application interfaces supplied by an engine class are implemented in terms of a Service Provider Interface (SPI). That is, for each engine class, there is a corresponding abstract SPI class, which defines the SPI methods that cryptographic service providers must implement.
An instance of an engine class, the API object, encapsulates (as a private field) an instance of the corresponding SPI class, the SPI object. All API methods of an API object are declared final and their implementations invoke the corresponding SPI methods of the encapsulated SPI object. An instance of an engine class (and of its corresponding SPI class) is created by a call to the getInstance factory method of the engine class.
The name of each SPI class is the same as that of the corresponding engine class, followed by Spi. For example, the SPI class corresponding to the Signature engine class is the SignatureSpi class.
Each SPI class is abstract. To supply the implementation of a particular type of service, for a specific algorithm, a provider must subclass the corresponding SPI class and provide implementations for all the abstract methods.
Another example of an engine class is the MessageDigest class, which provides access to a message digest algorithm. Its implementations, in MessageDigestSpi subclasses, can be those of various message digest algorithms such as SHA-1, MD5, or MD2.
As a final example, the KeyFactory engine class supports the conversion from opaque keys to transparent key specifications, and vice versa. (See the Key Specification Interfaces and Classes section.) The KeyFactorySpi subclass supplies an actual implementation for a specific type of key, for example, DSA public and private keys.
Other providers might define their own implementations of these services or of other services.
Using Factory Methods to Obtain Implementation Instances
For each engine class in the API, a particular implementation is requested and instantiated by calling a factory method on the engine class. A factory method is a static method that returns an instance of a class.
The basic mechanism for obtaining an appropriate Signature object, for example, is as follows: A user requests such an object by calling the getInstance method in the Signature class, specifying the name of a signature algorithm (such as "SHA1withDSA"), and, optionally, the name of the provider or the Provider class. The getInstance method finds an implementation that satisfies the supplied algorithm and provider parameters. If no provider is specified, getInstance searches the registered providers, in preference order, for one with an implementation of the specified algorithm. See The Provider Class for more information about registering providers.
What's New in JCE in IBM SDK Java Technology Edition Version 6
From Java 6 service refresh 10, default key lengths are increased for the Digital Signature Algorithm (DSA), the Diffie-Hellman Algorithm (DH), the RSA Algorithm (RSA), and the Elliptic Curve Algorithms (ECDH/ECDSA) to conform to the NIST 800-131A recommendations.
The default value is used when no other value is specified. The changes to the default values are listed in the table:
Table 1. Default algorithm key lengths. .
Algorithm
Old default
New default
RSA
1024
2048
DSA/DH
1024
2048
ECDSA/ECDH
192
256
If you do not want to use the default key size for an algorithm, you must initialize the KeyPairGenerator instance with one of the initialize(...) methods, specifying the key size you want with the appropriate parameter. This key size is then used when generateKeyPair() is called.
Here are the differences in JCE between v5.0 and IBM SDK for Java 6:
CTS is described in Bruce Schneier's book "Applied Cryptography-Second Edition", John Wiley & Sons, 1996 (pg. 195-196), and is used by some Kerberos implementations.
Support for ISO10126Padding padding
This padding for block ciphers is described in 5.2 Block Encryption Algorithms in the W3C's "XML Encryption Syntax and Processing" document.
Support for PBKDF2HmacSHA1Factory and PBKDF2KeyImpl
Constructs secret keys using the Password-Based Key Derivation Function function found in PKCS5 v2.0.
Support for various TLS algorithms for use by JSSE
An exception will be thrown for zero-length plain-texts
An IllegalArgumentException will be thrown when attempting to encrypt the empty-String (""). This matches Sun functionality, though Sun currently throws a different and less intuitive error. In 5.0, this type of String would have been encrypted by the API.
Core Classes and Interfaces
The core classes and interfaces provided in the Java Cryptography Architecture are as follows:
This section shows the signatures of the main methods in each class and interface. Examples for some of these classes (MessageDigest, Signature, KeyPairGenerator, SecureRandom, KeyFactory, and key specification classes) are supplied in the corresponding Examples sections. The complete reference documentation for the relevant Security API packages can be found in:
A Provider is a package or set of packages that supplies a concrete implementation of a subset of the Java 2 SDK Security API cryptography features. The Providerclass is the interface to such a package or set of packages. It has methods for accessing the provider name, version number, and other information. In addition to registering implementations of cryptographic services, the Provider class can also be used to register implementations of other security services that might get defined as part of the Java 2 SDK Security API or one of its extensions.
To supply implementations of cryptographic services, an entity (such as a development group) writes the implementation code and creates a subclass of the Provider class. The constructor of the Provider subclass sets the values of various properties; the Java 2 SDK Security API uses these values to look up the services that the provider implements. In other words, the subclass specifies the names of the classes that are implementing the services.
There are several types of services that can be implemented by provider packages; for more information, see Engine Classes and Algorithms.
The different implementations might have different characteristics. Some might be software-based, while others might be hardware-based. Some might be platform-independent, while others might be platform-specific. Some provider source code might be available for review and evaluation, while some might not. The Java Cryptography Architecture (JCA) lets both end-users and developers decide what their needs are.
How Provider Implementations Are Requested and Supplied
For each engine class in the API, a particular implementation is requested and instantiated by calling a getInstance method on the engine class and by specifying the name of the desired algorithm and, optionally, the name of the provider (or the Provider class) whose implementation is desired.
If no provider is specified, getInstance searches the registered providers for an implementation of the requested cryptographic service associated with the named algorithm. In any given Java Virtual Machine (JVM), providers are installed in a given preference order, the order in which the provider list is searched if a specific provider is not requested. For example, suppose there are two providers installed in a JVM, PROVIDER_1 and PROVIDER_2. Assume that:
PROVIDER_1 implements SHA1withDSA, SHA-1, MD5, DES, and DES3.
PROVIDER_1 has preference order 1 (the highest priority).
If we are looking for an MD5 implementation, both providers supply such an implementation. The PROVIDER_1 implementation is returned because PROVIDER_1 has the highest priority and is searched first.
If we are looking for an MD5withRSA signature algorithm, PROVIDER_1 is first searched for it. No implementation is found, so PROVIDER_2 is searched. An implementation is found and returned.
Suppose we are looking for a SHA1withRSA signature algorithm. Because no installed provider implements it, a NoSuchAlgorithmException is thrown.
The getInstance methods that include a provider argument are for developers who want to specify which provider they want an algorithm from. A federal agency, for example, will want to use a provider implementation that has received federal certification. Let's assume that the SHA1withDSA implementation from PROVIDER_1 has not received such certification, while the DSA implementation of PROVIDER_2 has received it.
A federal agency program would then have the following call, specifying PROVIDER_2 since it has the certified implementation:
In this case, if PROVIDER_2 was not installed, a NoSuchProviderException would be thrown, even if another installed provider implements the algorithm requested.
A program also has the option of getting a list of all the installed providers (using the getProviders method in the Security class) and choosing one from the list.
Installing Providers
There are two parts to installing a provider:
Installing the provider package classes,
Configuring the provider.
Installing the Provider Classes
There are two possible ways to install the provider classes:
Place a zip or JAR file containing the classes anywhere in your classpath.
Supply your provider JAR file as an "installed" or "bundled" extension. For more information on how to deploy an extension, see How is an extension deployed?.
Configuring the Provider
The next step is to add the provider to your list of approved providers. This step can be done statically by editing the java.security file in the lib/security directory of the SDK; therefore, if the SDK is installed in a directory called j2sdk1.2, the file would be j2sdk1.2/lib/security/java.security. One of the types of properties you can set in java.security has the following form:
security.provider.n=masterClassName
This property declares a provider, and specifies its preference order n. The preference order is the order in which providers are searched for requested algorithms (when no specific provider is requested). The order is 1-based: 1 is the most preferred, followed by 2, and so on.
The masterClassName must specify the provider's master class. The provider's documentation will specify its master class. This class is always a subclass of the Provider class. The subclass constructor sets the values of various properties that are required for the Java Cryptography API to look up the algorithms or other facilities that the provider implements.
Suppose that the master class is COM.acme.provider.Acme, and that you would like to configure Acme as your third preferred provider. To do so, you would add the following line to the java.security file:
security.provider.3=COM.acme.provider.Acme
Providers can also be registered dynamically. To do so, call either the addProvider or insertProviderAt method in the Security class. This type of registration is not persistent and can be done only by "trusted" programs. See Security.
Provider Class Methods
Each Provider class instance has a (currently case-sensitive) name, a version number, and a string description of the provider and its services. You can query the Provider instance for this information by calling the following methods:
public String getName()
public double getVersion()
public String getInfo()
The Security Class
The Security class manages installed providers and security-wide properties. It contains only static methods and is never instantiated. The methods for adding or removing providers, and for setting Security properties, can be executed only by a trusted program. Currently, a "trusted program" is either
A local application not running under a security manager, or
An applet or application with permission to execute the specified method (see tables).
To determine if code is considered trusted to perform an attempted action (such as adding a provider), the applet must be granted permission for that particular action.
For example, in the Policy reference implementation, the policy configuration files for a SDK installation specify what permissions (which types of system resource accesses) are allowed by code from specified code sources. (See tables and the Default Policy Implementation and Policy File Syntax and Java 2 Platform Security Architecture files for more information.)
Code being executed is always considered to come from a particular "code source." The code source includes not only the location (URL) where the applet originated from, but also a reference to the public key(s_ corresponding to the private key(s) that is used to sign the code. Public keys in a code source are referenced by (symbolic) alias names from the user's keystore .
In a policy configuration file, a code source is represented by two components: a code base (URL) and an alias name (preceded by signedBy), where the alias name identifies the keystore entry containing the public key that must be used to verify the code's signature.
Each "grant" statement in such a file grants to a specified code source a set of permissions, specifying which actions are allowed.
This configuration file specifies that only code loaded from a signed JAR file from the /home/sysadmin/ directory on the local file system can add or remove providers or set provider properties. (Note that the signature of the JAR file can be verified using the public key referenced by the alias name sysadmin in the user's keystore.)
Either component of the code source (or both) can be missing. Here's an example of a configuration file where codeBase is missing:
If this policy is in effect, code that comes in a JAR File signed by sysadmin can add or remove providers--regardless of where the JAR File originated.
In this case, code that comes from anywhere within the /home/sysadmin/ directory on the local filesystem can add or remove providers. The code does not need to be signed.
An example where neither codeBase nor signedBy is included is:
grant {
permission java.security.SecurityPermission "insertProvider.*";
permission java.security.SecurityPermission "removeProvider.*";
};
Here, with both code source components missing, any code (regardless of where it originates, or whether or not it is signed, or who signed it) can add or remove providers.
Managing Providers
The following tables summarize the methods in the Security class that you can use to query which providers are installed, and to install or remove providers at runtime.
Table 2. Querying Providers
Method
Description
static Provider[] getProviders()
Returns an array containing all the installed providers (technically, the Provider subclass for each package provider). The order of the Provider in the array is their preference order.
static Provider getProvider (String providerName)
Returns the Provider named providerName. It returns null if the Provider is not found.
Table 3. Adding Providers
Method
Description
static int addProvider(Provider provider)
Adds a Provider to the end of the list of installed Providers. It returns the preference position in which the Provider was added, or -1 if the Provider was not added because it was already installed.
static int insertProviderAt (Provider provider, int position)
Adds a new Provider at a specified position. If the given provider is installed at the requested position, the provider formerly at that position and all providers with a position greater than position are shifted up one position (towards the end of the list). This method returns the preference position in which the Provider was added, or -1 if the Provider was not added because it was already installed.
Table 4. Removing Providers
Method
Description
static void removeProvider(String name)
Removes the Provider with the specified name. It returns silently if the provider is not installed. When the specified provider is removed, all providers located at a position greater than where the specified provider was located are shifted down one position (towards the head of the list of installed providers).
Note: If you want to change the preference position of a provider, you must first remove it, and then insert it back in at the new preference position.
Security Properties
The Security class maintains a list of system-wide security properties. These properties are accessible and ca be set by a trusted program using the following methods:
The MessageDigest class is an engine class designed to provide the functionality of cryptographically secure message digests such as SHA-1 or MD5. A cryptographically secure message digest takes arbitrary-sized input (a byte array), and generates a fixed-size output, called a digest or hash. A digest has two properties:
It should be computationally infeasible to find two messages that hashed to the same value.
The digest should not reveal anything about the input that was used to generate it.
Message digests are used to produce unique and reliable identifiers of data. They are sometimes called the "digital fingerprints" of data.
Creating a MessageDigest Object
The first step for computing a digest is to create a message digest instance. As with all engine classes, the way to get a MessageDigest object for a particular type of message digest algorithm is to call the getInstance static factory method on the MessageDigest class:
A caller might optionally specify the name of a provider or a Provider instance, which guarantees that the implementation of the algorithm requested is from the specified provider:
A call to getInstance returns an initialized message digest object. It therefore does not need further initialization.
Updating a Message Digest Object
The next step for calculating the digest of some data is to supply the data to the initialized message digest object. This step is done by calling one of the update methods:
void update(byte input)
void update(byte[] input)
void update(byte[] input, int offset, int len)
Computing the Digest
After the data has been supplied by calls to update methods, the digest is computed using a call to one of the digest methods:
byte[] digest()
byte[] digest(byte[] input)
int digest(byte[] buf, int offset, int len)
The first two methods return the computed digest. The latter method stores the computed digest in the provided buffer buf, starting at offset. len is the number of bytes in buf allotted for the digest. The method returns the number of bytes actually stored in buf.
A call to the digest method that takes an input byte array argument is equivalent to making a call to the following method with the specified input, followed by a call to the digest method without any arguments:
The Signature class is an engine class designed to provide the functionality of a cryptographic digital signature algorithm such as DSA or RSA with MD5. A cryptographically secure signature algorithm takes arbitrary-sized input and a private key and generates a relatively short (often fixed-size) string of bytes, called the signature, with the following properties:
Given the public key corresponding to the private key used to generate the signature, it should be possible to verify the authenticity and integrity of the input.
The signature and the public key do not reveal anything about the private key.
A Signature object can be used to sign data. It can also be used to verify whether or not an alleged signature is in fact the authentic signature of the data associated with it. See the Examples section for an example of signing and verifying data.
Signature Object States
Signature objects are modal objects which means that a Signature object is always in a given state, where it can do only one type of operation. States are represented as final integer constants defined in their respective classes.
The three states a Signature object can have are:
UNINITIALIZED
SIGN
VERIFY
When it is first created, a Signature object is in the UNINITIALIZED state. The Signature class defines two initialization methods, initSign and initVerify, which change the state to SIGN and VERIFY, respectively.
Creating a Signature Object
The first step for signing or verifying a signature is to create a Signature instance. As with all engine classes, the way to get a Signature object for a particular type of signature algorithm is to call the getInstance static factory method on the Signature class:
static Signature getInstance(String algorithm)
Note: The algorithm name is not case-sensitive.
A caller can optionally specify the name of a provider or the Provider class, which will guarantee that the implementation of the algorithm requested is from the named provider:
A Signature object must be initialized before it is used. The initialization method depends on whether the object is going to be used for signing or for verification.
If it is going to be used for signing, the object must first be initialized with the private key of the entity whose signature is going to be generated. This initialization is done by calling the method:
final void initSign(PrivateKey privateKey)
This method puts the Signature object in the SIGN state.
If instead the Signature object is going to be used for verification, it must first be initialized with the public key of the entity whose signature is going to be verified. This initialization is done by calling either of these methods:
final void initVerify(PublicKey publicKey)
final void initVerify(Certificate certificate)
This method puts the Signature object in the VERIFY state.
Signing
If the Signature object has been initialized for signing (if it is in the SIGN state), the data to be signed can then be supplied to the object by making one or more calls to one of the update methods:
final void update(byte b)
final void update(byte[] data)
final void update(byte[] data, int off, int len)
Calls to the update methods should be made until all the data to be signed has been supplied to the Signature object.
To generate the signature, simply call one of the sign methods:
final byte[] sign()
final int sign(byte[] outbuf, int offset, int len)
The first method returns the signature result in a byte array. The second stores the signature result in the provided buffer outbuf, starting at offset. len is the number of bytes in outbuf allotted for the signature. The method returns the number of bytes actually stored.
Signature encoding is algorithm specific. See Appendix B for more information about the use of ASN.1 encoding in the Java Cryptography Architecture.
A call to a sign method resets the signature object to the state it was in when it was previously initialized for signing using a call to initSign. That is, the object is reset and available to generate another signature with the same private key, if desired, using new calls to update and sign.
Alternatively, a new call can be made to initSign specifying a different private key or to initVerify (to initialize the Signature object to verify a signature).
Verifying
If the Signature object has been initialized for verification (if it is in the VERIFY state), it can then verify if an alleged signature is in fact the authentic signature of the data associated with it. To start the process, the data to be verified (as opposed to the signature itself) is supplied to the object. The data is passed to the object by calling one of the update methods:
final void update(byte b)
final void update(byte[] data)
final void update(byte[] data, int off, int len)
Calls to the update methods should be made until all the data to be verified has been supplied to the Signature object. The signature can now be verified by calling one of the verify methods:
final boolean verify(byte[] signature)
final boolean verify(byte[] signature, int offset, int length)
The argument must be a byte array containing the signature. The argument must be a byte array containing the signature. This byte array would hold the signature bytes that were returned by a previous call to one of the sign methods.
The verify method returns a boolean indicating whether or not the encoded signature is the authentic signature of the data supplied to the update methods.
A call to the verify method resets the signature object to its state when it was initialized for verification using a call to initVerify. That is, the object is reset and available to verify another signature from the identity whose public key was specified in the call to initVerify.
Alternatively, a new call can be made to initVerify specifying a different public key (to initialize the Signature object for verifying a signature from a different entity), or to initSign (to initialize the Signature object for generating a signature).
Algorithm Parameters Classes
Algorithm Parameter Specification Interfaces and Classes
An algorithm parameter specification is a transparent representation of the sets of parameters used with an algorithm.
A transparent representation of a set of parameters means that you can access each parameter value in the set individually. You can access these values through one of the get methods defined in the corresponding specification class (for example, DSAParameterSpec defines getP, getQ, and getG methods, to access p, q, and g, respectively).
In contrast, the AlgorithmParameters class supplies an opaque representation, in which you have no direct access to the parameter fields. You can get only the name of the algorithm associated with the parameter set (using getAlgorithm) and some kind of encoding for the parameter set (using getEncoded).
The algorithm parameter specification interfaces and classes in the java.security.spec package are described in the following sections.
The AlgorithmParameterSpec Interface
AlgorithmParameterSpec is an interface to a transparent specification of cryptographic parameters.
This interface contains no methods or constants. Its only purpose is to group (and provide type safety for) all parameter specifications. All parameter specifications must implement this interface.
The DSAParameterSpec Class
This class (which implements the AlgorithmParameterSpec interface) specifies the set of parameters used with the DSA algorithm. It has the following methods:
These methods return the DSA algorithm parameters: the prime p, the sub-prime q, and the base g.
The AlgorithmParameters Class
The AlgorithmParameters class is an engine class that provides an opaque representation of cryptographic parameters.
An opaque representation is one in which you have no direct access to the parameter fields; you can get only the name of the algorithm associated with the parameter set and some kind of encoding for the parameter set. This method is in contrast to a transparent representation of parameters, in which you can access each value individually, through one of the get methods defined in the corresponding specification class. Note that you can call the AlgorithmParametersgetParameterSpec method to convert an AlgorithmParameters object to a transparent specification (see the following section).
Creating an AlgorithmParameters Object
As with all engine classes, the way to get an AlgorithmParameters object for a particular type of algorithm is to call the getInstance static factory method on the AlgorithmParameters class:
A caller can optionally specify the name of a provider or the Provider class, which will guarantee that the algorithm parameter implementation requested is from the named provider:
After an AlgorithmParameters object is instantiated, it must be initialized using a call to init, with an appropriate parameter specification or parameter encoding:
In these init methods, params is an array containing the encoded parameters, and format is the name of the decoding format. In the init method with a params argument but no format argument, the primary decoding format for parameters is used. The primary decoding format is ASN.1, if an ASN.1 specification for the parameters exists.
Note:AlgorithmParameters objects can be initialized only once. They are not reusable.
Obtaining the Encoded Parameters
A byte encoding of the parameters represented in an AlgorithmParameters object can be obtained using a call to getEncoded:
byte[] getEncoded()
This method returns the parameters in their primary encoding format. The primary encoding format for parameters is ASN.1, if an ASN.1 specification for this type of parameters exists.
If you want the parameters returned in a specified encoding format, use
byte[] getEncoded(String format)
If format is null, the primary encoding format for parameters is used, as in the other getEncoded method.
Note: In most AlgorithmParameters implementations, supplied by the "IBMJCE" provider, the format argument is currently ignored.
Converting an AlgorithmParameters Object to a Transparent Specification
A transparent parameter specification for the algorithm parameters can be obtained from an AlgorithmParameters object using a call to getParameterSpec:
paramSpec identifies the specification class in which the parameters should be returned. The specification class could be, for example, DSAParameterSpec.class to indicate that the parameters should be returned in an instance of the DSAParameterSpec class. (This class is in the java.security.spec package.)
The AlgorithmParameterGenerator Class
The AlgorithmParameterGenerator class is an engine class used to generate a set of parameters suitable for a certain algorithm (the algorithm specified when an AlgorithmParameterGenerator instance is created).
Creating an AlgorithmParameterGenerator Object
As with all engine classes, the way to get an AlgorithmParameterGenerator object for a particular type of algorithm is to call the getInstance static factory method on the AlgorithmParameterGenerator class:
A caller can optionally specify the name of a provider or the Provider class, which will guarantee that the algorithm parameter generator implementation is from the named provider:
Initializing an AlgorithmParameterGenerator Object
The AlgorithmParameterGenerator object can be initialized in two different ways: an algorithm-independent manner or an algorithm-specific manner.
The algorithm-independent approach uses the fact that all parameter generators share the concept of a "size" and a source of randomness. The measure of size is universally shared by all algorithm parameters, though it is interpreted differently for different algorithms. For example, in the case of parameters for the DSA algorithm, "size" corresponds to the size of the prime modulus, in bits. (See Appendix B: Algorithms for information about the sizes for specific algorithms.) When using this approach, algorithm-specific parameter generation values--if any--default to some standard values. One init method that takes these two universally shared types of arguments:
void init(int size, SecureRandom random);
Another init method takes only a size argument and uses a system-provided source of randomness:
void init(int size)
A third approach initializes a parameter generator object using algorithm-specific semantics, which are represented by a set of algorithm-specific parameter generation values supplied in an AlgorithmParameterSpec object:
To generate Diffie-Hellman system parameters, for example, the parameter generation values usually consist of the size of the prime modulus and the size of the random exponent, both specified in number of bits. (The Diffie-Hellman algorithm has been part of the JCE since JCE 1.2.)
Generating Algorithm Parameters
After you have created and initialized an AlgorithmParameterGenerator object, you can use the generateParameters method to generate the algorithm parameters:
AlgorithmParameters generateParameters()
Key Interfaces
The Key interface is the top-level interface for all opaque keys. It defines the functionality shared by all opaque key objects.
An opaque key representation is one in which you have no direct access to the key material that constitutes a key. In other words, "opaque" gives you limited access to the key--just the three methods defined by the Key interface: getAlgorithm, getFormat, and getEncoded. This is in contrast to a transparent representation, in which you can access each key material value individually, through one of the get methods defined in the corresponding specification class.
All opaque keys have three characteristics:
An Algorithm
The key algorithm for that key. The key algorithm is usually an encryption or asymmetric operation algorithm (such as DSA or RSA), which will work with those algorithms and with related algorithms (such as MD5 with RSA, SHA-1 with RSA, and so on.) The name of the algorithm of a key is obtained using this method:
String getAlgorithm()
An Encoded Form
The external encoded form for the key used when a standard representation of the key is needed outside the Java Virtual Machine, as when transmitting the key to some other party. The key is encoded according to a standard format (such as X.509 or PKCS #8), and is returned using the method:
byte[] getEncoded()
A Format
The name of the format of the encoded key. It is returned by the method:
String getFormat()
Keys are generally obtained through key generators, certificates, key specifications (using a KeyFactory), or a KeyStore implementation accessing a keystore database used to manage keys.
It is possible to parse encoded keys, in an algorithm-dependent manner, using a KeyFactory.
The PublicKey and PrivateKey interfaces (which both extend the Key interface) are methodless interfaces, used for type-safety and type-identification.
Key Specification Interfaces and Classes
Key specifications are transparent representations of the key material that constitutes a key. If the key is stored on a hardware device, its specification might contain information that helps identify the key on the device.
A transparent representation of keys means that you can access each key material value individually, through one of the get methods defined in the corresponding specification class. For example, DSAPrivateKeySpec defines getX, getP, getQ, and getG methods, to access the private key x, and the DSA algorithm parameters used to calculate the key: the prime p, the sub-prime q, and the base g.
This representation is contrasted with an opaque representation, as defined by the Key interface, in which you have no direct access to the key material fields. In other words, an "opaque" representation gives you limited access to the key--just the three methods defined by the Key interface: getAlgorithm, getFormat, and getEncoded.
A key can be specified in an algorithm-specific way or in an algorithm-independent encoding format (such as ASN.1). For example, a DSA private key can be specified by its components x, p, q, and g (see DSAPrivateKeySpec), or it may be specified using its DER encoding (see PKCS8EncodedKeySpec).
The key specification interfaces and classes in the java.security.spec package are:
The KeySpec Interface
This interface contains no methods or constants. Its only purpose is to group and provide type safety for all key specifications. All key specifications must implement this interface.
The DSAPrivateKeySpec Class
This class (which implements the KeySpec interface) specifies a DSA private key with its associated parameters. DSAPrivateKeySpec has the following methods:
These methods return the private key x, and the DSA algorithm parameters used to calculate the key: the prime p, the sub-prime q, and the base g.
The DSAPublicKeySpec Class
This class (which implements the KeySpec interface) specifies a DSA public key with its associated parameters. DSAPublicKeySpec has the following methods:
These methods return the RSA modulus n and private exponent d values that constitute the RSA private key.
The RSAPrivateCrtKeySpec Class
This class (which extends the RSAPrivateKeySpec class) specifies an RSA private key, as defined in the PKCS #1 standard, using the Chinese Remainder Theorem (CRT) information values. RSAPrivateCrtKeySpec has the following methods (in addition to the methods inherited from its superclass RSAPrivateKeySpec):
These methods return the public exponent e and the CRT information integers: the prime factor p of the modulus n, the prime factor q of n, the exponent d mod (p-1), the exponent d mod (q-1), and the Chinese Remainder Theorem coefficient (inverse of q) mod p.
An RSA private key logically consists of only the modulus and the private exponent. The presence of the CRT values is intended for efficiency.
The RSAMultiPrimePrivateCrtKeySpec Class
This class (which extends the RSAPrivateKeySpec class) specifies an RSA multi-prime private key, as defined in the PKCS #1 v2.1, using the Chinese Remainder Theorem (CRT) information values. RSAMultiPrimePrivateCrtKeySpec has the following methods (in addition to the methods inherited from its superclass RSAPrivateKeySpec):
These methods return the public exponent e and the CRT information integers: the prime factor p of the modulus n, the prime factor q of n, the exponent d mod (p-1), the exponent d mod (q-1), and the Chinese Remainder Theorem coefficient (inverse of q) mod p.
Method getOtherPrimeInfo returns a copy of the otherPrimeInfo (defined in PKCS #1 v 2.1) or null if there are only two prime factors (p and q).
An RSA private key logically consists of only the modulus and the private exponent. The presence of the CRT values is intended for efficiency.
The RSAPublicKeySpec Class
This class (which implements the KeySpec interface) specifies an RSA public key. RSAPublicKeySpec has the following methods:
These methods return the RSA modulus n and public exponent e values that constitute the RSA public key.
The EncodedKeySpec Class
This abstract class (which implements the KeySpec interface) represents a public or private key in encoded format. Its getEncoded method returns the encoded key:
abstract byte[] getEncoded();
and its getFormat method returns the name of the encoding format:
abstract String getFormat();
See the next sections for the concrete implementations PKCS8EncodedKeySpec and X509EncodedKeySpec.
The PKCS8EncodedKeySpec Class
This class, which is a subclass of EncodedKeySpec, represents the DER encoding of a private key, according to the format specified in the PKCS #8 standard. Its getEncoded method returns the key bytes, encoded according to the PKCS #8 standard. Its getFormat method returns the string "PKCS#8".
The X509EncodedKeySpec Class
This class, which is a subclass of EncodedKeySpec, represents the DER encoding of a public key, according to the format specified in the X.509 standard. Its getEncoded method returns the key bytes, encoded according to the X.509 standard. Its getFormat method returns the string "X.509".
The KeyFactory Class
The KeyFactory class is an engine class designed to provide conversions between opaque cryptographic keys (of type Key) and key specifications (transparent representations of the underlying key material).
Key factories are bidirectional. They allow you to build an opaque key object from a given key specification (key material), or to retrieve the underlying key material of a key object in a suitable format.
Multiple compatible key specifications can exist for the same key. For example, a DSA public key can be specified by its components y, p, q, and g (see DSAPublicKeySpec), or it can be specified using its DER encoding according to the X.509 standard (see X509EncodedKeySpec).
A key factory can be used to translate between compatible key specifications. Key parsing can be achieved through translation between compatible key specifications, for example, when you translate from X509EncodedKeySpec to DSAPublicKeySpec, you basically parse the encoded key into its components. For an example, see the end of the Generating/Verifying Signatures Using Key Specifications and KeyFactory section.
Creating a KeyFactory Object
As with all engine classes, the way to get a KeyFactory object for a particular type of key algorithm is to call the getInstance static factory method on the KeyFactory class:
static KeyFactory getInstance(String algorithm)
Note: The algorithm name is not case-sensitive.
A caller can optionally specify the name of a provider or the Provider class, which will guarantee that the implementation of the key factory requested is from the named provider.
Converting between a Key Specification and a Key Object
If you have a key specification for a public key, you can obtain an opaque PublicKey object from the specification by using the generatePublic method:
PublicKey generatePublic(KeySpec keySpec)
Similarly, if you have a key specification for a private key, you can obtain an opaque PrivateKey object from the specification by using the generatePrivate method:
PrivateKey generatePrivate(KeySpec keySpec)
Converting between a Key Object and a Key Specification
If you have a Key object, you can get a corresponding key specification object by calling the getKeySpec method:
KeySpec getKeySpec(Key key, Class keySpec)
keySpec identifies the specification class in which the key material should be returned. It could, for example, be DSAPublicKeySpec.class, to indicate that the key material should be returned in an instance of the DSAPublicKeySpec class.
The CertificateFactory class is an engine class that defines the functionality of a certificate factory, which is used to generate certificate and certificate revocation list (CRL) objects from their encodings.
A certificate factory for X.509 must return certificates that are an instance of java.security.cert.X509Certificate, and CRLs that are an instance of java.security.cert.X509CRL.
Creating a CertificateFactory Object
As with all engine classes, the way to get a CertificateFactory object for a particular certificate or CRL type is to call the getInstance static factory method on the CertificateFactory class:
A caller can optionally specify the name of a provider or the Provider class, which will guarantee that the implementation of the certificate factory requested is from the named provider.
To generate a certificate object and initialize it with the data read from an input stream, use the generateCertificate method:
final Certificate generateCertificate(InputStream inStream)
To return a (possibly empty) collection view of the certificates read from a given input stream, use the generateCertificates method:
final Collection generateCertificates(InputStream inStream)
Generating CRL Objects
To generate a certificate revocation list (CRL) object and initialize it with the data read from an input stream, use the generateCRL method:
final CRL generateCRL(InputStream inStream)
To return a (possibly empty) collection view of the CRLs read from a given input stream, use the generateCRLs method:
final Collection generateCRLs(InputStream inStream)
Generating CertPath Objects
To generate a CertPath object and initialize it with data read from an input stream, use one of the following generateCertPath methods (with or without specifying the encoding to be used for the data):
final CertPath generateCertPath(InputStream inStream)
final CertPath generateCertPath(InputStream inStream, String encoding)
To generate a CertPath object and initialize it with a list of certificates, use the following method:
final CertPath generateCertPath(List certificates)
To retrieve a list of the CertPath encodings supported by this certificate factory, you can call the getCertPathEncodings method:
final Iterator getCertPathEncodings()
The default encoding will be listed first.
The KeyPair Class
The KeyPair class is a simple holder for a key pair (a public key and a private key). It has two public methods, one for returning the private key, and the other for returning the public key:
PrivateKey getPrivate()
PublicKey getPublic()
The KeyPairGenerator Class
The KeyPairGenerator class is an engine class used to generate pairs of public and private keys.
There are two ways to generate a key pair: in an algorithm-independent manner, and in an algorithm-specific manner. The only difference between the two is the initialization of the object.
Please see the Examples section for examples of calls to the methods documented here.
Creating a KeyPairGenerator
All key pair generation starts with a KeyPairGenerator. This generation is done using one of the factory methods on KeyPairGenerator:
A key pair generator for a particular algorithm creates a public/private key pair that can be used with this algorithm. It also associates algorithm-specific parameters with each of the generated keys.
A key pair generator needs to be initialized before it can generate keys. In most cases, algorithm-independent initialization is sufficient. But in other cases, algorithm-specific initialization is used.
Algorithm-Independent Initialization
All key pair generators share the concepts of a key size and a source of randomness. The key size is interpreted differently for different algorithms. For example, in the case of the DSA algorithm, the key size corresponds to the length of the modulus. (See Appendix B: Algorithms for information about the key sizes for specific algorithms.)
An initialize method takes two universally shared types of arguments:
void initialize(int keysize, SecureRandom random)
Another initialize method takes only a keysize argument; it uses a system-provided source of randomness:
void initialize(int keysize)
Because no other parameters are specified when you call these algorithm-independent initialize methods, it is up to the provider what to do about the algorithm-specific parameters (if any) to be associated with each of the keys.
If the algorithm is a "DSA" algorithm, and the modulus size (key size) is 512, 768, or 1024, then the "IBMJCE" provider uses a set of precomputed values for the p, q, and g parameters. If the modulus size is not one of these values, the "IBMJCE" provider creates a new set of parameters. Other providers might have precomputed parameter sets for more than just the three modulus sizes mentioned. Yet others might not have a list of precomputed parameters at all and instead always create new parameter sets.
Algorithm-Specific Initialization
For situations where a set of algorithm-specific parameters already exists (such as "community parameters" in DSA), there are two initialize methods that have an AlgorithmParameterSpec argument. One also has a SecureRandom argument, while the source of randomness is system-provided for the other:
The procedure for generating a key pair is always the same, regardless of initialization (and of the algorithm). You always call the following method from KeyPairGenerator:
KeyPair generateKeyPair()
Multiple calls to generateKeyPair will yield different key pairs.
Key Management
A database called a "keystore" can be used to manage a repository of keys and certificates. (A certificate is a digitally signed statement from one entity, saying that the public key of some other entity has a particular value.)
Keystore Location
The keystore is by default stored in a file named .keystore in the user's home directory, as determined by the "user.home" system property. On Solaris systems "user.home" defaults to the user's home directory. On Win32 systems, given user name uName, "user.home" defaults to:
C:\Winnt\Profiles\uName on multi-user Windows NT systems
C:\Windows\Profiles\uName on multi-user Windows 95/98/2000 systems
C:\Windows on single-user Windows 95/98/2000 systems
Keystore Implementation
The KeyStore class supplies well-defined interfaces to access and modify the information in a keystore. It is possible for there to be multiple different concrete implementations, where each implementation is that for a particular type of keystore.
Currently, there are two command-line tools that make use of KeyStore: keytool and jarsigner, and also a GUI-based tool named policytool. policytool is also used by the Policy reference implementation when it processes policy files specifying the permissions (allowed accesses to system resources) to be granted to code from various sources. Because KeyStore is publicly available, SDK users can write additional security applications that use it.
There is a built-in default implementation, called "JCK". It implements the keystore as a file, utilizing a proprietary keystore type (format). It protects each private key with its individual password, and also protects the integrity of the entire keystore with a (possibly different) password.
Keystore implementations are provider-based. More specifically, the application interfaces supplied by KeyStore are implemented in terms of a Service Provider Interface (SPI). That is, there is a corresponding abstract KeystoreSpi class, also in the java.security package, which defines the SPI methods that "providers" must implement. (The term "provider" refers to a package or a set of packages that supply a concrete implementation of a subset of services that can be accessed by the Java 2 SDK Security API.) Therefore, to provide a keystore implementation, clients must implement a "provider" and supply a KeystoreSpi subclass implementation.
Applications can choose different types of keystore implementations from different providers, using the getInstance factory method in the KeyStore class. A keystore type defines the storage and data format of the keystore information, and the algorithms used to protect private keys in the keystore and the integrity of the keystore itself. Keystore implementations of different types are not compatible.
The default keystore type is "jks" (the proprietary type of the keystore implementation provided by the "IBMJCE" provider). This keystore type is specified by the following line in the security properties file:
keystore.type=jks
To specify that tools and other applications will use a keystore implementation other than the default keystore, you can change that line to specify a different keystore type. Or, you can let users of your tools and applications specify a keystore type, and pass that value to the getInstance method of KeyStore.
An example of the former approach is the following: If you have a provider package that supplies a keystore implementation for a keystore type called pkcs12, change the line to
keystore.type=pkcs12
Note: Keystore type designations are not case-sensitive. For example, "JKS" would be considered the same as "jks".
The KeyStore Class
The KeyStore class is an engine class that supplies well-defined interfaces to access and modify the information in a keystore.
This class represents an in-memory collection of keys and certificates. KeyStore manages two types of entries:
Key Entry
This type of keystore entry holds very sensitive cryptographic key information, which is stored in a protected format to prevent unauthorized access. Typically, a key stored in this type of entry is a secret key, or a private key accompanied by the certificate chain authenticating the corresponding public key.
Private keys and certificate chains are used by a given entity for self-authentication using digital signatures. For example, software distribution organizations digitally sign JAR files as part of releasing, or licensing software, or both.
Trusted Certificate Entry
This type of entry contains a single public key certificate belonging to another party. It is called a trusted certificate because the keystore owner trusts that the public key in the certificate indeed belongs to the identity identified by the subject (owner) of the certificate.
This type of entry can be used to authenticate other parties.
Each entry in a keystore is identified by an "alias" string. In the case of private keys and their associated certificate chains, these strings distinguish among the different ways in which the entity can authenticate itself. For example, the entity might authenticate itself using different certificate authorities, or using different public key algorithms.
The persistence of keystores, and the mechanisms used by the keystore if it is persistent are not specified here. This convention allows use of a variety of techniques for protecting sensitive (for example, private or secret) keys. Smart cards or other integrated cryptographic engines (SafeKeyper) are one option, and simpler mechanisms such as files can also be used (in a variety of formats).
The main KeyStore methods are described here.
Creating a KeyStore Object
As with all engine classes, the way to get a KeyStore object is to call the getInstance static factory method on the KeyStore class:
static KeyStore getInstance(String type)
A caller can optionally specify the name of a provider or the Provider class, which will guarantee that the implementation of the type requested is from the named provider:
Before a KeyStore object can be used, the actual keystore data must be loaded into memory using the load method:
final void load(InputStream stream, char[] password)
The optional password is used to check the integrity of the keystore data. If no password is supplied, no integrity check is performed.
To create an empty keystore, you pass null as the InputStream argument to the load method.
Getting a List of the Keystore Aliases
All keystore entries are accessed using unique aliases. The aliases method returns an enumeration of the alias names in the keystore:
final Enumeration aliases()
Determining Keystore Entry Types
As stated in The KeyStore Class, there are two different types of entries in a keystore.
The following methods determine whether the entry specified by the given alias is a key/certificate or a trusted certificate entry, respectively:
final boolean isKeyEntry(String alias)
final boolean isCertificateEntry(String alias)
Adding, Setting or Deleting Keystore Entries
The setCertificateEntry method assigns a certificate to a specified alias:
final void setCertificateEntry(String alias, Certificate cert)
If alias doesn't exist, a trusted certificate entry with that alias is created. If alias exists and identifies a trusted certificate entry, the certificate associated with it is replaced by cert.
The setKeyEntry methods add (if alias doesn't yet exist) or set key entries:
final void setKeyEntry(String alias,
Key key,
char[] password,
Certificate[] chain)
final void setKeyEntry(String alias,
byte[] key,
Certificate[] chain)
In the method with key as a byte array, it is the bytes for a key in protected format. For example, in the keystore implementation supplied by the "IBMJCE" provider, the key byte array is expected to contain a protected private key, encoded as an EncryptedPrivateKeyInfo as defined in the PKCS #8 standard. In the other method, the password is the password used to protect the key.
The deleteEntry method deletes an entry:
final void deleteEntry(String alias)
Getting Information from the Keystore
The getKey method returns the key associated with the given alias. The key is recovered using the given password:
final Key getKey(String alias, char[] password)
The following methods return the certificate, or certificate chain, respectively, associated with the given alias:
final Certificate getCertificate(String alias)
final Certificate[] getCertificateChain(String alias)
You can determine the name (alias) of the first entry whose certificate matches a given certificate using the following method:
final String getCertificateAlias(Certificate cert)
Saving the KeyStore
The in-memory keystore can be saved using the store method:
final void store(OutputStream stream, char[] password)
The password is used to calculate an integrity checksum of the keystore data, which is appended to the keystore data.
The SecureRandom Class
The SecureRandom class is an engine class that provides the functionality of a random number generator.
Creating a SecureRandom Object
As with all engine classes, the way to get a SecureRandom object is to call the getInstance static factory method on the SecureRandom class:
static SecureRandom getInstance(String algorithm)
A caller can optionally specify the name of a provider or the Provider class, which will guarantee that the implementation of the random number generation (RNG) algorithm requested is from the named provider:
static final SecureRandom getInstance(String algorithm, String provider)
static final SecureRandom getInstance(String algorithm, Provider provider)
Seeding or Re-Seeding the SecureRandom Object
The SecureRandom implementation attempts to completely randomize the internal state of the generator itself unless the caller follows the call to a getInstance method with a call to one of the setSeed methods:
synchronized public void setSeed(byte[] seed)
public void setSeed(long seed)
After the SecureRandom object has been seeded, it will produce bits as random as the original seeds.
At any time a SecureRandom object can be re-seeded using one of the setSeed methods. The given seed supplements, rather than replaces, the existing seed; therefore, repeated calls are guaranteed never to reduce randomness.
Using a SecureRandom Object
To get random bytes, a caller simply passes an array of any length, which is then filled with random bytes:
synchronized public void nextBytes(byte[] bytes)
Generating Seed Bytes
If desired, it is possible to invoke the generateSeed method to generate a given number of seed bytes (to seed other random number generators, for example):
byte[] generateSeed(int numBytes)
The Cipher Class
The Cipher class provides the functionality of a cryptographic cipher used for encryption and decryption. It forms the core of the JCE framework.
Creating a Cipher Object
Like other engine classes in the API, Cipher objects are created using the getInstance factory methods of the Cipher class. A factory method is a static method that returns an instance of a class, in this case, an instance of Cipher, which implements a requested transformation.
To create a Cipher object, you must specify the transformation name. You may also specify which provider you want to supply the implementation of the requested transformation:
public static Cipher getInstance(String transformation);
public static Cipher getInstance(String transformation, String provider);
If just a transformation name is specified, the system will determine if there is an implementation of the requested transformation available in the environment, and if there is more than one, if there is a preferred one.
If both a transformation name and a package provider are specified, the system will determine if there is an implementation of the requested transformation in the package requested, and throw an exception if there is not.
A transformation is a string that describes the operation (or set of operations) to be performed on the given input, to produce some output. A transformation always includes the name of a cryptographic algorithm (e.g., DES), and may be followed by a mode and padding scheme.
A transformation is of the form:
"algorithm/mode/padding" or
"algorithm"
For example, the following are valid transformations:
"DES/CBC/PKCS5Padding""DES"
If no mode or padding is specified, provider-specific default values for the mode and padding scheme are used. For example, the IBMJCE provider uses ECB as the default mode, and PKCS5Padding as the default padding scheme for DES, DES-EDE and Blowfish ciphers. This means that in the case of the IBMJCE provider,
When requesting a block cipher in stream cipher mode (e.g., DES in CFB or OFB mode), you may optionally specify the number of bits to be processed at a time, by appending this number to the mode name as shown in the "DES/CFB8/NoPadding" and "DES/OFB32/PKCS5Padding" transformations. If no such number is specified, a provider-specific default is used. (For example, the IBMJCE provider uses a default of 64 bits.)
Appendix A of this document contains a list of standard names that can be used to specify the algorithm name, mode, and padding scheme components of a transformation.
The objects returned by factory methods are uninitialized, and must be initialized before they become usable.
Initializing a Cipher Object
A Cipher object obtained via getInstance must be initialized for one of four modes, which are defined as final integer constants in the Cipher class. The modes can be referenced by their symbolic names, which are shown with a description of the purpose of each mode:
ENCRYPT_MODE
Encryption of data.
DECRYPT_MODE
Decryption of data.
WRAP_MODE
Wrapping a Key into bytes so that the key can be securely transported.
UNWRAP_MODE
Unwrapping of a previously wrapped key into a java.security.Key object.
Each of the Cipher initialization methods takes a mode parameter (opmode), and initializes the Cipher object for that mode. Other parameters include the key (key) or certificate containing the key (certificate), algorithm parameters (params), and a source of randomness (random).
To initialize a Cipher object, call one of the following init methods:
public void init(int opmode, Key key);
public void init(int opmode, Certificate certificate)
public void init(int opmode, Key key, SecureRandom random);
public void init(int opmode, Certificate certificate, SecureRandom random)
public void init(int opmode, Key key, AlgorithmParameterSpec params);
public void init(int opmode, Key key, AlgorithmParameterSpec params, SecureRandom random);
public void init(int opmode, Key key, AlgorithmParameters params)
public void init(int opmode, Key key, AlgorithmParameters params, SecureRandom random)
If a Cipher object that requires parameters (e.g., an initialization vector) is initialized for encryption, and no parameters are supplied to the init method, the underlying cipher implementation is supposed to supply the required parameters itself, either by generating random parameters or by using a default, provider-specific set of parameters.
However, if a Cipher object that requires parameters is initialized for decryption, and no parameters are supplied to the init method, an InvalidKeyException or InvalidAlgorithmParameterException exception will be raised, depending on the init method that has been used.
The same parameters that were used for encryption must be used for decryption.
Note that when a Cipher object is initialized, it loses all previously-acquired state. In other words, initializing a Cipher is equivalent to creating a new instance of that Cipher, and initializing it. For example, if a Cipher is first initialized for decryption with a given key, and then initialized for encryption, it will lose any state acquired while in decryption mode.
Encrypting and Decrypting Data
Data can be encrypted or decrypted in one step (single-part operation) or in multiple steps (multiple-part operation). A multiple-part operation is useful if you do not know in advance how long the data is going to be, or if the data is too long to be stored in memory all at once.
To encrypt or decrypt data in a single step, call one of the doFinal methods:
public byte[] doFinal(byte[] input);
public byte[] doFinal(byte[] input, int inputOffset, int inputLen);
public int doFinal(byte[] input, int inputOffset,
int inputLen, byte[] output);
public int doFinal(byte[] input, int inputOffset,
int inputLen, byte[] output, int outputOffset)
To encrypt or decrypt data in multiple steps, call one of the update methods:
public byte[] update(byte[] input);
public byte[] update(byte[] input, int inputOffset, int inputLen);
public int update(byte[] input, int inputOffset, int inputLen,
byte[] output);
public int update(byte[] input, int inputOffset, int inputLen,
byte[] output, int outputOffset)
A multiple-part operation must be terminated by one of the doFinal methods (if there is still some input data left for the last step), or by one of the following doFinal methods (if there is no input data left for the last step):
public byte[] doFinal();
public int doFinal(byte[] output, int outputOffset);
All the doFinal methods take care of any necessary padding (or unpadding), if padding (or unpadding) has been requested as part of the specified transformation.
A call to doFinal resets the Cipher object to the state it was in when initialized via a call to init. That is, the Cipher object is reset and available to encrypt or decrypt (depending on the operation mode that was specified in the call to init) more data.
Wrapping and Unwrapping Keys
Wrapping a key enables secure transfer of the key from one place to another.
The wrap/unwrap API makes it more convenient to write code since it works with key objects directly. These methods also enable the possibility of secure transfer of hardware-based keys.
To wrap a Key, first initialize the Cipher object for WRAP_MODE, and then call the following:
public final byte[] wrap(Key key);
If you are supplying the wrapped key bytes (the result of calling wrap) to someone else who will unwrap them, be sure to also send additional information the recipient will need in order to do the unwrap:
the name of the key algorithm, and
the type of the wrapped key (one of Cipher.SECRET_KEY, Cipher.PRIVATE_KEY, or Cipher.PUBLIC_KEY).
The key algorithm name can be determined by calling the getAlgorithm method from the Key interface:
public String getAlgorithm();
To unwrap the bytes returned by a previous call to wrap, first initialize a Cipher object for UNWRAP_MODE, then call the following:
public final Key unwrap(byte[] wrappedKey,
String wrappedKeyAlgorithm,
int wrappedKeyType));
Here, wrappedKey is the bytes returned from the previous call to wrap, wrappedKeyAlgorithm is the algorithm associated with the wrapped key, and wrappedKeyType is the type of the wrapped key. This must be one of Cipher.SECRET_KEY, Cipher.PRIVATE_KEY, or Cipher.PUBLIC_KEY.
Managing Algorithm Parameters
The parameters being used by the underlying Cipher implementation, which were either explicitly passed to the init method by the application or generated by the underlying implementation itself, can be retrieved from the Cipher object by calling its getParameters method, which returns the parameters as a java.security.AlgorithmParameters object (or null if no parameters are being used). If the parameter is an initialization vector (IV), it can also be retrieved by calling the getIV method.
In the following example, a Cipher object implementing password-based encryption is initialized with just a key and no parameters. However, the selected algorithm for password-based encryption requires two parameters - a salt and an iteration count. Those will be generated by the underlying algorithm implementation itself. The application can retrieve the generated parameters from the Cipher object as follows:
import javax.crypto.*;
import java.security.AlgorithmParameters;
// get cipher object for password-based encryption
Cipher c = Cipher.getInstance("PBEWithMD5AndDES");
// initialize cipher for encryption, without supplying
// any parameters. Here, "myKey" is assumed to refer
// to an already-generated key.
c.init(Cipher.ENCRYPT_MODE, myKey);
// encrypt some data and store away ciphertext
// for later decryption
byte[] cipherText = c.doFinal("This is just an example".getBytes());
// retrieve parameters generated by underlying cipher
// implementation
AlgorithmParameters algParams = c.getParameters();
// get parameter encoding and store it away
byte[] encodedAlgParams = algParams.getEncoded();
The same parameters that were used for encryption must be used for decryption. They can be instantiated from their encoding and used to initialize the corresponding Cipher object for decryption, as follows:
import javax.crypto.*;
import java.security.AlgorithmParameters;
// get parameter object for password-based encryption
AlgorithmParameters algParams;
algParams = AlgorithmParameters.getInstance("PBEWithMD5AndDES");
// initialize with parameter encoding
algParams.init(encodedAlgParams);
// get cipher object for password-based encryption
Cipher c = Cipher.getInstance("PBEWithMD5AndDES");
// initialize cipher for decryption, using one of the
// init() methods that takes an AlgorithmParameters
// object, and pass it the algParams object
c.init(Cipher.DECRYPT_MODE, myKey, algParams);
If you did not specify any parameters when you initialized a Cipher object, and you are not sure whether or not the underlying implementation uses any parameters, you can find out by simply calling the getParameters method of your Cipher object and checking the value returned. A return value of null indicates that no parameters were used.
The following cipher algorithms implemented by the IBMJCE provider use parameters:
DES, DES-EDE, and Blowfish, when used in feedback (i.e., CBC, CFB, OFB, or PCBC) mode, use an initialization vector (IV). The javax.crypto.spec.IvParameterSpec class can be used to initialize a Cipher object with a given IV.
PBEWithMD5AndDES uses a set of parameters, comprising a salt and an iteration count. The javax.crypto.spec.PBEParameterSpec class can be used to initialize a Cipher object implementing PBEWithMD5AndDES with a given salt and iteration count.
Note that you do not have to worry about storing or transferring any algorithm parameters for use by the decryption operation if you use the SealedObject class. This class attaches the parameters used for sealing (encryption) to the encrypted object contents, and uses the same parameters for unsealing (decryption).
Cipher Output Considerations
Some of the update and doFinal methods of Cipher allow the caller to specify the output buffer into which to encrypt or decrypt the data. In these cases, it is important to pass a buffer that is large enough to hold the result of the encryption or decryption operation.
The following method in Cipher can be used to determine how big the output buffer should be:
public int getOutputSize(int inputLen)
The Cipher Stream Classes
JCE introduces the concept of secure streams, which combine an InputStream or OutputStream with a Cipher object. Secure streams are provided by the CipherInputStream and CipherOutputStream classes.
The CipherInputStream Class
This class is a FilterInputStream that encrypts or decrypts the data passing through it. It is composed of an InputStream, or one of its subclasses, and a Cipher. CipherInputStream represents a secure input stream into which a Cipher object has been interposed. The read methods of CipherInputStream return data that are read from the underlying InputStream but have additionally been processed by the embedded Cipher object. The Cipher object must be fully initialized before being used by a CipherInputStream.
For example, if the embedded Cipher has been initialized for decryption, the CipherInputStream will attempt to decrypt the data it reads from the underlying InputStream before returning them to the application.
This class adheres strictly to the semantics, especially the failure semantics, of its ancestor classes java.io.FilterInputStream and java.io.InputStream. This class has exactly those methods specified in its ancestor classes, and overrides them all, so that the data are additionally processed by the embedded cipher. Moreover, this class catches all exceptions that are not thrown by its ancestor classes. In particular, the skip(long) method skips only data that has been processed by the Cipher.
It is crucial for a programmer using this class not to use methods that are not defined or overridden in this class (such as a new method or constructor that is later added to one of the super classes), because the design and implementation of those methods are unlikely to have considered security impact with regard to CipherInputStream.
As an example of its usage, suppose cipher1 has been initialized for encryption. The following code example shows how to use a CipherInputStream containing that cipher and a FileInputStream in order to encrypt input stream data:
FileInputStream fis;
FileOutputStream fos;
CipherInputStream cis;
fis = new FileInputStream("/tmp/a.txt");
cis = new CipherInputStream(fis, cipher1);
fos = new FileOutputStream("/tmp/b.txt");
byte[] b = new byte[8];
int i = cis.read(b);
while (i != -1) {
fos.write(b, 0, i);
i = cis.read(b);
}
This program reads and encrypts the content from the file /tmp/a.txt and then stores the result (the encrypted bytes) in /tmp/b.txt.
The following example demonstrates how to easily connect several instances of CipherInputStream and FileInputStream. In this example, assume that cipher1 and cipher2 have been initialized for encryption and decryption (with corresponding keys), respectively.
FileInputStream fis;
FileOutputStream fos;
CipherInputStream cis1, cis2;
fis = new FileInputStream("/tmp/a.txt");
cis1 = new CipherInputStream(fis, cipher1);
cis2 = new CipherInputStream(cis1, cipher2);
fos = new FileOutputStream("/tmp/b.txt");
byte[] b = new byte[8];
int i = cis2.read(b);
while (i != -1) {
fos.write(b, 0, i);
i = cis2.read(b);
}
This program copies the content from file /tmp/a.txt to /tmp/b.txt, except that the content is first encrypted and then decrypted back when it is read from /tmp/a.txt. Of course since this program simply encrypts text and decrypts it back right away, it's actually not very useful except as a simple way of illustrating chaining of CipherInputStreams.
The CipherOutputStream Class
This class is a FilterOutputStream that encrypts or decrypts the data passing through it. It is composed of an OutputStream, or one of its subclasses, and a Cipher. CipherOutputStream represents a secure output stream into which a Cipher object has been interposed. The write methods of CipherOutputStream first process the data with the embedded Cipher object before writing them out to the underlying OutputStream. The Cipher object must be fully initialized before being used by a CipherOutputStream.
For example, if the embedded Cipher has been initialized for encryption, the CipherOutputStream will encrypt its data, before writing them out to the underlying output stream.
This class adheres strictly to the semantics, especially the failure semantics, of its ancestor classes java.io.OutputStream and java.io.FilterOutputStream. This class has exactly those methods specified in its ancestor classes, and overrides them all, so that all data are additionally processed by the embedded cipher. Moreover, this class catches all exceptions that are not thrown by its ancestor classes.
It is crucial for a programmer using this class not to use methods that are not defined or overridden in this class (such as a new method or constructor that is later added to one of the super classes), because the design and implementation of those methods are unlikely to have considered security impact with regard to CipherOutputStream.
As an example of its usage, suppose cipher1 has been initialized for encryption. The following code example shows how to use a CipherOutputStream containing that cipher and a FileOutputStream in order to encrypt data to be written to an output stream:
FileInputStream fis;
FileOutputStream fos;
CipherOutputStream cos;
fis = new FileInputStream("/tmp/a.txt");
fos = new FileOutputStream("/tmp/b.txt");
cos = new CipherOutputStream(fos, cipher1);
byte[] b = new byte[8];
int i = fis.read(b);
while (i != -1) {
cos.write(b, 0, i);
i = fis.read(b);
}
cos.flush();
This program reads the content from the file /tmp/a.txt, then encrypts and stores the result (the encrypted bytes) in /tmp/b.txt.
The following example demonstrates how to easily connect several instances of CipherOutputStream and FileOutputStream. In this example, assume that cipher1 and cipher2 have been initialized for decryption and encryption (with corresponding keys), respectively:
FileInputStream fis;
FileOutputStream fos;
CipherOutputStream cos1, cos2;
fis = new FileInputStream("/tmp/a.txt");
fos = new FileOutputStream("/tmp/b.txt");
cos1 = new CipherOutputStream(fos, cipher1);
cos2 = new CipherOutputStream(cos1, cipher2);
byte[] b = new byte[8];
int i = fis.read(b);
while (i != -1) {
cos2.write(b, 0, i);
i = fis.read(b);
}
cos2.flush();
This program copies the content from file /tmp/a.txt to /tmp/b.txt, except that the content is first encrypted and then decrypted back before it is written to /tmp/b.txt.
There is one important difference between the flush and close methods of this class, which becomes even more relevant if the encapsulated Cipher object implements a block cipher algorithm with padding turned on:
flush flushes the underlying OutputStream by forcing any buffered output bytes that have already been processed by the encapsulated Cipher object to be written out. Any bytes buffered by the encapsulated Cipher object and waiting to be processed by it will not be written out.
close closes the underlying OutputStream and releases any system resources associated with it. It invokes the doFinal method of the encapsulated Cipher object, causing any bytes buffered by it to be processed and written out to the underlying stream by calling its flush method.
The KeyGenerator Class
A key generator is used to generate secret keys for symmetric algorithms.
Creating a Key Generator
Like other engine classes in the API, KeyGenerator objects are created using the getInstance factory methods of the KeyGenerator class. A factory method is a static method that returns an instance of a class, in this case, an instance of KeyGenerator which provides an implementation of the requested key generator.
getInstance takes as its argument the name of a symmetric algorithm for which a secret key is to be generated. Optionally, a package provider name may be specified:
public static KeyGenerator getInstance(String algorithm);
public static KeyGenerator getInstance(String algorithm,
String provider);
If just an algorithm name is specified, the system will determine if there is an implementation of the requested key generator available in the environment, and if there is more than one, if there is a preferred one.
If both an algorithm name and a package provider are specified, the system will determine if there is an implementation of the requested key generator in the package requested, and throw an exception if there is not.
Initializing a KeyGenerator Object
A key generator for a particular symmetric-key algorithm creates a symmetric key that can be used with that algorithm. It also associates algorithm-specific parameters (if any) with the generated key.
There are two ways to generate a key: in an algorithm-independent manner, and in an algorithm-specific manner. The only difference between the two is the initialization of the object:
Algorithm-Independent Initialization
All key generators share the concepts of a keysize and a source of randomness. There is an init method that takes these two universally shared types of arguments. There is also one that takes just a keysize argument, and uses a system-provided source of randomness, and one that takes just a source of randomness:
public void init(SecureRandom random);
public void init(int keysize);
public void init(int keysize, SecureRandom random);
Since no other parameters are specified when you call these algorithm-independent init methods, it is up to the provider what to do about the algorithm-specific parameters (if any) to be associated with the generated key.
Algorithm-Specific Initialization
For situations where a set of algorithm-specific parameters already exists, there are two init methods that have an AlgorithmParameterSpec argument. One also has a SecureRandom argument, while the source of randomness is system-provided for the other:
public void init(AlgorithmParameterSpec params);
public void init(AlgorithmParameterSpec params, SecureRandom random);
In case the client does not explicitly initialize the KeyGenerator (via a call to an init method), each provider must supply (and document) a default initialization.
Creating a Key
The following method generates a secret key:
public SecretKey generateKey();
The SecretKeyFactory Class
This class represents a factory for secret keys.
Key factories are used to convert keys (opaque cryptographic keys of type java.security.Key) into key specifications (transparent representations of the underlying key material in a suitable format), and vice versa.
A javax.crypto.SecretKeyFactory object operates only on secret (symmetric) keys, whereas a java.security.KeyFactory object processes the public and private key components of a key pair.
Objects of type java.security.Key, of which java.security.PublicKey, java.security.PrivateKey, and javax.crypto.SecretKey are subclasses, are opaque key objects, because you cannot tell how they are implemented. The underlying implementation is provider-dependent, and may be software or hardware based. Key factories allow providers to supply their own implementations of cryptographic keys.
For example, if you have a key specification for a Diffie Hellman public key, consisting of the public value y, the prime modulus p, and the base g, and you feed the same specification to Diffie-Hellman key factories from different providers, the resulting PublicKey objects will most likely have different underlying implementations.
A provider should document the key specifications supported by its secret key factory. For example, the SecretKeyFactory for DES keys supplied by the "IBMJCE" provider supports DESKeySpec as a transparent representation of DES keys, the SecretKeyFactory for DES-EDE keys supports DESedeKeySpec as a transparent representation of DES-EDE keys, and the SecretKeyFactory for PBE supports PBEKeySpec as a transparent representation of the underlying password.
The following is an example of how to use a SecretKeyFactory to convert secret key data into a SecretKey object, which can be used for a subsequent Cipher operation:
// Note the following bytes are not realistic secret key data
// bytes but are simply supplied as an illustration of using data
// bytes (key material) you already have to build a DESKeySpec.
byte[] desKeyData = { (byte)0x01, (byte)0x02, (byte)0x03,
(byte)0x04, (byte)0x05, (byte)0x06, (byte)0x07, (byte)0x08 };
DESKeySpec desKeySpec = new DESKeySpec(desKeyData);
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
In this case, the underlying implementation of secretKey is based on the provider of keyFactory.
An alternative, provider-independent way of creating a functionally equivalent SecretKey object from the same key material is to use the javax.crypto.spec.SecretKeySpec class, which implements the javax.crypto.SecretKey interface:
This class enables a programmer to create an object and protect its confidentiality with a cryptographic algorithm.
Given any object that implements the java.io.Serializable interface, one can create a SealedObject that encapsulates the original object, in serialized format (i.e., a "deep copy"), and seals (encrypts) its serialized contents, using a cryptographic algorithm such as DES, to protect its confidentiality. The encrypted content can later be decrypted (with the corresponding algorithm using the correct decryption key) and de-serialized, yielding the original object.
A typical usage is illustrated in the following code segment: In order to seal an object, you create a SealedObject from the object to be sealed and a fully initialized Cipher object that will encrypt the serialized object contents. In this example, the String "This is a secret" is sealed using the DES algorithm. Note that any algorithm parameters that may be used in the sealing operation are stored inside of SealedObject:
// create Cipher object
// Note: sKey is assumed to refer to an already-generated
// secret DES key.
Cipher c = Cipher.getInstance("DES");
c.init(Cipher.ENCRYPT_MODE, sKey);
// do the sealing
SealedObject so = new SealedObject("This is a secret", c);
The original object that was sealed can be recovered in two different ways:
by using a Cipher object that has been initialized with the exact same algorithm, key, padding scheme, etc., that were used to seal the object:
c.init(Cipher.DECRYPT_MODE, sKey);
try {
String s = (String)so.getObject(c);
} catch (Exception e) {
// do something
};
This approach has the advantage that the party who unseals the sealed object does not require knowledge of the decryption key. For example, after one party has initialized the cipher object with the required decryption key, it could hand over the cipher object to another party who then unseals the sealed object.
by using the appropriate decryption key (since DES is a symmetric encryption algorithm, we use the same key for sealing and unsealing):
try {
String s = (String)so.getObject(sKey);
} catch (Exception e) {
// do something
};
In this approach, the getObject method creates a cipher object for the appropriate decryption algorithm and initializes it with the given decryption key and the algorithm parameters (if any) that were stored in the sealed object. This approach has the advantage that the party who unseals the object does not need to keep track of the parameters (e.g., the IV) that were used to seal the object.
The KeyAgreement Class
The KeyAgreement class provides the functionality of a key agreement protocol. The keys involved in establishing a shared secret are created by one of the key generators (KeyPairGenerator or KeyGenerator), a KeyFactory, or as a result from an intermediate phase of the key agreement protocol.
Creating a KeyAgreement Object
Each party involved in the key agreement has to create a KeyAgreement object. Like other engine classes in the API, KeyAgreement objects are created using the getInstance factory methods of the KeyAgreement class. A factory method is a static method that returns an instance of a class, in this case, an instance of KeyAgreement which provides the requested key agreement algorithm.
getInstance takes as its argument the name of a key agreement algorithm. Optionally, a package provider name may be specified:
public static KeyAgreement getInstance(String algorithm);
public static KeyAgreement getInstance(String algorithm, String provider);
If just an algorithm name is specified, the system will determine if there is an implementation of the requested key agreement available in the environment, and if there is more than one, if there is a preferred one.
If both an algorithm name and a package provider are specified, the system will determine if there is an implementation of the requested key agreement in the package requested, and throw an exception if there is not.
Initializing a KeyAgreement Object
You initialize a KeyAgreement object with your private information. In the case of Diffie-Hellman, you initialize it with your Diffie-Hellman private key. Additional initialization information may contain a source of randomness and/or a set of algorithm parameters. Note that if the requested key agreement algorithm requires the specification of algorithm parameters, and only a key, but no parameters are provided to initialize the KeyAgreement object, the key must contain the required algorithm parameters. (For example, the Diffie-Hellman algorithm uses a prime modulus p and a base generator g as its parameters.)
To initialize a KeyAgreement object, call one of its init methods:
public void init(Key key);
public void init(Key key, SecureRandom random);
public void init(Key key, AlgorithmParameterSpec params);
public void init(Key key, AlgorithmParameterSpec params, SecureRandom random);
Executing a KeyAgreement Phase
Every key agreement protocol consists of a number of phases that need to be executed by each party involved in the key agreement.
To execute the next phase in the key agreement, call the doPhase method:
public Key doPhase(Key key, boolean lastPhase);
The key parameter contains the key to be processed by that phase. In most cases, this is the public key of one of the other parties involved in the key agreement, or an intermediate key that was generated by a previous phase. doPhase might return an intermediate key that you might have to send to the other parties of this key agreement, so they can process it in a subsequent phase.
The lastPhase parameter specifies whether or not the phase to be executed is the last one in the key agreement: A value of FALSE indicates that this is not the last phase of the key agreement (there are more phases to follow), and a value of TRUE indicates that this is the last phase of the key agreement and the key agreement is completed, i.e., generateSecret can be called next.
In the example of Diffie-Hellman between two parties (see Appendix E: Sample Programs of the Cryptography Extension Specification document), you call doPhase once, with lastPhase set to TRUE. In the example of Diffie-Hellman between three parties, you call doPhase twice: the first time with lastPhase set to FALSE, the 2nd time with lastPhase set to TRUE.
Generating the Shared Secret
After each party has executed all the required key agreement phases, it can compute the shared secret by calling one of the generateSecret methods:
public byte[] generateSecret();
public int generateSecret(byte[] sharedSecret, int offset);
public SecretKey generateSecret(String algorithm);
The Mac Class
The Mac class provides the functionality of a Message Authentication Code (MAC). Please refer to the code example in Appendix E: Sample Programs of the Cryptography Extension Specification document.
Creating a Mac Object
Like other engine classes in the API, Mac objects are created using the getInstance factory methods of the Mac class. A factory method is a static method that returns an instance of a class, in this case, an instance of Mac which provides the requested MAC algorithm.
getInstance takes as its argument the name of a MAC algorithm. Optionally, a package provider name may be specified:
public static Mac getInstance(String algorithm);
public static Mac getInstance(String algorithm, String provider);
If just an algorithm name is specified, the system will determine if there is an implementation of the requested MAC algorithm available in the environment, and if there is more than one, if there is a preferred one.
If both an algorithm name and a package provider are specified, the system will determine if there is an implementation of the requested MAC algorithm in the package requested, and throw an exception if there is not.
Initializing a Mac Object
A Mac object is always initialized with a (secret) key and may optionally be initialized with a set of parameters, depending on the underlying MAC algorithm.
To initialize a Mac object, call one of its init methods:
public void init(Key key);
public void init(Key key, AlgorithmParameterSpec params);
You can initialize your Mac object with any (secret-)key object that implements the javax.crypto.SecretKey interface. This could be an object returned by javax.crypto.KeyGenerator.generateKey(), or one that is the result of a key agreement protocol, as returned by javax.crypto.KeyAgreement.generateSecret(), or an instance of javax.crypto.spec.SecretKeySpec.
With some MAC algorithms, the (secret-)key algorithm associated with the (secret-)key object used to initialize the Mac object does not matter (this is the case with the HMAC-MD5 and HMAC-SHA1 implementations of the IBMJCE provider). With others, however, the (secret-)key algorithm does matter, and an InvalidKeyException is thrown if a (secret-)key object with an inappropriate (secret-)key algorithm is used.
Computing a MAC
A MAC can be computed in one step (single-part operation) or in multiple steps (multiple-part operation). A multiple-part operation is useful if you do not know in advance how long the data is going to be, or if the data is too long to be stored in memory all at once.
To compute the MAC of some data in a single step, call the following doFinal method:
public byte[] doFinal(byte[] input);
To compute the MAC of some data in multiple steps, call one of the update methods:
public void update(byte input);
public void update(byte[] input);
public void update(byte[] input, int inputOffset, int inputLen);
A multiple-part operation must be terminated by the doFinal method (if there is still some input data left for the last step), or by one of the following doFinal methods (if there is no input data left for the last step):
public byte[] doFinal();
public void doFinal(byte[] output, int outOffset);
Code Examples
Computing a MessageDigest Object
First create the message digest object, as in the following example:
This call assigns a properly initialized message digest object to the sha variable. The implementation implements the Secure Hash Algorithm (SHA-1), as defined in the National Institute for Standards and Technology's (NIST) FIPS 180-2 document. See Appendix A for a complete discussion of standard names and algorithms.
Next, suppose we have three byte arrays, i1, i2 and i3, which form the total input whose message digest we want to compute. This digest (or "hash") could be calculated using the following calls:
After the message digest has been calculated, the message digest object is automatically reset and ready to receive new data and calculate its digest. All former state (that is the data supplied to update calls) is lost.
Some hash implementations might support intermediate hashes through cloning. Suppose we want to calculate separate hashes for:
i1
i1 and i2
i1, i2, and i3
A way to calculate the hashes is:
/* compute the hash for i1 */
sha.update(i1);
byte[] i1Hash = sha.clone().digest();
/* compute the hash for i1 and i2 */
sha.update(i2);
byte[] i12Hash = sha.clone().digest();
/* compute the hash for i1, i2 and i3 */
sha.update(i3);
byte[] i123hash = sha.digest();
This code works only if the SHA-1 implementation is cloneable. While some implementations of message digests are cloneable, others are not. To determine whether or not cloning is possible, attempt to clone the MessageDigest object and catch the potential exception as follows:
try {
// try and clone it
/* compute the hash for i1 */
sha.update(i1);
byte[] i1Hash = sha.clone().digest();
. . .
byte[] i123hash = sha.digest();
} catch (CloneNotSupportedException cnse) {
// do something else, as in the next code example
}
If a message digest is not cloneable, you can compute intermediate digests by creating several digests. In this case, the number of intermediate digests to be computed must be known in advance:
In this example we will generate a public-private key pair for the algorithm named "DSA" (Digital Signature Algorithm). We will generate keys with a 1024-bit modulus, using a user-derived seed, called userSeed. We don't care which provider supplies the algorithm implementation.
The next step is to initialize the key pair generator. In most cases, algorithm-independent initialization is sufficient, but in some cases, algorithm-specific initialization is used.
Algorithm-Independent Initialization
All key pair generators share the concepts of a keysize and a source of randomness. A KeyPairGenerator class initialize method has these two types of arguments. Therefore, to generate keys with a keysize of 1024 and a new SecureRandom object seeded by the userSeed value, you can use the following code:
SecureRandom random = SecureRandom.getInstance("IBMSecureRandom", "IBMJCE");
random.setSeed(userSeed);
keyGen.initialize(1024, random);
Because no other parameters are specified when you call the algorithm-independent initialize method, it is up to the provider to handle the algorithm-specific parameters (if any) that need to be associated with each of the keys. The provider can use precomputed parameter values or can generate new values.
Algorithm-Specific Initialization
For situations where a set of algorithm-specific parameters already exists (such as "community parameters" in DSA), there are two initialize methods that have an AlgorithmParameterSpec argument. Suppose your key pair generator is for the "DSA" algorithm, and you have a set of DSA-specific parameters, p, q, and g, that you would like to use to generate your key pair. You could execute the following code to initialize your key pair generator (DSAParameterSpec is an AlgorithmParameterSpec):
DSAParameterSpec dsaSpec = new DSAParameterSpec(p, q, g);
SecureRandom random = SecureRandom.getInstance("IBMSecureRandom", "IBMJCE");
random.setSeed(userSeed);
keyGen.initialize(dsaSpec, random);
Note: The parameter named p is a prime number whose length is the modulus length ("size"). Therefore, you don't need to call any other method to specify the modulus length.
Generating the Pair of Keys
The final step is generating the key pair. No matter which type of initialization you used (algorithm-independent or algorithm-specific), the same code is used to generate the key pair:
KeyPair pair = keyGen.generateKeyPair();
Generating and Verifying a Signature Using Generated Keys
The following signature generation and verification examples use the key pair generated in the key pair example.
Next, using the key pair generated in the key pair example, we initialize the object with the private key, and then sign a byte array called data.
/* Initializing the object with a private key */
PrivateKey priv = pair.getPrivate();
dsa.initSign(priv);
/* Update and sign the data */
dsa.update(data);
byte[] sig = dsa.sign();
Verifying a Signature
Verifying the signature is straightforward. (Note that here we also use the key pair generated in the key pair example.)
/* Initializing the object with the public key */
PublicKey pub = pair.getPublic();
dsa.initVerify(pub);
/* Update and verify the data */
dsa.update(data);
boolean verifies = dsa.verify(sig);
System.out.println("signature verifies: " + verifies);
Generating or Verifying Signatures Using Key Specifications and KeyFactory
Suppose that, rather than having a public-private key pair (as, for example, was generated in the key pair example), you simply have the components of your DSA private key: x (the private key), p (the prime), q (the sub-prime), and g (the base).
Further suppose you want to use your private key to digitally sign some data, which is in a byte array named someData. You would do the following steps, which also illustrate creating a key specification and using a key factory to obtain a PrivateKey from the key specification (initSign requires a PrivateKey):
DSAPrivateKeySpec dsaPrivKeySpec = new DSAPrivateKeySpec(x, p, q, g);
KeyFactory keyFactory = KeyFactory.getInstance("DSA");
PrivateKey privKey = keyFactory.generatePrivate(dsaPrivKeySpec);
Signature sig = Signature.getInstance("SHA1withDSA");
sig.initSign(privKey);
sig.update(someData);
byte[] signature = sig.sign();
Suppose Alice wants to use the data you signed. In order for her to do so, and to verify your signature, you need to send three things to her:
the data,
the signature, and
the public key corresponding to the private key you used to sign the data.
You can store the someData bytes in one file, and the signature bytes in another, and send those to Alice.
For the public key, assume, as in the signing example, that you have the components of the DSA public key that corresponds to the DSA private key that was used to sign the data. Then you can create a DSAPublicKeySpec from those components:
DSAPublicKeySpec dsaPubKeySpec = new DSAPublicKeySpec(y, p, q, g);
You still need to extract the key bytes so that you can put them in a file. To do so, you can first call the generatePublic method on the DSA key factory already created in the last example:
Then you can extract the (encoded) key bytes using the following method:
byte[] encKey = pubKey.getEncoded();
You can now store these bytes in a file, and send it to Alice along with the files that contain the data and the signature.
Now, assume Alice has received these files, and that she copied the data bytes from the data file to a byte array named data, the signature bytes from the signature file to a byte array named signature, and the encoded public key bytes from the public key file to a byte array named encodedPubKey.
Alice can now execute the following code to verify the signature. The code also illustrates how to use a key factory in order to instantiate a DSA public key from its encoding (initVerify requires a PublicKey).
X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(encodedPubKey);
KeyFactory keyFactory = KeyFactory.getInstance("DSA");
PublicKey pubKey = keyFactory.generatePublic(pubKeySpec);
Signature sig = Signature.getInstance("SHA1withDSA");
sig.initVerify(pubKey);
sig.update(data);
sig.verify(signature);
Note: In the preceding example, Alice needed to generate a PublicKey from the encoded key bits, because initVerify requires a PublicKey. After she has a PublicKey, she could also use the KeyFactorygetKeySpec method to convert it to a DSAPublicKeySpec so that she can access the components, if desired, as in:
Now she can access the DSA public key components y, p, q, and g through the corresponding "get" methods on the DSAPublicKeySpec class (getY, getP, getQ, and getG).
Determining If Two Keys Are Equal
In many cases you would like to know if two keys are equal; however, the default method java.lang.Object.equals might not give the desired result. The most provider-independent approach is to compare the encoded keys. If this comparison isn't appropriate (for example, when comparing an RSAPrivateKey and an RSAPrivateCrtKey), you should compare each component. The following code demonstrates this idea:
static boolean keysEqual(Key key1, Key key2) {
if (key1.equals(key2)) {
return true;
}
if (Arrays.equals(key1.getEncoded(), key2.getEncoded())) {
return true;
}
// More code for different types of keys here.
// For example, the following code can check if
// an RSAPrivateKey and an RSAPrivateCrtKey are equal:
// if ((key1 instanceof RSAPrivateKey) &&
// (key2 instanceof RSAPrivateKey)) {
// if ((key1.getModulus().equals(key2.getModulus())) &&
// (key1.getPrivateExponent().equals(
// key2.getPrivateExponent()))) {
// return true;
// }
// }
return false;
}
Reading Base64-Encoded Certificates
The following example reads a file with Base64-encoded certificates, which are each bounded at the beginning by
-----BEGIN CERTIFICATE-----
and at the end by
-----END CERTIFICATE-----
We convert the FileInputStream (which does not support mark and reset) to a ByteArrayInputStream (which supports those methods), so that each call to generateCertificate consumes only one certificate, and the read position of the input stream is positioned to the next certificate in the file:
FileInputStream fis = new FileInputStream(filename);
DataInputStream dis = new DataInputStream(fis);
CertificateFactory cf = CertificateFactory.getInstance("X.509");
byte[] bytes = new byte[dis.available()];
dis.readFully(bytes);
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
while (bais.available() > 0) {
Certificate cert = cf.generateCertificate(bais);
System.out.println(cert.toString());
}
Parsing a Certificate Reply
The following example parses a PKCS #7-formatted certificate reply stored in a file and extracts all the certificates from it:
FileInputStream fis = new FileInputStream(filename);
CertificateFactory cf = CertificateFactory.getInstance("X.509");
Collection c = cf.generateCertificates(fis);
Iterator i = c.iterator();
while (i.hasNext()) {
Certificate cert = (Certificate)i.next();
System.out.println(cert);
}
This section is a short tutorial on how to use some of the major features of the JCE APIs in IBM SDK Java Technology Edition Version 6. Complete sample programs that exercise the APIs can be found in Appendix E: Sample Programs of the Cryptography Extension Specification document.
Using Encryption
This section takes the user through the process of generating a key, creating and initializing a cipher object, encrypting a file, and then decrypting it. Throughout this example, we use the Data Encryption Standard (DES).
Generating a Key
To create a DES key, we have to instantiate a KeyGenerator for DES. We do not specify a provider, because we do not care about a particular DES key generation implementation. Since we do not initialize the KeyGenerator, a system-provided source of randomness will be used to create the DES key:
After the key has been generated, the same KeyGenerator object can be re-used to create further keys.
Creating a Cipher
The next step is to create a Cipher instance. To do this, we use one of the getInstance factory methods of the Cipher class. We must specify the name of the requested transformation, which includes the following components, separated by slashes (/):
the algorithm name
the mode (optional)
the padding scheme (optional)
In this example, we create a DES (Data Encryption Standard) cipher in Electronic Codebook mode, with PKCS #5-style padding. We do not specify a provider, because we do not care about a particular implementation of the requested transformation.
The standard algorithm name for DES is "DES", the standard name for the Electronic Codebook mode is "ECB", and the standard name for PKCS #5-style padding is "PKCS5Padding":
Cipher desCipher;
// Create the cipher
desCipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
We use the generated desKey from the last example to initialize the Cipher object for encryption:
// Initialize the cipher for encryption
desCipher.init(Cipher.ENCRYPT_MODE, desKey);
// Our cleartext
byte[] cleartext = "This is just an example".getBytes();
// Encrypt the cleartext
byte[] ciphertext = desCipher.doFinal(cleartext);
// Initialize the same cipher for decryption
desCipher.init(Cipher.DECRYPT_MODE, desKey);
// Decrypt the ciphertext
byte[] cleartext1 = desCipher.doFinal(ciphertext);
cleartext and cleartext1 are identical.
Using Password-Based Encryption
In this example, we prompt the user for a password from which we derive an encryption key.
It would seem logical to collect and store the password in an object of type java.lang.String. However, here's the caveat: Objects of type String are immutable, i.e., there are no methods defined that allow you to change (overwrite) or zero out the contents of a String after usage. This feature makes String objects unsuitable for storing security sensitive information such as user passwords. You should always collect and store security sensitive information in a char array instead.
For that reason, the javax.crypto.spec.PBEKeySpec class takes (and returns) a password as a char array.
The following method is an example of how to collect a user password as a char array:
/**
* Reads user password from given input stream.
*/
public char[] readPasswd(InputStream in) throws IOException {
char[] lineBuffer;
char[] buf;
int i;
buf = lineBuffer = new char[128];
int room = buf.length;
int offset = 0;
int c;
loop: while (true) {
switch (c = in.read()) {
case -1:
case '\n':
break loop;
case '\r':
int c2 = in.read();
if ((c2 != '\n') && (c2 != -1)) {
if (!(in instanceof PushbackInputStream)) {
in = new PushbackInputStream(in);
}
((PushbackInputStream)in).unread(c2);
} else
break loop;
default:
if (--room < 0) {
buf = new char[offset + 128];
room = buf.length - offset - 1;
System.arraycopy(lineBuffer, 0, buf, 0, offset);
Arrays.fill(lineBuffer, ' ');
lineBuffer = buf;
}
buf[offset++] = (char) c;
break;
}
}
if (offset == 0) {
return null;
}
char[] ret = new char[offset];
System.arraycopy(buf, 0, ret, 0, offset);
Arrays.fill(buf, ' ');
return ret;
}
In order to use Password-Based Encryption (PBE) as defined in PKCS #5, we have to specify a salt and an iteration count. The same salt and iteration count that are used for encryption must be used for decryption:
PBEKeySpec pbeKeySpec;
PBEParameterSpec pbeParamSpec;
SecretKeyFactory keyFac;
// Salt
byte[] salt = {
(byte)0xc7, (byte)0x73, (byte)0x21, (byte)0x8c,
(byte)0x7e, (byte)0xc8, (byte)0xee, (byte)0x99
};
// Iteration count
int count = 20;
// Create PBE parameter set
pbeParamSpec = new PBEParameterSpec(salt, count);
// Prompt user for encryption password.
// Collect user password as char array (using the
// "readPasswd" method), and convert
// it into a SecretKey object, using a PBE key
// factory.
System.out.print("Enter encryption password: ");
System.out.flush();
pbeKeySpec = new PBEKeySpec(readPasswd(System.in));
keyFac = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
SecretKey pbeKey = keyFac.generateSecret(pbeKeySpec);
// Create PBE Cipher
Cipher pbeCipher = Cipher.getInstance("PBEWithMD5AndDES");
// Initialize PBE Cipher with key and parameters
pbeCipher.init(Cipher.ENCRYPT_MODE, pbeKey, pbeParamSpec);
// Our cleartext
byte[] cleartext = "This is another example".getBytes();
// Encrypt the cleartext
byte[] ciphertext = pbeCipher.doFinal(cleartext);
Using Key Agreement
Please refer to Appendix E: Sample Programs of the Cryptography Extension Specification document for sample programs exercising the Diffie-Hellman key exchange between 2 and 3 parties, respectively.
Appendix A: Standard Names
The Java 2 SDK Security API requires and uses a set of standard names for algorithms, certificate and keystore types. This specification establishes the following names as standard names.
In some cases, naming conventions are suggested for forming names that are not explicitly listed to facilitate name consistency across provider implementations. Such suggestions use items in angle brackets (such as <digest> and <encryption>) as placeholders to be replaced by specific message digest, encryption algorithm, and other names.
Note: Algorithm names are not case-sensitive.
This appendix includes corresponding lists of standard names relevant to the various security subareas:
The algorithm names in this section can be specified when you are generating an instance of MessageDigest.
MD2: The MD2 message digest algorithm as defined in RFC 1319.
MD5: The MD5 message digest algorithm as defined in RFC 1321.
SHA-1, SHA-256, SHA-384, SHA-512: The Secure Hash Algorithm, as defined in Secure Hash Standard, NIST FIPS 180-2.
Key and Parameter Algorithms
The algorithm names in this section can be specified when you are generating an instance of KeyPairGenerator, KeyFactory, AlgorithmParameterGenerator, and AlgorithmParameters.
DSA: The Digital Signature Algorithm as defined in FIPS 186-2.
RSA: The RSA encryption algorithm as defined in PKCS #1.
Digital Signature Algorithms
The algorithm names in this section can be specified when generating an instance of Signature.
MD2withRSA: The MD2 with RSA Encryption signature algorithm that uses the MD2 digest algorithm and RSA to create and verify RSA digital signatures as defined in PKCS #1.
MD5withRSA: The MD5 with RSA Encryption signature algorithm that uses the MD5 digest algorithm and RSA to create and verify RSA digital signatures as defined in PKCS #1.
SHA1withDSA: The DSA with SHA-1 signature algorithm that uses the SHA-1 digest algorithm and DSA to create and verify DSA digital signatures as defined in FIPS 186-2.
SHA1withRSA: The signature algorithm with SHA-1 and the RSA encryption algorithm as defined in the OSI Interoperability Workshop, using the padding conventions described in PKCS #1.
<digest>with<encryption>: Use this to form a name for a signature algorithm with a particular message digest (such as MD2 or MD5) and algorithm (such as RSA or DSA), just as was done for the explicitly defined standard names in this section (MD2withRSA, and so on). For the new signature schemes defined in PKCS #1 v 2.0, for which the <digest>with<encryption> form is insufficient, <digest>with<encryption>and<mgf> can be used to form a name. Here, <mgf> should be replaced by a mask generation function such as MGF1. Example: MD5withRSAandMGF1.
Random Number Generation (RNG) Algorithms
The algorithm names in this section can be specified when generating an instance of SecureRandom.
IBMSecureRandom: The name of the random number generation algorithm supplied by the IBMJCE provider. This implementation uses an MD5 message digest and computes the hash over a true-random seed value.
Certificate Types
The types in this section can be specified when you are generating an instance of CertificateFactory.
X.509: The certificate type defined in X.509.
Keystore Types
The types in this section can be specified when you are generating an instance of KeyStore.
JKS: The name of the keystore implementation provided by the IBMJCE provider.
PKCS12: The transfer syntax for personal identity information as defined in PKCS #12. Implementation provided by the IBMJCE provider.
Service Attributes
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 (such as DSA), and a CertificateFactory service is always associated with a particular certificate type (such as X.509).
The attributes in this section are for cryptographic services. The service attributes can be used as filters for selecting providers.
The attribute name and value are not case sensitive.
KeySize: The maximum key size that the provider supports for the cryptographic service.
ImplementedIn: Whether the implementation for the cryptographic service is done by software or hardware. The value of this attribute is "software" or "hardware".
Appendix B: Algorithms
This appendix specifies details concerning some of the algorithms defined in Appendix A.
Specification
The following table shows the fields of the algorithm specifications.
Field
Description
Name
The name by which the algorithm is known. This is the name passed to the getInstance method (when requesting the algorithm), and returned by the getAlgorithm method to determine the name of an existing algorithm object. These methods are in the relevant engine classes: Signature, MessageDigest, KeyPairGenerator, and AlgorithmParameterGenerator.
Type
The type of algorithm: Signature, MessageDigest, KeyPairGenerator, or ParameterGenerator.
Description
General notes about the algorithm, including any standards implemented by the algorithm, applicable patents, and so on
KeyPair Algorithm (optional)
The key pair algorithm for this algorithm.
Keysize (optional)
For a keyed algorithm or key generation algorithm: the legal key sizes.
Size (optional)
For an algorithm parameter generation algorithm: the legal "sizes" for algorithm parameter generation.
Parameter Defaults (optional)
For a key generation algorithm: the default parameter values.
Signature Format (optional)
For a Signature algorithm, the format of the signature, that is, the input and output of the verify and sign methods, respectively.
Algorithm Specifications
SHA-Family Message Digest Algorithms
Component
Description
Name
SHA-1, SHA-256, SHA-384, SHA-512
Type
MessageDigest
Description
The family of message digest algorithms as defined in the NIST FIPS 180-2. The output of these algorithm are a 160-bit, 256-bit, 384-bit, and 512-bit digest respectively.
MD2 Message Digest Algorithm
Component
Description
Name
MD2
Type
MessageDigest
Description
The message digest algorithm as defined in RFC 1319. The output of this algorithm is a 128-bit (16 byte) digest.
MD5 Message Digest Algorithm
Component
Description
Name
MD5
Type
MessageDigest
Description
The message digest algorithm as defined in RFC 1321. The output of this algorithm is a 128-bit (16 byte) digest.
The Digital Signature Algorithm
Component
Description
Name
SHA1withDSA, SHA2withDSA
Type
Signature
Description
This algorithm is the signature algorithm described in NIST FIPS 186-2, using DSA with the SHA-1 or SHA-256 message digest algorithm.
KeyPair Algorithm
DSA
Signature Format
ASN.1 sequence of two INTEGER values: r and s, in that order:
SEQUENCE ::= { r INTEGER, s INTEGER }
RSA-based Signature Algorithms
Component
Description
Name
MD2withRSA, MD5withRSA, SHA1withRSA, SHA2withRSA, SHA3withRSA, and SHA5withRSA
Type
Signature
Description
These are the signature algorithms that use the MD2, MD5, SHA-1, SHA-256, SHA-384, and SHA-512 message digest algorithms (respectively) with RSA encryption.
This algorithm is the key pair generation algorithm described in PKCS #1.
Strength
Any integer that is a multiple of 8, greater than or equal to 512.
DSA Parameter Generation Algorithm
Component
Description
Name
DSA
Type
ParameterGenerator
Description
This algorithm is the parameter generation algorithm described in NIST FIPS 186-2 for DSA.
Strength
The length, in bits, of the modulus p. This length must range from 512 to 2048, and must be a multiple of 64. The default size is 2048.
Appendix C: IBMJCE Keysize Restrictions
The IBMJCE provider enforces the following restrictions on the keysize passed to the initialization methods of the following classes:
KeyGenerator
Restrictions (by algorithm):
DES: keysize must be equal to 56
Triple DES: keysize must be equal to 112 or 168
Note: A keysize of 112 will generate a Triple DES key with 2 intermediate keys, and a keysize of 168 will generate a Triple DES key with 3 intermediate keys.
Blowfish: keysize must be a multiple of 8, and can only range from 32 to 448, inclusive
KeyPairGenerator
Restrictions (by algorithm):
Diffie-Hellman: keysize must be a multiple of 64, and can only range from 512 to 2048, inclusive
AlgorithmParameterGenerator
Restrictions (by algorithm):
Diffie-Hellman: keysize must be a multiple of 64, and can only range from 512 to 2048, inclusive
Appendix D: Jurisdiction Policy File Format
JCE represents its jurisdiction policy files as J2SE-style policy files with corresponding permission statements. As described in Default Policy Implementation and Policy File Syntax, a J2SE policy file specifies what permissions are allowed for code from specified code sources. A permission represents access to a system resource. In the case of JCE, the "resources" are cryptography algorithms, and code sources do not need to be specified, because the cryptographic restrictions apply to all code.
A jurisdiction policy file consists of a very basic "grant entry" containing one or more "permission entries."
grant {
<permission entries>;
};
The format of a permission entry in a jurisdiction policy file is:
permission <crypto permission class name>[ <alg_name>
[[, <exemption mechanism name>][, <maxKeySize>
[, <AlgorithmParameterSpec class name>,
<parameters for constructing an
AlgorithmParameterSpec object>]]]];
A sample jurisdiction policy file that includes restricting the "Blowfish" algorithm to maximum key sizes of 64 bits is:
grant {
permission javax.crypto.CryptoPermission "Blowfish", 64;
. . .;
};
A permission entry must begin with the word permission. The <crypto permission class name> in the template shown would actually be a specific permission class name, such as javax.crypto.CryptoPermission. A crypto permission class reflects the ability of an application/applet to use certain algorithms with certain key sizes in certain environments. There are two crypto permission classes: CryptoPermission and CryptoAllPermission. The special CryptoAllPermission class implies all cryptography-related permissions, that is, it specifies that there are no cryptography-related restrictions.
The <alg_name>, when utilized, is a quoted string specifying the standard name (see Appendix A) of a cryptography algorithm, such as "DES" or "RSA".
The <exemption mechanism name>, when specified, is a quoted string indicating an exemption mechanism which, if enforced, enables a reduction in cryptographic restrictions. Exemption mechanism names that can be used include "KeyRecovery""KeyEscrow", and "KeyWeakening".
<maxKeySize> is an integer specifying the maximum key size (in bits) allowed for the specified algorithm.
For some algorithms it may not be sufficient to specify the algorithm strength in terms of just a key size. For example, in the case of the "RC5" algorithm, the number of rounds must also be considered. For algorithms whose strength needs to be expressed as more than a key size, the permission entry should also specify an AlgorithmParameterSpec class name (such as javax.crypto.spec.RC5ParameterSpec) and a list of parameters for constructing the specified AlgorithmParameterSpec object.
Items that appear in a permission entry must appear in the specified order. An entry is terminated with a semicolon.
Case is unimportant for the identifiers (grant, permission) but is significant for the <crypto permission class name> or for any string that is passed in as a value.
Note: An "*" can be used as a wildcard for any permission entry option. For example, an "*" (without the quotes) for an <alg_name> option means "all algorithms."
Appendix E: Maximum Key Sizes Allowed by "Strong" Jurisdiction Policy Files
Due to import control restrictions, the jurisdiction policy files shipped with the IBM SDK Java Technology Edition Version 6 development kit allow "strong" but limited cryptography to be used. Here are the maximum key sizes allowed by this "strong" version of the jurisdiction policy files:
Table 5. Maximum key sizes
Algorithm
Maximum Key Size
DES
64
DESede
112 (effective) or 168 (effective)
RC2
128
RC4
256
RSA
65536
* (all others)
128
Appendix F: Supported Algorithms
For a list of algorithms supported by the IBM JCE provider, and the corresponding aliases, download the JCE Samples file. Extract, locate and run the JCEAlgorithms.java sample, which queries the IBM JCE provider and prints a list of supported algorithms.
Notices
This information was developed for products and services offered in the U.S.A. IBM may not offer the products, services, or features discussed in this document in other countries. Consult your local IBM representative for information on the products and services currently available in your area. Any reference to an IBM product, program, or service is not intended to state or imply that only that IBM product, program, or service may be used. Any functionally equivalent product, program, or service that does not infringe any IBM intellectual property right may be used instead. However, it is the user's responsibility to evaluate and verify the operation of any non-IBM product, program, or service.
IBM may have patents or pending patent applications covering subject matter in this document. The furnishing of this document does not give you any license to these patents. You can send license inquiries, in writing, to:
IBM Director of Licensing
IBM Corporation
North Castle Drive, Armonk
NY 10504-1758 U.S.A.
For license inquiries regarding double-byte (DBCS) information, contact the IBM Intellectual Property Department in your country or send inquiries, in writing, to:
Intellectual Property Licensing
Legal and Intellectual Property Law
IBM Japan Ltd.
1623-14, Shimotsuruma, Yamato-shi
Kanagawa 242-8502 Japan
The following paragraph does not apply to the United Kingdom or any other country where such provisions are inconsistent with local law:
INTERNATIONAL BUSINESS MACHINES CORPORATION PROVIDES THIS PUBLICATION "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Some states do not allow disclaimer of express or implied warranties in certain transactions, therefore, this statement may not apply to you.
This information could include technical inaccuracies or typographical errors. Changes are periodically made to the information herein; these changes will be incorporated in new editions of the information. IBM may make improvements and/or changes in the product(s) and/or the program(s) described in this information at any time without notice.
Any references in this information to non-IBM Web sites are provided for convenience only and do not in any manner serve as an endorsement of those Web sites. The materials at those Web sites are not part of the materials for this IBM product and use of those Web sites is at your own risk.
IBM may use or distribute any of the information you supply in any way it believes appropriate without incurring any obligation to you.
Licensees of this program who wish to have information about it for the purpose of enabling (i) the exchange of information between independently created programs and other programs (including this one) and (ii) the mutual use of the information which has been exchanged, should contact:
JIMMAIL@uk.ibm.com
[Hursley Java Technology Center (JTC) contact]
Such information may be available, subject to appropriate terms and conditions, including in some cases, payment of a fee.
The licensed program described in this document and all licensed material available for it are provided by IBM under terms of the IBM Customer Agreement, IBM International Program License Agreement or any equivalent agreement between us.
Any performance data contained herein was determined in a controlled environment. Therefore, the results obtained in other operating environments may vary significantly. Some measurements may have been made on development-level systems and there is no guarantee that these measurements will be the same on generally available systems. Furthermore, some measurement may have been estimated through extrapolation. Actual results may vary. Users of this document should verify the applicable data for their specific environment.
Information concerning non-IBM products was obtained from the suppliers of those products, their published announcements or other publicly available sources. IBM has not tested those products and cannot confirm the accuracy of performance, compatibility or any other claims related to non-IBM products. Questions on the capabilities of non-IBM products should be addressed to the suppliers of those products.
Trademarks
IBM is a trademark or registered trademark of International Business Machines Corporation in the United States, or other countries, or both.
Java and all Java-based trademarks and logos are trademarks or registered trademarks of Oracle and/or its affiliates in the United States, other countries, or both.
Other company, product, or service names may be trademarks or service marks of others.
Java Security Architecture Specification
