Java^TM Cryptography Extension 1.2

This document is intended as a companion to the Java^TM Cryptography Architecture (JCA) API Specification & Reference. References to chapters not present in this document are to chapters in the JCA Specification.
The Java^TM Cryptography Extension (JCE) 1.2 provides a framework and implementations for encryption, key generation and key agreement, and Message Authentication Code (MAC) algorithms. Support for encryption includes symmetric, asymmetric, block, and stream ciphers. The software also supports secure streams and sealed objects.
JCE 1.2 is designed so that other cryptography libraries can be plugged in as a service provider, and new algorithms can be added seamlessly.
JCE 1.2 supplements the Java Development Kit 1.2 (JDK^TM), which already includes interfaces and implementations of message digests and digital signatures. JCE 1.2 is provided as an extension to the Java^TM platform.
The architecture of the JCE follows the same design principles found elsewhere in the JCA: implementation independence and, whenever possible, algorithm independence. It uses the same "provider" architecture.
The JCE 1.2 API covers:

Symmetric bulk encryption, such as DES, RC2, and IDEA

Symmetric stream encryption, such as RC4

Asymmetric encryption, such as RSA

Password-based encryption (PBE)

Key Agreement

Message Authentication Codes (MAC)

JCE 1.2 comes standard with a provider named "SunJCE", which must be installed and which supplies the following cryptographic services:

An implementation of the DES (FIPS PUB 46-1), Triple DES, and Blowfish encryption algorithms in the Electronic Code Book (ECB), Cipher Block Chaining (CBC), Cipher Feedback (CFB), Output Feedback (OFB), and Propagating Cipher Block Chaining (PCBC) modes. (Note: Throughout this document, the terms "Triples DES" and "DES-EDE" will be used interchangeably.)

Key generators for generating keys suitable for the DES, Triple DES, Blowfish, HMAC-MD5, and HMAC-SHA1 algorithms.

An implementation of the MD5 with DES-CBC password-based encryption (PBE) algorithm defined in PKCS #5.

"Secret-key factories" providing bi-directional conversions between opaque DES, Triple DES and PBE key objects and transparent representations of their underlying key material.

An implementation of the Diffie-Hellman key agreement algorithm between two or more parties.

A Diffie-Hellman key pair generator for generating a pair of public and private values suitable for the Diffie-Hellman algorithm.

A Diffie-Hellman algorithm parameter generator.

A Diffie-Hellman "key factory" providing bi-directional conversions between opaque Diffie-Hellman key objects and transparent representations of their underlying key material.

Algorithm parameter managers for Diffie-Hellman, DES, Triple DES, Blowfish, and PBE parameters.

An implementation of the HMAC-MD5 and HMAC-SHA1 keyed-hashing algorithms defined in RFC 2104.

An implementation of the padding scheme described in PKCS#5.

A keystore implementation for the proprietary keystore type named "JCEKS".

Cryptographic Concepts

This section provides a high-level description of the concepts implemented by the API, and the exact meaning of the technical terms used in the API specification.
Encryption and Decryption

Encryption is the process of taking data (called cleartext) and a short string (a key), and producing data (ciphertext) meaningless to a third-party who does not know the key. Decryption is the inverse process: that of taking ciphertext and a short key string, and producing cleartext.
Password-Based Encryption

Password-Based Encryption (PBE) derives an encryption key from a password. In order to make the task of getting from password to key very time-consuming for an attacker, most PBE implementations will mix in a random number, known as a salt, to create the key.
Cipher

Encryption and decryption are done using a cipher. A cipher is an object capable of carrying out encryption and decryption according to an encryption scheme (algorithm).
Key Agreement

Key agreement is a protocol by which 2 or more parties can establish the same cryptographic keys, without having to exchange any secret information.

Message Authentication Code

A Message Authentication Code (MAC) provides a way to check the integrity of information transmitted over or stored in an unreliable medium, based on a secret key. Typically, message authentication codes are used between two parties that share a secret key in order to validate information transmitted between these parties.
A MAC mechanism that is based on cryptographic hash functions is referred to as HMAC. HMAC can be used with any cryptographic hash function, e.g., MD5 or SHA-1, in combination with a secret shared key. HMAC is specified in RFC 2104.

Core Classes

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.
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 feedback 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 have been specified, provider-specific default values for the mode and padding scheme are used. For example, the SunJCE 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 SunJCE provider,
Cipher c1 = Cipher.getInstance("DES/EBC/PKCS5Padding");

and
Cipher c1 = Cipher.getInstance("DES");

are equivalent statements.
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 SunJCE 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 two modes (encryption or decryption), which are defined as final integer constants in the Cipher class. The two modes can be referenced by their symbolic names:

ENCRYPT_MODE

DECRYPT_MODE

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), 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, Key key, 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 was used.
See the section about Managing Algorithm Parameters for more details.
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 above 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) was 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.
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.
    c.init(...);
 
    // encrypt some data and store away ciphertext
    // for later decryption
    byte[] cipherText = c.doFinal(...);

    // 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 from above
    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 from above
    c.init(...);
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 SunJCE 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 outOutputSize(int inputLen)
The Cipher Stream Classes
JCE 1.2 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 additonally 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 have been processed by the Cipher.
It is crucial for a programmer using this class not to use methods that are not defined or overriden 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 and cipher2 have been initialized for encryption and decryption (with corresponding keys), respectively. The code below demonstrates how to easily connect several instances of CipherInputStream and InputStream:
    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);
    }
