{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}

-- | DHKEM as an instance of @crypton@'s 'KEM' class.
--
-- RFC 9180 section 4.1 builds a key encapsulation mechanism out of a
-- Diffie-Hellman group: the exchange's output goes through HKDF with the
-- ephemeral and the recipient public keys as context, under labels that
-- name the ciphersuite.  That construction, and not the bare exchange, is
-- what a KEM is, which is why @crypton@ has the class and no instance for
-- the groups themselves.
--
-- There is one type per suite RFC 9180 registers, and no way to spell
-- anything else.  The group does not pick the suite on its own -- the hash
-- and the registered code point are part of what the shared secret is
-- derived from -- but the registry lists each group exactly once, so
-- naming the group names all three.
--
-- The instance is here rather than in @crypton@ because those labels carry
-- the HPKE ciphersuite identifier and the protocol's own version string,
-- which is the same reason TLS 1.3's labelled HKDF lives in @tls@ rather
-- than in @crypton@.
--
-- Only @Encap@ and @Decap@ are instance methods.  DHKEM also has
-- @AuthEncap@ and @AuthDecap@, in that same section 4.1, where a static
-- sender key contributes a second Diffie-Hellman and its public key joins
-- the context; they take an argument the class has no room for, so they
-- are not here.  'Crypto.HPKE.setupBaseS' with a sender key is the way to
-- those, through the mode of section 5.1.3.
module Crypto.HPKE.DHKEM (
    -- * The suites RFC 9180 registers
    DHKEM_P256,
    DHKEM_P384,
    DHKEM_P521,
    DHKEM_X25519,
    DHKEM_X448,

    -- * The classes they implement
    KEM (..),
    HPKEKEM (..),
    SharedSecret (..),
) where

import Crypto.ECC (
    Curve_P256R1,
    Curve_P384R1,
    Curve_P521R1,
    Curve_X25519,
    Curve_X448,
    EllipticCurve (..),
    EllipticCurveDH (..),
    KeyPair (..),
 )
import Crypto.Error (CryptoError (..))
import Crypto.KEM (KEM (..))
import Crypto.Random (MonadRandom)
import Data.Kind (Type)

import Crypto.HPKE.ID
import Crypto.HPKE.KDF
import Crypto.HPKE.KEM
import Crypto.HPKE.PublicKey
import Crypto.HPKE.Types

----------------------------------------------------------------

-- | DHKEM(P-256, HKDF-SHA256).
data DHKEM_P256

-- | DHKEM(P-384, HKDF-SHA384).
data DHKEM_P384

-- | DHKEM(P-521, HKDF-SHA512).
data DHKEM_P521

-- | DHKEM(X25519, HKDF-SHA256).
data DHKEM_X25519

-- | DHKEM(X448, HKDF-SHA512).
data DHKEM_X448

----------------------------------------------------------------

-- What a registered suite is made of.  Not exported: it exists so that the
-- five instances below are five names rather than five copies of the same
-- code, and a sixth suite would be a line here and not a design.
class
    ( EllipticCurve (HPKEKEMGroup kem)
    , EllipticCurveDH (HPKEKEMGroup kem)
    , HashAlgorithm (HPKEKEMHash kem)
    , KDF (HPKEKEMHash kem)
    ) =>
    HPKEKEMRegistered kem
    where
    type HPKEKEMGroup kem :: Type
    type HPKEKEMHash kem :: Type
    hpkeKEMID :: proxy kem -> KEM_ID
    hpkeKEMHash :: proxy kem -> HPKEKEMHash kem

{- FOURMOLU_DISABLE -}
instance HPKEKEMRegistered DHKEM_P256 where
    type HPKEKEMGroup DHKEM_P256    = Curve_P256R1
    type HPKEKEMHash  DHKEM_P256    = SHA256
    hpkeKEMID :: forall (proxy :: * -> *). proxy DHKEM_P256 -> KEM_ID
hpkeKEMID   proxy DHKEM_P256
_ = KEM_ID
DHKEM_P256_HKDF_SHA256
    hpkeKEMHash :: forall (proxy :: * -> *).
proxy DHKEM_P256 -> HPKEKEMHash DHKEM_P256
hpkeKEMHash proxy DHKEM_P256
_ = SHA256
HPKEKEMHash DHKEM_P256
SHA256

instance HPKEKEMRegistered DHKEM_P384 where
    type HPKEKEMGroup DHKEM_P384    = Curve_P384R1
    type HPKEKEMHash  DHKEM_P384    = SHA384
    hpkeKEMID :: forall (proxy :: * -> *). proxy DHKEM_P384 -> KEM_ID
hpkeKEMID   proxy DHKEM_P384
_ = KEM_ID
DHKEM_P384_HKDF_SHA384
    hpkeKEMHash :: forall (proxy :: * -> *).
proxy DHKEM_P384 -> HPKEKEMHash DHKEM_P384
hpkeKEMHash proxy DHKEM_P384
_ = SHA384
HPKEKEMHash DHKEM_P384
SHA384

instance HPKEKEMRegistered DHKEM_P521 where
    type HPKEKEMGroup DHKEM_P521    = Curve_P521R1
    type HPKEKEMHash  DHKEM_P521    = SHA512
    hpkeKEMID :: forall (proxy :: * -> *). proxy DHKEM_P521 -> KEM_ID
hpkeKEMID   proxy DHKEM_P521
_ = KEM_ID
DHKEM_P521_HKDF_SHA512
    hpkeKEMHash :: forall (proxy :: * -> *).
