LunaKey (Luna Java Security Provider API)

java.lang.Object
- com.safenetinc.luna.provider.key.LunaKey

All Implemented Interfaces:

java.io.Serializable, java.security.Key

Direct Known Subclasses:

LunaKeyDh, LunaKeyDsa, LunaKeyEC, LunaKeyRsa, LunaSecretKey
```
public class LunaKey
extends java.lang.Object
implements java.security.Key
```
The LunaKey class encapsulates all keys stored on Luna hardware.
LunaKey objects can be created through KeyGenerator and KeyPairGenerator objects making use of the "LunaProvider" provider. Alternately, they can be created to represent keys already stored on the hardware, using a KeyStore (type "Luna") or the LocateKeyByAlias() method.

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected static java.util.Random`	`ivRandom`
`protected static java.security.SecureRandom`	`ivSecureRandom`
`protected int`	`keySize` Size of the token key, in bits.
`protected static LunaAPI`	`lapi`
`protected long`	`mKeyClass`
`protected long`	`mKeyType`
`protected LunaTokenObject`	`mObject`
`static int`	`UNLIMITED_USE` Use this value with `setUsageLimit` to enable usage counting for this key without actually asserting a limit on the use.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`LunaKey()` Creates an uninitialized LunaKey object.
	`LunaKey(int hKey)` Create a LunaKey object from the key stored in the default slot with the given handle.
	`LunaKey(int hKey, int slot)` Create a LunaKey object from the key stored in the specified slot with the given handle.
`protected`	`LunaKey(int hKey, int slot, long keyClass, long keyType)` Create a LunaKey object from the key stored in the specified slot with the given handle.
`protected`	`LunaKey(int hKey, int slot, java.util.Map<java.lang.Long,java.lang.Object> sessionParameters)` Create a LunaKey object from the key stored in the specified slot with the given handle.
	`LunaKey(LunaTokenObject object)` Create a LunaKey object from the key stored on the Luna hardware.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`assign()` Assigns this key.
`static java.math.BigInteger`	`AttributeToBigInteger(byte[] in)` Turn an integer attribute (such as CKA_MODULUS) into a BigInteger.
`void`	`authorize(java.lang.String value, boolean override)` Authorizes this key.
`static byte[]`	`BigIntegerToAttribute(java.math.BigInteger b)` Converts a big integer into a byte array suitable for use as a token object attribute.
`void`	`cacheAuthorizedSession(LunaSession session)` cache the authorized session for this key.
`void`	`deleteCacheAuthorizedSession()` remove the authorized session for this key from the cache but leave the contained auth session.
`void`	`DestroyKey()` Destroys the key completely, including removing it from the hardware.
`boolean`	`equals(java.lang.Object obj)` Check for equivalence between this LunaKey object and the object that's passed in.
`static byte[]`	`generateRandomIv(int length, boolean secure, boolean derEncode)` Generate a new random IV.
`java.lang.String`	`getAlgorithm()` Returns a String representation of the key algorithm
`java.lang.String`	`GetAlias()` Returns the alias of the LunaKey object.
`LunaSession`	`getAuthorizedSession()` get the authorized session for this key.
`int`	`getBytesRemaining()` Get the bytes remaining that can be encrypted by this key .
`LunaSession`	`getCacheAuthorizedSession()` get the cached authorized session for this key.
`java.util.Date`	`GetDateMadePersistent()` Returns the date that the LunaKey was made persistent.
`byte[]`	`getEncoded()` Returns the encoded form of the LunaKey object.
`protected byte[]`	`getEncodedInternal()`
`byte[]`	`GetFingerprint()` Returns a fingerprint of an object (a byte array that contains a cryptographic hash of various attributes of the object).
`java.lang.String`	`getFormat()` Returns the name of the format used to encode the LunaKey object.
`static LunaKey`	`getKeyByType(LunaTokenObject tokenObj)`
`long`	`GetKeyClass()` Returns the PKCS11 object class of the key.
`int`	`GetKeyHandle()` Returns the handle of the key stored in hardware.
`int`	`getKeySize()` Returns the size of the key wrapped by this LunaKey, in bits.
`long`	`getKeyType()` Returns the type of the key wrapped by this LunaKey.
`static long`	`GetKeyType(java.lang.String algorithm)` Returns the key type identifier for the given algorithm
`byte[]`	`GetOUID()` Returns the CKA_OUID of the key object in the HSM.
`LunaSession`	`getSession()` Returns a new LunaSession on same slot as this key.
`int`	`getSlot()` Returns the slot the key is stored in.
`int`	`getUsageCount()` Get the number of times this key has been used.
`int`	`getUsageLimit()` Get the usage limit set on this on this key.
`int`	`hashCode()` Two Keys are considered equal if their encoded forms match, so we simply return the hash code of the encoded bytes.
`void`	`incrementFailedAuthorizationCount()` Increment the failed authorize attempt count for this key.
`protected void`	`Initialize(int hKey, int slot, long keyClass, long keyType)` Initialize a LunaKey object with the given data.
`protected void`	`Initialize(int hKey, int slot, java.util.Map<java.lang.Long,java.lang.Object> sessionParameters)` Initialize a LunaKey object with the given data.
`protected static int`	`injectKey(byte[] keyBytes, long keyAlg, long keyType, int slot, boolean extractable, boolean derive)`
`static java.security.PrivateKey`	`InjectPrivateKey(byte[] encodedKey, long algId)` Injects the given encoded private key of the specified algorithm type into the token at the default slot.
`static java.security.PrivateKey`	`InjectPrivateKey(byte[] encodedKey, long algId, int slot)` Injects the given encoded private key of the specified algorithm type into the token at the specified slot.
`static java.security.PrivateKey`	`InjectPrivateKey(java.security.PrivateKey key)` Inject (encrypt encoded key and unwrap) a non-Luna private key into the token at the default slot.
`static java.security.PrivateKey`	`InjectPrivateKey(java.security.PrivateKey key, int slot)` Inject (encrypt encoded key and unwrap) a non-Luna private key into the token at the specified slot.
`boolean`	`isInitialized()`
`boolean`	`IsKeyPersistent()` Returns a boolean indicating whether or not the given LunaKey object is persistent.
`static LunaKey`	`LocateKeyByAlias(java.lang.String alias)` Locate a persisted key on the default slot using the alias assigned when MakePersistant() was invoked.
`static LunaKey`	`LocateKeyByAlias(java.lang.String alias, int slot)` Locate a persisted key on the specified slot using the alias assigned when MakePersistant() was invoked.
`static LunaKey`	`LocateKeyByFingerprint(byte[] fingerprint)` Locate a persisted key on the default slot using the key's fingerprint.
`static LunaKey`	`LocateKeyByFingerprint(byte[] fingerprint, int slot)` Locate a persisted key on the specified slot using the key's fingerprint.
`static LunaKey`	`LocateKeyByHandle(int handle)` Locate a persisted key on the default slot using the handle assigned when MakePersistant() was invoked.
`static LunaKey`	`LocateKeyByHandle(int handle, int slot)` Locate a persisted key on the specified slot using the handle assigned when MakePersistent() was invoked.
`static LunaKey`	`LocateKeyByOUID(byte[] ouid)` Locate a persisted key using the CKA_OUID attribute.
`static LunaKey`	`LocateKeyByOUID(byte[] ouid, int slot)` Locate a persisted key on the specified slot using the CKA_OUID attribute.
`static LunaKey`	`LocateKeyOnlyByAlias(java.lang.String alias)` Locate a persisted key on the default slot using the alias assigned when MakePersistant() was invoked.
`static LunaKey`	`LocateKeyOnlyByAlias(java.lang.String alias, int slot)` Locate a persisted key on the specified slot using the alias assigned when MakePersistant() was invoked.
`void`	`MakePersistent(java.lang.String alias)` The MakePersistent() method can be used to ensure that a key that has been generated will continue to exist from one instance of an application to another.
`void`	`release()` This method is used to signal to the Luna provider that an application is finished with a session (temporary) object on the HSM.
`void`	`resetAuthorizationData(java.lang.String newValue)` Resets the auth data for this key.
`void`	`resetAuthorizedSession()` null out the authorized session for this key.
`void`	`setAuthorizationData(java.lang.String oldValue, java.lang.String newValue)` Sets the auth data for this key from old value to new value.
`protected void`	`setKeySize()` Sets the size of the key we're wrapping, in bits.
`boolean`	`setUsageCount(int count)` Set the usage count on this key.
`boolean`	`setUsageLimit(int limit)` Set the usage limit on this key.
`java.lang.String`	`toString()` Returns a string representation of the key object.
`protected void`	`verifyClassAndType()` Checks that the existing object handle being wrapped by this LunaKey objects has the key class and key type expected by the LunaKey subclass.

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

- Field Detail
  - lapi
```
protected static final LunaAPI lapi
```
  - mObject
```
protected transient LunaTokenObject mObject
```
  - mKeyClass
```
protected long mKeyClass
```
  - mKeyType
```
protected long mKeyType
```
  - keySize
```
protected int keySize
```
    Size of the token key, in bits. If 0, the key size is unknown
  - ivRandom
```
protected static java.util.Random ivRandom
```
  - ivSecureRandom
```
protected static java.security.SecureRandom ivSecureRandom
```
  - UNLIMITED_USE
```
public static final int UNLIMITED_USE
```
    Use this value with setUsageLimit to enable usage counting for this key without actually asserting a limit on the use. By default key usage is not counted.
    
    See Also:
    Constant Field Values
- Constructor Detail
  - LunaKey
```
protected LunaKey()
```
    Creates an uninitialized LunaKey object. This constructor does nothing, but cannot be removed as subclasses might depend on it. To initialize a LunaKey, use one of the other constructors or use one of the LocateKeyBy... factory methods
  - LunaKey
```
public LunaKey(int hKey)
```
    Create a LunaKey object from the key stored in the default slot with the given handle.
    
    Parameters:
    hKey - The handle of the key stored in hardware.
  - LunaKey
```
public LunaKey(int hKey,
       int slot)
