Skip to main content

KeyExchange

opaque_vx::key_exchange

Trait KeyExchange

pub trait KeyExchangewhere
    <Self::Hash as CoreProxy>::Core: ProxyHash,
    <<Self::Hash as CoreProxy>::Core as SmallBlockSizeUser>::_BlockSize: IsLess<U256>,
    Le<<<Self::Hash as CoreProxy>::Core as SmallBlockSizeUser>::_BlockSize, U256>: NonZero,
    <<Self::Hash as CoreProxy>::Core as OutputSizeUser>::OutputSize: ArrayLength,{
    type Group: Group;
    type Hash: Hash;
    type KE1State: ZeroizeOnDrop + Clone;
    type KE2State<CS: CipherSuite>: ZeroizeOnDrop + Clone;
    type KE1Message: ZeroizeOnDrop + Clone;
    type KE2Builder<'a, CS: CipherSuite<KeyExchange = Self>>: ZeroizeOnDrop + Clone;
    type KE2BuilderData<'a, CS: 'static + CipherSuite>;
    type KE2BuilderInput<CS: CipherSuite>;
    type KE2Message: ZeroizeOnDrop + Clone;
    type KE3Message: ZeroizeOnDrop + Clone;

    // Required methods
    fn generate_ke1<R: Rng + CryptoRng>(
        rng: &mut R,
    ) -> Result<GenerateKe1Result<Self>, ProtocolError>;
    fn ke2_builder<'a, CS: CipherSuite<KeyExchange = Self>, R: Rng + CryptoRng>(
        rng: &mut R,
        credential_request: SerializedCredentialRequest<CS>,
        ke1_message: Self::KE1Message,
        credential_response: SerializedCredentialResponse<CS>,
        client_s_pk: PublicKey<Self::Group>,
        identifiers: SerializedIdentifiers<'a, Self::Group>,
        context: SerializedContext<'a>,
    ) -> Result<Self::KE2Builder<'a, CS>, ProtocolError>;
    fn ke2_builder_data<'a, CS: CipherSuite<KeyExchange = Self>>(
        builder: &'a Self::KE2Builder<'_, CS>,
    ) -> Self::KE2BuilderData<'a, CS>;
    fn generate_ke2_input<CS: CipherSuite<KeyExchange = Self>, R: CryptoRng + Rng>(
        builder: &Self::KE2Builder<'_, CS>,
        rng: &mut R,
        server_s_sk: &PrivateKey<Self::Group>,
    ) -> Self::KE2BuilderInput<CS>;
    fn build_ke2<CS: CipherSuite<KeyExchange = Self>>(
        builder: Self::KE2Builder<'_, CS>,
        input: Self::KE2BuilderInput<CS>,
    ) -> Result<GenerateKe2Result<CS>, ProtocolError>;
    fn generate_ke3<CS: CipherSuite<KeyExchange = Self>, R: CryptoRng + Rng>(
        rng: &mut R,
        credential_request: SerializedCredentialRequest<CS>,
        ke1_message: Self::KE1Message,
        credential_response: SerializedCredentialResponse<CS>,
        ke1_state: &Self::KE1State,
        ke2_message: Self::KE2Message,
        server_s_pk: PublicKey<Self::Group>,
        client_s_sk: PrivateKey<Self::Group>,
        identifiers: SerializedIdentifiers<'_, Self::Group>,
        context: SerializedContext<'_>,
    ) -> Result<GenerateKe3Result<Self>, ProtocolError>;
    fn finish_ke<CS: CipherSuite<KeyExchange = Self>>(
        ke2_state: &Self::KE2State<CS>,
        ke3_message: Self::KE3Message,
        identifiers: Identifiers<'_>,
        context: SerializedContext<'_>,
    ) -> Result<Output<Self::Hash>, ProtocolError>;
}

Expand description

The key exchange trait.

Required Associated Types§

type Group: Group

The group used for the key exchange.

type Hash: Hash

The hash used for the key exchange.

type KE1State: ZeroizeOnDrop + Clone

Client state.

type KE2State<CS: CipherSuite>: ZeroizeOnDrop + Clone

Server state.

type KE1Message: ZeroizeOnDrop + Clone

First message sent by the client.

type KE2Builder<'a, CS: CipherSuite<KeyExchange = Self>>: ZeroizeOnDrop + Clone

Server state builder.

type KE2BuilderData<'a, CS: 'static + CipherSuite>

Server data for the remote key interaction.

type KE2BuilderInput<CS: CipherSuite>

Server remote key input.

type KE2Message: ZeroizeOnDrop + Clone

Message sent by the server.

type KE3Message: ZeroizeOnDrop + Clone

Second message sent by the client.

Required Methods§

fn generate_ke1<R: Rng + CryptoRng>( rng: &mut R, ) -> Result<GenerateKe1Result<Self>, ProtocolError>

Client generates KE1Message and KE1State.

fn ke2_builder<'a, CS: CipherSuite<KeyExchange = Self>, R: Rng + CryptoRng>( rng: &mut R, credential_request: SerializedCredentialRequest<CS>, ke1_message: Self::KE1Message, credential_response: SerializedCredentialResponse<CS>, client_s_pk: PublicKey<Self::Group>, identifiers: SerializedIdentifiers<'a, Self::Group>, context: SerializedContext<'a>, ) -> Result<Self::KE2Builder<'a, CS>, ProtocolError>

Server generates KE2Builder.

fn ke2_builder_data<'a, CS: CipherSuite<KeyExchange = Self>>( builder: &'a Self::KE2Builder<'_, CS>, ) -> Self::KE2BuilderData<'a, CS>