proxy DHKEM_P521 -> HPKEKEMHash DHKEM_P521
hpkeKEMHash proxy DHKEM_P521
_ = SHA512
HPKEKEMHash DHKEM_P521
SHA512

instance HPKEKEMRegistered DHKEM_X25519 where
    type HPKEKEMGroup DHKEM_X25519  = Curve_X25519
    type HPKEKEMHash  DHKEM_X25519  = SHA256
    hpkeKEMID :: forall (proxy :: * -> *). proxy DHKEM_X25519 -> KEM_ID
hpkeKEMID   proxy DHKEM_X25519
_ = KEM_ID
DHKEM_X25519_HKDF_SHA256
    hpkeKEMHash :: forall (proxy :: * -> *).
proxy DHKEM_X25519 -> HPKEKEMHash DHKEM_X25519
hpkeKEMHash proxy DHKEM_X25519
_ = SHA256
HPKEKEMHash DHKEM_X25519
SHA256

instance HPKEKEMRegistered DHKEM_X448 where
    type HPKEKEMGroup DHKEM_X448    = Curve_X448
    type HPKEKEMHash  DHKEM_X448    = SHA512
    hpkeKEMID :: forall (proxy :: * -> *). proxy DHKEM_X448 -> KEM_ID
hpkeKEMID   proxy DHKEM_X448
_ = KEM_ID
DHKEM_X448_HKDF_SHA512
    hpkeKEMHash :: forall (proxy :: * -> *).
proxy DHKEM_X448 -> HPKEKEMHash DHKEM_X448
hpkeKEMHash proxy DHKEM_X448
_ = SHA512
HPKEKEMHash DHKEM_X448
SHA512
{- FOURMOLU_ENABLE -}

----------------------------------------------------------------

-- | The keys and the encapsulated value are the serialized forms of RFC
-- 9180 section 4, which is what travels and what this package's other
-- entry points already speak.  The coins are the sender's ephemeral secret
-- key, @skE@, which is what the appendix A vectors fix.
instance KEM DHKEM_P256 where
    type EncapsulationKey DHKEM_P256 = EncodedPublicKey
    type DecapsulationKey DHKEM_P256 = EncodedSecretKey
    type Ciphertext DHKEM_P256 = EncodedPublicKey
    type Coins DHKEM_P256 = EncodedSecretKey
    generateKeyPair :: forall (m :: * -> *) (proxy :: * -> *).
MonadRandom m =>
proxy DHKEM_P256
-> m (EncapsulationKey DHKEM_P256, DecapsulationKey DHKEM_P256)
generateKeyPair = proxy DHKEM_P256 -> m (EncodedPublicKey, EncodedSecretKey)
proxy DHKEM_P256
-> m (EncapsulationKey DHKEM_P256, DecapsulationKey DHKEM_P256)
forall kem (m :: * -> *) (proxy :: * -> *).
(HPKEKEMRegistered kem, MonadRandom m) =>
proxy kem -> m (EncodedPublicKey, EncodedSecretKey)
dhkemGenerateKeyPair
    encapsulate :: forall (m :: * -> *) (proxy :: * -> *).
MonadRandom m =>
proxy DHKEM_P256
-> EncapsulationKey DHKEM_P256
-> m (CryptoFailable (Ciphertext DHKEM_P256, SharedSecret))
encapsulate = proxy DHKEM_P256
-> EncodedPublicKey
-> m (CryptoFailable (EncodedPublicKey, SharedSecret))
proxy DHKEM_P256
-> EncapsulationKey DHKEM_P256
-> m (CryptoFailable (Ciphertext DHKEM_P256, SharedSecret))
forall kem (m :: * -> *) (proxy :: * -> *).
(HPKEKEMRegistered kem, MonadRandom m) =>
proxy kem
-> EncodedPublicKey
-> m (CryptoFailable (EncodedPublicKey, SharedSecret))
dhkemEncapsulate
    encapsulateWith :: forall (proxy :: * -> *).
proxy DHKEM_P256
-> EncapsulationKey DHKEM_P256
-> Coins DHKEM_P256
-> CryptoFailable (Ciphertext DHKEM_P256, SharedSecret)
encapsulateWith = proxy DHKEM_P256
-> EncodedPublicKey
-> EncodedSecretKey
-> CryptoFailable (EncodedPublicKey, SharedSecret)
proxy DHKEM_P256
-> EncapsulationKey DHKEM_P256
-> Coins DHKEM_P256
-> CryptoFailable (Ciphertext DHKEM_P256, SharedSecret)
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedPublicKey
-> EncodedSecretKey
-> CryptoFailable (EncodedPublicKey, SharedSecret)
dhkemEncapsulateWith
    decapsulate :: forall (proxy :: * -> *).
proxy DHKEM_P256
-> DecapsulationKey DHKEM_P256
-> Ciphertext DHKEM_P256
-> CryptoFailable SharedSecret
decapsulate = proxy DHKEM_P256
-> EncodedSecretKey
-> EncodedPublicKey
-> CryptoFailable SharedSecret
proxy DHKEM_P256
-> DecapsulationKey DHKEM_P256
-> Ciphertext DHKEM_P256
-> CryptoFailable SharedSecret
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedSecretKey
-> EncodedPublicKey
-> CryptoFailable SharedSecret
dhkemDecapsulate

instance KEM DHKEM_P384 where
    type EncapsulationKey DHKEM_P384 = EncodedPublicKey
    type DecapsulationKey DHKEM_P384 = EncodedSecretKey
    type Ciphertext DHKEM_P384 = EncodedPublicKey
    type Coins DHKEM_P384 = EncodedSecretKey
    generateKeyPair :: forall (m :: * -> *) (proxy :: * -> *).