```
    Create a LunaKey object from the key stored in the specified slot with the given handle.
    
    Parameters:
    hKey - The handle of the key stored in hardware.
    slot - The slot the key is stored in
  - LunaKey
```
protected LunaKey(int hKey,
       int slot,
       long keyClass,
       long keyType)
```
    Create a LunaKey object from the key stored in the specified slot with the given handle. This private constructor is used when the providers knows the key class and type already, and can avoid a dip down to the HSM to get that information.
    
    Parameters:
    hKey - The handle of the key stored in hardware.
    slot - The slot the key is stored in
    keyClass - the PKCS class of the key
    keyType - the PKCS type of the key
  - LunaKey
```
protected LunaKey(int hKey,
       int slot,
       java.util.Map<java.lang.Long,java.lang.Object> sessionParameters)
```
    Create a LunaKey object from the key stored in the specified slot with the given handle. This private constructor is used when the providers knows the key class and type already, and can avoid a dip down to the HSM to get that information.
    
    Parameters:
    hKey - The handle of the key stored in hardware.
    slot - The slot the key is stored in
    sessionParameters - session parameters which will avoid an attribute call to the hsm.
  - LunaKey
```
public LunaKey(LunaTokenObject object)
```
    Create a LunaKey object from the key stored on the Luna hardware.
    
    Parameters:
    object - The LunaTokenObject corresponding to the key in hardware.
- Method Detail
  - Initialize
```
protected void Initialize(int hKey,
              int slot,
              long keyClass,
              long keyType)
