Struct KeyResponse 

pub struct KeyResponse {
    pub key_proofs: Vec<KeyProof>,
}

Response containing proofs of ML-DSA private key possession

The client responds to an KeyChallenge by providing one or more key proofs. Each proof demonstrates possession of a specific ML-DSA private key.

Proof Construction

For each key the client wishes to prove:

1. Construct signature data: nonce || server_public_key
2. Sign the data using the ML-DSA private key
3. Create a KeyProof with the public key and signature

Wire Size

Approximate serialized size per key proof: ~2500 bytes

• public_key: ~1312 bytes (ML-DSA-65 public key)
• signature: ~2420 bytes (ML-DSA-65 signature)
• overhead: ~8 bytes (postcard encoding)

Total message size scales linearly with number of keys being proven.

Fields

key_proofs: Vec<KeyProof>

List of key proofs - one for each ML-DSA key being proven

The client can prove multiple keys in a single response. Each proof is verified independently by the server. At least one proof must succeed for the handshake to complete successfully.

Ordering

The order of proofs in this vector corresponds to the indices used in KeyResult.failed_indices for error reporting.

Trait Implementations

impl Clone for KeyResponse

fn clone(&self) -> KeyResponse

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyResponse

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KeyResponse

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for KeyResponse

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.