MonadRandom m =>
proxy DHKEM_P384
-> m (EncapsulationKey DHKEM_P384, DecapsulationKey DHKEM_P384)
generateKeyPair = proxy DHKEM_P384 -> m (EncodedPublicKey, EncodedSecretKey)
proxy DHKEM_P384
-> m (EncapsulationKey DHKEM_P384, DecapsulationKey DHKEM_P384)
forall kem (m :: * -> *) (proxy :: * -> *).
(HPKEKEMRegistered kem, MonadRandom m) =>
proxy kem -> m (EncodedPublicKey, EncodedSecretKey)
dhkemGenerateKeyPair
    encapsulate :: forall (m :: * -> *) (proxy :: * -> *).
MonadRandom m =>
proxy DHKEM_P384
-> EncapsulationKey DHKEM_P384
-> m (CryptoFailable (Ciphertext DHKEM_P384, SharedSecret))
encapsulate = proxy DHKEM_P384
-> EncodedPublicKey
-> m (CryptoFailable (EncodedPublicKey, SharedSecret))
proxy DHKEM_P384
-> EncapsulationKey DHKEM_P384
-> m (CryptoFailable (Ciphertext DHKEM_P384, SharedSecret))
forall kem (m :: * -> *) (proxy :: * -> *).
(HPKEKEMRegistered kem, MonadRandom m) =>
proxy kem
-> EncodedPublicKey
-> m (CryptoFailable (EncodedPublicKey, SharedSecret))
dhkemEncapsulate
    encapsulateWith :: forall (proxy :: * -> *).
proxy DHKEM_P384
-> EncapsulationKey DHKEM_P384
-> Coins DHKEM_P384
-> CryptoFailable (Ciphertext DHKEM_P384, SharedSecret)
encapsulateWith = proxy DHKEM_P384
-> EncodedPublicKey
-> EncodedSecretKey
-> CryptoFailable (EncodedPublicKey, SharedSecret)
proxy DHKEM_P384
-> EncapsulationKey DHKEM_P384
-> Coins DHKEM_P384
-> CryptoFailable (Ciphertext DHKEM_P384, SharedSecret)
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedPublicKey
-> EncodedSecretKey
-> CryptoFailable (EncodedPublicKey, SharedSecret)
dhkemEncapsulateWith
    decapsulate :: forall (proxy :: * -> *).
proxy DHKEM_P384
-> DecapsulationKey DHKEM_P384
-> Ciphertext DHKEM_P384
-> CryptoFailable SharedSecret
decapsulate = proxy DHKEM_P384
-> EncodedSecretKey
-> EncodedPublicKey
-> CryptoFailable SharedSecret
proxy DHKEM_P384
-> DecapsulationKey DHKEM_P384
-> Ciphertext DHKEM_P384
-> CryptoFailable SharedSecret
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedSecretKey
-> EncodedPublicKey
-> CryptoFailable SharedSecret
dhkemDecapsulate

instance KEM DHKEM_P521 where
    type EncapsulationKey DHKEM_P521 = EncodedPublicKey
    type DecapsulationKey DHKEM_P521 = EncodedSecretKey
    type Ciphertext DHKEM_P521 = EncodedPublicKey
    type Coins DHKEM_P521 = EncodedSecretKey
    generateKeyPair :: forall (m :: * -> *) (proxy :: * -> *).
MonadRandom m =>
proxy DHKEM_P521
-> m (EncapsulationKey DHKEM_P521, DecapsulationKey DHKEM_P521)
generateKeyPair = proxy DHKEM_P521 -> m (EncodedPublicKey, EncodedSecretKey)
proxy DHKEM_P521
-> m (EncapsulationKey DHKEM_P521, DecapsulationKey DHKEM_P521)
forall kem (m :: * -> *) (proxy :: * -> *).
(HPKEKEMRegistered kem, MonadRandom m) =>
proxy kem -> m (EncodedPublicKey, EncodedSecretKey)
dhkemGenerateKeyPair
    encapsulate :: forall (m :: * -> *) (proxy :: * -> *).
MonadRandom m =>
proxy DHKEM_P521
-> EncapsulationKey DHKEM_P521
-> m (CryptoFailable (Ciphertext DHKEM_P521, SharedSecret))
encapsulate = proxy DHKEM_P521
-> EncodedPublicKey
-> m (CryptoFailable (EncodedPublicKey, SharedSecret))
proxy DHKEM_P521
-> EncapsulationKey DHKEM_P521
-> m (CryptoFailable (Ciphertext DHKEM_P521, SharedSecret))
forall kem (m :: * -> *) (proxy :: * -> *).
(HPKEKEMRegistered kem, MonadRandom m) =>
proxy kem
-> EncodedPublicKey
-> m (CryptoFailable (EncodedPublicKey, SharedSecret))
dhkemEncapsulate
    encapsulateWith :: forall (proxy :: * -> *).
proxy DHKEM_P521
-> EncapsulationKey DHKEM_P521
-> Coins DHKEM_P521
-> CryptoFailable (Ciphertext DHKEM_P521, SharedSecret)
encapsulateWith = proxy DHKEM_P521
-> EncodedPublicKey
-> EncodedSecretKey
-> CryptoFailable (EncodedPublicKey, SharedSecret)
proxy DHKEM_P521
-> EncapsulationKey DHKEM_P521
-> Coins DHKEM_P521
-> CryptoFailable (Ciphertext DHKEM_P521, SharedSecret)
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedPublicKey
-> EncodedSecretKey
-> CryptoFailable (EncodedPublicKey, SharedSecret)
dhkemEncapsulateWith
    decapsulate :: forall (proxy :: * -> *).