The above 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.
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 overriden 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.
The following example demonstrates the usage of CipherOutputStream, where several instances of CipherOutputStream and OutputStream are connected. It is assumed 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();
The above 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 the above 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 "SunJCE" 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:
    byte[] desKeyData = { (byte)0x01, (byte)0x02, ...};
    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:
    byte[] desKeyData = { (byte)0x01, (byte)0x02, ...};
    SecretKeySpec secretKey = new SecretKeySpec(desKeyData, "DES");
The SealedObject Class
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
    byte[] sKey; // the secret DES key (already generated)
    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 may return an intermediate key that you may 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 agreeement: 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 D), 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 D.
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 SunJCE 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 one of the doFinal methods:
    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 one of the above 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 void doFinal(byte[] output, int outOffset);

Installing Providers for JCE 1.2

Cryptographic providers for JCE 1.2 are installed and configured in much the same way as cryptographic providers for the JDK. The only difference is that when you install a JCE 1.2 provider other than the default "SunJCE" (which comes standard with JCE 1.2), you also need to make sure that JCE 1.2 is installed. More information about installing and configuring providers can be found in the Installing Providers section of the Java^TM Cryptography Architecture API Specification & Reference document.
Note that although the "SunJCE" provider is supplied with every JCE 1.2 installation, it still needs to be registered explicitly: either statically or dynamically.
Static registration of SunJCE provider
In order to statically add "SunJCE" to your list of approved providers, you need to edit the security properties file
<java-home>\lib\security\java.security         [Win32]
<java-home>/lib/security/java.security         [Solaris]
Here <java-home> refers to the directory where the JRE was installed. For example, if you have JDK 1.2 installed on Solaris, you need to edit the following file:
jdk1.2/jre/lib/security/java.security
Similarly, if you have JRE 1.2 installed on Solaris, you need to edit this file:
jre1.2/lib/security
Add the following line to the java.security file, substituting the preference order of "SunJCE" for n:
    security.provider.n=com.sun.crypto.provider.SunJCE
This declares the "SunJCE" provider, and specifies its preference order n.
Dynamic registration of SunJCE provider
To dynamically add the "SunJCE" provider to your list of providers, call either the addProvider or insertProviderAt method in the Security class:
    Provider sunJce = new com.sun.crypto.provider.SunJCE();
    Security.addProvider(sunJce);
This type of registration is not persistent and can only be done by "trusted" programs. See Security.
Note that the "SunJCE" provider relies on some of the algorithm implementations supplied by the "SUN" provider, which is the default provider of JDK 1.2. This means that when you install the "SunJCE" provider, you need to make sure that the "SUN" provider is also installed. Note that when you install JDK 1.2 (or JRE 1.2), the "SUN" provider is automatically configured as a static provider.

JCE Keystore

The "SunJCE" provider supplies its own implementation of the java.security.KeyStore class in JDK 1.2. Its implementation employs a much stronger protection of private keys (using password-based encryption with Triple DES) than the keystore implementation supplied by the "SUN" provider in JDK 1.2. (Note that because JDK 1.2 is distributed world-wide in binary and source format, it cannot employ any strong encryption mechanisms.)
In order to take advantage of the keystore implementation of the "SunJCE" provider, you specify "JCEKS" as the keystore type.
You may upgrade your keystore of type "JKS" - this is the name of the keystore type implemented by the "SUN" provider in JDK 1.2 - to a JCE 1.2 keystore of type "JCEKS" by changing the password of a private-key entry in your keystore. Note that once you have upgraded your keystore, your keystore can no longer be accessed without JCE 1.2 installed.
To apply the cryptographically strong(er) key protection supplied by "SunJCE" to a private key named "signkey" in your default keystore, use the following command, which will prompt you for the old and new key passwords:
    keytool -keypasswd -alias signkey -storetype jceks
You may want to change the password back to its old value, using the same command.
See the keytool user guide for more information about keystores and how they are managed.

Code Examples

This section is a short tutorial on how to use some of the major features of the JCE APIs. Complete sample programs that exercise the APIs can be found in Appendix D of this 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:
    KeyGenerator keygen = KeyGenerator.getInstance("DES");
    SecretKey desKey = keygen.generateKey();
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 above 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 from above), and convert
    // it into a SecretKey object, using a PBE key
    // factory.
    System.err.print("Enter encryption password:  ");
    System.err.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 D for sample programs exercising the Diffie-Hellman key exchange between 2 and 3 parties, respectively.

Appendix A: Standard Names

The JCE 1.2 API requires and utilizes a set of standard names for algorithms, algorithm modes, and padding schemes. This specification establishes the following names as standard names. It supplements the list of standard names defined in Appendix A in the Java^TM Cryptography Architecture API Specification & Reference. Note that algorithm names are treated case-insensitive.
Cipher
Algorithm

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

DES: The Digital Encryption Standard as described in FIPS PUB 46-2.

