Struct ConnectionAuthEncrypted 

pub struct ConnectionAuthEncrypted(Box<[u8; 92]>);

Encrypted connection authentication data.

ConnectionAuthEncrypted represents the connection authentication data after it has been encrypted using public key cryptography. The encrypted data is stored in a fixed-size array of 92 bytes, which corresponds to the output size of the encryption algorithm used.

Encryption Process

The encryption uses the recipient’s public key to ensure that only the intended recipient can decrypt and verify the authentication data. This prevents man-in-the-middle attackers from forging authentication tokens.

Fixed Size

The 92-byte fixed size is determined by the cryptographic parameters:

• The encryption algorithm produces a deterministic output size
• Fixed sizing enables efficient serialization and network transmission
• Prevents information leakage through size analysis

Network Transmission

This type is designed for transmission over the network and includes serialization support for JSON and binary formats.

Example

// After receiving encrypted authentication data
let decrypted_auth = encrypted_auth.decrypt(&my_secret_key, &peer_public_key)?;
// Verify that the decrypted data matches expected values

Tuple Fields

0: Box<[u8; 92]>

Implementations

impl ConnectionAuthEncrypted

pub fn decrypt( &self, sec_key: &SecretKey, other_pk: &PublicKey, ) -> Option<ConnectionAuth>

Decrypts the connection authentication data using public key cryptography.

This method decrypts the authentication data using the recipient’s secret key and the sender’s public key. Successful decryption proves that the sender possesses the private key corresponding to their advertised public key, providing authentication and preventing man-in-the-middle attacks.

Parameters

• sec_key - The recipient’s secret key used for decryption
• other_pk - The sender’s public key used for decryption

Returns

• Some(ConnectionAuth) if decryption succeeds and authentication is valid
• None if decryption fails (e.g., due to invalid keys, corrupted data, or cryptographic errors)

Security Verification

Successful decryption provides several security guarantees:

• Identity Verification: The sender possesses the private key corresponding to their public key
• Message Integrity: The encrypted data has not been tampered with
• Authenticity: The authentication data came from the claimed sender

Usage in Authentication Flow

This method is typically called during the final stage of WebRTC connection establishment to verify the peer’s identity before allowing the connection to proceed.

Example

// After receiving encrypted authentication data from peer
if let Some(decrypted_auth) = encrypted_auth.decrypt(&my_secret_key, &peer_public_key) {
    // Authentication successful, proceed with connection
    println!("Peer authentication verified");
} else {
    // Authentication failed, reject connection
    println!("Peer authentication failed");
}

Trait Implementations

impl AsRef<[u8]> for ConnectionAuthEncrypted

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for ConnectionAuthEncrypted

fn clone(&self) -> ConnectionAuthEncrypted

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConnectionAuthEncrypted

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ConnectionAuthEncrypted

fn deserialize<D>( deserializer: D, ) -> Result<ConnectionAuthEncrypted, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ConnectionAuthEncrypted

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&[u8]> for ConnectionAuthEncrypted

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from( value: &[u8], ) -> Result<ConnectionAuthEncrypted, <ConnectionAuthEncrypted as TryFrom<&[u8]>>::Error>

Performs the conversion.

impl TryFrom<Vec<u8>> for ConnectionAuthEncrypted

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from( value: Vec<u8>, ) -> Result<ConnectionAuthEncrypted, <ConnectionAuthEncrypted as TryFrom<Vec<u8>>>::Error>

Performs the conversion.