@desklink/host 0.5.3 → 0.5.6

package/engine/vendor/rtc-ice/src/rand/mod.rs

@@ -0,0 +1,91 @@
+use crypto::RTCRandom;
+use shared::error::{Error, Result};
+use shared::util::generate_crypto_random_string;
+
+#[cfg(test)]
+mod rand_test;
+
+const RUNES_ALPHA: &[u8] = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const RUNES_CANDIDATE_ID_FOUNDATION: &[u8] =
+    b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789/+";
+
+const LEN_UFRAG: usize = 16;
+const LEN_PWD: usize = 32;
+
+/// <https://tools.ietf.org/html/rfc5245#section-15.1>
+/// candidate-id = "candidate" ":" foundation
+/// foundation   = 1*32ice-char
+/// ice-char     = ALPHA / DIGIT / "+" / "/"
+///
+/// Candidate IDs provide local uniqueness and diagnostics; they are not credentials or
+/// cryptographic identities. This standalone helper therefore uses `rand`'s thread-local CSPRNG
+/// rather than requiring a crypto provider.
+pub fn generate_cand_id() -> String {
+    format!(
+        "candidate:{}",
+        generate_crypto_random_string(32, RUNES_CANDIDATE_ID_FOUNDATION)
+    )
+}
+
+fn generate_string_with_random(
+    length: usize,
+    alphabet: &[u8],
+    random: &dyn RTCRandom,
+) -> Result<String> {
+    debug_assert!(!alphabet.is_empty() && alphabet.len() <= u8::MAX as usize + 1);
+
+    let acceptance_limit = 256 - (256 % alphabet.len());
+    let mut output = String::with_capacity(length);
+    let mut random_bytes = [0_u8; 64];
+    while output.len() < length {
+        random
+            .fill(&mut random_bytes)
+            .map_err(|error| Error::Crypto(error.to_string()))?;
+        for byte in random_bytes {
+            if byte as usize >= acceptance_limit {
+                continue;
+            }
+            output.push(alphabet[byte as usize % alphabet.len()] as char);
+            if output.len() == length {
+                break;
+            }
+        }
+    }
+    Ok(output)
+}
+
+/// Generates an ICE password with `rand`'s thread-local CSPRNG.
+///
+/// ICE agents use the provider-backed internal variant. This function remains as a standalone
+/// compatibility helper for callers that do not own an [`crypto::RTCCryptoProvider`].
+pub fn generate_pwd() -> String {
+    generate_crypto_random_string(LEN_PWD, RUNES_ALPHA)
+}
+
+/// Generates an ICE password using an explicitly supplied cryptographically secure random source.
+pub(crate) fn generate_pwd_with_random(random: &dyn RTCRandom) -> Result<String> {
+    generate_string_with_random(LEN_PWD, RUNES_ALPHA, random)
+}
+
+/// Generates the 64-bit ICE role-conflict tie breaker from the agent's random provider.
+pub(crate) fn generate_tie_breaker(random: &dyn RTCRandom) -> Result<u64> {
+    let mut bytes = [0_u8; std::mem::size_of::<u64>()];
+    random
+        .fill(&mut bytes)
+        .map_err(|error| Error::Crypto(error.to_string()))?;
+    Ok(u64::from_be_bytes(bytes))
+}
+
+/// Generates an ICE username fragment with `rand`'s thread-local CSPRNG.
+///
+/// ICE agents use the provider-backed internal variant. This function remains as a standalone
+/// compatibility helper for callers that do not own an [`crypto::RTCCryptoProvider`].
+pub fn generate_ufrag() -> String {
+    generate_crypto_random_string(LEN_UFRAG, RUNES_ALPHA)
+}
+
+/// Generates an ICE username fragment using an explicitly supplied cryptographically secure random
+/// source.
+pub(crate) fn generate_ufrag_with_random(random: &dyn RTCRandom) -> Result<String> {
+    generate_string_with_random(LEN_UFRAG, RUNES_ALPHA, random)
+}

package/engine/vendor/rtc-ice/src/rand/rand_test.rs