DESede: Triple DES Encryption (DES-EDE).

PBEWithMD5AndDES: The password-based encryption algorithm as defined in: RSA Laboratories, "PKCS #5: Password-Based Encryption Standard," version 1.5, Nov 1993. Note that this algorithm implies CBC as the cipher mode and PKCS5Padding as the padding scheme and cannot be used with any other cipher modes or padding schemes.

Blowfish: The block cipher designed by Bruce Schneier.

Mode

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

ECB: Electronic Codebook Mode, as defined in: The National Institute of Standards and Technology (NIST) Federal Information Processing Standard (FIPS) PUB 81, "DES Modes of Operation," U.S. Department of Commerce, Dec 1980.

CBC: Cipher Block Chaining Mode, as defined in FIPS PUB 81.

CFB: Cipher Feedback Mode, as defined in FIPS PUB 81.

OFB: Output Feedback Mode, as defined in FIPS PUB 81.

PCBC: Plaintext Cipher Block Chaining, as defined by Kerberos.

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

PKCS5Padding: The padding scheme described in: RSA Laboratories, "PKCS #5: Password-Based Encryption Standard," version 1.5, November 1993.
SSL3Padding: The padding scheme defined in the SSL Protocol Version 3.0, November 18, 1996, section 5.2.3.2 (CBC block cipher):
    block-ciphered struct {
        opaque content[SSLCompressed.length];
        opaque MAC[CipherSpec.hash_size];
        uint8 padding[GenericBlockCipher.padding_length];
        uint8 padding_length;
    } GenericBlockCipher;
The size of an instance of a GenericBlockCipher must be a multiple of the block cipher's block length.
The padding length, which is always present, contributes to the padding, which implies that if:
    sizeof(content) + sizeof(MAC) % block_length = 0,
padding has to be (block_length - 1) bytes long, because of the existence of padding_length.
This make the padding scheme similar (but not quite) to PKCS5Padding, where the padding length is encoded in the padding (and ranges from 1 to block_length). With the SSL scheme, the sizeof(padding) is encoded in the always present padding_length and therefore ranges from 0 to block_length-1.
Note that this padding mechanism is not supported by the "SunJCE" provider.
KeyAgreement

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

DiffieHellman: Diffie-Hellman Key Agreement as defined in PKCS #3: Diffie-Hellman Key-Agreement Standard, RSA Laboratories, version 1.4, November 1993.

KeyGenerator

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

DES

DESede

Blowfish

HmacMD5

HmacSHA1

KeyPairGenerator

The following algorithm names can be specified when requesting an instance of KeyPairGenerator:

DiffieHellman

SecretKeyFactory

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

DES

DESede

PBEWithMD5AndDES: Secret-key factory for use with PKCS #5 password-based encryption. Uses only the low order 8 bits of each password character.

KeyFactory

The following algorithm names can be specified when requesting an instance of KeyFactory:

DiffieHellman

AlgorithmParameterGenerator

The following algorithm names can be specified when requesting an instance of AlgorithmParameterGenerator:

DiffieHellman

AlgorithmParameters

The following algorithm names can be specified when requesting an instance of AlgorithmParameters:

DiffieHellman

DES

DESede

PBE

Blowfish

MAC

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

HmacMD5: The HMAC-MD5 keyed-hashing algorithm as defined in RFC 2104: "HMAC: Keyed-Hashing for Message Authentication" (February 1997).

HmacSHA1: The HMAC-SHA1 keyed-hashing algorithm as defined in RFC 2104: "HMAC: Keyed-Hashing for Message Authentication" (February 1997).

Keystore Types

The following types can be specified when requesting an instance of KeyStore:

JCEKS: The proprietary keystore type implemented by the "SunJCE" provider.

Appendix B: SunJCE Default Keysizes

The SunJCE provider uses the following default keysizes:

KeyGenerator

DES: 56 bits

Triple DES: 112 bits

Blowfish: 56 bytes

HmacMD5: 64 bytes

HmacSHA1: 64 bytes

KeyPairGenerator

Diffie-Hellman: 1024 bits

AlgorithmParameterGenerator

Diffie-Hellman: 1024 bits

Appendix C: SunJCE Keysize Restrictions

The SunJCE 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 multiple of 8, and can only range from 32 to 448, inclusive

KeyPairGenerator
Restrictions (by algorithm):

Diffie-Hellman: keysize must be multiple of 64, and can only range from 512 to 1024, inclusive

AlgorithmParameterGenerator
Restrictions (by algorithm):

Diffie-Hellman: keysize must be multiple of 64, and can only range from 512 to 1024, inclusive

Appendix D: Sample Programs

Diffie-Hellman Key Exchange between 2 Parties

/*
 * Copyright 1997, 1998 by Sun Microsystems, Inc.,
 * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
 * All rights reserved.
 *
 * This software is the confidential and proprietary information
 * of Sun Microsystems, Inc. ("Confidential Information").  You
 * shall not disclose such Confidential Information and shall use
 * it only in accordance with the terms of the license agreement
 * you entered into with Sun.
 */

import java.io.*;
import java.math.BigInteger;
import java.security.*;
import java.security.spec.*;
import java.security.interfaces.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import javax.crypto.interfaces.*;
import com.sun.crypto.provider.SunJCE;