proxy DHKEM_P521
-> DecapsulationKey DHKEM_P521
-> Ciphertext DHKEM_P521
-> CryptoFailable SharedSecret
decapsulate = proxy DHKEM_P521
-> EncodedSecretKey
-> EncodedPublicKey
-> CryptoFailable SharedSecret
proxy DHKEM_P521
-> DecapsulationKey DHKEM_P521
-> Ciphertext DHKEM_P521
-> CryptoFailable SharedSecret
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedSecretKey
-> EncodedPublicKey
-> CryptoFailable SharedSecret
dhkemDecapsulate

instance KEM DHKEM_X25519 where
    type EncapsulationKey DHKEM_X25519 = EncodedPublicKey
    type DecapsulationKey DHKEM_X25519 = EncodedSecretKey
    type Ciphertext DHKEM_X25519 = EncodedPublicKey
    type Coins DHKEM_X25519 = EncodedSecretKey
    generateKeyPair :: forall (m :: * -> *) (proxy :: * -> *).
MonadRandom m =>
proxy DHKEM_X25519
-> m (EncapsulationKey DHKEM_X25519, DecapsulationKey DHKEM_X25519)
generateKeyPair = proxy DHKEM_X25519 -> m (EncodedPublicKey, EncodedSecretKey)
proxy DHKEM_X25519
-> m (EncapsulationKey DHKEM_X25519, DecapsulationKey DHKEM_X25519)
forall kem (m :: * -> *) (proxy :: * -> *).
(HPKEKEMRegistered kem, MonadRandom m) =>
proxy kem -> m (EncodedPublicKey, EncodedSecretKey)
dhkemGenerateKeyPair
    encapsulate :: forall (m :: * -> *) (proxy :: * -> *).
MonadRandom m =>
proxy DHKEM_X25519
-> EncapsulationKey DHKEM_X25519
-> m (CryptoFailable (Ciphertext DHKEM_X25519, SharedSecret))
encapsulate = proxy DHKEM_X25519
-> EncodedPublicKey
-> m (CryptoFailable (EncodedPublicKey, SharedSecret))
proxy DHKEM_X25519
-> EncapsulationKey DHKEM_X25519
-> m (CryptoFailable (Ciphertext DHKEM_X25519, SharedSecret))
forall kem (m :: * -> *) (proxy :: * -> *).
(HPKEKEMRegistered kem, MonadRandom m) =>
proxy kem
-> EncodedPublicKey
-> m (CryptoFailable (EncodedPublicKey, SharedSecret))
dhkemEncapsulate
    encapsulateWith :: forall (proxy :: * -> *).
proxy DHKEM_X25519
-> EncapsulationKey DHKEM_X25519
-> Coins DHKEM_X25519
-> CryptoFailable (Ciphertext DHKEM_X25519, SharedSecret)
encapsulateWith = proxy DHKEM_X25519
-> EncodedPublicKey
-> EncodedSecretKey
-> CryptoFailable (EncodedPublicKey, SharedSecret)
proxy DHKEM_X25519
-> EncapsulationKey DHKEM_X25519
-> Coins DHKEM_X25519
-> CryptoFailable (Ciphertext DHKEM_X25519, SharedSecret)
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedPublicKey
-> EncodedSecretKey
-> CryptoFailable (EncodedPublicKey, SharedSecret)
dhkemEncapsulateWith
    decapsulate :: forall (proxy :: * -> *).
proxy DHKEM_X25519
-> DecapsulationKey DHKEM_X25519
-> Ciphertext DHKEM_X25519
-> CryptoFailable SharedSecret
decapsulate = proxy DHKEM_X25519
-> EncodedSecretKey
-> EncodedPublicKey
-> CryptoFailable SharedSecret
proxy DHKEM_X25519
-> DecapsulationKey DHKEM_X25519
-> Ciphertext DHKEM_X25519
-> CryptoFailable SharedSecret
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedSecretKey
-> EncodedPublicKey
-> CryptoFailable SharedSecret
dhkemDecapsulate

instance KEM DHKEM_X448 where
    type EncapsulationKey DHKEM_X448 = EncodedPublicKey
    type DecapsulationKey DHKEM_X448 = EncodedSecretKey
    type Ciphertext DHKEM_X448 = EncodedPublicKey
    type Coins DHKEM_X448 = EncodedSecretKey
    generateKeyPair :: forall (m :: * -> *) (proxy :: * -> *).
MonadRandom m =>
proxy DHKEM_X448
-> m (EncapsulationKey DHKEM_X448, DecapsulationKey DHKEM_X448)
generateKeyPair = proxy DHKEM_X448 -> m (EncodedPublicKey, EncodedSecretKey)
proxy DHKEM_X448
-> m (EncapsulationKey DHKEM_X448, DecapsulationKey DHKEM_X448)
forall kem (m :: * -> *) (proxy :: * -> *).
(HPKEKEMRegistered kem, MonadRandom m) =>
proxy kem -> m (EncodedPublicKey, EncodedSecretKey)
dhkemGenerateKeyPair
    encapsulate :: forall (m :: * -> *) (proxy :: * -> *).