```
    Initialize a LunaKey object with the given data.
    
    Parameters:
    hKey - the key's handle on the HSM
    slot - the slot the key resides in
    keyClass - the PKCS class of the key
    keyType - the PKCS type of the key
  - Initialize
```
protected void Initialize(int hKey,
              int slot,
              java.util.Map<java.lang.Long,java.lang.Object> sessionParameters)
```
    Initialize a LunaKey object with the given data.
    
    Parameters:
    hKey - the key's handle on the HSM
    slot - the slot the key resides in
    sessionParameters - the (session or token) indicator, PKCS class, type and length of the key
  - verifyClassAndType
```
protected void verifyClassAndType()
```
    Checks that the existing object handle being wrapped by this LunaKey objects has the key class and key type expected by the LunaKey subclass.
    
    Throws:
    
    LunaException - if there is a mismatch
  - setKeySize
```
protected void setKeySize()
```
    Sets the size of the key we're wrapping, in bits. This method should be called when a LunaKey is initialized with a key token object.
  - getKeySize
```
public int getKeySize()
```
    Returns the size of the key wrapped by this LunaKey, in bits.
    
    Returns:
    The key size in bits
  - getKeyType
```
public long getKeyType()
```
    Returns the type of the key wrapped by this LunaKey.
    
    Returns:
    The key type
  - GetKeyHandle
```
public int GetKeyHandle()
```
    Returns the handle of the key stored in hardware.
    
    Returns:
    the handle of the key in the HSM
  - isInitialized
```
public boolean isInitialized()
```
  - getSession
```
public LunaSession getSession()
```
    Returns a new LunaSession on same slot as this key.
    
    Returns:
    A LunaSession that can access this key
  - getSlot
```
public int getSlot()
```
    Returns the slot the key is stored in.
    
    Returns:
    the slot number the key is stored in
  - GetFingerprint
```
public byte[] GetFingerprint()
```
    Returns a fingerprint of an object (a byte array that contains a cryptographic hash of various attributes of the object). It is exceedingly unlikely that any two objects will share a fingerprint unless the objects are true duplicates of each other.
    
    Returns:
    the fingerprint of the key object on the HSM
  - GetOUID
```
public byte[] GetOUID()
```
    Returns the CKA_OUID of the key object in the HSM.
    
    Returns:
    the OUID as a byte array
  - GetKeyClass
```
public long GetKeyClass()
```
    Returns the PKCS11 object class of the key. This will indicate it is a public, private or secret key.
    
    Returns:
    the PKCS11 object class of the key
  - toString
```
public java.lang.String toString()
```
    Returns a string representation of the key object. This will consist of the handle, the PKCS11 object class, and the algorithm type of the key.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    a String representation of the key object.
  - MakePersistent
```
public void MakePersistent(java.lang.String alias)
```
    The MakePersistent() method can be used to ensure that a key that has been generated will continue to exist from one instance of an application to another. If a key is made persistent, it is associated with the given alias, and can be retrieved later using the LocateKeyByAlias static method.
    The same alias can be assigned to both a public and a private key. If the same alias is assigned to two public or two private keys, an exception is thrown.
    If a key is not made persistent after it is generated, it will disappear from the token when the application terminates.
    
    Parameters:
    alias - The alias to assign to the key.
  - GetDateMadePersistent
```
public java.util.Date GetDateMadePersistent()
```
    Returns the date that the LunaKey was made persistent.
    
    Returns:
    the date that the LunaKey was made persistent
  - DestroyKey
```
public void DestroyKey()
```
    Destroys the key completely, including removing it from the hardware.
  - getAlgorithm
```
public java.lang.String getAlgorithm()
```
    Returns a String representation of the key algorithm
    
    Specified by:
    
    getAlgorithm in interface java.security.Key
    
    Returns:
    a String representation of the key algorithm
  - getFormat
```
public java.lang.String getFormat()
```
    Returns the name of the format used to encode the LunaKey object.
    This will be one of
    - proprietary: keys with sensitive information, where the LunaKey only contains a reference to the handle of the key; the actual key bytes can't be extracted for encoding
    - X.509: public keys
    - RAW: secret keys, if they're set to be extractable
    Specified by:
    
    getFormat in interface java.security.Key
    
    Returns:
    the format of the encoded key
  - getEncoded
```
public byte[] getEncoded()
```
    Returns the encoded form of the LunaKey object. This key class does not allow its key data to be extracted from the HSM, so the encoded form will contain only the a reference to the key's handle on the HSM.
    
    Specified by:
    
    getEncoded in interface java.security.Key
    
    Returns:
    an 8-byte encoding of object's handle on the HSM. The first four bytes are always zero. The last 4 bytes are the integer handle encoded as a byte array
  - getEncodedInternal
```
protected byte[] getEncodedInternal()
```
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Check for equivalence between this LunaKey object and the object that's passed in.
    This method compares the two keys by getting their encoded form, so it would compare this key's:
    1. Field values if it's a public and or an extractable secret key (better)
    2. Encoded PKCS#11 handle if it's a private and or a non-extractable secret key (not so good but not much we can do about it)
    The second case, where we compare the encoded handle, would not work out when the comparison's done against a software key. Since we can't extract the field values from the hardware, there's no real solution to this problem.
    Overrides:
    
    equals in class java.lang.Object
    
    Returns:
    true if the keys are equal, as per the definition above
  - hashCode
```
public int hashCode()
```
    Two Keys are considered equal if their encoded forms match, so we simply return the hash code of the encoded bytes.
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    the hash code of the encoded key
  - GetAlias
```
public java.lang.String GetAlias()
```
    Returns the alias of the LunaKey object.
    
    Returns:
    the alias of the LunaKey object
  - IsKeyPersistent
```
public boolean IsKeyPersistent()
```
    Returns a boolean indicating whether or not the given LunaKey object is persistent.
    
    Returns:
    true if the key is persistent on the HSM
  - release
```
public void release()
```
    This method is used to signal to the Luna provider that an application is finished with a session (temporary) object on the HSM. The object on the HSM is *not* deleted. This method should be used when a process is finished with a session object that it did not create and does not explicitly want to delete. This method should not be used under normal operation. It is meant for situations like the following:
    Two processes A and B share the same PKCS application id. Process A creates a session key. Process B can get a reference to this key by using the LunaKey(handle) constructor. When B is finished with the object it shouldn't delete it since A might still need it. It shouldn't let it just go out of scope either since when it gets GC'd, B's SessionObjectAuditor will delete the object on the HSM. B should call release() first on the key to avoid this latter situation.
    Programming note: sharing session objects across processes is not a standard use of the Luna provider and may cause strange behaviour unless you are very careful about what you are doing. In almost all cases it is better to persist a key on the HSM with MakePersistent() before using it outside the originating process.
  - BigIntegerToAttribute
```
public static byte[] BigIntegerToAttribute(java.math.BigInteger b)
```
    Converts a big integer into a byte array suitable for use as a token object attribute.
    Since BigIntegers are signed, they use the upper bit for the sign. If an unsigned value with the upper bit set is converted to a BigInteger, the BigInteger will have an extra zero added. This routine removes that extra zero if necessary.
    
    Parameters:
    b - the BigInteger to convert
    
    Returns:
    an encoded attribute form of b
  - AttributeToBigInteger
```
public static java.math.BigInteger AttributeToBigInteger(byte[] in)
```
    Turn an integer attribute (such as CKA_MODULUS) into a BigInteger. Sign conversions (attributes are unsigned while BigIntegers are signed) are handled by adding a leading zero if necessary.
    
    Parameters:
    in - the encoded attribute to convert
    
    Returns:
    a BigInteger representation of in
  - GetKeyType
```
public static long GetKeyType(java.lang.String algorithm)
                       throws java.security.ProviderException
