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

java.lang.Object
- iaik.pkcs.pkcs8.PrivateKeyInfo
- - iaik.security.rsa.RSAPrivateKey

All Implemented Interfaces:

ASN1Type, java.io.Serializable, java.lang.Cloneable, java.security.interfaces.RSAKey, java.security.interfaces.RSAPrivateCrtKey, java.security.interfaces.RSAPrivateKey, java.security.Key, java.security.PrivateKey
```
public class RSAPrivateKey
extends PrivateKeyInfo
implements java.security.interfaces.RSAPrivateCrtKey, java.io.Serializable, java.lang.Cloneable
```
This class implements an RSA private key and supports ASN.1 encoding.
This class extends iaik.pkcs.pkcs8.PrivateKeyInfo for supporting the PKCS#8 Private Key Information Standard for RSA private keys. This class implements the java.security.interfaces.RSAPrivateKeyCrt interface for providing the functionality of a private key, as used for data decrypting or digital signing based on the RSA algorithm. This class implements the RSAPrivateKeyCrt interface for using the Chinese Remainder Theorem to speed up private key operations by extending the standard RSA private key components modulus n and private exponent d according to PKCS #1: RSA Encryption Version 1.5 (RFC 2313):
```
 RSAPrivateKey ::= SEQUENCE {
   version Version, -- a INTEGER version number; 0 for this standard
   modulus INTEGER, -- n
   publicExponent INTEGER, -- e
   privateExponent INTEGER, -- d
   prime1 INTEGER, -- primeP (p) (first prime factor of n)
   prime2 INTEGER, -- primeQ (q) (second prime factor of n)
   exponent1 INTEGER, -- primeExponentP: d mod (p - 1)
   exponent2 INTEGER, -- primeExponentQ: d mod (q - 1)
   crtCoefficient INTEGER -- Chinese Remainder Theorem ((inverse of q) mod p) }
 
```
An application wishing to create a RSAPrivateKey to be used for, e.g. data decryption or digital signing with the RSA algorithm, uses a proper getInstance method of the java.security.KeyPairGenerator class, which subsequently maybe casted to RSAKeyPairGenerator for performing an algorithm-specific initialization with proper RSA parameters. If an algorithm-specific initialization is not required, the cast to RSAKeyPairGenerator can be omitted.
Generally four steps have to be performed for creating a RSAPrivateKey by using a proper KeyPairGenerator:
- First the KeyPairGenerator has to be instantiated thereby specifying the application's intention to create keys for use within the RSA algorithm:
```
 KeyPairGenerator key_gen = KeyPairGenerator.getInstance("RSA");
 
```
- Second, the KeyPairGenerator just created may be initialized using a proper initialize method. For initializing the generator to create keys with a modulus length of, e.g., 512 bits, this can be explicitly specified (when not initializing the generator explicitly, per default the modulus length is set to 1024 bits):
```
 key_gen.initialize(512);
 
```
- Third the key pair is created by calling generateKeyPair():
```
 KeyPair key_pair = key_gen.generateKeyPair();
 
```
- And finally, if there is need for the RSA private key, it has to be obtained from the key pair just created:
```
 RSAPrivateKey rsa_priv_key = (RSAPrivateKey)key_pair.getPrivate();
 
```
For performing an algorithm-specific initialization with particular RSA parameters (e.g. using a particular public exponent e), an explicit cast of the KeyPairGenerator will be necessary for obtaining a specific RSAKeyPairGenerator to be initialized with the desired RSA parameters:
```
 RSAKeyPairGenerator rsa_key_gen = (RSAKeyPairGenerator)key_gen;
 rsa_key_gen.initialize(512, pub_exponent, sec_random);
 
```
(where sec_random denotes some random seed)
Guidelines on how to create some key using a KeyPairGenerator can be found in http://java.sun.com/products/JDK/1.2/docs/guide/security/CryptoSpec.html.
See Also:
PrivateKeyInfo, RSAPrivateCrtKey, KeyPairGenerator, KeyPair, iaik.pkcs.pkcs1.RSACipher, RSAKey, RSAPublicKey, RSAKeyPairGenerator, RSAKeyFactory, Serialized Form

Field Summary
- Fields inherited from class iaik.pkcs.pkcs8.PrivateKeyInfo
  private_key_algorithm, private_key_info