@@ -0,0 +1,115 @@
+use super::*;
+use crypto::{CryptoError, RTCRandom};
+use shared::error::Result;
+
+struct FixedRandom(u8);
+
+impl RTCRandom for FixedRandom {
+    fn fill(&self, output: &mut [u8]) -> std::result::Result<(), CryptoError> {
+        output.fill(self.0);
+        Ok(())
+    }
+}
+
+struct FailingRandom;
+
+impl RTCRandom for FailingRandom {
+    fn fill(&self, _output: &mut [u8]) -> std::result::Result<(), CryptoError> {
+        Err(CryptoError::RandomnessFailed)
+    }
+}
+
+#[test]
+fn provider_backed_credentials_have_required_lengths_and_alphabet() -> Result<()> {
+    let random = FixedRandom(0);
+    let ufrag = generate_ufrag_with_random(&random)?;
+    let password = generate_pwd_with_random(&random)?;
+
+    assert_eq!(ufrag.len(), LEN_UFRAG);
+    assert_eq!(password.len(), LEN_PWD);
+    assert!(ufrag.bytes().all(|byte| RUNES_ALPHA.contains(&byte)));
+    assert!(password.bytes().all(|byte| RUNES_ALPHA.contains(&byte)));
+    Ok(())
+}
+
+#[test]
+fn provider_backed_credentials_propagate_randomness_failure() {
+    assert!(matches!(
+        generate_pwd_with_random(&FailingRandom),
+        Err(Error::Crypto(_))
+    ));
+}
+
+#[test]
+fn provider_backed_tie_breaker_uses_all_random_bytes() -> Result<()> {
+    assert_eq!(
+        generate_tie_breaker(&FixedRandom(0x2a))?,
+        u64::from_be_bytes([0x2a; 8])
+    );
+    Ok(())
+}
+
+#[test]
+fn provider_backed_tie_breaker_propagates_randomness_failure() {
+    assert!(matches!(
+        generate_tie_breaker(&FailingRandom),
+        Err(Error::Crypto(_))
+    ));
+}
+
+#[test]
+fn test_random_generator_collision() -> Result<()> {
+    let test_cases = vec![
+        (
+            "CandidateID",
+            0, /*||-> String {
+                   generate_cand_id()
+               },*/
+        ),
+        (
+            "PWD", 1, /*||-> String {
+                  generate_pwd()
+              },*/
+        ),
+        (
+            "Ufrag", 2, /*|| ->String {
+                  generate_ufrag()
+              },*/
+        ),
+    ];
+
+    const N: usize = 10;
+    const ITERATION: usize = 10;
+
+    for (name, test_case) in test_cases {
+        for _ in 0..ITERATION {
+            let mut rs = vec![];
+
+            for _ in 0..N {
+                let s = if test_case == 0 {
+                    generate_cand_id()
+                } else if test_case == 1 {
+                    generate_pwd()
+                } else {
+                    generate_ufrag()
+                };
+
+                rs.push(s);
+            }
+
+            assert_eq!(rs.len(), N, "{name} Failed to generate randoms");
+
+            for i in 0..N {
+                for j in i + 1..N {
+                    assert_ne!(
+                        rs[i], rs[j],
+                        "{}: generateRandString caused collision: {} == {}",
+                        name, rs[i], rs[j],
+                    );
+                }
+            }
+        }
+    }
+
+    Ok(())
+}

package/engine/vendor/rtc-ice/src/state/mod.rs