```
    Returns the key type identifier for the given algorithm
    
    Parameters:
    algorithm - A string containing the name of the key algorithm
    
    Returns:
    An integer which identifies the algorithm type
    
    Throws:
    
    java.security.ProviderException
  - InjectPrivateKey
```
public static java.security.PrivateKey InjectPrivateKey(byte[] encodedKey,
                                        long algId)
                                                 throws java.security.InvalidKeyException
```
    Injects the given encoded private key of the specified algorithm type into the token at the default slot. The key should be the entire pkcs8-encoded bytestream, wrapped as an octet string.
    
    Parameters:
    encodedKey - The PKCS-8 encoded private key
    algId - The algorithm type of the key
    
    Returns:
    The Luna PrivateKey object corresponding to the encoded key
    
    Throws:
    
    java.security.InvalidKeyException - exception
  - InjectPrivateKey
```
public static java.security.PrivateKey InjectPrivateKey(byte[] encodedKey,
                                        long algId,
                                        int slot)
                                                 throws java.security.InvalidKeyException
```
    Injects the given encoded private key of the specified algorithm type into the token at the specified slot. The key should be the entire pkcs8-encoded bytestream, wrapped as an octet string.
    
    Parameters:
    encodedKey - The PKCS-8 encoded private key
    algId - The algorithm type of the key
    slot - The slot of the token to inject the key into
    
    Returns:
    The Luna PrivateKey object corresponding to the encoded key
    
    Throws:
    
    java.security.InvalidKeyException - exception
  - InjectPrivateKey
```
public static java.security.PrivateKey InjectPrivateKey(java.security.PrivateKey key)
                                                 throws java.security.InvalidKeyException