Server returns the data for the remote key interaction.

fn generate_ke2_input<CS: CipherSuite<KeyExchange = Self>, R: CryptoRng + Rng>( builder: &Self::KE2Builder<'_, CS>, rng: &mut R, server_s_sk: &PrivateKey<Self::Group>, ) -> Self::KE2BuilderInput<CS>

Server generates the input without a remote key.

fn build_ke2<CS: CipherSuite<KeyExchange = Self>>( builder: Self::KE2Builder<'_, CS>, input: Self::KE2BuilderInput<CS>, ) -> Result<GenerateKe2Result<CS>, ProtocolError>

Server generates KE2Message and KE2State.

fn generate_ke3<CS: CipherSuite<KeyExchange = Self>, R: CryptoRng + Rng>( rng: &mut R, credential_request: SerializedCredentialRequest<CS>, ke1_message: Self::KE1Message, credential_response: SerializedCredentialResponse<CS>, ke1_state: &Self::KE1State, ke2_message: Self::KE2Message, server_s_pk: PublicKey<Self::Group>, client_s_sk: PrivateKey<Self::Group>, identifiers: SerializedIdentifiers<'_, Self::Group>, context: SerializedContext<'_>, ) -> Result<GenerateKe3Result<Self>, ProtocolError>

Client generates KE3Message and the session key.

fn finish_ke<CS: CipherSuite<KeyExchange = Self>>( ke2_state: &Self::KE2State<CS>, ke3_message: Self::KE3Message, identifiers: Identifiers<'_>, context: SerializedContext<'_>, ) -> Result<Output<Self::Hash>, ProtocolError>

Server generates the session key.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors§

impl<G, H, K> KeyExchange for TripleDhKem<G, H, K>
where G: Group + 'static, G::Sk: DiffieHellman<G>, H: Hash, H::Core: ProxyHash, <<H as CoreProxy>::Core as SmallBlockSizeUser>::_BlockSize: IsLess<U256> + Cmp<U256>, Le<<<H as CoreProxy>::Core as SmallBlockSizeUser>::_BlockSize, U256>: NonZero, <<H as CoreProxy>::Core as OutputSizeUser>::OutputSize: ArrayLength, K: KemCoreWrapper, U32: Add<K::EncapsulationKeyLen>, Sum<U32, K::EncapsulationKeyLen>: ArrayLength,

Available on crate feature kem only.

type Group = G

type Hash = H

type KE1State = KemKe1State<G, K>

type KE2State<CS: CipherSuite> = KemKe2State<K, H>

type KE1Message = KemKe1Message<G, K>

type KE2Builder<'a, CS: CipherSuite<KeyExchange = Self>> = KemKe2Builder<G, H, K>

type KE2BuilderData<'a, CS: 'static + CipherSuite> = (&'a PublicKey<G>, &'a GenericArray<u8, <K as KemCoreWrapper>::EncapsulationKeyLen>)

type KE2BuilderInput<CS: CipherSuite> = GenericArray<u8, <G as Group>::PkLen>

type KE2Message = KemKe2Message<G, H, K>

type KE3Message = Ke3Message<H>

impl<G: Group + 'static, H: Hash> KeyExchange for TripleDh<G, H>
where G::Sk: DiffieHellman<G>, H::Core: ProxyHash, <<H as CoreProxy>::Core as SmallBlockSizeUser>::_BlockSize: IsLess<U256>, Le<<<H as CoreProxy>::Core as SmallBlockSizeUser>::_BlockSize, U256>: NonZero, <<H as CoreProxy>::Core as OutputSizeUser>::OutputSize: ArrayLength,

type Group = G

type Hash = H

type KE1State = Ke1State<G>

type KE2State<CS: CipherSuite> = Ke2State<H>

type KE1Message = Ke1Message<G>

type KE2Builder<'a, CS: CipherSuite<KeyExchange = Self>> = Ke2Builder<G, H>

type KE2BuilderData<'a, CS: 'static + CipherSuite> = &'a PublicKey<G>

type KE2BuilderInput<CS: CipherSuite> = GenericArray<u8, <G as Group>::PkLen>

type KE2Message = Ke2Message<G, H>

type KE3Message = Ke3Message<H>

impl<SIG: SignatureProtocol, KE: 'static + Group, KEH: Hash + BlockSizeUser> KeyExchange for SigmaI<SIG, KE, KEH>
where KE::Sk: DiffieHellman<KE>, KEH::Core: ProxyHash, <<KEH as CoreProxy>::Core as SmallBlockSizeUser>::_BlockSize: IsLess<U256>, Le<<<KEH as CoreProxy>::Core as SmallBlockSizeUser>::_BlockSize, U256>: NonZero, <<KEH as CoreProxy>::Core as OutputSizeUser>::OutputSize: ArrayLength,

type Group = <SIG as SignatureProtocol>::Group

type Hash = KEH

type KE1State = Ke1State<KE>

type KE2State<CS: CipherSuite> = Ke2State<CS, SIG, KE>

type KE1Message = Ke1Message<KE>

type KE2Builder<'a, CS: CipherSuite<KeyExchange = Self>> = Ke2Builder<'a, CS, KE>

type KE2BuilderData<'a, CS: 'static + CipherSuite> = &'a Message<'a, CS, KE>

type KE2BuilderInput<CS: CipherSuite> = (<SIG as SignatureProtocol>::Signature, <SIG as SignatureProtocol>::VerifyState<CS, KE>)

type KE2Message = Ke2Message<SIG, KE, KEH>

type KE3Message = Ke3Message<SIG, KEH>