# Interface KEMSpi

public interface KEMSpi
This class defines the Service Provider Interface (SPI) for the `KEM` class. A security provider implements this interface to provide an implementation of a Key Encapsulation Mechanism (KEM) algorithm.

A KEM algorithm may support a family of configurations. Each configuration may accept different types of keys, cryptographic primitives, and sizes of shared secrets and key encapsulation messages. A configuration is defined by the KEM algorithm name, the key it uses, and an optional `AlgorithmParameterSpec` argument that is specified when creating an encapsulator or decapsulator. The result of calling `engineNewEncapsulator(PublicKey, AlgorithmParameterSpec, SecureRandom)` or `engineNewDecapsulator(PrivateKey, AlgorithmParameterSpec)` must return an encapsulator or decapsulator that maps to a single configuration, where its `engineSecretSize()` and `engineEncapsulationSize()` methods return constant values.

A `KEMSpi` implementation must be immutable. It must be safe to call multiple `engineNewEncapsulator` and `engineNewDecapsulator` methods at the same time.

`EncapsulatorSpi` and `DecapsulatorSpi` implementations must also be immutable. It must be safe to invoke multiple `encapsulate` and `decapsulate` methods at the same time. Each invocation of `encapsulate` should generate a new shared secret and key encapsulation message.

For example,

    public static class MyKEMImpl implements KEMSpi {

        @Override
        public KEMSpi.EncapsulatorSpi engineNewEncapsulator(PublicKey publicKey,
                AlgorithmParameterSpec spec, SecureRandom secureRandom)
                throws InvalidAlgorithmParameterException, InvalidKeyException {
            if (!checkPublicKey(publicKey)) {
                throw new InvalidKeyException("unsupported key");
            }
            if (!checkParameters(spec)) {
                throw new InvalidAlgorithmParameterException("unsupported params");
            }
            return new MyEncapsulator(publicKey, spec, secureRandom);
        }

        class MyEncapsulator implements KEMSpi.EncapsulatorSpi {
            MyEncapsulator(PublicKey publicKey, AlgorithmParameterSpec spec,
                    SecureRandom secureRandom){
                this.spec = spec != null ? spec : getDefaultParameters();
                this.secureRandom = secureRandom != null
                        ? secureRandom
                        : getDefaultSecureRandom();
                this.publicKey = publicKey;
            }

            @Override
            public KEM.Encapsulated encapsulate(int from, int to, String algorithm) {
                byte[] encapsulation;
                byte[] secret;
                // calculating...
                return new KEM.Encapsulated(
                        new SecretKeySpec(secret, from, to - from, algorithm),
                        encapsulation, null);
            }

            // ...
        }

        // ...
    }

Since:
  21
See Also:
  - `KEM`

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Interface
  Description
  `static interface`
  `KEMSpi.DecapsulatorSpi`
  The KEM decapsulator implementation, generated by `engineNewDecapsulator(PrivateKey, AlgorithmParameterSpec)` on the KEM receiver side.
  `static interface`
  `KEMSpi.EncapsulatorSpi`
  The KEM encapsulator implementation, generated by `engineNewEncapsulator(PublicKey, AlgorithmParameterSpec, SecureRandom)` on the KEM sender side.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `KEMSpi.DecapsulatorSpi`
  `engineNewDecapsulator(PrivateKey privateKey, AlgorithmParameterSpec spec)`
  Creates a KEM decapsulator on the KEM receiver side.
  `KEMSpi.EncapsulatorSpi`
  `engineNewEncapsulator(PublicKey publicKey, AlgorithmParameterSpec spec, SecureRandom secureRandom)`
  Creates a KEM encapsulator on the KEM sender side.

- ## Method Details

  - ### engineNewEncapsulator

    KEMSpi.EncapsulatorSpi engineNewEncapsulator(PublicKey publicKey, AlgorithmParameterSpec spec, SecureRandom secureRandom) throws InvalidAlgorithmParameterException, InvalidKeyException
    Creates a KEM encapsulator on the KEM sender side.
    Parameters:
      `publicKey` - the receiver's public key, must not be `null`
      `spec` - the optional parameter, can be `null`
      `secureRandom` - the source of randomness for encapsulation. If `null`, the implementation must provide a default one.
    Returns:
      the encapsulator for this key
    Throws:
      `InvalidAlgorithmParameterException` - if `spec` is invalid or one is required but `spec` is `null`
      `InvalidKeyException` - if `publicKey` is `null` or invalid
    See Also:
      - `KEM.newEncapsulator(PublicKey, AlgorithmParameterSpec, SecureRandom)`

  - ### engineNewDecapsulator

    KEMSpi.DecapsulatorSpi engineNewDecapsulator(PrivateKey privateKey, AlgorithmParameterSpec spec) throws InvalidAlgorithmParameterException, InvalidKeyException
    Creates a KEM decapsulator on the KEM receiver side.
    Parameters:
      `privateKey` - the receiver's private key, must not be `null`
      `spec` - the optional parameter, can be `null`
    Returns:
      the decapsulator for this key
    Throws:
      `InvalidAlgorithmParameterException` - if `spec` is invalid or one is required but `spec` is `null`
      `InvalidKeyException` - if `privateKey` is `null` or invalid
    See Also:
      - `KEM.newDecapsulator(PrivateKey, AlgorithmParameterSpec)`