```
    Inject (encrypt encoded key and unwrap) a non-Luna private key into the token at the default slot.
    
    Parameters:
    key - The non-Luna key object
    
    Returns:
    The corresponding Luna private key
    
    Throws:
    
    java.security.InvalidKeyException - exception
  - InjectPrivateKey
```
public static java.security.PrivateKey InjectPrivateKey(java.security.PrivateKey key,
                                        int slot)
                                                 throws java.security.InvalidKeyException
```
    Inject (encrypt encoded key and unwrap) a non-Luna private key into the token at the specified slot.
    
    Parameters:
    key - The non-Luna key object
    slot - The slot of the token to inject the key into
    
    Returns:
    The corresponding Luna private key
    
    Throws:
    
    java.security.InvalidKeyException - If the key is not encoded in PKCS8 format, or if it is an ECC key on an unsupported named curve
  - injectKey
```
protected static int injectKey(byte[] keyBytes,
            long keyAlg,
            long keyType,
            int slot,
            boolean extractable,
            boolean derive)
```
  - setUsageLimit
```
public boolean setUsageLimit(int limit)
```
    Set the usage limit on this key. Once this key has been used for signing the specified number of times, any further operations using this key will return an exception.
    
    Parameters:
    limit - The maximum number of times this key may be used. This number cannot be less than zero.
    
    Returns:
    true if the limit was set successfully, false otherwise
  - getUsageLimit
```
public int getUsageLimit()
```
    Get the usage limit set on this on this key.
    
    Returns:
    the usage limit set on this key
    
    Throws:
    
    LunaException - if there is no limit set on this key
  - setUsageCount
```
public boolean setUsageCount(int count)
```
    Set the usage count on this key. This can be useful if a key has been restored from backup and you need to increase the usage count to match the last know count of the formerly active key.
    
    Parameters:
    count - The new usage count of the key. This number cannot be less than zero.
    
    Returns:
    true if the count was set successfully, false otherwise
  - getUsageCount
```
public int getUsageCount()
```
    Get the number of times this key has been used.
    
    Returns:
    the usage count of this key
    
    Throws:
    
    LunaException - if the count isn't being tracked (i.e. there is no usage limit specified for this key)
  - getBytesRemaining
```
public int getBytesRemaining()
```
    Get the bytes remaining that can be encrypted by this key .
    
    Returns:
    the nbr of bytes that can be encrypted by this key
    
    Throws:
    
    LunaException - if the count isn't being tracked (i.e. there is no FIPS restriction specified for this key)
  - LocateKeyByAlias
```
public static LunaKey LocateKeyByAlias(java.lang.String alias)
```
    Locate a persisted key on the default slot using the alias assigned when MakePersistant() was invoked. This method will find public keys, private keys and secret keys.
    
    Parameters:
    alias - The alias of the key to retrieve
    
    Returns:
    Returns the key object, or null if nothing matched
  - LocateKeyByAlias
```
public static LunaKey LocateKeyByAlias(java.lang.String alias,
                       int slot)
