Reject colons in target specs

Author: oli-obk

CHANGELOG.md

@@ -13,6 +13,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+* `only`/`ignore` filters now only accept integers, alphabetic characters, `-` and `_`
+
 ### Removed
 
 ## [0.26.4] - 2024-09-09

src/config.rs

@@ -395,8 +395,8 @@ impl Config {
         let target = self.target.as_ref().unwrap();
         match condition {
             Condition::Bitwidth(bits) => bits.iter().any(|bits| self.get_pointer_width() == *bits),
-            Condition::Target(t) => t.iter().any(|t| target.contains(t)),
-            Condition::Host(t) => t.iter().any(|t| self.host.as_ref().unwrap().contains(t)),
+            Condition::Target(t) => t.iter().any(|t| target.contains(&**t)),
+            Condition::Host(t) => t.iter().any(|t| self.host.as_ref().unwrap().contains(&**t)),
             Condition::OnHost => self.host_matches_target(),
         }
     }

src/parser.rs

@@ -225,15 +225,51 @@ impl<T> std::ops::DerefMut for CommentParser<T> {
 #[derive(Debug, Clone)]
 pub enum Condition {
     /// One of the given strings must appear in the host triple.
-    Host(Vec<String>),
+    Host(Vec<TargetSubStr>),
     /// One of the given string must appear in the target triple.
-    Target(Vec<String>),
+    Target(Vec<TargetSubStr>),
     /// Tests that the bitwidth is one of the given ones.
     Bitwidth(Vec<u8>),
     /// Tests that the target is the host.
     OnHost,
 }
 
+#[derive(Debug, Clone)]
+/// A sub string of a target (or a whole target).
+/// Effectively a `String` that only allows lowercase chars, integers and dashes
+pub struct TargetSubStr(String);
+
+impl PartialEq<&str> for TargetSubStr {
+    fn eq(&self, other: &&str) -> bool {
+        self.0 == *other
+    }
+}
+
+impl std::ops::Deref for TargetSubStr {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl TryFrom<String> for TargetSubStr {
+    type Error = String;
+
+    fn try_from(value: String) -> std::result::Result<Self, Self::Error> {
+        if value
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
+        {
+            Ok(Self(value))
+        } else {
+            Err(format!(
+                "target strings can only contain integers, basic alphabet characters or dashes"
+            ))
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 /// An error pattern parsed from a `//~` comment.
 pub enum Pattern {
@@ -270,8 +306,8 @@ impl Condition {
                 })).collect::<Result<Vec<_>, _>>()?;
                 Ok(Condition::Bitwidth(bits))
             }
-            "target" => Ok(Condition::Target(args.map(|arg|arg.to_owned()).collect())),
-            "host" => Ok(Condition::Host(args.map(|arg|arg.to_owned()).collect())),
+            "target" => Ok(Condition::Target(args.map(|arg|TargetSubStr::try_from(arg.to_owned())).collect::<Result<_, _>>()?)),
+            "host" => Ok(Condition::Host(args.map(|arg|TargetSubStr::try_from(arg.to_owned())).collect::<Result<_, _>>()?)),
             _ => Err(format!("`{c}` is not a valid condition, expected `on-host`, /[0-9]+bit/, /host-.*/, or /target-.*/")),
         }
     }

src/parser/tests.rs

@@ -255,7 +255,10 @@ fn parse_x86_64() {
     let revisioned = &comments.revisioned[&vec![]];
     assert_eq!(revisioned.only.len(), 1);
     match &revisioned.only[0] {
-        Condition::Target(t) => assert_eq!(t, &["x86_64-unknown-linux"]),
+        Condition::Target(t) => {
+            assert_eq!(t.len(), 1);
+            assert_eq!(t[0], "x86_64-unknown-linux")
+        }
         _ => unreachable!(),
     }
 }
@@ -279,7 +282,27 @@ fn parse_two_only_filters() {
     let revisioned = &comments.revisioned[&vec![]];
     assert_eq!(revisioned.only.len(), 1);
     match &revisioned.only[0] {
-        Condition::Target(t) => assert_eq!(t, &["hello", "world"]),
+        Condition::Target(t) => {
+            assert_eq!(t.len(), 2);
+            assert_eq!(t[0], "hello");
+            assert_eq!(t[1], "world")
+        }
         _ => unreachable!(),
     }
 }
+
+#[test]
+fn parse_invalid_filter() {
+    let s = r"//@only-target: hello world: somecomment";
+    Comments::parse(
+        Spanned::new(
+            s.as_bytes(),
+            Span {
+                file: PathBuf::new(),
+                bytes: 0..s.len(),
+            },
+        ),
+        &Config::dummy(),
+    )
+    .unwrap_err();
+}