/**
 * This program executes the Diffie-Hellman key agreement protocol
 * between 2 parties: Alice and Bob.
 *
 * By default, preconfigured parameters (1024-bit prime modulus and base
 * generator used by SKIP) are used.
 * If this program is called with the "-gen" option, a new set of
 * parameters is created.
 */

public class DHKeyAgreement2 {

    private DHKeyAgreement2() {}

    public static void main(String argv[]) {
	try {
	    String mode = "USE_SKIP_DH_PARAMS";

	    // Add JCE to the list of providers
            SunJCE jce = new SunJCE();
            Security.addProvider(jce);

	    DHKeyAgreement2 keyAgree = new DHKeyAgreement2();

	    if (argv.length > 1) {
		keyAgree.usage();
		throw new Exception("Wrong number of command options");
	    } else if (argv.length == 1) {
		if (!(argv[0].equals("-gen"))) {
		    keyAgree.usage();
		    throw new Exception("Unrecognized flag: " + argv[0]);
		}
		mode = "GENERATE_DH_PARAMS";
	    }

	    keyAgree.run(mode);
	} catch (Exception e) {
	    System.err.println("Error: " + e);
	    System.exit(1);
	}
    }

    private void run(String mode) throws Exception {

	DHParameterSpec dhSkipParamSpec;

	if (mode.equals("GENERATE_DH_PARAMS")) {
	    // Some central authority creates new DH parameters
	    System.err.println
		("Creating Diffie-Hellman parameters (takes VERY long) ...");
	    AlgorithmParameterGenerator paramGen
		= AlgorithmParameterGenerator.getInstance("DH");
	    paramGen.init(512);
	    AlgorithmParameters params = paramGen.generateParameters();
	    dhSkipParamSpec = (DHParameterSpec)params.getParameterSpec
		(DHParameterSpec.class);
	} else {
	    // use some pre-generated, default DH parameters
	    System.err.println("Using SKIP Diffie-Hellman parameters");
	    dhSkipParamSpec = new DHParameterSpec(skip1024Modulus,
						  skip1024Base);
	}

	/*
	 * Alice creates her own DH key pair, using the DH parameters from
	 * above
	 */
	System.err.println("ALICE: Generate DH keypair ...");
	KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");
	aliceKpairGen.initialize(dhSkipParamSpec);
	KeyPair aliceKpair = aliceKpairGen.generateKeyPair();

	// Alice executes Phase1 of her version of the DH protocol
	System.err.println("ALICE: Execute PHASE1 ...");
	KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");
	aliceKeyAgree.init(aliceKpair.getPrivate());

	// Alice encodes her public key, and sends it over to Bob.
	byte[] alicePubKeyEnc = aliceKpair.getPublic().getEncoded();

	/*
	 * Let's turn over to Bob. Bob has received Alice's public key
	 * in encoded format.
	 * He instantiates a DH public key from the encoded key material.
	 */
	KeyFactory bobKeyFac = KeyFactory.getInstance("DH");
	X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec
	    (alicePubKeyEnc);
	PublicKey alicePubKey = bobKeyFac.generatePublic(x509KeySpec);

	/*
	 * Bob gets the DH parameters associated with Alice's public key. 
	 * He must use the same parameters when he generates his own key
	 * pair.
	 */
	DHParameterSpec dhParamSpec = ((DHPublicKey)alicePubKey).getParams();

	// Bob creates his own DH key pair
	System.err.println("BOB: Generate DH keypair ...");
	KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");
	bobKpairGen.initialize(dhParamSpec);
	KeyPair bobKpair = bobKpairGen.generateKeyPair();

	// Bob executes Phase1 of his version of the DH protocol
	System.err.println("BOB: Execute PHASE1 ...");
	KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");
	bobKeyAgree.init(bobKpair.getPrivate());

	// Bob encodes his public key, and sends it over to Alice.
	byte[] bobPubKeyEnc = bobKpair.getPublic().getEncoded();

	/*
	 * Alice uses Bob's public key for Phase2 of her version of the DH
	 * protocol.
	 * Before she can do so, she has to instanticate a DH public key
	 * from Bob's encoded key material.
	 */
	KeyFactory aliceKeyFac = KeyFactory.getInstance("DH");
	x509KeySpec = new X509EncodedKeySpec(bobPubKeyEnc);
	PublicKey bobPubKey = aliceKeyFac.generatePublic(x509KeySpec);
	System.err.println("ALICE: Execute PHASE2 ...");
	aliceKeyAgree.doPhase(bobPubKey, true);

	/*
	 * Bob uses Alice's public key for Phase2 of his version of the DH
	 * protocol.
	 */
	System.err.println("BOB: Execute PHASE2 ...");
	bobKeyAgree.doPhase(alicePubKey, true);
	    
	/*
	 * At this stage, both Alice and Bob have completed the DH key
	 * agreement protocol.
	 * Both generate the (same) shared secret.
	 */
	byte[] aliceSharedSecret = aliceKeyAgree.generateSecret();
	int aliceLen = aliceSharedSecret.length;

	byte[] bobSharedSecret = new byte[aliceLen];
	int bobLen;
	try {
	    // provide output buffer that is too short
	    bobLen = bobKeyAgree.generateSecret(bobSharedSecret, 1);
	} catch (ShortBufferException e) {
	    System.out.println(e.getMessage());
	}
	// provide output buffer of required size
	bobLen = bobKeyAgree.generateSecret(bobSharedSecret, 0);

	System.out.println("Alice secret: " + toHexString(aliceSharedSecret));
	System.out.println("Bob secret: " + toHexString(bobSharedSecret));

        if (!java.util.Arrays.equals(aliceSharedSecret, bobSharedSecret))
	    throw new Exception("Shared secrets differ");
	System.err.println("Shared secrets are the same");

	/*
         * Now let's return the shared secret as a SecretKey object
	 * and use it for encryption. First, we use DES in ECB mode
         * as the encryption algorithm. DES in ECB mode does not require any
         * parameters.
         *
         * Then we use DES in CBC mode, which requires an initialization
         * vector (IV) parameter. In CBC mode, you need to initialize the
         * Cipher object with an IV, which can be supplied using the
         * javax.crypto.spec.IvParameterSpec class. Note that you have to use
         * the same IV for encryption and decryption: If you use a different
         * IV for decryption than you used for encryption, decryption will
         * fail.
         *
         * Note: If you do not specify an IV when you initialize the
         * Cipher object for encryption, the underlying implementation
         * will generate a random one, which you have to retrieve using the
         * javax.crypto.Cipher.getParameters() method, which returns an 
         * instance of java.security.AlgorithmParameters. You need to transfer
         * the contents of that object (e.g., in encoded format, obtained via
         * the AlgorithmParameters.getEncoded() method) to the party who will
         * do the decryption. When initializing the Cipher for decryption,
         * the (reinstantiated) AlgorithmParameters object must be passed to
         * the Cipher.init() method.
         */
	System.out.println("Return shared secret as SecretKey object ...");
        // Bob
	bobKeyAgree.doPhase(alicePubKey, true);
	SecretKey bobDesKey = bobKeyAgree.generateSecret("DES");

        // Alice
	aliceKeyAgree.doPhase(bobPubKey, true);
	SecretKey aliceDesKey = aliceKeyAgree.generateSecret("DES");

        /*
         * Bob encrypts, using DES in ECB mode
         */
	Cipher bobCipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
	bobCipher.init(Cipher.ENCRYPT_MODE, bobDesKey);

	byte[] cleartext = "This is just an example".getBytes();
	byte[] ciphertext = bobCipher.doFinal(cleartext);

        /*
         * Alice decrypts, using DES in ECB mode
         */
	Cipher aliceCipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
	aliceCipher.init(Cipher.DECRYPT_MODE, aliceDesKey);
	byte[] recovered = aliceCipher.doFinal(ciphertext);
	    
	if (!java.util.Arrays.equals(cleartext, recovered))
	    throw new Exception("DIFFERENT");
	System.err.println("SAME");    

        /*
         * Bob encrypts, using DES in CBC mode
         */
	bobCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
	bobCipher.init(Cipher.ENCRYPT_MODE, bobDesKey);

	cleartext = "This is just an example".getBytes();
	ciphertext = bobCipher.doFinal(cleartext);
        // Retrieve the parameter that was used, and transfer it to Alice in
        // encoded format
        byte[] encodedParams = bobCipher.getParameters().getEncoded();

        /*
         * Alice decrypts, using DES in CBC mode
         */
        // Instantiate AlgorithmParameters object from parameter encoding
        // obtained from Bob
        AlgorithmParameters params = AlgorithmParameters.getInstance("DES");
        params.init(encodedParams);
	aliceCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
	aliceCipher.init(Cipher.DECRYPT_MODE, aliceDesKey, params);
	recovered = aliceCipher.doFinal(ciphertext);
	    
	if (!java.util.Arrays.equals(cleartext, recovered))
	    throw new Exception("DIFFERENT");
	System.err.println("SAME");    
    }