```
    Locate a persisted key on the specified slot using the alias assigned when MakePersistant() was invoked. This method will find public keys, private keys and secret keys.
    
    Parameters:
    alias - The alias of the key to retrieve
    slot - The slot to search
    
    Returns:
    Returns the key object, or null if nothing matched
  - LocateKeyByFingerprint
```
public static LunaKey LocateKeyByFingerprint(byte[] fingerprint)
```
    Locate a persisted key on the default slot using the key's fingerprint.
    
    Parameters:
    fingerprint - The fingerprint of the key to retrieve
    
    Returns:
    Returns the key object, or null if nothing matched
  - LocateKeyByFingerprint
```
public static LunaKey LocateKeyByFingerprint(byte[] fingerprint,
                             int slot)
```
    Locate a persisted key on the specified slot using the key's fingerprint.
    
    Parameters:
    fingerprint - The fingerprint of the key to retrieve
    slot - The slot to search
    
    Returns:
    Returns the key object.
  - LocateKeyOnlyByAlias
```
public static LunaKey LocateKeyOnlyByAlias(java.lang.String alias)
```
    Locate a persisted key on the default slot using the alias assigned when MakePersistant() was invoked. This method will find private keys and secret keys.
    
    Parameters:
    alias - The alias of the key to retrieve
    
    Returns:
    Returns the key object
  - LocateKeyOnlyByAlias
```
public static LunaKey LocateKeyOnlyByAlias(java.lang.String alias,
                           int slot)