MonadRandom m =>
proxy DHKEM_X448
-> EncapsulationKey DHKEM_X448
-> m (CryptoFailable (Ciphertext DHKEM_X448, SharedSecret))
encapsulate = proxy DHKEM_X448
-> EncodedPublicKey
-> m (CryptoFailable (EncodedPublicKey, SharedSecret))
proxy DHKEM_X448
-> EncapsulationKey DHKEM_X448
-> m (CryptoFailable (Ciphertext DHKEM_X448, SharedSecret))
forall kem (m :: * -> *) (proxy :: * -> *).
(HPKEKEMRegistered kem, MonadRandom m) =>
proxy kem
-> EncodedPublicKey
-> m (CryptoFailable (EncodedPublicKey, SharedSecret))
dhkemEncapsulate
    encapsulateWith :: forall (proxy :: * -> *).
proxy DHKEM_X448
-> EncapsulationKey DHKEM_X448
-> Coins DHKEM_X448
-> CryptoFailable (Ciphertext DHKEM_X448, SharedSecret)
encapsulateWith = proxy DHKEM_X448
-> EncodedPublicKey
-> EncodedSecretKey
-> CryptoFailable (EncodedPublicKey, SharedSecret)
proxy DHKEM_X448
-> EncapsulationKey DHKEM_X448
-> Coins DHKEM_X448
-> CryptoFailable (Ciphertext DHKEM_X448, SharedSecret)
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedPublicKey
-> EncodedSecretKey
-> CryptoFailable (EncodedPublicKey, SharedSecret)
dhkemEncapsulateWith
    decapsulate :: forall (proxy :: * -> *).
proxy DHKEM_X448
-> DecapsulationKey DHKEM_X448
-> Ciphertext DHKEM_X448
-> CryptoFailable SharedSecret
decapsulate = proxy DHKEM_X448
-> EncodedSecretKey
-> EncodedPublicKey
-> CryptoFailable SharedSecret
proxy DHKEM_X448
-> DecapsulationKey DHKEM_X448
-> Ciphertext DHKEM_X448
-> CryptoFailable SharedSecret
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedSecretKey
-> EncodedPublicKey
-> CryptoFailable SharedSecret
dhkemDecapsulate

----------------------------------------------------------------

-- | DHKEM has all four operations of RFC 9180 section 4.1, so the
-- authenticated pair is defined rather than left to refuse.
instance HPKEKEM DHKEM_P256 where
    authEncapWith :: forall (proxy :: * -> *).
proxy DHKEM_P256
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
authEncapWith = proxy DHKEM_P256
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
dhkemAuthEncapWith
    authDecap :: forall (proxy :: * -> *).
proxy DHKEM_P256
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
authDecap = proxy DHKEM_P256
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
dhkemAuthDecap
    toEncapsulationKey :: forall (proxy :: * -> *).
proxy DHKEM_P256
-> EncodedSecretKey -> Either HPKEError EncodedPublicKey
toEncapsulationKey = proxy DHKEM_P256
-> EncodedSecretKey -> Either HPKEError EncodedPublicKey
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem -> EncodedSecretKey -> Either HPKEError EncodedPublicKey
dhkemToEncapsulationKey

instance HPKEKEM DHKEM_P384 where
    authEncapWith :: forall (proxy :: * -> *).
proxy DHKEM_P384
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
authEncapWith = proxy DHKEM_P384
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
dhkemAuthEncapWith
    authDecap :: forall (proxy :: * -> *).
proxy DHKEM_P384
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
authDecap = proxy DHKEM_P384
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
dhkemAuthDecap
    toEncapsulationKey :: forall (proxy :: * -> *).
proxy DHKEM_P384
-> EncodedSecretKey -> Either HPKEError EncodedPublicKey
toEncapsulationKey = proxy DHKEM_P384
-> EncodedSecretKey -> Either HPKEError EncodedPublicKey
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem -> EncodedSecretKey -> Either HPKEError EncodedPublicKey
dhkemToEncapsulationKey

instance HPKEKEM DHKEM_P521 where
    authEncapWith :: forall (proxy :: * -> *).
proxy DHKEM_P521
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
authEncapWith = proxy DHKEM_P521
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
dhkemAuthEncapWith
    authDecap :: forall (proxy :: * -> *).
proxy DHKEM_P521
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
authDecap = proxy DHKEM_P521
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
dhkemAuthDecap
    toEncapsulationKey :: forall (proxy :: * -> *).
proxy DHKEM_P521
-> EncodedSecretKey -> Either HPKEError EncodedPublicKey
toEncapsulationKey = proxy DHKEM_P521
-> EncodedSecretKey -> Either HPKEError EncodedPublicKey
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem -> EncodedSecretKey -> Either HPKEError EncodedPublicKey
dhkemToEncapsulationKey

instance HPKEKEM DHKEM_X25519 where
    authEncapWith :: forall (proxy :: * -> *).
proxy DHKEM_X25519
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
authEncapWith = proxy DHKEM_X25519
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
dhkemAuthEncapWith
    authDecap :: forall (proxy :: * -> *).
proxy DHKEM_X25519
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
authDecap = proxy DHKEM_X25519
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
dhkemAuthDecap
    toEncapsulationKey :: forall (proxy :: * -> *).
proxy DHKEM_X25519
-> EncodedSecretKey -> Either HPKEError EncodedPublicKey
toEncapsulationKey = proxy DHKEM_X25519
-> EncodedSecretKey -> Either HPKEError EncodedPublicKey
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem -> EncodedSecretKey -> Either HPKEError EncodedPublicKey
dhkemToEncapsulationKey

instance HPKEKEM DHKEM_X448 where
    authEncapWith :: forall (proxy :: * -> *).
proxy DHKEM_X448
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
authEncapWith = proxy DHKEM_X448
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
dhkemAuthEncapWith
    authDecap :: forall (proxy :: * -> *).