- Fields inherited from interface java.security.interfaces.RSAPrivateCrtKey
  serialVersionUID

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`RSAPrivateKey()` Default constructor.
	`RSAPrivateKey(ASN1Object obj)` Creates a new private key from an ASN1Object.
	`RSAPrivateKey(java.math.BigInteger modulus, java.math.BigInteger privateExponent)` Creates a new RSAPrivate key from given modulus and private exponent.
	`RSAPrivateKey(java.math.BigInteger modulus, java.math.BigInteger publicExponent, java.math.BigInteger privateExponent, java.math.BigInteger primeP, java.math.BigInteger primeQ, java.math.BigInteger primeExponentP, java.math.BigInteger primeExponentQ, java.math.BigInteger crtCoefficient)` Creates a RSAPrivateKey from the given values.
	`RSAPrivateKey(byte[] pk)` Creates a new RSAPrivateKey from a DER encoded ASN.1 data structure.
	`RSAPrivateKey(java.io.InputStream is)` Creates a new RSAPrivateKey from an InputStream.
	`RSAPrivateKey(java.security.interfaces.RSAPrivateKey key)` Creates a new RSAPrivateKey from a RSAPrivateKey or RSAPrivateKeyCrt.
	`RSAPrivateKey(java.security.spec.RSAPrivateKeySpec keySpec)` Creates a new RSAPrivateKey from a RSAPrivateKeySpec or RSAPrivateKeyCrtSpec.

Method Summary