```
    Locate a persisted key on the specified slot using the alias assigned when MakePersistant() was invoked. This method will find private keys and secret keys.
    
    Parameters:
    alias - The alias of the key to retrieve
    slot - The slot to search
    
    Returns:
    Returns the key object
  - LocateKeyByHandle
```
public static LunaKey LocateKeyByHandle(int handle)
```
    Locate a persisted key on the default slot using the handle assigned when MakePersistant() was invoked.
    This method should not be used to look up a session (non-persisted) key that was created by another Java process. Doing so may make the key unavailable at an unexpected time in this process or the originating process. If you need to share keys between processes, persist them first.
    
    Parameters:
    handle - The handle of the key to retrieve
    
    Returns:
    Returns the key object
  - LocateKeyByHandle
```
public static LunaKey LocateKeyByHandle(int handle,
                        int slot)
```
    Locate a persisted key on the specified slot using the handle assigned when MakePersistent() was invoked.
    This method should not be used to look up a session (non-persisted) key that was created by another Java process. Doing so may make the key unavailable at an unexpected time in this process or the originating process. If you need to share keys between processes, persist them first.
    
    Parameters:
    handle - The handle of the key to retrieve
    slot - The slot to search
    
    Returns:
    Returns the key object
  - LocateKeyByOUID
```
public static LunaKey LocateKeyByOUID(byte[] ouid)
```
    Locate a persisted key using the CKA_OUID attribute.
    
    Parameters:
    ouid - The OUID of the key to retrieve
    
    Returns:
    Returns the key object
  - LocateKeyByOUID
```
public static LunaKey LocateKeyByOUID(byte[] ouid,
                      int slot)
