1use 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#[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 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#[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#[derive(Debug, Clone, Serialize, Deserialize)]
105pub struct JavaSecurityAnalysis {
106 pub has_native_libraries: bool,
107}
108
109pub struct JavaAnalyzer;
111
112impl JavaAnalyzer {
113 pub fn new() -> Result<Self> {
115 Ok(Self)
116 }
117
118 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 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 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 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 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 false,
341 supply_chain_signal,
342 50.0, )?;
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 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}