    /*
     * Converts a byte to hex digit and writes to the supplied buffer
     */
    private void byte2hex(byte b, StringBuffer buf) {
        char[] hexChars = { '0', '1', '2', '3', '4', '5', '6', '7', '8',
                            '9', 'A', 'B', 'C', 'D', 'E', 'F' };
        int high = ((b & 0xf0) >> 4);
        int low = (b & 0x0f);
        buf.append(hexChars[high]);
        buf.append(hexChars[low]);
    }

    /*
     * Converts a byte array to hex string
     */
    private String toHexString(byte[] block) {
        StringBuffer buf = new StringBuffer();

	int len = block.length;

        for (int i = 0; i < len; i++) {
             byte2hex(block[i], buf);
	     if (i < len-1) {
		 buf.append(":");
	     }
        } 
        return buf.toString();
    }

    /*
     * Prints the usage of this test.
     */
    private void usage() {
	System.err.print("DHKeyAgreement usage: ");
	System.err.println("[-gen]");
    }

    // The 1024 bit Diffie-Hellman modulus values used by SKIP
    private static final byte skip1024ModulusBytes[] = {
	(byte)0xF4, (byte)0x88, (byte)0xFD, (byte)0x58,
	(byte)0x4E, (byte)0x49, (byte)0xDB, (byte)0xCD,
	(byte)0x20, (byte)0xB4, (byte)0x9D, (byte)0xE4,
	(byte)0x91, (byte)0x07, (byte)0x36, (byte)0x6B,
	(byte)0x33, (byte)0x6C, (byte)0x38, (byte)0x0D,
	(byte)0x45, (byte)0x1D, (byte)0x0F, (byte)0x7C,
	(byte)0x88, (byte)0xB3, (byte)0x1C, (byte)0x7C,
	(byte)0x5B, (byte)0x2D, (byte)0x8E, (byte)0xF6,
	(byte)0xF3, (byte)0xC9, (byte)0x23, (byte)0xC0,
	(byte)0x43, (byte)0xF0, (byte)0xA5, (byte)0x5B,
	(byte)0x18, (byte)0x8D, (byte)0x8E, (byte)0xBB,
	(byte)0x55, (byte)0x8C, (byte)0xB8, (byte)0x5D,
	(byte)0x38, (byte)0xD3, (byte)0x34, (byte)0xFD,
	(byte)0x7C, (byte)0x17, (byte)0x57, (byte)0x43,
	(byte)0xA3, (byte)0x1D, (byte)0x18, (byte)0x6C,
	(byte)0xDE, (byte)0x33, (byte)0x21, (byte)0x2C,
	(byte)0xB5, (byte)0x2A, (byte)0xFF, (byte)0x3C,
	(byte)0xE1, (byte)0xB1, (byte)0x29, (byte)0x40,
	(byte)0x18, (byte)0x11, (byte)0x8D, (byte)0x7C,
	(byte)0x84, (byte)0xA7, (byte)0x0A, (byte)0x72,
	(byte)0xD6, (byte)0x86, (byte)0xC4, (byte)0x03,
	(byte)0x19, (byte)0xC8, (byte)0x07, (byte)0x29,
	(byte)0x7A, (byte)0xCA, (byte)0x95, (byte)0x0C,
	(byte)0xD9, (byte)0x96, (byte)0x9F, (byte)0xAB,
	(byte)0xD0, (byte)0x0A, (byte)0x50, (byte)0x9B,
	(byte)0x02, (byte)0x46, (byte)0xD3, (byte)0x08,
	(byte)0x3D, (byte)0x66, (byte)0xA4, (byte)0x5D,
	(byte)0x41, (byte)0x9F, (byte)0x9C, (byte)0x7C,
	(byte)0xBD, (byte)0x89, (byte)0x4B, (byte)0x22,
	(byte)0x19, (byte)0x26, (byte)0xBA, (byte)0xAB,
	(byte)0xA2, (byte)0x5E, (byte)0xC3, (byte)0x55,
	(byte)0xE9, (byte)0x2F, (byte)0x78, (byte)0xC7
    };