@@ -0,0 +1,106 @@
+#[cfg(test)]
+mod state_test;
+
+use std::fmt;
+
+/// An enum showing the state of a ICE Connection List of supported States.
+#[derive(Default, Debug, Copy, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ConnectionState {
+    /// No state was set.
+    #[default]
+    Unspecified,
+
+    /// ICE agent is gathering addresses.
+    New,
+
+    /// ICE agent has been given local and remote candidates, and is attempting to find a match.
+    Checking,
+
+    /// ICE agent has a pairing, but is still checking other pairs.
+    Connected,
+
+    /// ICE agent has finished.
+    Completed,
+
+    /// ICE agent never could successfully connect.
+    Failed,
+
+    /// ICE agent connected successfully, but has entered a failed state.
+    Disconnected,
+
+    /// ICE agent has finished and is no longer handling requests.
+    Closed,
+}
+
+impl fmt::Display for ConnectionState {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let s = match *self {
+            Self::Unspecified => "Unspecified",
+            Self::New => "New",
+            Self::Checking => "Checking",
+            Self::Connected => "Connected",
+            Self::Completed => "Completed",
+            Self::Failed => "Failed",
+            Self::Disconnected => "Disconnected",
+            Self::Closed => "Closed",
+        };
+        write!(f, "{s}")
+    }
+}
+
+impl From<u8> for ConnectionState {
+    fn from(v: u8) -> Self {
+        match v {
+            1 => Self::New,
+            2 => Self::Checking,
+            3 => Self::Connected,
+            4 => Self::Completed,
+            5 => Self::Failed,
+            6 => Self::Disconnected,
+            7 => Self::Closed,
+            _ => Self::Unspecified,
+        }
+    }
+}
+
+/// Describes the state of the candidate gathering process.
+#[derive(Default, PartialEq, Eq, Copy, Clone)]
+#[non_exhaustive]
+pub enum GatheringState {
+    /// No state was set.
+    #[default]
+    Unspecified,
+
+    /// Indicates candidate gathering is not yet started.
+    New,
+
+    /// Indicates candidate gathering is ongoing.
+    Gathering,
+
+    /// Indicates candidate gathering has been completed.
+    Complete,
+}
+
+impl From<u8> for GatheringState {
+    fn from(v: u8) -> Self {
+        match v {
+            1 => Self::New,
+            2 => Self::Gathering,
+            3 => Self::Complete,
+            _ => Self::Unspecified,
+        }
+    }
+}
+
+impl fmt::Display for GatheringState {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let s = match *self {
+            Self::New => "new",
+            Self::Gathering => "gathering",
+            Self::Complete => "complete",
+            Self::Unspecified => "unspecified",
+        };
+        write!(f, "{s}")
+    }
+}

package/engine/vendor/rtc-ice/src/state/state_test.rs

