feat: remove UUID v4 constraint on link_id, require non-empty string (agntcy#1713)

# Description

The link_id field no longer needs to be a valid UUID v4.
Any non-empty string is now accepted. This relaxes
validation in both the config and datapath crates.

## Type of Change

- [ ] Bugfix
- [x] New Feature
- [ ] Breaking Change
- [x] Refactor
- [ ] Documentation
- [ ] Other (please describe)

## Checklist

- [x] I have read the [contributing
guidelines](/agntcy/repo-template/blob/main/CONTRIBUTING.md)
- [x] Existing issues have been referenced (where applicable)
- [x] I have verified this change is not present in other open pull
requests
- [x] Functionality is documented
- [x] All code style checks pass
- [x] New code contribution is covered by automated tests
- [x] All new and existing tests pass

---------

Signed-off-by: Mauro Sardara <msardara@cisco.com>
Signed-off-by: Mark Marton <mark.p.marton@gmail.com>
Signed-off-by: Michele Papalini <micpapal@cisco.com>
Signed-off-by: amitami2 <amitami2@cisco.com>
Signed-off-by: Sam Betts <1769706+Tehsmash@users.noreply.github.com>
Signed-off-by: Janos Sarusi-Kis <janossk@cisco.com>
Signed-off-by: Mark Marton <30534230+markpmarton@users.noreply.github.com>
Co-authored-by: Mark Marton <30534230+markpmarton@users.noreply.github.com>
Co-authored-by: Michele Papalini <49271675+micpapal@users.noreply.github.com>
Co-authored-by: Amit kumar <amit9116260192@gmail.com>
Co-authored-by: amitami2 <amitami2@cisco.com>
Co-authored-by: Sam Betts <1769706+Tehsmash@users.noreply.github.com>
Co-authored-by: János Sarusi-Kis <janossk@cisco.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

Author: 8 people

data-plane/core/config/src/client.rs

@@ -285,7 +285,7 @@ pub struct ClientConfig {
     pub metadata: Option<MetadataMap>,
 
     /// Link identifier for this connection, used during link negotiation.
-    /// Must be a valid UUID v4. Defaults to a randomly generated UUID v4.
+    /// Defaults to a randomly generated UUID v4.
     #[serde(default = "default_link_id")]
     pub link_id: String,
 
@@ -369,13 +369,6 @@ impl std::fmt::Display for ClientConfig {
     }
 }
 
-pub fn is_valid_uuid_v4(s: &str) -> bool {
-    match uuid::Uuid::parse_str(s) {
-        Ok(id) => id.get_version() == Some(uuid::Version::Random),
-        Err(_) => false,
-    }
-}
-
 impl Configuration for ClientConfig {
     type Error = ConfigError;
 
@@ -384,11 +377,6 @@ impl Configuration for ClientConfig {
             return Err(ConfigError::MissingEndpoint);
         }
 
-        // Validate link_id is a UUID v4
-        if !is_valid_uuid_v4(&self.link_id) {
-            return Err(ConfigError::InvalidLinkId);
-        }
-
         // Validate the client configuration
         self.tls_setting.validate()?;
         validate_endpoint_scheme(&self.endpoint)?;
@@ -742,24 +730,9 @@ mod tests {
     }
 
     #[test]
-    fn test_validate_rejects_non_uuid_link_id() {
-        let mut config = ClientConfig::with_endpoint("http://localhost:1234");
-        config.link_id = "not-a-uuid".to_string();
-        assert!(matches!(config.validate(), Err(ConfigError::InvalidLinkId)));
-    }
-
-    #[test]
-    fn test_validate_rejects_non_v4_uuid() {
+    fn test_validate_accepts_any_link_id() {
         let mut config = ClientConfig::with_endpoint("http://localhost:1234");
-        // Version 1 UUID.
-        config.link_id = "00000000-0000-1000-8000-000000000000".to_string();
-        assert!(matches!(config.validate(), Err(ConfigError::InvalidLinkId)));
-    }
-
-    #[test]
-    fn test_validate_accepts_default_v4_link_id() {
-        // default_link_id() generates a v4 UUID; validation must pass.
-        let config = ClientConfig::with_endpoint("http://localhost:1234");
+        config.link_id = "my-custom-link-id".to_string();
         assert!(config.validate().is_ok());
     }
 }

data-plane/core/config/src/errors.rs

@@ -108,10 +108,6 @@ pub enum ConfigError {
     #[error("resolution error")]
     ResolutionError,
 
-    // Link negotiation
-    #[error("link_id must be a valid UUID v4")]
-    InvalidLinkId,
-
     // ServerHandler routing
     #[error("server handler does not provide gRPC routes, but transport is gRPC")]
     HandlerMissingGrpcSupport,

data-plane/core/config/src/grpc/client.rs

@@ -3,7 +3,6 @@
 
 pub use crate::client::{
     AuthenticationConfig, BackoffConfig, ClientConfig, KeepaliveConfig, TransportChannel,
-    is_valid_uuid_v4,
 };
 
 use std::str::FromStr;

data-plane/core/config/src/schema/client-config.schema.json

@@ -72,7 +72,7 @@
       ]
     },
     "link_id": {
-      "description": "Link identifier for this connection, used during link negotiation.\nMust be a valid UUID v4. Defaults to a randomly generated UUID v4.",
+      "description": "Link identifier for this connection, used during link negotiation.\nDefaults to a randomly generated UUID v4.",
       "type": "string",
       "default": "5809da77-44e1-4b56-b221-de07c3b641e9"
     },

data-plane/core/datapath/src/connection.rs

@@ -7,7 +7,7 @@ use crate::api::proto::dataplane::v1::Message;
 use aws_lc_rs::agreement::EphemeralPrivateKey;
 use parking_lot::RwLock;
 use semver::Version;
-use slim_config::client::{ClientConfig, is_valid_uuid_v4};
+use slim_config::client::ClientConfig;
 use std::net::SocketAddr;
 use tokio::sync::mpsc;
 use tokio_util::sync::CancellationToken;
@@ -228,15 +228,15 @@ impl Connection {
 
     /// Atomically complete link negotiation on the server (incoming) path.
     ///
-    /// Validates `link_id` as a UUID v4 and stores it together with `version` under one lock.
-    /// Returns `false` if `link_id` is not a valid UUID v4 or negotiation is already complete
+    /// Validates `link_id` is non-empty and stores it together with `version` under one lock.
+    /// Returns `false` if `link_id` is empty or negotiation is already complete
     /// (replay protection).
     pub fn complete_negotiation_as_server(&self, link_id: &str, version: Version) -> bool {
         let mut state = self.negotiation.write();
         if state.remote_slim_version.is_some() {
             return false;
         }
-        if !is_valid_uuid_v4(link_id) {
+        if link_id.is_empty() {
             return false;
         }
         state.link_id = Some(link_id.to_string());
@@ -347,21 +347,19 @@ mod tests {
     }
 
     #[test]
-    fn test_complete_negotiation_as_server_stores_valid_uuid() {
+    fn test_complete_negotiation_as_server_stores_link_id() {
         let conn = server_conn();
-        let id = uuid::Uuid::new_v4().to_string();
+        let id = "my-custom-link-id";
         let v = Version::parse("1.2.3").unwrap();
-        assert!(conn.complete_negotiation_as_server(&id, v.clone()));
-        assert_eq!(conn.link_id(), Some(id));
+        assert!(conn.complete_negotiation_as_server(id, v.clone()));
+        assert_eq!(conn.link_id(), Some(id.to_string()));
         assert_eq!(conn.remote_slim_version(), Some(v));
     }
 
     #[test]
-    fn test_complete_negotiation_as_server_rejects_invalid_uuid() {
+    fn test_complete_negotiation_as_server_rejects_empty_link_id() {
         let conn = server_conn();
-        assert!(
-            !conn.complete_negotiation_as_server("not-a-uuid", Version::parse("1.0.0").unwrap())
-        );
+        assert!(!conn.complete_negotiation_as_server("", Version::parse("1.0.0").unwrap()));
         assert!(conn.link_id().is_none());
         assert!(conn.remote_slim_version().is_none());
     }

data-plane/core/datapath/src/header_mac.rs

@@ -15,7 +15,6 @@ use std::cell::RefCell;
 
 use aws_lc_rs::hmac;
 use thiserror::Error;
-use uuid::Uuid;
 
 use crate::api::proto::dataplane::v1::{Name, SlimHeader};
 
@@ -31,8 +30,8 @@ const TAG_LEN: usize = 32;
 pub enum HeaderMacError {
     #[error("header_mac key must be at least {MIN_KEY_LEN} bytes")]
     KeyTooShort,
-    #[error("invalid link_id for header MAC")]
-    InvalidLinkId,
+    #[error("link_id must not be empty")]
+    EmptyLinkId,
     #[error("missing SLIM header integrity tag")]
     MissingTag,
     #[error("invalid integrity tag length")]
@@ -73,13 +72,15 @@ impl HeaderMacSession {
         header: &mut SlimHeader,
         link_id: &str,
     ) -> Result<(), HeaderMacError> {
+        if link_id.is_empty() {
+            return Err(HeaderMacError::EmptyLinkId);
+        }
         header.header_mac = None;
-        let uuid = link_uuid_bytes(link_id)?;
         PREIMAGE_BUF.with(|cell| {
             let mut buf = cell.borrow_mut();
             buf.clear();
-            reserve_preimage_upper_bound(&mut buf, header);
-            write_preimage(&mut buf, header, &uuid);
+            reserve_preimage_upper_bound(&mut buf, header, link_id);
+            write_preimage(&mut buf, header, link_id.as_bytes());
             let tag = hmac::sign(&self.key, buf.as_slice());
             header.header_mac = Some(Vec::from(tag.as_ref()));
             Ok(())
@@ -92,19 +93,21 @@ impl HeaderMacSession {
         header: &SlimHeader,
         link_id: &str,
     ) -> Result<(), HeaderMacError> {
+        if link_id.is_empty() {
+            return Err(HeaderMacError::EmptyLinkId);
+        }
         let tag = header
             .header_mac
             .as_deref()
             .ok_or(HeaderMacError::MissingTag)?;
         if tag.len() != TAG_LEN {
             return Err(HeaderMacError::InvalidTagLength);
         }
-        let uuid = link_uuid_bytes(link_id)?;
         PREIMAGE_BUF.with(|cell| {
             let mut buf = cell.borrow_mut();
             buf.clear();
-            reserve_preimage_upper_bound(&mut buf, header);
-            write_preimage(&mut buf, header, &uuid);
+            reserve_preimage_upper_bound(&mut buf, header, link_id);
+            write_preimage(&mut buf, header, link_id.as_bytes());
             hmac::verify(&self.key, buf.as_slice(), tag)
                 .map_err(|_| HeaderMacError::VerificationFailed)
         })
@@ -113,19 +116,18 @@ impl HeaderMacSession {
 
 /// Ensure `buf` can hold the worst-case preimage without reallocation during `write_preimage`.
 #[inline]
-fn reserve_preimage_upper_bound(buf: &mut Vec<u8>, hdr: &SlimHeader) {
-    let need = preimage_upper_bound(hdr);
+fn reserve_preimage_upper_bound(buf: &mut Vec<u8>, hdr: &SlimHeader, link_id: &str) {
+    let need = preimage_upper_bound(hdr, link_id);
     let cap = buf.capacity();
     if need > cap {
         buf.reserve(need - cap);
     }
 }
 
 #[inline]
-fn preimage_upper_bound(header: &SlimHeader) -> usize {
-    /// Byte size of `link_uuid` field.
-    /// * 16 bytes for `&[u8; 16]`.
-    const LINK_UUID_SIZE: usize = 16;
+fn preimage_upper_bound(header: &SlimHeader, link_id: &str) -> usize {
+    /// Byte size of the link_id length prefix (u32).
+    const LINK_ID_LEN_PREFIX: usize = 4;
 
     /// Byte size of `fanout`, serialized by [`to_le_bytes`]
     /// * 4 bytes for `u32`
@@ -152,7 +154,8 @@ fn preimage_upper_bound(header: &SlimHeader) -> usize {
     const TTL_SIZE: usize = 4;
 
     DOMAIN_V1.len()
-        + LINK_UUID_SIZE
+        + LINK_ID_LEN_PREFIX
+        + link_id.len()
         + FANOUT_SIZE
         + RECV_FROM_SIZE
         + FORWARD_TO_SIZE
@@ -194,12 +197,6 @@ fn encoded_name_upper_bound(name_opt: &Option<Name>) -> usize {
     }
 }
 
-fn link_uuid_bytes(link_id: &str) -> Result<[u8; 16], HeaderMacError> {
-    Uuid::parse_str(link_id)
-        .map(|u| *u.as_bytes())
-        .map_err(|_| HeaderMacError::InvalidLinkId)
-}
-
 #[inline]
 fn push_bytes(buf: &mut Vec<u8>, data: &[u8]) {
     buf.extend_from_slice(&(data.len() as u32).to_le_bytes());
@@ -261,10 +258,11 @@ fn push_encoded_name(buf: &mut Vec<u8>, n: &Option<Name>) {
     }
 }
 
-/// Canonical preimage: domain || link_uuid || routing header fields (no incoming_conn, no tag).
-fn write_preimage(buf: &mut Vec<u8>, hdr: &SlimHeader, link_uuid: &[u8; 16]) {
+/// Canonical preimage: domain || len(link_id) || link_id || routing header fields (no incoming_conn, no tag).
+fn write_preimage(buf: &mut Vec<u8>, hdr: &SlimHeader, link_id_bytes: &[u8]) {
     buf.extend_from_slice(DOMAIN_V1);
-    buf.extend_from_slice(link_uuid);
+    buf.extend_from_slice(&(link_id_bytes.len() as u32).to_le_bytes());
+    buf.extend_from_slice(link_id_bytes);
     push_encoded_name(buf, &hdr.source);
     push_encoded_name(buf, &hdr.destination);
     push_bytes(buf, hdr.identity.as_bytes());
@@ -280,6 +278,7 @@ mod tests {
     use super::*;
     use crate::api::proto::dataplane::v1::{EncodedName, Name, NameId, StringName};
     use crate::messages::utils::DEFAULT_TTL;
+    use uuid::Uuid;
 
     fn test_key() -> Vec<u8> {
         b"01234567890123456789012345678901".to_vec()

data-plane/core/datapath/src/message_processing.rs

@@ -323,7 +323,7 @@ impl MessageProcessor {
         };
         let link_id = conn
             .link_id()
-            .filter(|id| slim_config::grpc::client::is_valid_uuid_v4(id))
+            .filter(|id| !id.is_empty())
             .ok_or(DataPathError::HeaderMacAwaitingLinkNegotiation(conn_index))?;
         mac.verify_slim_header(header, &link_id)
             .map_err(DataPathError::HeaderIntegrity)
@@ -710,7 +710,7 @@ impl MessageProcessor {
                     let link_id = conn
                         .link_id()
                         .or_else(|| conn.config_data().map(|c| c.link_id.clone()))
-                        .filter(|id| slim_config::grpc::client::is_valid_uuid_v4(id));
+                        .filter(|id| !id.is_empty());
                     if let Some(ref id) = link_id {
                         let header = msg.get_slim_header_mut();
 
@@ -1801,7 +1801,6 @@ impl DataPlaneService for MessageProcessor {
 #[cfg(test)]
 mod tests {
     use slim_config::client::ClientConfig;
-    use slim_config::grpc::client::is_valid_uuid_v4;
     use std::sync::Arc;
     use std::time::Duration;
 
@@ -1868,24 +1867,6 @@ mod tests {
         assert_failed_subscription_ack_is_sent(false).await;
     }
 
-    #[test]
-    fn test_is_valid_uuid_v4_accepts_v4() {
-        let id = uuid::Uuid::new_v4().to_string();
-        assert!(is_valid_uuid_v4(&id));
-    }
-
-    #[test]
-    fn test_is_valid_uuid_v4_rejects_non_uuid_string() {
-        assert!(!is_valid_uuid_v4("not-a-uuid"));
-        assert!(!is_valid_uuid_v4(""));
-    }
-
-    #[test]
-    fn test_is_valid_uuid_v4_rejects_non_v4_uuid() {
-        // Version 1 UUID (time-based).
-        assert!(!is_valid_uuid_v4("00000000-0000-1000-8000-000000000000"));
-    }
-
     // ── handle_link_message ───────────────────────────────────────────────────
 
     #[tokio::test]
@@ -2036,11 +2017,11 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_handle_link_negotiation_server_invalid_uuid_ignored() {
+    async fn test_handle_link_negotiation_server_empty_link_id_ignored() {
         let processor = MessageProcessor::new();
         let (conn_id, _rx) = make_server_conn(&processor);
         let payload = LinkNegotiationPayload {
-            link_id: "not-a-uuid".into(),
+            link_id: "".into(),
             slim_version: "1.0.0".into(),
             is_reply: false,
             link_ecdh_public_key: vec![],