use super::capabilities::{get_technique_metadata, Capability};
 
 #[derive(Debug, Clone)]
 pub struct ValidationError {
     pub message: String,
     pub suggestion: Option<String>,
 }
 
 impl ValidationError {
     pub fn new(message: String, suggestion: Option<String>) -> Self {
         Self {
             message,
             suggestion,
         }
     }
 }
 
 pub struct TechniqueValidator;
 
 impl TechniqueValidator {
     pub fn validate(
         technique_name: &str,
         with_dynamic_resolver: bool,
         requires_process_param: bool,
     ) -> Result<(), Vec<ValidationError>> {
         let mut errors = Vec::new();
 
         let meta = match get_technique_metadata(technique_name) {
             Some(m) => m,
             None => {
                 errors.push(ValidationError::new(
                     format!("Unknown technique: '{}'", technique_name),
                     Some("Use --help to see available techniques".to_string()),
                 ));
                 return Err(errors);
             }
         };
 
         if with_dynamic_resolver && !meta.supports_dynamic_resolver() {
             errors.push(ValidationError::new(
                 format!(
                     "Technique '{}' does not support dynamic function resolver",
                     technique_name
                 ),
                 Some(
                     "Remove --with-dynamic-function-resolver flag or choose a different technique"
                         .to_string(),
                 ),
             ));
         }
 
         if requires_process_param && !meta.requires_process() {
             errors.push(ValidationError::new(
                 format!(
                     "Technique '{}' is for local execution only and does not use the --process parameter",
                     technique_name
                 ),
                 Some("Remove --process flag or use a process injection technique (crt, crtx, process-hollowing, nt-create-thread-ex, thread-hijacking, early-bird)".to_string()),
             ));
         }
 
         if errors.is_empty() {
             Ok(())
         } else {
             Err(errors)
         }
     }
 
     pub fn display_technique_info(technique_name: &str) -> Option<String> {
         let meta = get_technique_metadata(technique_name)?;
         let mut output = String::new();
 
         output.push_str(&format!("Technique: {}\n", meta.name));
         output.push_str(&format!("Description: {}\n", meta.description));
         output.push_str(&format!(
             "Detection Difficulty: {}\n",
             meta.detection_difficulty.as_str()
         ));
         output.push_str("\nCapabilities:\n");
 
         for cap in &meta.capabilities {
             output.push_str(&format!("  - {}\n", cap.description()));
         }
 
         if meta.has_capability(Capability::RequiresAdmin) {
             output.push_str("\n[!] WARNING: This technique requires administrator privileges\n");
         }
 
         Some(output)
     }
 
     pub fn suggest_compatible_techniques(with_dynamic_resolver: bool) -> Vec<String> {
         let all_techniques = super::capabilities::list_all_techniques();
         all_techniques
             .into_iter()
             .filter(|meta| {
                 if with_dynamic_resolver {
                     meta.supports_dynamic_resolver()
                 } else {
                     true
                 }
             })
             .map(|meta| meta.name.to_string())
             .collect()
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_validate_crt_with_process() {
         let result = TechniqueValidator::validate("crt", false, true);
         assert!(result.is_ok());
     }
 
     #[test]
     fn test_validate_crt_without_process() {
         // CRT without process parameter should now pass since process param is auto-generated
         let result = TechniqueValidator::validate("crt", false, false);
         assert!(result.is_ok());
     }
 
     #[test]
     fn test_validate_create_fiber_without_process() {
         let result = TechniqueValidator::validate("create-fiber", false, false);
         assert!(result.is_ok());
     }
 
     #[test]
     fn test_validate_create_fiber_with_process() {
         let result = TechniqueValidator::validate("create-fiber", false, true);
         assert!(result.is_err());
         let errors = result.unwrap_err();
         assert_eq!(errors.len(), 1);
         assert!(errors[0].message.contains("local execution only"));
     }
 
     #[test]
     fn test_validate_unknown_technique() {
         let result = TechniqueValidator::validate("unknown-tech", false, false);
         assert!(result.is_err());
         let errors = result.unwrap_err();
         assert_eq!(errors.len(), 1);
         assert!(errors[0].message.contains("Unknown technique"));
     }
 
     #[test]
     fn test_validate_with_dynamic_resolver() {
         let result = TechniqueValidator::validate("crt", true, true);
         assert!(result.is_ok());
     }
 
     #[test]
     fn test_display_technique_info() {
         let info = TechniqueValidator::display_technique_info("crt");
         assert!(info.is_some());
         let info_str = info.unwrap();
         assert!(info_str.contains("crt"));
         assert!(info_str.contains("CreateRemoteThread"));
     }
 
     #[test]
     fn test_display_technique_info_fairy_law() {
         let info = TechniqueValidator::display_technique_info("fairy-law");
         assert!(info.is_some());
         let info_str = info.unwrap();
         assert!(info_str.contains("fairy-law"));
         assert!(info_str.contains("WARNING"));
         assert!(info_str.contains("administrator"));
     }
 
     #[test]
     fn test_display_technique_info_unknown() {
         let info = TechniqueValidator::display_technique_info("unknown");
         assert!(info.is_none());
     }
 
     #[test]
     fn test_suggest_compatible_techniques_all() {
         let techniques = TechniqueValidator::suggest_compatible_techniques(false);
         assert_eq!(techniques.len(), 17);
     }
 
     #[test]
     fn test_suggest_compatible_techniques_with_dynamic_resolver() {
         let techniques = TechniqueValidator::suggest_compatible_techniques(true);
         assert_eq!(techniques.len(), 17);
     }
 }

© 2024 - 2026 djnn, inc • generated with stagit