Struct ConnectionAuth 

pub struct ConnectionAuth(Vec<u8>);

Connection authentication data derived from WebRTC signaling.

ConnectionAuth contains the authentication material generated from the SDP (Session Description Protocol) hashes of both the WebRTC offer and answer. This creates a unique, connection-specific authentication token that can be used to verify the authenticity of the WebRTC connection.

Construction

The authentication data is created by concatenating the SDP hashes from both the offer and answer messages:

ConnectionAuth = SDP_Hash(Offer) || SDP_Hash(Answer)

This ensures that both parties contributed to the authentication material and that any tampering with either the offer or answer would be detected.

Security Properties

• Uniqueness: Each connection attempt generates unique SDP data, preventing replay attacks
• Integrity: Any modification to the offer or answer changes the hashes, invalidating the authentication
• Binding: Cryptographically binds the authentication to the specific WebRTC session parameters

Usage

use openmina_p2p::webrtc::{ConnectionAuth, Offer, Answer};

let connection_auth = ConnectionAuth::new(&offer, &answer);
let encrypted_auth = connection_auth.encrypt(&my_secret_key, &peer_public_key, rng)?;

Tuple Fields

0: Vec<u8>

Implementations

impl ConnectionAuth

pub fn new(offer: &Offer, answer: &Answer) -> Self

Creates new connection authentication data from WebRTC offer and answer.

This method generates connection authentication data by concatenating the SDP hashes from both the WebRTC offer and answer messages. The resulting authentication token is unique to this specific connection attempt and binds the authentication to the exact WebRTC session parameters.

Parameters

• offer - The WebRTC offer containing SDP data and peer information
• answer - The WebRTC answer containing SDP data and peer information

Returns

A new ConnectionAuth instance containing the concatenated SDP hashes.

Security Considerations

The authentication data is derived from both the offer and answer, ensuring that any tampering with either message will result in different authentication data. This prevents attackers from modifying signaling messages without detection.

Example

use openmina_p2p::webrtc::ConnectionAuth;

let auth = ConnectionAuth::new(&offer, &answer);
// Use auth for connection verification

pub fn encrypt( &self, sec_key: &SecretKey, other_pk: &PublicKey, rng: impl Rng + CryptoRng, ) -> Option<ConnectionAuthEncrypted>

Encrypts the connection authentication data using public key cryptography.

This method encrypts the authentication data using the recipient’s public key, ensuring that only the intended recipient (who possesses the corresponding private key) can decrypt and verify the authentication token.

Parameters

• sec_key - The sender’s secret key used for encryption
• other_pk - The recipient’s public key used for encryption
• rng - A cryptographically secure random number generator

Returns

• Some(ConnectionAuthEncrypted) if encryption succeeds
• None if encryption fails (e.g., due to invalid keys or cryptographic errors)

Security Properties

• Confidentiality: Only the holder of the corresponding private key can decrypt the authentication data
• Authenticity: The encryption process provides assurance about the sender’s identity

Example

use rand::thread_rng;

let mut rng = thread_rng();
let encrypted_auth = connection_auth.encrypt(&my_secret_key, &peer_public_key, &mut rng);

if let Some(encrypted) = encrypted_auth {
    // Send encrypted authentication data to peer
}

Trait Implementations

impl Clone for ConnectionAuth

fn clone(&self) -> ConnectionAuth

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConnectionAuth

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ConnectionAuth

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ConnectionAuth

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ConnectionAuth

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ConnectionAuth

impl StructuralPartialEq for ConnectionAuth