fix: don't panic on STUN requests for unknown interfaces

src/ice/agent.rs

@@ -842,14 +842,14 @@ impl IceAgent {
     /// Handles an incoming STUN message.
     ///
     /// Will not be used if [`IceAgent::accepts_message`] returns false.
-    pub fn handle_packet(&mut self, now: Instant, packet: StunPacket) {
+    pub fn handle_packet(&mut self, now: Instant, packet: StunPacket) -> bool {
         trace!("Handle receive: {:?}", &packet.message);
 
         // Regardless of whether we have remote_creds at this point, we can
         // at least check the message integrity.
         if !self.accepts_message(&packet.message) {
             debug!("Message not accepted");
-            return;
+            return false;
         }
 
         if packet.message.is_binding_request() {
@@ -864,6 +864,8 @@ impl IceAgent {
         });
 
         // TODO handle unsuccessful responses.
+
+        true
     }
 
     /// Provide the current time to the [`IceAgent`].
@@ -1169,25 +1171,28 @@ impl IceAgent {
             self.remote_candidates.len() - 1
         };
 
-        let local_idx = self
-            .local_candidates
-            .iter()
-            .enumerate()
-            .find(|(_, v)| {
-                // The local candidate will be
-                // either a host candidate (for cases where the request was not received
-                // through a relay) or a relayed candidate (for cases where it is
-                // received through a relay).  The local candidate can never be a
-                // server-reflexive candidate.
-                matches!(v.kind(), CandidateKind::Host | CandidateKind::Relayed)
-                    && v.addr() == req.destination && v.proto() == req.proto
-            })
-            // Receiving traffic for an IP address that neither is a HOST nor RELAY is a configuration
-            // fault. We need to be aware of the interfaces that the ice agent is connected to.
-            .expect(
-                "STUN request for socket that is neither a host nor a relay candidate. This is a config error.",
-            )
-            .0;
+        let local_idx = match self.local_candidates.iter().enumerate().find(|(_, v)| {
+            // The local candidate will be
+            // either a host candidate (for cases where the request was not received
+            // through a relay) or a relayed candidate (for cases where it is
+            // received through a relay).  The local candidate can never be a
+            // server-reflexive candidate.
+            matches!(v.kind(), CandidateKind::Host | CandidateKind::Relayed)
+                && v.addr() == req.destination
+                && v.proto() == req.proto
+        }) {
+            Some((i, _)) => i,
+            None => {
+                // Receiving traffic for an IP address that neither is a HOST nor RELAY is most likely a configuration fault where the user forgot to add a candidate for the local interface.
+                // We are network-connected application so we need to handle this gracefully: Log a message and discard the packet.
+
+                debug!(
+                    "Discarding STUN request on unknown interface: {}",
+                    req.destination
+                );
+                return;
+            }
+        };
 
         let maybe_pair = self
             .candidate_pairs
@@ -1893,6 +1898,28 @@ mod test {
         assert!(stun_message.is_successful_binding_response());
     }
 
+    #[test]
+    pub fn discards_packet_from_unknown_candidate() {
+        let mut agent = IceAgent::new();
+        let remote_creds = IceCreds::new();
+        agent.set_remote_credentials(remote_creds.clone());
+
+        let request =
+            make_serialized_binding_request(&agent.local_credentials, &remote_creds, false, 0);
+
+        agent.handle_packet(
+            Instant::now(),
+            StunPacket {
+                proto: Protocol::Udp,
+                source: ipv4_1(),
+                destination: ipv4_2(),
+                message: StunMessage::parse(&request).unwrap(),
+            },
+        );
+
+        assert!(agent.poll_transmit().is_none());
+    }
+
     fn make_serialized_binding_request(
         local_creds: &IceCreds,
         remote_creds: &IceCreds,

src/lib.rs

@@ -1618,15 +1618,15 @@ impl Rtc {
         self.peer_bytes_rx += bytes_rx as u64;
 
         match r.contents.inner {
-            Stun(stun) => self.ice.handle_packet(
-                now,
-                io::StunPacket {
+            Stun(stun) => {
+                let packet = io::StunPacket {
                     proto: r.proto,
                     source: r.source,
                     destination: r.destination,
                     message: stun,
-                },
-            ),
+                };
+                self.ice.handle_packet(now, packet);
+            }
             Dtls(dtls) => self.dtls.handle_receive(dtls)?,
             Rtp(rtp) => self.session.handle_rtp_receive(now, rtp),
             Rtcp(rtcp) => self.session.handle_rtcp_receive(now, rtcp),