proxy DHKEM_X448
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
authDecap = proxy DHKEM_X448
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
dhkemAuthDecap
    toEncapsulationKey :: forall (proxy :: * -> *).
proxy DHKEM_X448
-> EncodedSecretKey -> Either HPKEError EncodedPublicKey
toEncapsulationKey = proxy DHKEM_X448
-> EncodedSecretKey -> Either HPKEError EncodedPublicKey
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem -> EncodedSecretKey -> Either HPKEError EncodedPublicKey
dhkemToEncapsulationKey

----------------------------------------------------------------

dhkemAuthEncapWith
    :: HPKEKEMRegistered kem
    => proxy kem
    -> EncodedSecretKey
    -> EncodedPublicKey
    -> EncodedSecretKey
    -> Either HPKEError (EncodedPublicKey, SharedSecret)
dhkemAuthEncapWith :: forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedSecretKey
-> EncodedPublicKey
-> EncodedSecretKey
-> Either HPKEError (EncodedPublicKey, SharedSecret)
dhkemAuthEncapWith proxy kem
p EncodedSecretKey
skSm EncodedPublicKey
pkRm EncodedSecretKey
skEm =
    (SharedSecret, EncodedPublicKey)
-> (EncodedPublicKey, SharedSecret)
flop ((SharedSecret, EncodedPublicKey)
 -> (EncodedPublicKey, SharedSecret))
-> Either HPKEError (SharedSecret, EncodedPublicKey)
-> Either HPKEError (EncodedPublicKey, SharedSecret)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy (HPKEKEMGroup kem)
-> KeyDeriveFunction
-> EncodedSecretKey
-> Maybe EncodedSecretKey
-> Encap
forall group.
(EllipticCurve group, EllipticCurveDH group) =>
Proxy group
-> KeyDeriveFunction
-> EncodedSecretKey
-> Maybe EncodedSecretKey
-> Encap
encapEnv (proxy kem -> Proxy (HPKEKEMGroup kem)
forall (proxy :: * -> *) kem. proxy kem -> Proxy (HPKEKEMGroup kem)
groupOf proxy kem
p) (proxy kem -> KeyDeriveFunction
forall (proxy :: * -> *) kem.
HPKEKEMRegistered kem =>
proxy kem -> KeyDeriveFunction
deriveOf proxy kem
p) EncodedSecretKey
skEm (EncodedSecretKey -> Maybe EncodedSecretKey
forall a. a -> Maybe a
Just EncodedSecretKey
skSm) EncodedPublicKey
pkRm

dhkemAuthDecap
    :: HPKEKEMRegistered kem
    => proxy kem
    -> EncodedPublicKey
    -> EncodedSecretKey
    -> EncodedPublicKey
    -> Either HPKEError SharedSecret
dhkemAuthDecap :: forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedPublicKey
-> EncodedSecretKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
dhkemAuthDecap proxy kem
p EncodedPublicKey
pkSm EncodedSecretKey
skRm EncodedPublicKey
enc =
    Proxy (HPKEKEMGroup kem)
-> KeyDeriveFunction
-> EncodedSecretKey
-> Maybe EncodedPublicKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
forall group.
(EllipticCurve group, EllipticCurveDH group) =>
Proxy group
-> KeyDeriveFunction
-> EncodedSecretKey
-> Maybe EncodedPublicKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
decapEnv (proxy kem -> Proxy (HPKEKEMGroup kem)
forall (proxy :: * -> *) kem. proxy kem -> Proxy (HPKEKEMGroup kem)
groupOf proxy kem
p) (proxy kem -> KeyDeriveFunction
forall (proxy :: * -> *) kem.
HPKEKEMRegistered kem =>
proxy kem -> KeyDeriveFunction
deriveOf proxy kem
p) EncodedSecretKey
skRm (EncodedPublicKey -> Maybe EncodedPublicKey
forall a. a -> Maybe a
Just EncodedPublicKey
pkSm) EncodedPublicKey
enc

dhkemToEncapsulationKey
    :: HPKEKEMRegistered kem
    => proxy kem -> EncodedSecretKey -> Either HPKEError EncodedPublicKey
dhkemToEncapsulationKey :: forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem -> EncodedSecretKey -> Either HPKEError EncodedPublicKey
dhkemToEncapsulationKey proxy kem
p EncodedSecretKey
skm =
    Proxy (HPKEKEMGroup kem)
-> Point (HPKEKEMGroup kem) -> EncodedPublicKey
forall group.
EllipticCurve group =>
Proxy group -> PublicKey group -> EncodedPublicKey
serializePublicKey Proxy (HPKEKEMGroup kem)
g (Point (HPKEKEMGroup kem) -> EncodedPublicKey)
-> (Scalar (HPKEKEMGroup kem) -> Point (HPKEKEMGroup kem))
-> Scalar (HPKEKEMGroup kem)
-> EncodedPublicKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (HPKEKEMGroup kem)
-> Scalar (HPKEKEMGroup kem) -> Point (HPKEKEMGroup kem)
forall curve (proxy :: * -> *).
EllipticCurve curve =>
proxy curve -> Scalar curve -> Point curve
forall (proxy :: * -> *).
proxy (HPKEKEMGroup kem)
-> Scalar (HPKEKEMGroup kem) -> Point (HPKEKEMGroup kem)
scalarToPoint Proxy (HPKEKEMGroup kem)
g (Scalar (HPKEKEMGroup kem) -> EncodedPublicKey)
-> Either HPKEError (Scalar (HPKEKEMGroup kem))
-> Either HPKEError EncodedPublicKey
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy (HPKEKEMGroup kem)
-> EncodedSecretKey -> Either HPKEError (Scalar (HPKEKEMGroup kem))
forall group.
EllipticCurve group =>
Proxy group
-> EncodedSecretKey -> Either HPKEError (SecretKey group)
deserializeSecretKey Proxy (HPKEKEMGroup kem)
g EncodedSecretKey
skm
  where
    g :: Proxy (HPKEKEMGroup kem)