@@ -0,0 +1,46 @@
+use super::*;
+use shared::error::Result;
+
+#[test]
+fn test_connected_state_string() -> Result<()> {
+    let tests = vec![
+        (ConnectionState::Unspecified, "Unspecified"),
+        (ConnectionState::New, "New"),
+        (ConnectionState::Checking, "Checking"),
+        (ConnectionState::Connected, "Connected"),
+        (ConnectionState::Completed, "Completed"),
+        (ConnectionState::Failed, "Failed"),
+        (ConnectionState::Disconnected, "Disconnected"),
+        (ConnectionState::Closed, "Closed"),
+    ];
+
+    for (connection_state, expected_string) in tests {
+        assert_eq!(
+            connection_state.to_string(),
+            expected_string,
+            "testCase: {expected_string} vs {connection_state}",
+        )
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_gathering_state_string() -> Result<()> {
+    let tests = vec![
+        (GatheringState::Unspecified, "unspecified"),
+        (GatheringState::New, "new"),
+        (GatheringState::Gathering, "gathering"),
+        (GatheringState::Complete, "complete"),
+    ];
+
+    for (gathering_state, expected_string) in tests {
+        assert_eq!(
+            gathering_state.to_string(),
+            expected_string,
+            "testCase: {expected_string} vs {gathering_state}",
+        )
+    }
+
+    Ok(())
+}

package/engine/vendor/rtc-ice/src/stats/mod.rs

@@ -0,0 +1,166 @@
+use std::time::Instant;
+
+use crate::candidate::candidate_pair::CandidatePairState;
+use crate::candidate::*;
+
+/// CandidatePairStats contains ICE candidate pair statistics.
+#[derive(Debug, Clone)]
+pub struct CandidatePairStats {
+    /// The timestamp associated with this object.
+    pub timestamp: Instant,
+
+    /// The id of the local candidate.
+    pub local_candidate_id: String,
+
+    /// The id of the remote candidate.
+    pub remote_candidate_id: String,
+
+    /// The state of the checklist for the local and remote
+    /// candidates in a pair.
+    pub state: CandidatePairState,
+
+    /// True when this valid pair that should be used for media
+    /// if it is the highest-priority one amongst those whose nominated flag is set.
+    pub nominated: bool,
+
+    /// The total number of packets sent on this candidate pair.
+    pub packets_sent: u32,
+
+    /// The total number of packets received on this candidate pair.
+    pub packets_received: u32,
+
+    /// The total number of payload bytes sent on this candidate pair
+    /// not including headers or padding.
+    pub bytes_sent: u64,
+
+    /// The total number of payload bytes received on this candidate pair
+    /// not including headers or padding.
+    pub bytes_received: u64,
+
+    /// The timestamp at which the last packet was
+    /// sent on this particular candidate pair, excluding STUN packets.
+    pub last_packet_sent_timestamp: Instant,
+
+    /// The timestamp at which the last packet
+    /// was received on this particular candidate pair, excluding STUN packets.
+    pub last_packet_received_timestamp: Instant,
+
+    /// The timestamp at which the first STUN request
+    /// was sent on this particular candidate pair.
+    pub first_request_timestamp: Instant,
+
+    /// The timestamp at which the last STUN request
+    /// was sent on this particular candidate pair. The average interval between two
+    /// consecutive connectivity checks sent can be calculated with
+    /// (last_request_timestamp - first_request_timestamp) / requests_sent.
+    pub last_request_timestamp: Instant,
+
+    /// The timestamp at which the last STUN response
+    /// was received on this particular candidate pair.
+    pub last_response_timestamp: Instant,
+
+    /// The sum of all round trip time measurements
+    /// in seconds since the beginning of the session, based on STUN connectivity
+    /// check responses (responses_received), including those that reply to requests
+    /// that are sent in order to verify consent. The average round trip time can
+    /// be computed from total_round_trip_time by dividing it by responses_received.
+    pub total_round_trip_time: f64,
+
+    /// The latest round trip time measured in seconds,
+    /// computed from both STUN connectivity checks, including those that are sent
+    /// for consent verification.
+    pub current_round_trip_time: f64,
+
+    /// Calculated by the underlying congestion control
+    /// by combining the available bitrate for all the outgoing RTP streams using
+    /// this candidate pair. The bitrate measurement does not count the size of the
+    /// ip or other transport layers like TCP or UDP. It is similar to the TIAS defined
+    /// in RFC 3890, i.e., it is measured in bits per second and the bitrate is calculated
+    /// over a 1 second window.
+    pub available_outgoing_bitrate: f64,
+
+    /// Calculated by the underlying congestion control
+    /// by combining the available bitrate for all the incoming RTP streams using
+    /// this candidate pair. The bitrate measurement does not count the size of the
+    /// ip or other transport layers like TCP or UDP. It is similar to the TIAS defined
+    /// in  RFC 3890, i.e., it is measured in bits per second and the bitrate is
+    /// calculated over a 1 second window.
+    pub available_incoming_bitrate: f64,
+
+    /// The number of times the circuit breaker
+    /// is triggered for this particular 5-tuple, ceasing transmission.
+    pub circuit_breaker_trigger_count: u32,
+
+    /// The total number of connectivity check requests
+    /// received (including retransmissions). It is impossible for the receiver to
+    /// tell whether the request was sent in order to check connectivity or check
+    /// consent, so all connectivity checks requests are counted here.
+    pub requests_received: u64,
+
+    /// The total number of connectivity check requests
+    /// sent (not including retransmissions).
+    pub requests_sent: u64,
+
+    /// The total number of connectivity check responses received.
+    pub responses_received: u64,
+
+    /// Responses_sent epresents the total number of connectivity check responses sent.
+    /// Since we cannot distinguish connectivity check requests and consent requests,
+    /// all responses are counted.
+    pub responses_sent: u64,
+
+    /// The total number of connectivity check
+    /// request retransmissions received.
+    pub retransmissions_received: u64,
+
+    /// The total number of connectivity check
+    /// request retransmissions sent.
+    pub retransmissions_sent: u64,
+
+    /// The total number of consent requests sent.
+    pub consent_requests_sent: u64,
+
+    /// The timestamp at which the latest valid.
+    /// STUN binding response expired.
+    pub consent_expired_timestamp: Instant,
+}
+
+/// CandidateStats contains ICE candidate statistics related to the ICETransport objects.
+#[derive(Debug, Clone)]
+pub struct CandidateStats {
+    /// The timestamp associated with this object.
+    pub timestamp: Instant,
+
+    /// The candidate id.
+    pub id: String,
+
+    /// The ip address of the candidate, allowing for IPv4 addresses and.
+    /// IPv6 addresses, but fully qualified domain names (FQDNs) are not allowed.
+    pub ip: String,
+
+    /// The port number of the candidate.
+    pub port: u16,
+
+    /// The "Type" field of the ICECandidate.
+    pub candidate_type: CandidateType,
+
+    /// The "priority" field of the ICECandidate.
+    pub priority: u32,
+
+    /// The url of the TURN or STUN server indicated in the that translated
+    /// this ip address. It is the url address surfaced in an PeerConnectionICEEvent.
+    pub url: String,
+
+    /// The protocol used by the endpoint to communicate with the.
+    /// TURN server. This is only present for local candidates. Valid values for
+    /// the TURN url protocol is one of udp, tcp, or tls.
+    pub relay_protocol: String,
+
+    // deleted is true if the candidate has been deleted/freed. For host candidates,
+    // this means that any network resources (typically a socket) associated with the
+    // candidate have been released. For TURN candidates, this means the TURN allocation
+    // is no longer active.
+    //
+    /// Only defined for local candidates. For remote candidates, this property is not applicable.
+    pub deleted: bool,
+}

package/engine/vendor/rtc-ice/src/tcp_type/mod.rs

@@ -0,0 +1,47 @@
+#[cfg(test)]
+mod tcp_type_test;
+
+use std::fmt;
+
+// TCPType is the type of ICE TCP candidate as described in
+// https://tools.ietf.org/html/rfc6544#section-4.5
+#[derive(Default, PartialEq, Eq, Debug, Copy, Clone)]
+/// The role of an ICE-TCP candidate, per [RFC 6544] §4.5.
+///
+/// [RFC 6544]: https://datatracker.ietf.org/doc/html/rfc6544#section-4.5
+#[non_exhaustive]
+pub enum TcpType {
+    /// The default value. For example UDP candidates do not need this field.
+    #[default]
+    Unspecified,
+    /// Active TCP candidate, which initiates TCP connections.
+    Active,
+    /// Passive TCP candidate, only accepts TCP connections.
+    Passive,
+    /// Like `Active` and `Passive` at the same time.
+    SimultaneousOpen,
+}
+
+// from creates a new TCPType from string.
+impl From<&str> for TcpType {
+    fn from(raw: &str) -> Self {
+        match raw {
+            "active" => Self::Active,
+            "passive" => Self::Passive,
+            "so" => Self::SimultaneousOpen,
+            _ => Self::Unspecified,
+        }
+    }
+}
+
+impl fmt::Display for TcpType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let s = match *self {
+            Self::Active => "active",
+            Self::Passive => "passive",
+            Self::SimultaneousOpen => "so",
+            Self::Unspecified => "unspecified",
+        };
+        write!(f, "{s}")
+    }
+}

package/engine/vendor/rtc-ice/src/tcp_type/tcp_type_test.rs

@@ -0,0 +1,18 @@
+use super::*;
+use shared::error::Result;
+
+#[test]
+fn test_tcp_type() -> Result<()> {
+    //assert_eq!(tcpType, TCPType::Unspecified)
+    assert_eq!(TcpType::from("active"), TcpType::Active);
+    assert_eq!(TcpType::from("passive"), TcpType::Passive);
+    assert_eq!(TcpType::from("so"), TcpType::SimultaneousOpen);
+    assert_eq!(TcpType::from("something else"), TcpType::Unspecified);
+
+    assert_eq!(TcpType::Unspecified.to_string(), "unspecified");
+    assert_eq!(TcpType::Active.to_string(), "active");
+    assert_eq!(TcpType::Passive.to_string(), "passive");
+    assert_eq!(TcpType::SimultaneousOpen.to_string(), "so");
+
+    Ok(())
+}