Embeds the detections in the bin

Author: ryanlabouve

Cargo.lock

@@ -13,6 +13,7 @@ xargo = false
 [dependencies]
 clap = { version = "4.5.8", features = ["derive"] }
 regex = "1.10.5"
+rust-embed = "8.4.0"
 serde = { version = "1.0.203", features = ["derive"] }
 thiserror = "1.0.61"
 toml = "0.8.14"

Cargo.toml

@@ -8,7 +8,7 @@ fn main() {
 }
 
 fn run() -> Result<(), MinosCodexError> {
-    let mut scanner = create_scanner("detections")?;
+    let mut scanner = create_scanner()?;
 
     let input = "My email is example@email.com and my AWS access key is AKIAIOSFODNN7EXAMPLE";
 

examples/basic_usage.rs

@@ -1,5 +1,6 @@
 use clap::Parser;
 use minos_codex::{create_scanner, MinosCodexError};
+use rust_embed::RustEmbed;
 
 #[derive(Parser)]
 #[clap(
@@ -13,10 +14,13 @@ struct Opts {
     input: String,
 }
 
+#[derive(RustEmbed)]
+#[folder = "detections/"]
+struct Assets;
+
 fn main() -> Result<(), MinosCodexError> {
     let opts: Opts = Opts::parse();
-
-    let mut scanner = create_scanner("detections")?;
+    let mut scanner = create_scanner()?;
 
     let found_secrets = scanner.scan(&opts.input)?;
 

src/bin/minos-codex.rs

@@ -1,15 +1,25 @@
 use crate::secret_type::SecretType;
 use crate::MinosCodexError;
+use rust_embed::RustEmbed;
 use serde::Deserialize;
 use std::collections::HashMap;
-use std::fs;
-use std::path::{Path, PathBuf};
+use std::str::Utf8Error;
+
+impl From<Utf8Error> for MinosCodexError {
+    fn from(err: Utf8Error) -> Self {
+        MinosCodexError::ConfigLoadError(std::io::Error::new(std::io::ErrorKind::InvalidData, err))
+    }
+}
 
 #[derive(Deserialize)]
 struct SecretTypeWrapper {
     secret_type: SecretType,
 }
 
+#[derive(RustEmbed)]
+#[folder = "detections/"]
+struct ConfigAssets;
+
 pub struct Config {
     secret_types: HashMap<String, SecretType>,
 }
@@ -21,15 +31,19 @@ impl Config {
         }
     }
 
-    pub fn load_from_directory<P: AsRef<Path>>(dir_path: P) -> Result<Self, MinosCodexError> {
+    pub fn load_from_embedded() -> Result<Self, MinosCodexError> {
         let mut config = Config::new();
-        let dir = fs::read_dir(dir_path)?;
 
-        for entry in dir {
-            let entry = entry?;
-            let path = entry.path();
-            if path.is_file() && path.extension().map_or(false, |ext| ext == "toml") {
-                let secret_type = Config::load_secret_type_from_file(&path)?;
+        for file in ConfigAssets::iter() {
+            if file.ends_with(".toml") {
+                let file_data = ConfigAssets::get(&file).ok_or_else(|| {
+                    MinosCodexError::ConfigLoadError(std::io::Error::new(
+                        std::io::ErrorKind::NotFound,
+                        "File not found",
+                    ))
+                })?;
+                let contents = std::str::from_utf8(file_data.data.as_ref())?;
+                let secret_type = Config::load_secret_type_from_data(contents)?;
                 config
                     .secret_types
                     .insert(secret_type.name.clone(), secret_type);
@@ -39,13 +53,12 @@ impl Config {
         Ok(config)
     }
 
-    fn load_secret_type_from_file(file_path: &PathBuf) -> Result<SecretType, MinosCodexError> {
-        let contents = fs::read_to_string(file_path)?;
-        let wrapper: SecretTypeWrapper = toml::from_str(&contents)?;
+    fn load_secret_type_from_data(data: &str) -> Result<SecretType, MinosCodexError> {
+        let wrapper: SecretTypeWrapper = toml::from_str(data)?;
         wrapper
             .secret_type
             .validate()
-            .map_err(|e| MinosCodexError::ValidationError(e))?;
+            .map_err(MinosCodexError::ValidationError)?;
         Ok(wrapper.secret_type)
     }
 

src/config/mod.rs

@@ -24,11 +24,10 @@ pub enum MinosCodexError {
     ValidationError(String),
 }
 
-pub fn create_scanner(config_dir: &str) -> Result<Scanner, MinosCodexError> {
-    let config = Config::load_from_directory(config_dir)?;
+pub fn create_scanner() -> Result<Scanner, MinosCodexError> {
+    let config = Config::load_from_embedded()?;
     Ok(Scanner::new(config))
 }
-
 impl From<extern_regex::Error> for MinosCodexError {
     fn from(err: extern_regex::Error) -> Self {
         match err {