g = proxy kem -> Proxy (HPKEKEMGroup kem)
forall (proxy :: * -> *) kem. proxy kem -> Proxy (HPKEKEMGroup kem)
groupOf proxy kem
p

flop :: (SharedSecret, EncodedPublicKey) -> (EncodedPublicKey, SharedSecret)
flop :: (SharedSecret, EncodedPublicKey)
-> (EncodedPublicKey, SharedSecret)
flop (SharedSecret
ss, EncodedPublicKey
enc) = (EncodedPublicKey
enc, SharedSecret
ss)

----------------------------------------------------------------

dhkemGenerateKeyPair
    :: (HPKEKEMRegistered kem, MonadRandom m)
    => proxy kem -> m (EncodedPublicKey, EncodedSecretKey)
dhkemGenerateKeyPair :: forall kem (m :: * -> *) (proxy :: * -> *).
(HPKEKEMRegistered kem, MonadRandom m) =>
proxy kem -> m (EncodedPublicKey, EncodedSecretKey)
dhkemGenerateKeyPair proxy kem
p = do
    KeyPair pk sk <- Proxy (HPKEKEMGroup kem) -> m (KeyPair (HPKEKEMGroup kem))
forall curve (randomly :: * -> *) (proxy :: * -> *).
(EllipticCurve curve, MonadRandom randomly) =>
proxy curve -> randomly (KeyPair curve)
forall (randomly :: * -> *) (proxy :: * -> *).
MonadRandom randomly =>
proxy (HPKEKEMGroup kem) -> randomly (KeyPair (HPKEKEMGroup kem))
curveGenerateKeyPair Proxy (HPKEKEMGroup kem)
g
    return (serializePublicKey g pk, serializeSecretKey g sk)
  where
    g :: Proxy (HPKEKEMGroup kem)
g = proxy kem -> Proxy (HPKEKEMGroup kem)
forall (proxy :: * -> *) kem. proxy kem -> Proxy (HPKEKEMGroup kem)
groupOf proxy kem
p

dhkemEncapsulate
    :: (HPKEKEMRegistered kem, MonadRandom m)
    => proxy kem
    -> EncodedPublicKey
    -> m (CryptoFailable (EncodedPublicKey, SharedSecret))
dhkemEncapsulate :: forall kem (m :: * -> *) (proxy :: * -> *).
(HPKEKEMRegistered kem, MonadRandom m) =>
proxy kem
-> EncodedPublicKey
-> m (CryptoFailable (EncodedPublicKey, SharedSecret))
dhkemEncapsulate proxy kem
p EncodedPublicKey
pkRm =
    proxy kem
-> EncodedPublicKey
-> EncodedSecretKey
-> CryptoFailable (EncodedPublicKey, SharedSecret)
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedPublicKey
-> EncodedSecretKey
-> CryptoFailable (EncodedPublicKey, SharedSecret)
dhkemEncapsulateWith proxy kem
p EncodedPublicKey
pkRm (EncodedSecretKey
 -> CryptoFailable (EncodedPublicKey, SharedSecret))
-> ((EncodedPublicKey, EncodedSecretKey) -> EncodedSecretKey)
-> (EncodedPublicKey, EncodedSecretKey)
-> CryptoFailable (EncodedPublicKey, SharedSecret)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (EncodedPublicKey, EncodedSecretKey) -> EncodedSecretKey
forall a b. (a, b) -> b
snd ((EncodedPublicKey, EncodedSecretKey)
 -> CryptoFailable (EncodedPublicKey, SharedSecret))
-> m (EncodedPublicKey, EncodedSecretKey)
-> m (CryptoFailable (EncodedPublicKey, SharedSecret))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> proxy kem -> m (EncodedPublicKey, EncodedSecretKey)
forall kem (m :: * -> *) (proxy :: * -> *).
(HPKEKEMRegistered kem, MonadRandom m) =>
proxy kem -> m (EncodedPublicKey, EncodedSecretKey)
dhkemGenerateKeyPair proxy kem
p

dhkemEncapsulateWith
    :: HPKEKEMRegistered kem
    => proxy kem
    -> EncodedPublicKey
    -> EncodedSecretKey
    -> CryptoFailable (EncodedPublicKey, SharedSecret)
dhkemEncapsulateWith :: forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedPublicKey
-> EncodedSecretKey
-> CryptoFailable (EncodedPublicKey, SharedSecret)
dhkemEncapsulateWith proxy kem
p EncodedPublicKey
pkRm EncodedSecretKey
skEm =
    Either HPKEError (EncodedPublicKey, SharedSecret)
-> CryptoFailable (EncodedPublicKey, SharedSecret)
forall a. Either HPKEError a -> CryptoFailable a
toCryptoFailable (Either HPKEError (EncodedPublicKey, SharedSecret)
 -> CryptoFailable (EncodedPublicKey, SharedSecret))
-> Either HPKEError (EncodedPublicKey, SharedSecret)
-> CryptoFailable (EncodedPublicKey, SharedSecret)
forall a b. (a -> b) -> a -> b
$ (SharedSecret, EncodedPublicKey)
-> (EncodedPublicKey, SharedSecret)
flop ((SharedSecret, EncodedPublicKey)
 -> (EncodedPublicKey, SharedSecret))
