threatflux_package_security/
lib.rs1pub mod analyzers;
7pub mod core;
8pub mod limits;
9pub mod utils;
10pub mod vulnerability_db;
11
12pub use core::{
13 AnalysisResult, MaliciousPattern, PackageAnalyzer, PackageInfo, RiskLevel, RiskScore,
14 TyposquattingRisk, Vulnerability, VulnerabilitySeverity,
15};
16
17pub use analyzers::{java::JavaAnalyzer, npm::NpmAnalyzer, python::PythonAnalyzer};
18
19pub use core::AdvisoryCatalog;
20pub use vulnerability_db::VulnerabilityDatabase;
21
22use anyhow::Result;
23use std::path::Path;
24
25pub struct PackageSecurityAnalyzer {
27 npm_analyzer: NpmAnalyzer,
28 python_analyzer: PythonAnalyzer,
29 java_analyzer: JavaAnalyzer,
30}
31
32impl PackageSecurityAnalyzer {
33 pub fn new() -> Result<Self> {
35 Ok(Self {
36 npm_analyzer: NpmAnalyzer::new()?,
37 python_analyzer: PythonAnalyzer::new()?,
38 java_analyzer: JavaAnalyzer::new()?,
39 })
40 }
41
42 pub fn from_analyzers(
44 npm_analyzer: NpmAnalyzer,
45 python_analyzer: PythonAnalyzer,
46 java_analyzer: JavaAnalyzer,
47 ) -> Self {
48 Self {
49 npm_analyzer,
50 python_analyzer,
51 java_analyzer,
52 }
53 }
54
55 pub fn with_vulnerability_databases(
58 npm_database: Box<dyn VulnerabilityDatabase>,
59 python_database: Box<dyn VulnerabilityDatabase>,
60 ) -> Result<Self> {
61 Ok(Self {
62 npm_analyzer: NpmAnalyzer::with_database(npm_database)?,
63 python_analyzer: PythonAnalyzer::with_database(python_database)?,
64 java_analyzer: JavaAnalyzer::new()?,
65 })
66 }
67
68 pub async fn analyze(&self, path: impl AsRef<Path>) -> Result<Box<dyn AnalysisResult>> {
73 crate::utils::require_tokio_runtime()?;
74 let path = path.as_ref();
75
76 let npm = self.is_npm_package(path);
77 let python = self.is_python_package(path);
78 let java = self.is_java_package(path);
79 match (npm, python, java) {
80 (true, false, false) => Ok(Box::new(self.npm_analyzer.analyze(path).await?)),
81 (false, true, false) => Ok(Box::new(self.python_analyzer.analyze(path).await?)),
82 (false, false, true) => Ok(Box::new(self.java_analyzer.analyze(path).await?)),
83 (false, false, false) => anyhow::bail!("Unknown package type for path: {path:?}"),
84 _ => anyhow::bail!(
85 "Ambiguous package input at {path:?}; choose an ecosystem analyzer explicitly"
86 ),
87 }
88 }
89
90 fn is_npm_package(&self, path: &Path) -> bool {
92 crate::utils::input::has_regular_project_file(path, Path::new("package.json"))
93 }
94
95 fn is_python_package(&self, path: &Path) -> bool {
97 ["pyproject.toml", "setup.cfg", "setup.py"]
98 .iter()
99 .any(|file| crate::utils::input::has_regular_project_file(path, Path::new(file)))
100 }
101
102 fn is_java_package(&self, path: &Path) -> bool {
104 if let Some(ext) = path.extension() {
105 matches!(
106 ext.to_str().map(str::to_ascii_lowercase).as_deref(),
107 Some("jar") | Some("war") | Some("ear") | Some("apk") | Some("aar")
108 )
109 } else {
110 false
111 }
112 }
113}
114
115#[cfg(test)]
116mod tests {
117 use super::*;
118
119 #[test]
120 fn test_package_detection() {
121 let analyzer = PackageSecurityAnalyzer::new().expect("construct analyzer");
122 let npm = tempfile::tempdir().expect("temporary npm project");
123 std::fs::write(npm.path().join("package.json"), "{}").expect("write package.json");
124 let python = tempfile::tempdir().expect("temporary Python project");
125 std::fs::write(python.path().join("pyproject.toml"), "").expect("write pyproject");
126
127 assert!(analyzer.is_npm_package(npm.path()));
128 assert!(analyzer.is_python_package(python.path()));
129 assert!(!analyzer.is_npm_package(Path::new("package.tgz")));
130 assert!(!analyzer.is_python_package(Path::new("package.whl")));
131 assert!(analyzer.is_java_package(Path::new("app.JAR")));
132 }
133}