Skip to main content

threatflux_package_security/analyzers/
java.rs

1//! Java package analyzer
2
3use anyhow::{Context, Result, bail};
4use async_trait::async_trait;
5use serde::{Deserialize, Serialize};
6use std::collections::BTreeMap;
7use std::io::{Read, Seek, SeekFrom};
8use std::path::Path;
9use zip::ZipArchive;
10
11use crate::core::{
12    AnalysisResult, DependencyAnalysis, MaliciousPattern, PackageAnalyzer, PackageInfo,
13    PackageMetadata, RiskAssessment, RiskCalculator, SupplyChainSignal, Vulnerability,
14};
15
16/// Java package information
17#[derive(Debug, Clone, Serialize, Deserialize)]
18pub struct JavaPackage {
19    pub metadata: PackageMetadata,
20    pub archive_type: JavaArchiveType,
21    pub main_class: Option<String>,
22    pub manifest_attributes: BTreeMap<String, String>,
23    /// Whether the archive contains a JAR-style signature block filename.
24    /// This is a presence signal, not cryptographic verification.
25    pub has_signature_block_entry: bool,
26}
27
28#[derive(Debug, Clone, Serialize, Deserialize)]
29pub enum JavaArchiveType {
30    Jar,
31    War,
32    Ear,
33    Apk,
34    Aar,
35}
36
37impl PackageInfo for JavaPackage {
38    fn metadata(&self) -> &PackageMetadata {
39        &self.metadata
40    }
41
42    fn package_type(&self) -> &str {
43        "java"
44    }
45
46    fn custom_attributes(&self) -> BTreeMap<String, serde_json::Value> {
47        let mut attrs = BTreeMap::new();
48        attrs.insert(
49            "archive_type".to_string(),
50            serde_json::json!(self.archive_type),
51        );
52        attrs.insert("main_class".to_string(), serde_json::json!(self.main_class));
53        attrs.insert(
54            "has_signature_block_entry".to_string(),
55            serde_json::json!(self.has_signature_block_entry),
56        );
57        attrs
58    }
59}
60
61/// Java analysis result
62#[derive(Debug, Clone, Serialize, Deserialize)]
63pub struct JavaAnalysisResult {
64    pub package: JavaPackage,
65    pub risk_assessment: RiskAssessment,
66    pub dependency_analysis: DependencyAnalysis,
67    pub vulnerabilities: Vec<Vulnerability>,
68    pub malicious_patterns: Vec<MaliciousPattern>,
69    pub security_analysis: JavaSecurityAnalysis,
70    pub vulnerability_database: Option<crate::core::DatabaseMetadata>,
71}
72
73impl AnalysisResult for JavaAnalysisResult {
74    fn package_info(&self) -> &dyn PackageInfo {
75        &self.package
76    }
77
78    fn risk_assessment(&self) -> &RiskAssessment {
79        &self.risk_assessment
80    }
81
82    fn dependency_analysis(&self) -> &DependencyAnalysis {
83        &self.dependency_analysis
84    }
85
86    fn vulnerabilities(&self) -> &[Vulnerability] {
87        &self.vulnerabilities
88    }
89
90    fn malicious_patterns(&self) -> &[MaliciousPattern] {
91        &self.malicious_patterns
92    }
93
94    fn vulnerability_database_metadata(&self) -> Option<&crate::core::DatabaseMetadata> {
95        self.vulnerability_database.as_ref()
96    }
97
98    fn to_json(&self) -> Result<serde_json::Value> {
99        Ok(serde_json::to_value(self)?)
100    }
101}
102
103/// Java-specific security analysis
104#[derive(Debug, Clone, Serialize, Deserialize)]
105pub struct JavaSecurityAnalysis {
106    pub has_native_libraries: bool,
107}
108
109/// Java package analyzer
110pub struct JavaAnalyzer;
111
112impl JavaAnalyzer {
113    /// Create a new Java analyzer
114    pub fn new() -> Result<Self> {
115        Ok(Self)
116    }
117
118    /// Detect archive type from file extension
119    fn detect_archive_type(path: &Path) -> Option<JavaArchiveType> {
120        match path.extension().and_then(|e| e.to_str()) {
121            Some(ext) if ext.eq_ignore_ascii_case("jar") => Some(JavaArchiveType::Jar),
122            Some(ext) if ext.eq_ignore_ascii_case("war") => Some(JavaArchiveType::War),
123            Some(ext) if ext.eq_ignore_ascii_case("ear") => Some(JavaArchiveType::Ear),
124            Some(ext) if ext.eq_ignore_ascii_case("apk") => Some(JavaArchiveType::Apk),
125            Some(ext) if ext.eq_ignore_ascii_case("aar") => Some(JavaArchiveType::Aar),
126            _ => None,
127        }
128    }
129
130    /// Inspect a Java archive without extracting it.
131    fn inspect_archive(path: &Path) -> Result<(JavaPackage, JavaSecurityAnalysis)> {
132        let archive_type = Self::detect_archive_type(path)
133            .ok_or_else(|| anyhow::anyhow!("unsupported Java archive extension"))?;
134        let metadata = std::fs::symlink_metadata(path)
135            .with_context(|| format!("failed to inspect Java archive {path:?}"))?;
136        if metadata.file_type().is_symlink() {
137            bail!("refusing symlinked Java archive: {path:?}");
138        }
139        if !metadata.is_file() {
140            bail!("Java archive is not a regular file: {path:?}");
141        }
142        if metadata.len() > crate::limits::MAX_ARCHIVE_BYTES {
143            bail!(
144                "Java archive exceeds the {}-byte compressed-size limit",
145                crate::limits::MAX_ARCHIVE_BYTES
146            );
147        }
148
149        let file = std::fs::File::open(path)
150            .with_context(|| format!("failed to open Java archive {path:?}"))?;
151        let opened_metadata = file.metadata()?;
152        if !same_file_identity(&metadata, &opened_metadata) {
153            bail!("Java archive changed while it was being opened");
154        }
155        if opened_metadata.len() > crate::limits::MAX_ARCHIVE_BYTES
156            || opened_metadata.len() != metadata.len()
157        {
158            bail!("Java archive changed size while it was being opened");
159        }
160        let mut file = file;
161        preflight_zip_directory(&mut file, opened_metadata.len())?;
162        let final_identity_handle = file.try_clone()?;
163        let mut archive = ZipArchive::new(file).context("invalid Java ZIP archive")?;
164        if archive.len() > crate::limits::MAX_ARCHIVE_ENTRIES {
165            bail!(
166                "Java archive exceeds the {}-entry limit",
167                crate::limits::MAX_ARCHIVE_ENTRIES
168            );
169        }
170
171        let mut manifest_index = None;
172        let mut has_signature_block_entry = false;
173        let mut total_uncompressed = 0u64;
174        let mut security_analysis = JavaSecurityAnalysis {
175            has_native_libraries: false,
176        };
177
178        for i in 0..archive.len() {
179            let file = archive.by_index(i)?;
180            let name = file
181                .name()
182                .context("Java archive contains an invalid entry name")?;
183            if name.len() > crate::limits::MAX_ARCHIVE_ENTRY_NAME_BYTES {
184                bail!("Java archive contains an overlong entry name");
185            }
186            if is_unsafe_archive_entry_name(name.as_ref()) || file.enclosed_name().is_none() {
187                bail!("Java archive contains an unsafe entry path");
188            }
189            if file.is_symlink() {
190                bail!("Java archive contains a symbolic-link entry");
191            }
192            if file.encrypted() {
193                bail!("encrypted Java archive entries are unsupported");
194            }
195            if file.size() > crate::limits::MAX_ARCHIVE_ENTRY_BYTES {
196                bail!("Java archive entry exceeds the configured uncompressed-size limit");
197            }
198            total_uncompressed = total_uncompressed
199                .checked_add(file.size())
200                .ok_or_else(|| anyhow::anyhow!("Java archive size accounting overflow"))?;
201            if total_uncompressed > crate::limits::MAX_ARCHIVE_TOTAL_UNCOMPRESSED_BYTES {
202                bail!("Java archive exceeds the aggregate uncompressed-size limit");
203            }
204
205            if name == "META-INF/MANIFEST.MF" {
206                if manifest_index.replace(i).is_some() {
207                    bail!("Java archive contains duplicate manifests");
208                }
209                if file.size() > crate::limits::MAX_MANIFEST_BYTES {
210                    bail!("Java manifest exceeds the configured size limit");
211                }
212            }
213            let lowercase_name = name.to_ascii_lowercase();
214            if let Some(signature_name) = lowercase_name.strip_prefix("meta-inf/")
215                && !signature_name.contains('/')
216                && signature_name
217                    .rsplit_once('.')
218                    .is_some_and(|(base, extension)| {
219                        !base.is_empty() && matches!(extension, "rsa" | "dsa" | "ec")
220                    })
221            {
222                has_signature_block_entry = true;
223            }
224            if !file.is_dir()
225                && (lowercase_name.ends_with(".so")
226                    || lowercase_name.ends_with(".dll")
227                    || lowercase_name.ends_with(".dylib"))
228            {
229                security_analysis.has_native_libraries = true;
230            }
231        }
232
233        let manifest_attributes = if let Some(index) = manifest_index {
234            let mut manifest = archive.by_index(index)?;
235            let mut bytes = Vec::with_capacity(usize::try_from(manifest.size()).unwrap_or(0));
236            manifest
237                .by_ref()
238                .take(crate::limits::MAX_MANIFEST_BYTES.saturating_add(1))
239                .read_to_end(&mut bytes)?;
240            if u64::try_from(bytes.len()).unwrap_or(u64::MAX) > crate::limits::MAX_MANIFEST_BYTES {
241                bail!("Java manifest exceeds the configured size limit");
242            }
243            let content = String::from_utf8(bytes).context("Java manifest is not valid UTF-8")?;
244            parse_manifest(&content)?
245        } else {
246            BTreeMap::new()
247        };
248        let final_metadata = final_identity_handle.metadata()?;
249        if !same_file_identity(&opened_metadata, &final_metadata)
250            || final_metadata.len() != opened_metadata.len()
251        {
252            bail!("Java archive changed during analysis");
253        }
254
255        let main_class = manifest_attributes.get("main-class").cloned();
256
257        // Extract metadata
258        let metadata = PackageMetadata {
259            name: path
260                .file_stem()
261                .and_then(|s| s.to_str())
262                .unwrap_or("unknown")
263                .to_string(),
264            version: manifest_attributes
265                .get("implementation-version")
266                .or_else(|| manifest_attributes.get("bundle-version"))
267                .cloned()
268                .unwrap_or_else(|| "unknown".to_string()),
269            description: manifest_attributes
270                .get("bundle-description")
271                .or_else(|| manifest_attributes.get("implementation-title"))
272                .cloned(),
273            author: manifest_attributes
274                .get("implementation-vendor")
275                .or_else(|| manifest_attributes.get("bundle-vendor"))
276                .cloned(),
277            license: manifest_attributes.get("bundle-license").cloned(),
278            homepage: manifest_attributes.get("bundle-docurl").cloned(),
279            repository: None,
280            keywords: vec![],
281            publish_date: None,
282        };
283        validate_java_metadata(&metadata)?;
284
285        Ok((
286            JavaPackage {
287                metadata,
288                archive_type,
289                main_class,
290                manifest_attributes,
291                has_signature_block_entry,
292            },
293            security_analysis,
294        ))
295    }
296}
297
298#[async_trait]
299impl PackageAnalyzer for JavaAnalyzer {
300    type Package = JavaPackage;
301    type Analysis = JavaAnalysisResult;
302
303    async fn analyze(&self, path: &Path) -> Result<Self::Analysis> {
304        crate::utils::require_tokio_runtime()?;
305        let archive_path = path.to_path_buf();
306        let (package, security_analysis) =
307            tokio::task::spawn_blocking(move || Self::inspect_archive(&archive_path))
308                .await
309                .context("Java archive inspection task failed")??;
310        let dependency_analysis = DependencyAnalysis::default();
311
312        // Manifest values are metadata, not executable code. Bytecode inspection
313        // is outside this analyzer's current capability boundary.
314        let malicious_patterns = vec![];
315
316        let mut vulnerabilities = vec![];
317        for dep in &dependency_analysis.dependency_tree {
318            vulnerabilities.extend(dep.vulnerabilities.clone());
319        }
320
321        // Calculate risk assessment
322        let risk_calculator = RiskCalculator::new();
323        let supply_chain_signal = if security_analysis.has_native_libraries {
324            Some(SupplyChainSignal {
325                score: 30.0,
326                description: "Native library entries detected".to_string(),
327                evidence: vec!["Archive contains .so, .dll, or .dylib entries".to_string()],
328                mitigation: Some(
329                    "Review native binaries for the target platforms before deployment".to_string(),
330                ),
331            })
332        } else {
333            None
334        };
335
336        let risk_score = risk_calculator.calculate(
337            &vulnerabilities,
338            &malicious_patterns,
339            // Archive filenames do not establish authoritative Maven coordinates.
340            false,
341            supply_chain_signal,
342            50.0, // Default maintenance score
343        )?;
344
345        let risk_assessment = RiskAssessment {
346            risk_score: risk_score.clone(),
347            summary: format!(
348                "Java archive '{}' has {} risk",
349                package.metadata.name.escape_default(),
350                risk_score.risk_level
351            ),
352            detailed_findings: vec![],
353            recommendations: vec![],
354            security_posture: crate::core::SecurityPosture {
355                vulnerability_matches_present: !vulnerabilities.is_empty(),
356                high_severity_pattern_matches_present: false,
357                supply_chain_risks: security_analysis.has_native_libraries,
358                actively_maintained: None,
359                // Signature blocks are only detected, never cryptographically
360                // verified or tied to a trusted identity.
361                trusted_publisher: None,
362                security_practices_score: None,
363            },
364        };
365
366        Ok(JavaAnalysisResult {
367            package,
368            risk_assessment,
369            dependency_analysis,
370            vulnerabilities,
371            malicious_patterns,
372            security_analysis,
373            vulnerability_database: None,
374        })
375    }
376
377    fn can_analyze(&self, path: &Path) -> bool {
378        std::fs::symlink_metadata(path).is_ok_and(|metadata| {
379            metadata.is_file()
380                && !metadata.file_type().is_symlink()
381                && path
382                    .extension()
383                    .and_then(|ext| ext.to_str())
384                    .map(|ext| {
385                        ["jar", "war", "ear", "apk", "aar"]
386                            .iter()
387                            .any(|supported| ext.eq_ignore_ascii_case(supported))
388                    })
389                    .unwrap_or(false)
390        })
391    }
392
393    fn name(&self) -> &str {
394        "Java Package Analyzer"
395    }
396
397    fn supported_extensions(&self) -> Vec<&str> {
398        vec!["jar", "war", "ear", "apk", "aar"]
399    }
400}
401
402fn parse_manifest(content: &str) -> Result<BTreeMap<String, String>> {
403    let mut attributes: BTreeMap<String, String> = BTreeMap::new();
404    let mut current_key: Option<String> = None;
405
406    let normalized = content.replace("\r\n", "\n").replace('\r', "\n");
407    for (line_number, line) in normalized.lines().enumerate() {
408        if line.is_empty() {
409            break;
410        }
411        if line.len() > 72 || line.contains('\0') {
412            bail!("Java manifest contains an invalid physical line");
413        }
414        if let Some(continuation) = line.strip_prefix(' ') {
415            let key = current_key
416                .as_ref()
417                .ok_or_else(|| anyhow::anyhow!("Java manifest starts with a continuation line"))?;
418            let value = attributes
419                .get_mut(key)
420                .ok_or_else(|| anyhow::anyhow!("invalid Java manifest continuation"))?;
421            value.push_str(continuation);
422            if value.len() > crate::limits::MAX_METADATA_FIELD_BYTES {
423                bail!("Java manifest attribute exceeds the configured size limit");
424            }
425            continue;
426        }
427
428        let (key, value) = line
429            .split_once(": ")
430            .ok_or_else(|| anyhow::anyhow!("invalid Java manifest attribute"))?;
431        if line_number == 0 && (key != "Manifest-Version" || !valid_manifest_version(value)) {
432            bail!("Java manifest has no valid leading Manifest-Version attribute");
433        }
434        if key.is_empty()
435            || key.len() > 70
436            || !key
437                .bytes()
438                .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_'))
439        {
440            bail!("invalid Java manifest attribute name");
441        }
442        if value.len() > crate::limits::MAX_METADATA_FIELD_BYTES {
443            bail!("Java manifest attribute exceeds the configured size limit");
444        }
445        if attributes.len() == crate::limits::MAX_MANIFEST_ATTRIBUTES {
446            bail!("Java manifest exceeds the configured attribute-count limit");
447        }
448        let key = key.to_ascii_lowercase();
449        if attributes.insert(key.clone(), value.to_string()).is_some() {
450            bail!("Java manifest contains a duplicate main attribute");
451        }
452        current_key = Some(key);
453    }
454
455    if !attributes.contains_key("manifest-version") {
456        bail!("Java manifest has no valid leading Manifest-Version attribute");
457    }
458    Ok(attributes)
459}
460
461fn valid_manifest_version(value: &str) -> bool {
462    value.split('.').all(|component| {
463        !component.is_empty() && component.bytes().all(|byte| byte.is_ascii_digit())
464    })
465}
466
467fn validate_java_metadata(metadata: &PackageMetadata) -> Result<()> {
468    for value in [
469        Some(metadata.name.as_str()),
470        Some(metadata.version.as_str()),
471        metadata.description.as_deref(),
472        metadata.author.as_deref(),
473        metadata.license.as_deref(),
474        metadata.homepage.as_deref(),
475    ]
476    .into_iter()
477    .flatten()
478    {
479        if value.len() > crate::limits::MAX_METADATA_FIELD_BYTES {
480            bail!("Java package metadata exceeds the configured field limit");
481        }
482    }
483    Ok(())
484}
485
486fn is_unsafe_archive_entry_name(name: &str) -> bool {
487    name.is_empty()
488        || name.starts_with('/')
489        || name.bytes().any(|byte| matches!(byte, b'\\' | b'\0'))
490        || (name.len() >= 2
491            && name.as_bytes()[0].is_ascii_alphabetic()
492            && name.as_bytes()[1] == b':')
493        || name
494            .split('/')
495            .any(|component| component == ".." || component == ".")
496        || name.contains("//")
497}
498
499fn preflight_zip_directory(file: &mut std::fs::File, file_len: u64) -> Result<()> {
500    const EOCD_MIN_BYTES: u64 = 22;
501    const MAX_COMMENT_BYTES: u64 = u16::MAX as u64;
502    if file_len < EOCD_MIN_BYTES {
503        bail!("Java archive is too short to contain a ZIP directory");
504    }
505    let tail_len = file_len.min(EOCD_MIN_BYTES + MAX_COMMENT_BYTES);
506    file.seek(SeekFrom::End(-i64::try_from(tail_len)?))?;
507    let mut tail = vec![0u8; usize::try_from(tail_len)?];
508    file.read_exact(&mut tail)?;
509
510    let eocd_offset = (0..=tail.len() - EOCD_MIN_BYTES as usize)
511        .rev()
512        .find(|offset| {
513            tail[*offset..].starts_with(b"PK\x05\x06")
514                && read_u16(&tail[*offset + 20..*offset + 22]).is_some_and(|comment_len| {
515                    *offset + EOCD_MIN_BYTES as usize + usize::from(comment_len) == tail.len()
516                })
517        })
518        .ok_or_else(|| anyhow::anyhow!("Java archive has no valid ZIP end record"))?;
519    let eocd = &tail[eocd_offset..eocd_offset + EOCD_MIN_BYTES as usize];
520    let disk = read_u16(&eocd[4..6]).unwrap_or(u16::MAX);
521    let directory_disk = read_u16(&eocd[6..8]).unwrap_or(u16::MAX);
522    let entries_on_disk = read_u16(&eocd[8..10]).unwrap_or(u16::MAX);
523    let entries = read_u16(&eocd[10..12]).unwrap_or(u16::MAX);
524    let directory_size = read_u32(&eocd[12..16]).unwrap_or(u32::MAX);
525    let directory_offset = read_u32(&eocd[16..20]).unwrap_or(u32::MAX);
526
527    if disk != 0 || directory_disk != 0 || entries_on_disk != entries {
528        bail!("multi-disk Java ZIP archives are unsupported");
529    }
530    if entries == u16::MAX || directory_size == u32::MAX || directory_offset == u32::MAX {
531        bail!("ZIP64 Java archives are unsupported by the bounded preflight");
532    }
533    if usize::from(entries) > crate::limits::MAX_ARCHIVE_ENTRIES {
534        bail!("Java archive exceeds the configured entry limit");
535    }
536    if u64::from(directory_size) > crate::limits::MAX_ARCHIVE_DIRECTORY_BYTES {
537        bail!("Java ZIP central directory exceeds the configured size limit");
538    }
539    let directory_end = u64::from(directory_offset)
540        .checked_add(u64::from(directory_size))
541        .ok_or_else(|| anyhow::anyhow!("Java ZIP directory size overflow"))?;
542    if directory_end > file_len {
543        bail!("Java ZIP central directory lies outside the archive");
544    }
545    file.seek(SeekFrom::Start(0))?;
546    Ok(())
547}
548
549fn read_u16(bytes: &[u8]) -> Option<u16> {
550    bytes.try_into().ok().map(u16::from_le_bytes)
551}
552
553fn read_u32(bytes: &[u8]) -> Option<u32> {
554    bytes.try_into().ok().map(u32::from_le_bytes)
555}
556
557#[cfg(unix)]
558fn same_file_identity(before: &std::fs::Metadata, opened: &std::fs::Metadata) -> bool {
559    use std::os::unix::fs::MetadataExt;
560    before.dev() == opened.dev() && before.ino() == opened.ino()
561}
562
563#[cfg(not(unix))]
564fn same_file_identity(before: &std::fs::Metadata, opened: &std::fs::Metadata) -> bool {
565    before.file_type() == opened.file_type() && before.len() == opened.len()
566}
567
568#[cfg(test)]
569mod tests {
570    use super::*;
571    use std::io::Write;
572    use zip::write::SimpleFileOptions;
573
574    fn write_zip(path: &Path, entries: Vec<(&str, Vec<u8>)>) {
575        let file = std::fs::File::create(path).expect("create test archive");
576        let mut writer = zip::ZipWriter::new(file);
577        for (name, content) in entries {
578            writer
579                .start_file(name, SimpleFileOptions::default())
580                .expect("start archive entry");
581            writer.write_all(&content).expect("write archive entry");
582        }
583        writer.finish().expect("finish test archive");
584    }
585
586    #[test]
587    fn valid_archive_parses_case_insensitive_manifest_and_continuation() {
588        let directory = tempfile::tempdir().expect("temporary directory");
589        let path = directory.path().join("sample.JAR");
590        write_zip(
591            &path,
592            vec![
593                (
594                    "META-INF/MANIFEST.MF",
595                    b"Manifest-Version: 1.0\rimplementation-version: 1.2.\r 3\rMain-Class: example.Main\rCustom_Attr: accepted\r\rignored: value\r".to_vec(),
596                ),
597                ("META-INF/SIGNATURE.RSA", vec![1]),
598                ("lib/native.SO", vec![1]),
599            ],
600        );
601
602        let (package, security) = JavaAnalyzer::inspect_archive(&path).expect("inspect archive");
603        assert_eq!(package.metadata.version, "1.2.3");
604        assert_eq!(package.main_class.as_deref(), Some("example.Main"));
605        assert_eq!(
606            package
607                .manifest_attributes
608                .get("custom_attr")
609                .map(String::as_str),
610            Some("accepted")
611        );
612        assert!(package.has_signature_block_entry);
613        assert!(security.has_native_libraries);
614        assert!(!package.manifest_attributes.contains_key("ignored"));
615    }
616
617    #[tokio::test]
618    async fn native_library_risk_evidence_does_not_claim_install_scripts() {
619        let directory = tempfile::tempdir().expect("temporary directory");
620        let path = directory.path().join("native.jar");
621        write_zip(&path, vec![("lib/native.so", vec![1])]);
622
623        let result = JavaAnalyzer::new()
624            .expect("construct analyzer")
625            .analyze(&path)
626            .await
627            .expect("analyze archive");
628        let factor = result
629            .risk_assessment
630            .risk_score
631            .factors
632            .iter()
633            .find(|factor| factor.category == crate::core::risk::RiskCategory::SupplyChain)
634            .expect("supply-chain factor");
635        assert!(factor.evidence.iter().any(|value| value.contains(".so")));
636        assert!(
637            factor
638                .evidence
639                .iter()
640                .all(|value| !value.contains("Installation scripts"))
641        );
642    }
643
644    #[test]
645    fn nested_signature_like_file_is_not_a_signature_block_entry() {
646        let directory = tempfile::tempdir().expect("temporary directory");
647        let path = directory.path().join("nested.jar");
648        write_zip(&path, vec![("META-INF/docs/example.RSA", vec![1])]);
649        let (package, _) = JavaAnalyzer::inspect_archive(&path).expect("inspect archive");
650        assert!(!package.has_signature_block_entry);
651    }
652
653    #[test]
654    fn rejects_unsafe_paths_and_oversized_manifests() {
655        let directory = tempfile::tempdir().expect("temporary directory");
656        for (index, entry) in [
657            "../../outside",
658            "/etc/passwd",
659            r"C:\temp\payload.dll",
660            r"\\server\share\payload.dll",
661        ]
662        .into_iter()
663        .enumerate()
664        {
665            let unsafe_path = directory.path().join(format!("unsafe-{index}.jar"));
666            write_zip(&unsafe_path, vec![(entry, vec![1])]);
667            assert!(
668                JavaAnalyzer::inspect_archive(&unsafe_path)
669                    .expect_err("unsafe path must fail")
670                    .to_string()
671                    .contains("unsafe entry path"),
672                "accepted unsafe entry {entry:?}"
673            );
674        }
675
676        let oversized_path = directory.path().join("oversized.jar");
677        write_zip(
678            &oversized_path,
679            vec![(
680                "META-INF/MANIFEST.MF",
681                vec![b'a'; crate::limits::MAX_MANIFEST_BYTES as usize + 1],
682            )],
683        );
684        assert!(
685            JavaAnalyzer::inspect_archive(&oversized_path)
686                .expect_err("oversized manifest must fail")
687                .to_string()
688                .contains("manifest")
689        );
690    }
691
692    #[test]
693    fn preflight_rejects_entry_count_before_zip_parser_allocation() {
694        let directory = tempfile::tempdir().expect("temporary directory");
695        let path = directory.path().join("count.jar");
696        let entries = u16::try_from(crate::limits::MAX_ARCHIVE_ENTRIES + 1)
697            .expect("test limit fits ZIP32 count");
698        let mut eocd = Vec::from(*b"PK\x05\x06");
699        eocd.extend_from_slice(&0u16.to_le_bytes());
700        eocd.extend_from_slice(&0u16.to_le_bytes());
701        eocd.extend_from_slice(&entries.to_le_bytes());
702        eocd.extend_from_slice(&entries.to_le_bytes());
703        eocd.extend_from_slice(&0u32.to_le_bytes());
704        eocd.extend_from_slice(&0u32.to_le_bytes());
705        eocd.extend_from_slice(&0u16.to_le_bytes());
706        std::fs::write(&path, eocd).expect("write synthetic EOCD");
707
708        assert!(
709            JavaAnalyzer::inspect_archive(&path)
710                .expect_err("entry count must fail")
711                .to_string()
712                .contains("entry limit")
713        );
714    }
715
716    #[test]
717    fn manifest_keys_are_case_insensitive_and_duplicates_fail() {
718        let error =
719            parse_manifest("Manifest-Version: 1.0\nMain-Class: first\nmain-class: second\n")
720                .expect_err("case-insensitive duplicate must fail");
721        assert!(error.to_string().contains("duplicate"));
722    }
723
724    #[test]
725    fn inspect_rejects_unsupported_extension_even_for_valid_zip() {
726        let directory = tempfile::tempdir().expect("temporary directory");
727        let path = directory.path().join("sample.zip");
728        write_zip(&path, vec![("a", vec![1])]);
729        assert!(
730            JavaAnalyzer::inspect_archive(&path)
731                .expect_err("extension must be enforced")
732                .to_string()
733                .contains("unsupported")
734        );
735    }
736}