    // The SKIP 1024 bit modulus
    private static final BigInteger skip1024Modulus
    = new BigInteger(1, skip1024ModulusBytes);

    // The base used with the SKIP 1024 bit modulus
    private static final BigInteger skip1024Base = BigInteger.valueOf(2);
}

Diffie-Hellman Key Exchange between 3 Parties

/*
 * Copyright 1997, 1998 by Sun Microsystems, Inc.,
 * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
 * All rights reserved.
 *
 * This software is the confidential and proprietary information
 * of Sun Microsystems, Inc. ("Confidential Information").  You
 * shall not disclose such Confidential Information and shall use
 * it only in accordance with the terms of the license agreement
 * you entered into with Sun.
 */

import java.io.*;
import java.math.BigInteger;
import java.security.*;
import java.security.spec.*;
import java.security.interfaces.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import javax.crypto.interfaces.*;
import com.sun.crypto.provider.SunJCE;

/**
 * This program executes the Diffie-Hellman key agreement protocol
 * between 3 parties: Alice, Bob, and Carol.
 *
 * We use the same 1024-bit prime modulus and base generator that are used by
 * SKIP.
 */

public class DHKeyAgreement3 {

    private DHKeyAgreement3() {}

    public static void main(String argv[]) {
	try {
	    // Add JCE to the list of providers
            SunJCE jce = new SunJCE();
            Security.addProvider(jce);

	    DHKeyAgreement3 keyAgree = new DHKeyAgreement3();
	    keyAgree.run();
	} catch (Exception e) {
	    System.err.println("Error: " + e);
	    System.exit(1);
	}
    }