```
    Locate a persisted key on the specified slot using the CKA_OUID attribute.
    
    Parameters:
    ouid - The OUID of the key to retrieve
    slot - The slot to search
    
    Returns:
    Returns the key object
  - getKeyByType
```
public static LunaKey getKeyByType(LunaTokenObject tokenObj)
```
  - setAuthorizationData
```
public void setAuthorizationData(java.lang.String oldValue,
                        java.lang.String newValue)
```
    Sets the auth data for this key from old value to new value.
    
    Parameters:
    oldValue - old auth data
    newValue - new auth data
  - resetAuthorizationData
```
public void resetAuthorizationData(java.lang.String newValue)
```
    Resets the auth data for this key.
    
    Parameters:
    newValue - new auth data
  - authorize
```
public void authorize(java.lang.String value,
             boolean override)
```
    Authorizes this key.
    
    Parameters:
    value - auth data
    override - get a new session from the HSM regardless as to whether we've already got one
  - assign
```
public void assign()
```
    Assigns this key.
  - incrementFailedAuthorizationCount
```
public void incrementFailedAuthorizationCount()
```
    Increment the failed authorize attempt count for this key. (mainly here for completeness as it's needed by HA)
  - getAuthorizedSession
```
public LunaSession getAuthorizedSession()
```
    get the authorized session for this key.
    
    Returns:
    the authorized session associated with this key
  - cacheAuthorizedSession
```
public void cacheAuthorizedSession(LunaSession session)
```
    cache the authorized session for this key.
    
    Parameters:
    session - the authorized session associated with this key to cache
  - deleteCacheAuthorizedSession
```
public void deleteCacheAuthorizedSession()
```
    remove the authorized session for this key from the cache but leave the contained auth session. Use resetAuthorizedSession to remove the contained auth session.
  - getCacheAuthorizedSession
```
public LunaSession getCacheAuthorizedSession()
```
    get the cached authorized session for this key.
    
    Returns:
    that authorized cached session associated with this key
  - resetAuthorizedSession
```
public void resetAuthorizedSession()
```
    null out the authorized session for this key.
  - generateRandomIv
```
public static byte[] generateRandomIv(int length,
                      boolean secure,
                      boolean derEncode)
```
    Generate a new random IV.
    
    Parameters:
    length - the length in bytes of the IV
    secure - if true use SecureRandom, otherwise Random
    derEncode - if true will prepend DER encoding bytes
    
    Returns:
    random IV byte array

Class LunaKey

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

lapi

mObject

mKeyClass

mKeyType

keySize

ivRandom

ivSecureRandom

UNLIMITED_USE

Constructor Detail

LunaKey

LunaKey

LunaKey

LunaKey

LunaKey

LunaKey

Method Detail

Initialize

Initialize

verifyClassAndType

setKeySize

getKeySize

getKeyType

GetKeyHandle

isInitialized

getSession

getSlot

GetFingerprint

GetOUID

GetKeyClass

toString

MakePersistent

GetDateMadePersistent

DestroyKey

getAlgorithm

getFormat

getEncoded

getEncodedInternal

equals

hashCode

GetAlias

IsKeyPersistent

release

BigIntegerToAttribute

AttributeToBigInteger

GetKeyType

InjectPrivateKey

InjectPrivateKey

InjectPrivateKey

InjectPrivateKey

injectKey

setUsageLimit

getUsageLimit

setUsageCount

getUsageCount

getBytesRemaining

LocateKeyByAlias

LocateKeyByAlias

LocateKeyByFingerprint

LocateKeyByFingerprint

LocateKeyOnlyByAlias

LocateKeyOnlyByAlias

LocateKeyByHandle

LocateKeyByHandle

LocateKeyByOUID

LocateKeyByOUID

getKeyByType

setAuthorizationData

resetAuthorizationData

authorize

assign

incrementFailedAuthorizationCount

getAuthorizedSession

cacheAuthorizedSession

deleteCacheAuthorizedSession