Skip to main content

threatflux_package_security/
lib.rs

1//! ThreatFlux Package Security Library
2//!
3//! Bounded metadata inspection and review signals for npm and Python project
4//! directories plus ZIP-compatible Java package archives.
5
6pub 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
25/// Main entry point for package security analysis
26pub struct PackageSecurityAnalyzer {
27    npm_analyzer: NpmAnalyzer,
28    python_analyzer: PythonAnalyzer,
29    java_analyzer: JavaAnalyzer,
30}
31
32impl PackageSecurityAnalyzer {
33    /// Create a new package security analyzer with default settings
34    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    /// Create a unified analyzer from application-configured ecosystem analyzers.
43    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    /// Create a unified analyzer with application-provided npm and Python
56    /// vulnerability databases.
57    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    /// Analyze a package file or directory.
69    ///
70    /// Call this from an active Tokio runtime. If the returned future is
71    /// polled without one, analysis returns an error.
72    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    /// Check if path is an npm package
91    fn is_npm_package(&self, path: &Path) -> bool {
92        crate::utils::input::has_regular_project_file(path, Path::new("package.json"))
93    }
94
95    /// Check if path is a Python package
96    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    /// Check if path is a Java package
103    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}