feat(relay): add mechanism to only allow events from trusted relays

CHANGELOG.md

@@ -5,6 +5,7 @@
 **Features**:
 
 - Add configuration to allow high cardinality tags in metrics. ([#4805](https://github.com/getsentry/relay/pull/4805))
+- Add mechanism to allow ingestion only from trusted relays. ([#4772](https://github.com/getsentry/relay/pull/4772))
 
 **Internal**:
 

relay-auth/Cargo.toml

@@ -25,3 +25,4 @@ serde_json = { workspace = true }
 sha2 = { workspace = true }
 thiserror = { workspace = true }
 uuid = { workspace = true }
+bytes = { workspace = true }

relay-auth/src/lib.rs

@@ -22,9 +22,7 @@
     html_favicon_url = "https://raw.githubusercontent.com/getsentry/relay/master/artwork/relay-icon.png"
 )]
 
-use std::fmt;
-use std::str::FromStr;
-
+use bytes::Bytes;
 use chrono::{DateTime, Duration, Utc};
 use data_encoding::BASE64URL_NOPAD;
 use ed25519_dalek::{Signer, Verifier};
@@ -35,6 +33,9 @@ use relay_common::time::UnixTimestamp;
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 use sha2::Sha512;
+use std::fmt;
+use std::fmt::{Display, Formatter};
+use std::str::FromStr;
 use uuid::Uuid;
 
 include!(concat!(env!("OUT_DIR"), "/constants.gen.rs"));
@@ -147,6 +148,14 @@ pub enum UnpackError {
     SignatureExpired,
 }
 
+/// Errors during the signature or verification process.
+#[derive(Debug, Clone, PartialEq, thiserror::Error)]
+pub enum SignatureError {
+    /// Credentials for a required signature were missing.
+    #[error("missing credentials")]
+    MissingCredentials,
+}
+
 /// A wrapper around packed data that adds a timestamp.
 ///
 /// This is internally automatically used when data is signed.
@@ -196,7 +205,7 @@ impl SecretKey {
     /// Signs some data with the secret key and returns the signature.
     ///
     /// This is will sign with the default header.
-    pub fn sign(&self, data: &[u8]) -> String {
+    pub fn sign(&self, data: &[u8]) -> Signature {
         self.sign_with_header(data, &SignatureHeader::default())
     }
 
@@ -205,7 +214,7 @@ impl SecretKey {
     ///
     /// The default behavior is to attach the timestamp in the header to the
     /// signature so that old signatures on verification can be rejected.
-    pub fn sign_with_header(&self, data: &[u8], header: &SignatureHeader) -> String {
+    pub fn sign_with_header(&self, data: &[u8], header: &SignatureHeader) -> Signature {
         let mut header =
             serde_json::to_vec(&header).expect("attempted to pack non json safe header");
         let header_encoded = BASE64URL_NOPAD.encode(&header);
@@ -215,11 +224,11 @@ impl SecretKey {
         let mut sig_encoded = BASE64URL_NOPAD.encode(&sig.to_bytes());
         sig_encoded.push('.');
         sig_encoded.push_str(&header_encoded);
-        sig_encoded
+        Signature(sig_encoded.into_bytes())
     }
 
     /// Packs some serializable data into JSON and signs it with the default header.
-    pub fn pack<S: Serialize>(&self, data: S) -> (Vec<u8>, String) {
+    pub fn pack<S: Serialize>(&self, data: S) -> (Vec<u8>, Signature) {
         self.pack_with_header(data, &SignatureHeader::default())
     }
 
@@ -228,7 +237,7 @@ impl SecretKey {
         &self,
         data: S,
         header: &SignatureHeader,
-    ) -> (Vec<u8>, String) {
+    ) -> (Vec<u8>, Signature) {
         // this can only fail if we deal with badly formed data.  In that case we
         // consider that a panic.  Should not happen.
         let json = serde_json::to_vec(&data).expect("attempted to pack non json safe data");
@@ -302,16 +311,16 @@ pub struct PublicKey {
 impl PublicKey {
     /// Verifies the signature and returns the embedded signature
     /// header.
-    pub fn verify_meta(&self, data: &[u8], sig: &str) -> Option<SignatureHeader> {
-        let mut iter = sig.splitn(2, '.');
+    pub fn verify_meta(&self, data: &[u8], sig: SignatureRef) -> Option<SignatureHeader> {
+        let mut iter = sig.0.splitn(2, |b| *b == b'.');
         let sig_bytes = match iter.next() {
-            Some(sig_encoded) => BASE64URL_NOPAD.decode(sig_encoded.as_bytes()).ok()?,
+            Some(sig_encoded) => BASE64URL_NOPAD.decode(sig_encoded).ok()?,
             None => return None,
         };
         let sig = ed25519_dalek::Signature::from_slice(&sig_bytes).ok()?;
 
         let header = match iter.next() {
-            Some(header_encoded) => BASE64URL_NOPAD.decode(header_encoded.as_bytes()).ok()?,
+            Some(header_encoded) => BASE64URL_NOPAD.decode(header_encoded).ok()?,
             None => return None,
         };
         let mut to_verify = header.clone();
@@ -325,12 +334,17 @@ impl PublicKey {
     }
 
     /// Verifies a signature but discards the header.
-    pub fn verify(&self, data: &[u8], sig: &str) -> bool {
+    pub fn verify(&self, data: &[u8], sig: SignatureRef) -> bool {
         self.verify_meta(data, sig).is_some()
     }
 
     /// Verifies a signature and checks the timestamp.
-    pub fn verify_timestamp(&self, data: &[u8], sig: &str, max_age: Option<Duration>) -> bool {
+    pub fn verify_timestamp(
+        &self,
+        data: &[u8],
+        sig: SignatureRef,
+        max_age: Option<Duration>,
+    ) -> bool {
         self.verify_meta(data, sig)
             .map(|header| max_age.is_none() || !header.expired(max_age.unwrap()))
             .unwrap_or(false)
@@ -340,7 +354,7 @@ impl PublicKey {
     pub fn unpack_meta<D: DeserializeOwned>(
         &self,
         data: &[u8],
-        signature: &str,
+        signature: SignatureRef,
     ) -> Result<(SignatureHeader, D), UnpackError> {
         if let Some(header) = self.verify_meta(data, signature) {
             serde_json::from_slice(data)
@@ -358,7 +372,7 @@ impl PublicKey {
     pub fn unpack<D: DeserializeOwned>(
         &self,
         data: &[u8],
-        signature: &str,
+        signature: SignatureRef,
         max_age: Option<Duration>,
     ) -> Result<D, UnpackError> {
         let (header, data) = self.unpack_meta(data, signature)?;
@@ -575,7 +589,7 @@ impl RegisterRequest {
     /// the data is returned.
     pub fn bootstrap_unpack(
         data: &[u8],
-        signature: &str,
+        signature: SignatureRef,
         max_age: Option<Duration>,
     ) -> Result<RegisterRequest, UnpackError> {
         let req: RegisterRequest = serde_json::from_slice(data).map_err(UnpackError::BadPayload)?;
@@ -653,7 +667,7 @@ impl RegisterResponse {
     /// Unpacks the register response and validates signatures.
     pub fn unpack(
         data: &[u8],
-        signature: &str,
+        signature: SignatureRef,
         secret: &[u8],
         max_age: Option<Duration>,
     ) -> Result<(Self, RegisterState), UnpackError> {
@@ -687,6 +701,104 @@ impl RegisterResponse {
     }
 }
 
+/// A wrapper around a byte vector that represents a signature.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Signature(pub Vec<u8>);
+
+impl Signature {
+    /// Verifies the signature against any of the provided public keys.
+    ///
+    /// Returns `true` if the signature is valid with one of the given
+    /// public keys and satisfies the timestamp constraints defined by `start_time`
+    /// and `max_age`.
+    pub fn verify_signature_any(
+        &self,
+        public_key: &[PublicKey],
+        start_time: DateTime<Utc>,
+        max_age: Duration,
+    ) -> bool {
+        public_key
+            .iter()
+            .any(|p| self.verify_signature(p, start_time, max_age))
+    }
+
+    /// Verifies the signature using the specified public key.
+    ///
+    /// The signature is considered valid if it can be verified using the given
+    /// public key and its embedded timestamp falls within the valid time range,
+    /// starting from `start_time` and not exceeding `max_age`.
+    pub fn verify_signature(
+        &self,
+        public_key: &PublicKey,
+        start_time: DateTime<Utc>,
+        max_age: Duration,
+    ) -> bool {
+        let Some(header) = public_key.verify_meta(&[], self.as_signature_ref()) else {
+            return false;
+        };
+        let Some(timestamp) = header.timestamp else {
+            return false;
+        };
+        let elapsed = start_time - timestamp;
+        elapsed >= Duration::zero() && elapsed <= max_age
+    }
+
+    /// Verifies the signature against the given data and public key.
+    ///
+    /// Returns `true` if the signature is valid for the provided `data`
+    /// when verified with the given public key.
+    pub fn verify_bytes(&self, data: &[u8], public_key: &PublicKey) -> bool {
+        public_key
+            .verify_meta(data, self.as_signature_ref())
+            .is_some()
+    }
+
+    /// Returns a borrowed view of the signature as a `SignatureRef`.
+    ///
+    /// This method provides a lightweight reference wrapper over the internal
+    /// signature data.
+    pub fn as_signature_ref(&self) -> SignatureRef {
+        SignatureRef(self.0.as_slice())
+    }
+}
+
+impl Display for Signature {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        // Bytes in Signature are already encoded as Base64 so this should never allocate.
+        let s = String::from_utf8_lossy(&self.0);
+        write!(f, "{s}")
+    }
+}
+
+/// A borrowed reference to a byte slice used for signature validation.
+///
+/// `SignatureRef` provides a view into the raw bytes of a signature and is
+/// the primary type used in signature validation and verification routines.
+/// It enables working with either owned or borrowed signature data without
+/// unnecessary allocations, typically by borrowing from a [`Signature`] or
+/// directly from a byte slice.
+pub struct SignatureRef<'a>(pub &'a [u8]);
+
+/// Types of signatures that are supported by Relay.
+#[derive(Debug)]
+pub enum SignatureType {
+    /// Bytes of an envelope body that are used to produce a signature.
+    Body(Bytes),
+    /// No data is needed for this signature because we only want to see if
+    /// the receiving relay can verify the signature correctly.
+    RequestSign,
+}
+
+impl SignatureType {
+    /// Creates a signature data based on the variant.
+    pub fn create_signature(self, secret_key: &SecretKey) -> Signature {
+        match self {
+            SignatureType::Body(data) => secret_key.sign(data.as_ref()),
+            SignatureType::RequestSign => secret_key.sign(&[]),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -753,10 +865,10 @@ mod tests {
         let data = b"Hello World!";
 
         let sig = sk.sign(data);
-        assert!(pk.verify(data, &sig));
+        assert!(pk.verify(data, sig.as_signature_ref()));
 
         let bad_sig = "jgubwSf2wb2wuiRpgt2H9_bdDSMr88hXLp5zVuhbr65EGkSxOfT5ILIWr623twLgLd0bDgHg6xzOaUCX7XvUCw";
-        assert!(!pk.verify(data, bad_sig));
+        assert!(!pk.verify(data, SignatureRef(bad_sig.as_bytes())));
     }
 
     #[test]
@@ -774,8 +886,12 @@ mod tests {
         let (request_bytes, request_sig) = sk.pack(request);
 
         // attempt to get the data through bootstrap unpacking.
-        let request =
-            RegisterRequest::bootstrap_unpack(&request_bytes, &request_sig, Some(max_age)).unwrap();
+        let request = RegisterRequest::bootstrap_unpack(
+            &request_bytes,
+            request_sig.as_signature_ref(),
+            Some(max_age),
+        )
+        .unwrap();
         assert_eq!(request.relay_id(), relay_id);
         assert_eq!(request.public_key(), &pk);
 
@@ -800,7 +916,7 @@ mod tests {
         let (response_bytes, response_sig) = sk.pack(response);
         let (response, _) = RegisterResponse::unpack(
             &response_bytes,
-            &response_sig,
+            response_sig.as_signature_ref(),
             upstream_secret,
             Some(max_age),
         )
@@ -836,8 +952,12 @@ mod tests {
         println!("REQUEST_SIG = \"{request_sig}\"");
 
         // attempt to get the data through bootstrap unpacking.
-        let request =
-            RegisterRequest::bootstrap_unpack(&request_bytes, &request_sig, Some(max_age)).unwrap();
+        let request = RegisterRequest::bootstrap_unpack(
+            &request_bytes,
+            request_sig.as_signature_ref(),
+            Some(max_age),
+        )
+        .unwrap();
 
         let upstream_secret = b"secret";
 
@@ -906,4 +1026,63 @@ mod tests {
     fn test_relay_version_from_str() {
         assert_eq!(RelayVersion::new(20, 7, 0), "20.7.0".parse().unwrap());
     }
+
+    #[test]
+    fn test_verify_any() {
+        let pair1 = generate_key_pair();
+        let pair2 = generate_key_pair();
+        let pair3 = generate_key_pair();
+
+        let data = Bytes::new();
+        let signature = pair3.0.sign(&data);
+        assert!(signature.verify_signature_any(
+            &[pair1.1, pair2.1, pair3.1],
+            Utc::now(),
+            Duration::seconds(10)
+        ));
+    }
+
+    #[test]
+    fn test_verify_max_age() {
+        let pair = generate_key_pair();
+        let signature = pair.0.sign(&[]);
+        let start_time = Utc::now();
+        // The signature is valid in general
+        assert!(signature.verify_signature(&pair.1, start_time, Duration::seconds(10)));
+        // Signature is no longer valid because too much time elapsed
+        assert!(!signature.verify_signature(
+            &pair.1,
+            start_time - Duration::seconds(1),
+            Duration::milliseconds(500)
+        ))
+    }
+
+    #[test]
+    fn test_verify_any_max_age() {
+        let start_time = Utc::now();
+        let pair1 = generate_key_pair();
+        let pair2 = generate_key_pair();
+        let pair3 = generate_key_pair();
+
+        let data = Bytes::new();
+        let header = SignatureHeader {
+            timestamp: Some(start_time),
+        };
+        let signature = pair3.0.sign_with_header(&data, &header);
+
+        let public_keys = &[pair1.1, pair2.1, pair3.1];
+
+        // Signature still valid after 1 second
+        assert!(signature.verify_signature_any(
+            public_keys,
+            start_time + Duration::seconds(1),
+            Duration::seconds(2)
+        ));
+        // Signature is no longer valid because too much time elapsed
+        assert!(!signature.verify_signature_any(
+            public_keys,
+            start_time + Duration::seconds(3),
+            Duration::seconds(2)
+        ))
+    }
 }