Methods
Modifier and Type	Method and Description
`java.lang.Object`	`clone()`
`java.math.BigInteger`	`crypt(java.math.BigInteger message)` Encrypts or decrypts a BigInteger using the private key.
`protected void`	`decode(byte[] privateKey)` Decodes a DER encoded RSAPrivateKey (PKCS#1).
`protected byte[]`	`encode()` Returns this RSA private key as DER encoded byte array (PKCS#1).
`java.lang.String`	`getAlgorithm()` Returns the name of the appertaining algorithm.
`java.math.BigInteger`	`getCrtCoefficient()` Returns the Chinese Remainder Theorem coefficient of this private key.
`java.math.BigInteger`	`getModulus()` Returns the modulus of this private key.
`java.math.BigInteger`	`getPrimeExponentP()` Returns the first exponent of this private key.
`java.math.BigInteger`	`getPrimeExponentQ()` Returns the second exponent of this private key.
`java.math.BigInteger`	`getPrimeP()` Returns the first prime of this private key.
`java.math.BigInteger`	`getPrimeQ()` Returns the second prime of this private key.
`java.math.BigInteger`	`getPrivateExponent()` Returns the private exponent of this private key.
`java.math.BigInteger`	`getPublicExponent()` Returns the public exponent of this private key.
`java.security.PublicKey`	`getPublicKey()` Returns the public parts (modulus `n` and public exponent `e` of this private key.
`int`	`hashCode()` Returns a hash code for this object.
`static RSAPrivateKey`	`parse(byte[] privateKey)` This method parses a RSA private key.
`java.lang.String`	`toString()` Returns a string that represents the contents of this private key.

Methods inherited from class iaik.pkcs.pkcs8.PrivateKeyInfo
createPrivateKeyInfo, decode, equals, getEncoded, getFormat, getPrivateKey, getPrivateKey, toASN1Object, writeTo

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

Methods inherited from interface java.security.Key
getEncoded, getFormat

- Constructor Detail
  - RSAPrivateKey
```
protected RSAPrivateKey()
```
    Default constructor.
  - RSAPrivateKey
```
public RSAPrivateKey(java.math.BigInteger modulus,
             java.math.BigInteger privateExponent)
```
    Creates a new RSAPrivate key from given modulus and private exponent. Public exponent, prime factors p and q, primeExponentP and primeExponentQ, and Chinese Remainder Theorem Coefficient are set to ZERO (0).
    
    Parameters:
    privateExponent - the private exponent e
    modulus - the modulus n
  - RSAPrivateKey
```
public RSAPrivateKey(java.math.BigInteger modulus,
             java.math.BigInteger publicExponent,
             java.math.BigInteger privateExponent,
             java.math.BigInteger primeP,
             java.math.BigInteger primeQ,
             java.math.BigInteger primeExponentP,
             java.math.BigInteger primeExponentQ,
             java.math.BigInteger crtCoefficient)
```
    Creates a RSAPrivateKey from the given values.
    
    Parameters:
    modulus - the modulus n
    publicExponent - the public exponent e
    privateExponent - the private exponent d
    primeP - first prime factor of the modulus
    primeQ - second prime factor of the modulus
    primeExponentP - privateExponent mod (primeP-1)
    primeExponentQ - privateExponent mod (primeQ-1)
    crtCoefficient - the Chinese Remainder Theorem coefficient (multiplic inverse of primeP mod primeQ)
  - RSAPrivateKey
```
public RSAPrivateKey(java.security.spec.RSAPrivateKeySpec keySpec)
```
    Creates a new RSAPrivateKey from a RSAPrivateKeySpec or RSAPrivateKeyCrtSpec. If the given key specification is an instance of RSAPrivateKeySpec the Chinese Remainder Theorem would not be considered by only parsing modulus and private exponent from the given specification and setting the other parameters to ZERO (0).
    If the given key specification is an instance of RSAPrivateKeyCrtSpec, all parameters (modulus, public and private exponent, prime factors p and q, primeExponentP and primeExponentQ, and Chinese Remainder Theorem coefficient) are parsed from the given specification.
    
    Parameters:
    keySpec - the key spec
  - RSAPrivateKey
```
public RSAPrivateKey(java.security.interfaces.RSAPrivateKey key)
```
    Creates a new RSAPrivateKey from a RSAPrivateKey or RSAPrivateKeyCrt. If the given key specification is an instance of RSAPrivateKey the Chinese Remainder Theorem would not be considered by only parsing modulus and private exponent from the given specification and setting the other parameters to ZERO (0).
    If the given key specification is an instance of RSAPrivateKeyCrt, all parameters (modulus, public and private exponent, prime factors p and q, primeExponentP and primeExponentQ, and Chinese Remainder Theorem coefficient) are parsed from the given specification.
    
    Parameters:
    key - the key
  - RSAPrivateKey
```
public RSAPrivateKey(byte[] pk)
              throws java.security.InvalidKeyException
```
    Creates a new RSAPrivateKey from a DER encoded ASN.1 data structure.
    This constructor may be used for parsing an already exisiting RSA private key, wrapped into a PKCS#8 PrivateKeyInfo that is supplied as DER encoded byte array.
    
    Parameters:
    the - byte array holding the DER encoded private key info
    
    Throws:
    
    java.security.InvalidKeyException - if something is wrong with the key encoding
  - RSAPrivateKey
```
public RSAPrivateKey(ASN1Object obj)
              throws java.security.InvalidKeyException
```
    Creates a new private key from an ASN1Object. The supplied ASN1Object represents a PKCS#8 PrivateKeyInfo holding the RSA private key.
    
    Parameters:
    obj - the private key as ASN1Object
    
    Throws:
    
    java.security.InvalidKeyException - if something is wrong with the key encoding
  - RSAPrivateKey
```
public RSAPrivateKey(java.io.InputStream is)
              throws java.io.IOException,
                     java.security.InvalidKeyException
```
    Creates a new RSAPrivateKey from an InputStream.
    This constructor may be used for parsing an already exisiting RSA private key, wrapped into a PKCS#8 PrivateKeyInfo that is supplied as DER encoded byte array.
    
    Parameters:
    is - the input stream with the data to be read to initialize the private key
    
    Throws:
    
    java.io.IOException - if an I/O error occurs
    
    java.security.InvalidKeyException - if something is wrong with the key encoding
- Method Detail
  - decode
```
protected void decode(byte[] privateKey)
               throws java.security.InvalidKeyException
```
    Decodes a DER encoded RSAPrivateKey (PKCS#1).
    From the given DER encoded byte array an ASN.1 object is created and parsed for the RSAPrivateKey parameters according to PKCS#1: version, modulus n, public and private exponent (e and d), prime factor primeP of n, prime factor primeQ of n, primeExponentP (d mod(p-1)), primeExponentQ (d mod(q-1)), and crtCoefficient, the Chinese Remainder Thereom coefficient q^-1 mod p.
    This method is protected and typically will not be used by an application. Rather it is used by the parent PKCS#8 PrivateKeyInfo class for decoding the inherent RSA private key.
    
    Specified by:
    
    decode in class PrivateKeyInfo
    
    Parameters:
    privateKey - the RSA private key as DER encoded byte array
    
    Throws:
    
    java.security.InvalidKeyException - if the given key is not a RSA private key
  - parse
```
public static RSAPrivateKey parse(byte[] privateKey)
                           throws java.security.InvalidKeyException
```
    This method parses a RSA private key. The format must be RSAPrivateKey as defined in PKCS#1.
    
    Parameters:
    privateKey - a "RAW" RSA private key
    
    Throws:
    
    java.security.InvalidKeyException - if the given key is not a RSA private key
  - crypt
```
public java.math.BigInteger crypt(java.math.BigInteger message)
```
    Encrypts or decrypts a BigInteger using the private key. This method uses a fast algorithm based on the chinese remainder theorem.
    
    Parameters:
    message - the BigInteger message to encrypt or encrypt
    
    Returns:
    the encrypted or decrypted message
  - encode
```
protected byte[] encode()
```
    Returns this RSA private key as DER encoded byte array (PKCS#1).
    This method is protected and typically will not be used by an application. Rather it is used by the parent PKCS#8 PrivateKeyInfo class for encoding the inherent RSA private key.
    
    Specified by:
    
    encode in class PrivateKeyInfo
    
    Returns:
    the RSA private key as a DER encoded ASN.1 datastructure
  - getPublicKey
```
public java.security.PublicKey getPublicKey()
```
    Returns the public parts (modulus n and public exponent e of this private key.
    
    Returns:
    the public key part of this private key
  - getPrivateExponent
```
public java.math.BigInteger getPrivateExponent()
```
    Returns the private exponent of this private key.
    
    Specified by:
    
    getPrivateExponent in interface java.security.interfaces.RSAPrivateKey
    
    Returns:
    the private exponent of the private key.
  - getPublicExponent
```
public java.math.BigInteger getPublicExponent()
```
    Returns the public exponent of this private key.
    
    Specified by:
    
    getPublicExponent in interface java.security.interfaces.RSAPrivateCrtKey
    
    Returns:
    the public exponent of the private key.
  - getModulus
```
public java.math.BigInteger getModulus()
```
    Returns the modulus of this private key.
    
    Specified by:
    
    getModulus in interface java.security.interfaces.RSAKey
    
    Returns:
    the public modulus of the private key.
  - getPrimeP
```
public java.math.BigInteger getPrimeP()
```
    Returns the first prime of this private key.
    
    Specified by:
    
    getPrimeP in interface java.security.interfaces.RSAPrivateCrtKey
    
    Returns:
    the prime 1 of the private key.
  - getPrimeQ
```
public java.math.BigInteger getPrimeQ()
```
    Returns the second prime of this private key.
    
    Specified by:
    
    getPrimeQ in interface java.security.interfaces.RSAPrivateCrtKey
    
    Returns:
    the prime 2 of the private key.
  - getPrimeExponentP
```
public java.math.BigInteger getPrimeExponentP()
```
    Returns the first exponent of this private key.
    exponent = privateExponent mod (prime_p-1);
    
    Specified by:
    
    getPrimeExponentP in interface java.security.interfaces.RSAPrivateCrtKey
    
    Returns:
    the exponent 1 of the private key.
  - getPrimeExponentQ
```
public java.math.BigInteger getPrimeExponentQ()
```
    Returns the second exponent of this private key.
    exponent = privateExponent mod (prime_q-1);
    
    Specified by:
    
    getPrimeExponentQ in interface java.security.interfaces.RSAPrivateCrtKey
    
    Returns:
    the exponent 2 of the private key.
  - getCrtCoefficient
```
public java.math.BigInteger getCrtCoefficient()
```
    Returns the Chinese Remainder Theorem coefficient of this private key.
    crtCoefficient = multiplic inverse of prime_p mod prime_q;
    
    Specified by:
    
    getCrtCoefficient in interface java.security.interfaces.RSAPrivateCrtKey
    
    Returns:
    the Chinese Remainder Theorem coefficient of the private key.
  - getAlgorithm
```
public java.lang.String getAlgorithm()
```
    Returns the name of the appertaining algorithm.
    
    Specified by:
    
    getAlgorithm in interface java.security.Key
    
    Specified by:
    
    getAlgorithm in class PrivateKeyInfo
    
    Returns:
    the string "RSA"
  - hashCode
```
public int hashCode()
```
    Returns a hash code for this object.
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    the hash code
  - toString
```
public java.lang.String toString()
```
    Returns a string that represents the contents of this private key.
    
    Overrides:
    
    toString in class PrivateKeyInfo
    
    Returns:
    the string representation
  - clone
```
public java.lang.Object clone()
```
    Overrides:
    
    clone in class java.lang.Object

Class RSAPrivateKey

Field Summary

Fields inherited from class iaik.pkcs.pkcs8.PrivateKeyInfo

Fields inherited from interface java.security.interfaces.RSAPrivateCrtKey

Constructor Summary

Method Summary

Methods inherited from class iaik.pkcs.pkcs8.PrivateKeyInfo

Methods inherited from class java.lang.Object

Methods inherited from interface java.security.Key

Constructor Detail

RSAPrivateKey

RSAPrivateKey

RSAPrivateKey

RSAPrivateKey

RSAPrivateKey

RSAPrivateKey

RSAPrivateKey

RSAPrivateKey

Method Detail

decode

parse

crypt

encode

getPublicKey

getPrivateExponent

getPublicExponent

getModulus

getPrimeP

getPrimeQ

getPrimeExponentP

getPrimeExponentQ

getCrtCoefficient

getAlgorithm

hashCode

toString

clone