Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.mozilla.jss.pkcs11
Class PK11KeyPairGenerator

    java.lang.Object
      org.mozilla.jss.crypto.KeyPairGeneratorSpi
          org.mozilla.jss.pkcs11.PK11KeyPairGenerator

    public final class PK11KeyPairGenerator

extends KeyPairGeneratorSpi

A Key Pair Generator implemented using PKCS #11.

See Also:
  `PQGParams`

Field Summary
`static PQGParams` | `PQG1024` Pre-cooked PQG values for 1024-bit keypairs, along with the seed, counter, and H values needed to verify them.
`static PQGParams` | `PQG512` Pre-cooked PQG values for 512-bit keypairs, along with the seed, counter, and H values needed to verify them.
`static PQGParams` | `PQG768` Pre-cooked PQG values for 768-bit keypairs, along with the seed, counter, and H values needed to verify them.

Constructor Summary
`PK11KeyPairGenerator(PK11Token token, KeyPairAlgorithm algorithm)` Constructor for PK11KeyPairGenerator.

Method Summary
`void` | `extractablePairs(boolean extractable)`
`java.security.KeyPair` | `generateKeyPair()` Generates a key pair on a token.
`void` | `initialize(java.security.spec.AlgorithmParameterSpec params, java.security.SecureRandom random)` Initializes this KeyPairGenerator with the given algorithm-specific parameters.
`void` | `initialize(int strength, java.security.SecureRandom random)` Initializes this KeyPairGenerator with the given key strength.
`boolean` | `keygenOnInternalToken()`
`void` | `sensitivePairs(boolean sensitive)`
`void` | `temporaryPairs(boolean temp)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### PQG1024

    public static final PQGParams PQG1024

  Pre-cooked PQG values for 1024-bit keypairs, along with the seed, counter, and H values needed to verify them.

### PQG768

    public static final PQGParams PQG768

  Pre-cooked PQG values for 768-bit keypairs, along with the seed, counter, and H values needed to verify them.

### PQG512

    public static final PQGParams PQG512

  Pre-cooked PQG values for 512-bit keypairs, along with the seed, counter, and H values needed to verify them.

Constructor Detail

### PK11KeyPairGenerator

    public PK11KeyPairGenerator(PK11Token token,
                                KeyPairAlgorithm algorithm)
                         throws java.security.NoSuchAlgorithmException,
                                TokenException

  Constructor for PK11KeyPairGenerator.

  Parameters:
    `token` - The PKCS #11 token that the keypair will be generated on.
    `algorithm` - The type of key that will be generated. Currently, `KeyPairAlgorithm.RSA` , `KeyPairAlgorithm.DSA` and `KeyPairAlgorithm.EC` are supported.
  Throws:
    `java.security.NoSuchAlgorithmException`
    `TokenException`

Method Detail

### initialize

    public void initialize(int strength,
                           java.security.SecureRandom random)
                    throws java.security.InvalidParameterException

  Initializes this KeyPairGenerator with the given key strength.

  For DSA key generation, pre-cooked PQG values will be used be used if the key size is 512, 768, or 1024. Otherwise, an InvalidParameterException will be thrown.

  Specified by:
    `initialize` in class `KeyPairGeneratorSpi`
  Parameters:
    `strength` - The strength (size) of the keys that will be generated.
    `random` - Ignored
  Throws:
    `java.security.InvalidParameterException` - If the key strength is not supported by the algorithm or this implementation.

### initialize

    public void initialize(java.security.spec.AlgorithmParameterSpec params,
                           java.security.SecureRandom random)
                    throws java.security.InvalidAlgorithmParameterException

  Initializes this KeyPairGenerator with the given algorithm-specific parameters.

  Specified by:
    `initialize` in class `KeyPairGeneratorSpi`
  Parameters:
    `params` - The algorithm-specific parameters that will govern key pair generation.
    `random` - Ignored
  Throws:
    `java.security.InvalidAlgorithmParameterException` - If the parameters are inappropriate for the key type or are not supported by this implementation.

### generateKeyPair

    public java.security.KeyPair generateKeyPair()
                                          throws TokenException

  Generates a key pair on a token. Uses parameters if they were passed in through a call to `initialize`, otherwise uses defaults.

  Specified by:
    `generateKeyPair` in class `KeyPairGeneratorSpi`
  Throws:
    `TokenException`

### keygenOnInternalToken

    public boolean keygenOnInternalToken()

  Specified by:
    `keygenOnInternalToken` in class `KeyPairGeneratorSpi`
  Returns:
    true if the keypair generation will be done on the internal token and then moved to this token.

### temporaryPairs

    public void temporaryPairs(boolean temp)

  Specified by:
    `temporaryPairs` in class `KeyPairGeneratorSpi`

### sensitivePairs

    public void sensitivePairs(boolean sensitive)

  Specified by:
    `sensitivePairs` in class `KeyPairGeneratorSpi`

### extractablePairs

    public void extractablePairs(boolean extractable)

  Specified by:
    `extractablePairs` in class `KeyPairGeneratorSpi`

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD