Struct pqc_kyber::Ake

pub struct Ake {
    pub shared_secret: SharedSecret,
    // some fields omitted
}

Used for mutually authenticated key exchange between two parties.

Example:

let mut rng = rand::thread_rng();
 
let mut alice = Ake::new();
let mut bob = Ake::new();
 
let alice_keys = keypair(&mut rng);
let bob_keys = keypair(&mut rng);
 
let client_init = alice.client_init(&bob_keys.public, &mut rng);
let server_send = bob.server_receive(client_init, &alice_keys.public, &bob_keys.secret, &mut rng)?;
let client_confirm = alice.client_confirm(server_send, &alice_keys.secret);
 
assert_eq!(alice.shared_secret, bob.shared_secret);

Fields

shared_secret: SharedSecret

The resulting shared secret from a key exchange

Implementations

impl Ake

pub fn new() -> Self

Builds a new AKE struct

let mut kex = Ake::new();

pub fn client_init<R>(&mut self, pubkey: &PublicKey, rng: &mut R) -> AkeSendInit where
    R: CryptoRng + RngCore, 

Initiates a Mutually Authenticated Key Exchange.

let mut rng = rand::thread_rng();
let mut alice = Ake::new();
let bob_keys = keypair(&mut rng);
let client_init = alice.client_init(&bob_keys.public, &mut rng);

pub fn server_receive<R>(
    &mut self,
    ake_send_a: AkeSendInit,
    pubkey: &PublicKey,
    secretkey: &SecretKey,
    rng: &mut R
) -> Result<AkeSendResponse, KyberError> where
    R: CryptoRng + RngCore, 

Handles and authenticates the output of a client_init() request

let mut alice = Ake::new();
let mut bob = Ake::new();
let alice_keys = keypair(&mut rng);
let bob_keys = keypair(&mut rng);
let client_init = alice.client_init(&bob_keys.public, &mut rng);
let server_send = bob.server_receive(client_init, &alice_keys.public, &bob_keys.secret, &mut rng)?;

pub fn client_confirm(
    &mut self,
    send_b: AkeSendResponse,
    secretkey: &SecretKey
) -> Result<(), KyberError>

Decapsulates and authenticates the shared secret from the output of server_receive()

let server_send = bob.server_receive(client_init, &alice_keys.public, &bob_keys.secret, &mut rng)?;
let client_confirm = alice.client_confirm(server_send, &alice_keys.secret);
assert_eq!(alice.shared_secret, bob.shared_secret);

Trait Implementations

impl Clone for Ake

fn clone(&self) -> Ake

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Ake

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Ake

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq<Ake> for Ake

fn eq(&self, other: &Ake) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Ake) -> bool

This method tests for !=.

impl Copy for Ake

impl Eq for Ake

impl StructuralEq for Ake

impl StructuralPartialEq for Ake