    private void run() throws Exception {

	DHParameterSpec dhSkipParamSpec;

	System.err.println("Using SKIP Diffie-Hellman parameters");
	dhSkipParamSpec = new DHParameterSpec(skip1024Modulus, skip1024Base);

	// Alice creates her own DH key pair
	System.err.println("ALICE: Generate DH keypair ...");
	KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");
	aliceKpairGen.initialize(dhSkipParamSpec);
	KeyPair aliceKpair = aliceKpairGen.generateKeyPair();

	// Bob creates his own DH key pair
	System.err.println("BOB: Generate DH keypair ...");
	KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");
	bobKpairGen.initialize(dhSkipParamSpec);
	KeyPair bobKpair = bobKpairGen.generateKeyPair();

	// Carol creates her own DH key pair
	System.err.println("CAROL: Generate DH keypair ...");
	KeyPairGenerator carolKpairGen = KeyPairGenerator.getInstance("DH");
	carolKpairGen.initialize(dhSkipParamSpec);
	KeyPair carolKpair = carolKpairGen.generateKeyPair();


	// Alice initialize
	System.err.println("ALICE: Initialize ...");
	KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");
	aliceKeyAgree.init(aliceKpair.getPrivate());

	// Bob initialize
	System.err.println("BOB: Initialize ...");
	KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");
	bobKeyAgree.init(bobKpair.getPrivate());

	// Carol initialize
	System.err.println("CAROL: Initialize ...");
	KeyAgreement carolKeyAgree = KeyAgreement.getInstance("DH");
	carolKeyAgree.init(carolKpair.getPrivate());


	// Alice uses Carol's public key
	Key ac = aliceKeyAgree.doPhase(carolKpair.getPublic(), false);

	// Bob uses Alice's public key
	Key ba = bobKeyAgree.doPhase(aliceKpair.getPublic(), false);

	// Carol uses Bob's public key
	Key cb = carolKeyAgree.doPhase(bobKpair.getPublic(), false);


	// Alice uses Carol's result from above
	aliceKeyAgree.doPhase(cb, true);

	// Bob uses Alice's result from above
	bobKeyAgree.doPhase(ac, true);

	// Carol uses Bob's result from above
	carolKeyAgree.doPhase(ba, true);


	// Alice, Bob and Carol compute their secrets
	byte[] aliceSharedSecret = aliceKeyAgree.generateSecret();
	System.out.println("Alice secret: " + toHexString(aliceSharedSecret));

	byte[] bobSharedSecret = bobKeyAgree.generateSecret();
	System.out.println("Bob secret: " + toHexString(bobSharedSecret));

	byte[] carolSharedSecret = carolKeyAgree.generateSecret();
	System.out.println("Carol secret: " + toHexString(carolSharedSecret));


	// Compare Alice and Bob
	if (!java.util.Arrays.equals(aliceSharedSecret, bobSharedSecret))
            throw new Exception("Alice and Bob differ");
	System.err.println("Alice and Bob are the same");

	// Compare Bob and Carol
	if (!java.util.Arrays.equals(bobSharedSecret, carolSharedSecret))
	    throw new Exception("Bob and Carol differ");
	System.err.println("Bob and Carol are the same");
    }


    /*
     * Converts a byte to hex digit and writes to the supplied buffer
     */
    private void byte2hex(byte b, StringBuffer buf) {
        char[] hexChars = { '0', '1', '2', '3', '4', '5', '6', '7', '8',
                            '9', 'A', 'B', 'C', 'D', 'E', 'F' };
        int high = ((b & 0xf0) >> 4);
        int low = (b & 0x0f);
        buf.append(hexChars[high]);
        buf.append(hexChars[low]);
    }

    /*
     * Converts a byte array to hex string
     */
    private String toHexString(byte[] block) {
        StringBuffer buf = new StringBuffer();

	int len = block.length;

        for (int i = 0; i < len; i++) {
             byte2hex(block[i], buf);
	     if (i < len-1) {
		 buf.append(":");
	     }
        } 
        return buf.toString();
    }

    /*
     * Prints the usage of this test.
     */
    private void usage() {
	System.err.print("DHKeyAgreement usage: ");
	System.err.println("[-gen]");
    }

    // The 1024 bit Diffie-Hellman modulus values used by SKIP
    private static final byte skip1024ModulusBytes[] = {
	(byte)0xF4, (byte)0x88, (byte)0xFD, (byte)0x58,
	(byte)0x4E, (byte)0x49, (byte)0xDB, (byte)0xCD,
	(byte)0x20, (byte)0xB4, (byte)0x9D, (byte)0xE4,
	(byte)0x91, (byte)0x07, (byte)0x36, (byte)0x6B,
	(byte)0x33, (byte)0x6C, (byte)0x38, (byte)0x0D,
	(byte)0x45, (byte)0x1D, (byte)0x0F, (byte)0x7C,
	(byte)0x88, (byte)0xB3, (byte)0x1C, (byte)0x7C,
	(byte)0x5B, (byte)0x2D, (byte)0x8E, (byte)0xF6,
	(byte)0xF3, (byte)0xC9, (byte)0x23, (byte)0xC0,
	(byte)0x43, (byte)0xF0, (byte)0xA5, (byte)0x5B,
	(byte)0x18, (byte)0x8D, (byte)0x8E, (byte)0xBB,
	(byte)0x55, (byte)0x8C, (byte)0xB8, (byte)0x5D,
	(byte)0x38, (byte)0xD3, (byte)0x34, (byte)0xFD,
	(byte)0x7C, (byte)0x17, (byte)0x57, (byte)0x43,
	(byte)0xA3, (byte)0x1D, (byte)0x18, (byte)0x6C,
	(byte)0xDE, (byte)0x33, (byte)0x21, (byte)0x2C,
	(byte)0xB5, (byte)0x2A, (byte)0xFF, (byte)0x3C,
	(byte)0xE1, (byte)0xB1, (byte)0x29, (byte)0x40,
	(byte)0x18, (byte)0x11, (byte)0x8D, (byte)0x7C,
	(byte)0x84, (byte)0xA7, (byte)0x0A, (byte)0x72,
	(byte)0xD6, (byte)0x86, (byte)0xC4, (byte)0x03,
	(byte)0x19, (byte)0xC8, (byte)0x07, (byte)0x29,
	(byte)0x7A, (byte)0xCA, (byte)0x95, (byte)0x0C,
	(byte)0xD9, (byte)0x96, (byte)0x9F, (byte)0xAB,
	(byte)0xD0, (byte)0x0A, (byte)0x50, (byte)0x9B,
	(byte)0x02, (byte)0x46, (byte)0xD3, (byte)0x08,
	(byte)0x3D, (byte)0x66, (byte)0xA4, (byte)0x5D,
	(byte)0x41, (byte)0x9F, (byte)0x9C, (byte)0x7C,
	(byte)0xBD, (byte)0x89, (byte)0x4B, (byte)0x22,
	(byte)0x19, (byte)0x26, (byte)0xBA, (byte)0xAB,
	(byte)0xA2, (byte)0x5E, (byte)0xC3, (byte)0x55,
	(byte)0xE9, (byte)0x2F, (byte)0x78, (byte)0xC7
    };