-> Either HPKEError (SharedSecret, EncodedPublicKey)
-> Either HPKEError (EncodedPublicKey, SharedSecret)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy (HPKEKEMGroup kem)
-> KeyDeriveFunction
-> EncodedSecretKey
-> Maybe EncodedSecretKey
-> Encap
forall group.
(EllipticCurve group, EllipticCurveDH group) =>
Proxy group
-> KeyDeriveFunction
-> EncodedSecretKey
-> Maybe EncodedSecretKey
-> Encap
encapEnv (proxy kem -> Proxy (HPKEKEMGroup kem)
forall (proxy :: * -> *) kem. proxy kem -> Proxy (HPKEKEMGroup kem)
groupOf proxy kem
p) (proxy kem -> KeyDeriveFunction
forall (proxy :: * -> *) kem.
HPKEKEMRegistered kem =>
proxy kem -> KeyDeriveFunction
deriveOf proxy kem
p) EncodedSecretKey
skEm Maybe EncodedSecretKey
forall a. Maybe a
Nothing EncodedPublicKey
pkRm

dhkemDecapsulate
    :: HPKEKEMRegistered kem
    => proxy kem
    -> EncodedSecretKey
    -> EncodedPublicKey
    -> CryptoFailable SharedSecret
dhkemDecapsulate :: forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem
-> EncodedSecretKey
-> EncodedPublicKey
-> CryptoFailable SharedSecret
dhkemDecapsulate proxy kem
p EncodedSecretKey
skRm EncodedPublicKey
enc =
    Either HPKEError SharedSecret -> CryptoFailable SharedSecret
forall a. Either HPKEError a -> CryptoFailable a
toCryptoFailable (Either HPKEError SharedSecret -> CryptoFailable SharedSecret)
-> Either HPKEError SharedSecret -> CryptoFailable SharedSecret
forall a b. (a -> b) -> a -> b
$ Proxy (HPKEKEMGroup kem)
-> KeyDeriveFunction
-> EncodedSecretKey
-> Maybe EncodedPublicKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
forall group.
(EllipticCurve group, EllipticCurveDH group) =>
Proxy group
-> KeyDeriveFunction
-> EncodedSecretKey
-> Maybe EncodedPublicKey
-> EncodedPublicKey
-> Either HPKEError SharedSecret
decapEnv (proxy kem -> Proxy (HPKEKEMGroup kem)
forall (proxy :: * -> *) kem. proxy kem -> Proxy (HPKEKEMGroup kem)
groupOf proxy kem
p) (proxy kem -> KeyDeriveFunction
forall (proxy :: * -> *) kem.
HPKEKEMRegistered kem =>
proxy kem -> KeyDeriveFunction
deriveOf proxy kem
p) EncodedSecretKey
skRm Maybe EncodedPublicKey
forall a. Maybe a
Nothing EncodedPublicKey
enc

----------------------------------------------------------------

groupOf :: proxy kem -> Proxy (HPKEKEMGroup kem)
groupOf :: forall (proxy :: * -> *) kem. proxy kem -> Proxy (HPKEKEMGroup kem)
groupOf proxy kem
_ = Proxy (HPKEKEMGroup kem)
forall {k} (t :: k). Proxy t
Proxy

deriveOf :: forall proxy kem. HPKEKEMRegistered kem => proxy kem -> KeyDeriveFunction
deriveOf :: forall (proxy :: * -> *) kem.
HPKEKEMRegistered kem =>
proxy kem -> KeyDeriveFunction
deriveOf proxy kem
p = HPKEKEMHash kem -> Suite -> KeyDeriveFunction
forall h.
(HashAlgorithm h, KDF h) =>
h -> Suite -> KeyDeriveFunction
extractAndExpand (proxy kem -> HPKEKEMHash kem
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem -> HPKEKEMHash kem
forall (proxy :: * -> *). proxy kem -> HPKEKEMHash kem
hpkeKEMHash proxy kem
p) (KEM_ID -> Suite
suiteKEM (proxy kem -> KEM_ID
forall kem (proxy :: * -> *).
HPKEKEMRegistered kem =>
proxy kem -> KEM_ID
forall (proxy :: * -> *). proxy kem -> KEM_ID
hpkeKEMID proxy kem
p))

-- | The class answers with a 'CryptoFailable', which carries a reason from
-- a fixed list and not a message.  What is lost is the string; what each
-- error means is kept.  'Crypto.HPKE.setupBaseS' and its neighbours still
-- throw the 'HPKEError' with its message.
toCryptoFailable :: Either HPKEError a -> CryptoFailable a
toCryptoFailable :: forall a. Either HPKEError a -> CryptoFailable a
toCryptoFailable (Right a
a) = a -> CryptoFailable a
forall a. a -> CryptoFailable a
CryptoPassed a
a
toCryptoFailable (Left HPKEError
e) = CryptoError -> CryptoFailable a
forall a. CryptoError -> CryptoFailable a
CryptoFailed (CryptoError -> CryptoFailable a)
-> CryptoError -> CryptoFailable a
forall a b. (a -> b) -> a -> b
$ case HPKEError
e of
    DeserializeError String
_ -> CryptoError
CryptoError_PointFormatInvalid
    EncapError String
_ -> CryptoError
CryptoError_ScalarMultiplicationInvalid
    DecapError String
_ -> CryptoError
CryptoError_ScalarMultiplicationInvalid
    HPKEError
_ -> CryptoError
CryptoError_ParameterInvalid