package parser import ( "archive/zip" "bytes" "hash/crc32" "os" "path/filepath" "strings" "testing" "time" ) type zipTestFile struct { name string content string method uint16 raw bool // sizes and CRC in the local header, no data descriptor } // buildTestZip returns the archive bytes and the offset where the central // directory starts. func buildTestZip(t *testing.T, modTime time.Time, files []zipTestFile) ([]byte, int) { t.Helper() var buf bytes.Buffer zw := zip.NewWriter(&buf) for _, f := range files { hdr := &zip.FileHeader{Name: f.name, Method: f.method, Modified: modTime} if f.raw { // CreateRaw writes the header as given: only the DOS time is set. hdr = &zip.FileHeader{Name: f.name, Method: zip.Store} hdr.SetModTime(modTime) hdr.CRC32 = crc32.ChecksumIEEE([]byte(f.content)) hdr.CompressedSize64 = uint64(len(f.content)) hdr.UncompressedSize64 = uint64(len(f.content)) w, err := zw.CreateRaw(hdr) if err != nil { t.Fatalf("create raw %s: %v", f.name, err) } if _, err := w.Write([]byte(f.content)); err != nil { t.Fatalf("write %s: %v", f.name, err) } continue } w, err := zw.CreateHeader(hdr) if err != nil { t.Fatalf("create %s: %v", f.name, err) } if _, err := w.Write([]byte(f.content)); err != nil { t.Fatalf("write %s: %v", f.name, err) } } if err := zw.Close(); err != nil { t.Fatalf("close zip: %v", err) } centralDirOffset := bytes.Index(buf.Bytes(), []byte("PK\x01\x02")) if centralDirOffset < 0 { t.Fatal("central directory not found") } return buf.Bytes(), centralDirOffset } func recoverTestFiles() []zipTestFile { return []zipTestFile{ {name: "README.md", content: strings.Repeat("streamed deflate member\n", 200), method: zip.Deflate}, {name: "export/", method: zip.Store, raw: true}, // Contains a data descriptor signature that must not end the member. {name: "export/stored.bin", content: "head PK\x07\x08 middle PK\x03\x04 tail", method: zip.Store}, {name: "export/empty.txt", content: "", method: zip.Deflate}, {name: "export/raw.txt", content: "sizes in the local header", raw: true}, {name: "tasks/last.log", content: strings.Repeat("last member ", 50), method: zip.Deflate}, } } func assertRecoveredFiles(t *testing.T, got []ExtractedFile, want []zipTestFile, modTime time.Time) { t.Helper() var wantFiles []zipTestFile for _, f := range want { if !strings.HasSuffix(f.name, "/") { wantFiles = append(wantFiles, f) } } if len(got) != len(wantFiles) { t.Fatalf("expected %d files, got %d", len(wantFiles), len(got)) } for i, f := range wantFiles { if got[i].Path != f.name { t.Fatalf("file %d: expected path %q, got %q", i, f.name, got[i].Path) } if string(got[i].Content) != f.content { t.Fatalf("file %s: content mismatch", f.name) } if !got[i].ModTime.Equal(modTime) { t.Fatalf("file %s: expected mtime %v, got %v", f.name, modTime, got[i].ModTime) } } } func TestExtractArchiveFromReaderZIP_RecoversTruncatedCentralDirectory(t *testing.T) { modTime := time.Date(2026, 10, 2, 16, 4, 12, 0, time.UTC) want := recoverTestFiles() data, centralDirOffset := buildTestZip(t, modTime, want) // Sanity: the intact archive goes through archive/zip. files, err := ExtractArchiveFromReader(bytes.NewReader(data), "blackbox.zip") if err != nil { t.Fatalf("extract intact zip: %v", err) } assertRecoveredFiles(t, files, want, modTime) cuts := map[string]int{ "mid central directory": centralDirOffset + (len(data)-centralDirOffset)/2, "central directory missing": centralDirOffset, "end of central directory lost": len(data) - 10, } for name, cut := range cuts { t.Run(name, func(t *testing.T) { files, err := ExtractArchiveFromReader(bytes.NewReader(data[:cut]), "blackbox.zip") if err != nil { t.Fatalf("extract truncated zip: %v", err) } assertRecoveredFiles(t, files, want, modTime) }) } } func TestExtractArchiveZIP_RecoversTruncatedCentralDirectoryFromPath(t *testing.T) { modTime := time.Date(2026, 10, 2, 16, 4, 12, 0, time.UTC) want := recoverTestFiles() data, centralDirOffset := buildTestZip(t, modTime, want) path := filepath.Join(t.TempDir(), "blackbox.zip") if err := os.WriteFile(path, data[:centralDirOffset+20], 0o600); err != nil { t.Fatalf("write zip: %v", err) } files, err := ExtractArchive(path) if err != nil { t.Fatalf("extract truncated zip: %v", err) } assertRecoveredFiles(t, files, want, modTime) } func TestExtractArchiveFromReaderZIP_TruncatedMemberKeepsEarlierEntries(t *testing.T) { modTime := time.Date(2026, 10, 2, 16, 4, 12, 0, time.UTC) want := recoverTestFiles() data, centralDirOffset := buildTestZip(t, modTime, want) // Cut inside the last member's compressed data. files, err := ExtractArchiveFromReader(bytes.NewReader(data[:centralDirOffset-20]), "blackbox.zip") if err != nil { t.Fatalf("extract truncated zip: %v", err) } assertRecoveredFiles(t, files, want[:len(want)-1], modTime) } func TestExtractArchiveFromReaderZIP_CorruptMemberStopsRecovery(t *testing.T) { modTime := time.Date(2026, 10, 2, 16, 4, 12, 0, time.UTC) want := recoverTestFiles() data, centralDirOffset := buildTestZip(t, modTime, want) damaged := append([]byte(nil), data[:centralDirOffset]...) at := bytes.Index(damaged, []byte("sizes in the local header")) if at < 0 { t.Fatal("raw member content not found") } damaged[at] ^= 0xff files, err := ExtractArchiveFromReader(bytes.NewReader(damaged), "blackbox.zip") if err != nil { t.Fatalf("extract damaged zip: %v", err) } // Everything before export/raw.txt; the CRC mismatch ends recovery. assertRecoveredFiles(t, files, want[:4], modTime) } func TestExtractArchiveFromReaderZIP_NotAZipStillFails(t *testing.T) { for name, data := range map[string][]byte{ "garbage": []byte("this is not a zip archive at all"), "empty": {}, "truncated first entry": []byte("PK\x03\x04\x14\x00\x08\x00\x08\x00"), } { t.Run(name, func(t *testing.T) { _, err := ExtractArchiveFromReader(bytes.NewReader(data), "blackbox.zip") if err == nil || !strings.Contains(err.Error(), "open zip") { t.Fatalf("expected open zip error, got %v", err) } }) } }