    // The SKIP 1024 bit modulus
    private static final BigInteger skip1024Modulus
    = new BigInteger(1, skip1024ModulusBytes);

    // The base used with the SKIP 1024 bit modulus
    private static final BigInteger skip1024Base = BigInteger.valueOf(2);
}

Blowfish Example

/*
 * Copyright 1997, 1998 by Sun Microsystems, Inc.,
 * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
 * All rights reserved.
 *
 * This software is the confidential and proprietary information
 * of Sun Microsystems, Inc. ("Confidential Information").  You
 * shall not disclose such Confidential Information and shall use
 * it only in accordance with the terms of the license agreement
 * you entered into with Sun.
 */

import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;

/**
 * This program generates a Blowfish key, retrieves its raw bytes, and then
 * reinstantiates a Blowfish key from the key bytes.
 * The reinstantiated key is used to initialize a Blowfish cipher for
 * encryption.
 */

public class BlowfishKey {

    public static void main(String[] args) throws Exception {

	// Install SunJCE provider
	Provider sunJce = new com.sun.crypto.provider.SunJCE();
	Security.addProvider(sunJce);
    
	KeyGenerator kgen = KeyGenerator.getInstance("Blowfish");
	SecretKey skey = kgen.generateKey();
	byte[] raw = skey.getEncoded();
	SecretKeySpec skeySpec = new SecretKeySpec(raw, "Blowfish");

        Cipher cipher = Cipher.getInstance("Blowfish");
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
        byte[] encrypted = cipher.doFinal("This is just an example".getBytes());
    }
}

HMAC-MD5 Example

/*
 * Copyright 1997, 1998 by Sun Microsystems, Inc.,
 * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
 * All rights reserved.
 *
 * This software is the confidential and proprietary information
 * of Sun Microsystems, Inc. ("Confidential Information").  You
 * shall not disclose such Confidential Information and shall use
 * it only in accordance with the terms of the license agreement
 * you entered into with Sun.
 */

import java.security.*;
import javax.crypto.*;

/**
 * This program demonstrates how to generate a secret-key object for
 * HMAC-MD5, and initialize an HMAC-MD5 object with it.
 */

public class initMac {

    public static void main(String[] args) throws Exception {

	// Install SunJCE provider
	Provider sunJce = new com.sun.crypto.provider.SunJCE();
	Security.addProvider(sunJce);

	// Generate secret key for HMAC-MD5
	KeyGenerator kg = KeyGenerator.getInstance("HmacMD5");
	SecretKey sk = kg.generateKey();

	// Get instance of Mac object implementing HMAC-MD5, and initialize it
	// with the above secret key
	Mac mac = Mac.getInstance("HmacMD5");
	mac.init(sk);
	byte[] result = mac.doFinal("Hi There".getBytes());
    }
}

Please send comments to: java-security@java.sun.com.

Java Software

Last modified: Thu Mar 11 14:45:43 PST 1999

JavaTM Cryptography Extension 1.2

API Specification & Reference

Creating a Cipher Object

Initializing a Cipher Object

Encrypting and Decrypting Data

Cipher Output Considerations

Creating a Key Generator

Initializing a KeyGenerator Object

Creating a Key

Creating a KeyAgreement Object

Initializing a KeyAgreement Object

Executing a KeyAgreement Phase

Generating the Shared Secret

Creating a Mac Object

Initializing a Mac Object

Computing a MAC

Generating a Key

Creating a Cipher

Cipher

Algorithm

Mode

Padding

KeyAgreement

KeyGenerator

KeyPairGenerator

SecretKeyFactory

KeyFactory

AlgorithmParameterGenerator

AlgorithmParameters

MAC

Keystore Types

Diffie-Hellman Key Exchange between 2 Parties

Diffie-Hellman Key Exchange between 3 Parties

Blowfish Example

HMAC-MD5 Example

Java^TM Cryptography Extension 1.2