package rar5 import ( "bytes" "errors" "fmt" "io" "os" "path/filepath" "testing" "time" ) // dumpArchive writes a generated archive to $RAR5_TEST_DUMP_DIR so it can be // checked against the reference implementation (`unrar t -mt1 `). func dumpArchive(t *testing.T, archive []byte) { t.Helper() dir := os.Getenv("RAR5_TEST_DUMP_DIR") if dir == "" { return } name := filepath.Join(dir, filepath.Base(t.Name())+".rar") if err := os.WriteFile(name, archive, 0o600); err != nil { t.Fatalf("dump archive: %v", err) } } // testText builds deterministic log-like text: mostly short repetitions, plus // occasional copies of data from far back so matches use long offsets. func testText(size int) []byte { words := []string{"error", "link", "width", "speed", "0000:1a:00.0", "DIMM_P0_A0", "Mellanox", "NVMe", "temperature", "serial"} seed := uint32(42) next := func(n int) int { seed = seed*1664525 + 1013904223 return int(seed>>8) % n } var out bytes.Buffer for out.Len() < size { switch { case out.Len() > 200_000 && next(40) == 0: from := out.Len() - 100_000 - next(90_000) out.Write(bytes.Clone(out.Bytes()[from : from+200+next(400)])) case next(6) == 0: fmt.Fprintf(&out, "%08x\n", seed) default: out.WriteString(words[next(len(words))]) out.WriteByte(" :\t\n"[next(4)]) } } return out.Bytes()[:size] } type extracted struct { header Header content []byte } func readAll(t *testing.T, archive []byte) []extracted { t.Helper() r, err := NewReader(bytes.NewReader(archive)) if err != nil { t.Fatalf("NewReader: %v", err) } var out []extracted for { h, err := r.Next() if err == io.EOF { return out } if err != nil { t.Fatalf("Next: %v", err) } content, err := io.ReadAll(r) if err != nil { t.Fatalf("read %s: %v", h.Name, err) } out = append(out, extracted{header: *h, content: content}) } } func TestStoredMembers(t *testing.T) { mtime := time.Date(2026, 10, 2, 7, 37, 52, 0, time.UTC) archive := testArchive(0, testMember{name: "host01", isDir: true}, testMember{name: "host01/System-info.txt", content: []byte("System Information\n"), mtime: mtime}, testMember{name: "host01/empty.txt", content: nil, mtime: mtime.Add(1500 * time.Millisecond), filetime: true}, ) dumpArchive(t, archive) files := readAll(t, archive) if len(files) != 3 { t.Fatalf("expected 3 members, got %d", len(files)) } if !files[0].header.IsDir || files[0].header.Name != "host01" { t.Fatalf("unexpected directory entry: %+v", files[0].header) } if files[1].header.Name != "host01/System-info.txt" || string(files[1].content) != "System Information\n" || files[1].header.UnpackedSize != 19 || !files[1].header.ModTime.Equal(mtime) { t.Fatalf("unexpected file: %+v %q", files[1].header, files[1].content) } if len(files[2].content) != 0 || !files[2].header.ModTime.Equal(mtime.Add(1500*time.Millisecond)) { t.Fatalf("unexpected FILETIME member: %+v", files[2].header) } } func TestCompressedMember(t *testing.T) { // Larger than the 256 KiB window, so matches cross the window wrap. content := testText(900_000) cases := []struct { name string blockLen int shareTables bool }{ {name: "large blocks", blockLen: 40000}, {name: "many small blocks", blockLen: 97}, {name: "blocks reusing the first tables", blockLen: 1009, shareTables: true}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { enc := &testEncoder{blockLen: tc.blockLen, shareTables: tc.shareTables} packed := enc.compress(content, 0, 256<<10) if len(packed) >= len(content) { t.Fatalf("test encoder did not compress: %d -> %d", len(content), len(packed)) } archive := testArchive(0, testMember{name: "log.txt", content: content, packed: packed, dictBits: 1}) dumpArchive(t, archive) files := readAll(t, archive) if len(files) != 1 || !bytes.Equal(files[0].content, content) { t.Fatalf("decoded content differs from the original") } }) } } func TestCompressedMemberSmallReads(t *testing.T) { content := testText(300_000) archive := testArchive(0, testMember{ name: "log.txt", content: content, packed: new(testEncoder).compress(content, 0, 128<<10), }) r, err := NewReader(iotest{bytes.NewReader(archive)}) if err != nil { t.Fatalf("NewReader: %v", err) } if _, err := r.Next(); err != nil { t.Fatalf("Next: %v", err) } var got bytes.Buffer buf := make([]byte, 7) for { n, err := r.Read(buf) got.Write(buf[:n]) if err == io.EOF { break } if err != nil { t.Fatalf("Read: %v", err) } } if !bytes.Equal(got.Bytes(), content) { t.Fatal("decoded content differs from the original") } } // iotest returns one byte per Read to exercise short reads of the source. type iotest struct{ r io.Reader } func (o iotest) Read(p []byte) (int, error) { if len(p) > 1 { p = p[:1] } return o.r.Read(p) } func TestDeltaFilter(t *testing.T) { // Three interleaved slowly changing channels, like raw sample data. const channels = 3 content := make([]byte, 30_000) for i := range content { content[i] = byte(i/channels/7 + i%channels*40) } // Delta-code per channel into planar order: what the decoder undoes. filtered := make([]byte, 0, len(content)) for c := 0; c < channels; c++ { var prev byte for i := c; i < len(content); i += channels { filtered = append(filtered, prev-content[i]) prev = content[i] } } enc := new(testEncoder) enc.writeTables() enc.deltaFilter(len(filtered), channels) enc.symbols = 1 packed := enc.compressBody(filtered, 0, 128<<10) archive := testArchive(0, testMember{name: "samples.bin", content: content, packed: packed}) dumpArchive(t, archive) files := readAll(t, archive) if len(files) != 1 || !bytes.Equal(files[0].content, content) { t.Fatal("delta-filtered content differs from the original") } } func solidArchive() (archive []byte, first, second []byte) { all := testText(500_000) first, second = all[:300_000], all[300_000:] enc := new(testEncoder) packedFirst := enc.compress(first, 0, 512<<10) packedSecond := enc.compress(all, len(first), 512<<10) archive = testArchive(archiveIsSolid, testMember{name: "a.txt", content: first, packed: packedFirst, dictBits: 2}, testMember{name: "b.txt", content: second, packed: packedSecond, dictBits: 2, solid: true}, ) return archive, first, second } func TestSolidArchive(t *testing.T) { archive, first, second := solidArchive() dumpArchive(t, archive) files := readAll(t, archive) if len(files) != 2 || !bytes.Equal(files[0].content, first) || !bytes.Equal(files[1].content, second) { t.Fatal("solid archive content differs from the original") } } // The second file of a solid archive depends on the first one being decoded, // even when the caller never reads it. func TestSolidArchiveSkippedMember(t *testing.T) { archive, _, second := solidArchive() r, err := NewReader(bytes.NewReader(archive)) if err != nil { t.Fatalf("NewReader: %v", err) } if _, err := r.Next(); err != nil { t.Fatalf("Next: %v", err) } h, err := r.Next() if err != nil || h.Name != "b.txt" { t.Fatalf("Next: %v %+v", err, h) } got, err := io.ReadAll(r) if err != nil || !bytes.Equal(got, second) { t.Fatalf("skipping a solid member broke the next one: %v", err) } } func TestSkippedMembers(t *testing.T) { content := testText(50_000) archive := testArchive(0, testMember{name: "skip-compressed.txt", content: content, packed: new(testEncoder).compress(content, 0, 128<<10)}, testMember{name: "skip-stored.txt", content: content}, testMember{name: "link", content: nil, extra: append(testVint(2), append(testVint(extraRedirection), 0)...)}, testMember{name: "wanted.txt", content: []byte("wanted")}, ) r, err := NewReader(bytes.NewReader(archive)) if err != nil { t.Fatalf("NewReader: %v", err) } var names []string var last []byte for { h, err := r.Next() if err == io.EOF { break } if err != nil { t.Fatalf("Next: %v", err) } names = append(names, h.Name) if h.Name == "wanted.txt" { if last, err = io.ReadAll(r); err != nil { t.Fatalf("read: %v", err) } } } if fmt.Sprint(names) != "[skip-compressed.txt skip-stored.txt wanted.txt]" || string(last) != "wanted" { t.Fatalf("unexpected members %v, content %q", names, last) } } func TestRejectedArchives(t *testing.T) { stored := testMember{name: "a.txt", content: []byte("content")} encrypted := stored encrypted.extra = append(testVint(2), append(testVint(extraEncryption), 0)...) split := stored split.flags = headerSplitAfter headerEncrypted := append([]byte(signature), testBlock(bytes.Join([][]byte{testVint(blockEncryption), testVint(0), testVint(0)}, nil))...) cases := []struct { name string archive []byte want error }{ {name: "not an archive", archive: []byte("PK\x03\x04 this is a zip"), want: ErrNotRAR}, {name: "empty input", archive: nil, want: ErrNotRAR}, {name: "RAR 4 archive", archive: []byte("Rar!\x1a\x07\x00\xcf\x90\x73\x00\x00\x0d\x00"), want: ErrLegacyFormat}, {name: "encrypted file", archive: testArchive(0, encrypted), want: ErrEncrypted}, {name: "encrypted headers", archive: headerEncrypted, want: ErrEncrypted}, {name: "volume of a multi-volume set", archive: testArchive(archiveIsVolume, stored), want: ErrMultiVolume}, {name: "file split across volumes", archive: testArchive(0, split), want: ErrMultiVolume}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { r, err := NewReader(bytes.NewReader(tc.archive)) if err == nil { _, err = r.Next() } if !errors.Is(err, tc.want) { t.Fatalf("got error %v, want %v", err, tc.want) } }) } } func TestCorruptArchives(t *testing.T) { content := testText(20_000) packed := new(testEncoder).compress(content, 0, 128<<10) good := testArchive(0, testMember{name: "a.txt", content: content, packed: packed}) flipped := bytes.Clone(good) flipped[len(flipped)-200] ^= 0x10 // inside the compressed data badHeader := bytes.Clone(good) badHeader[len(signature)+5] ^= 0xff // inside the main archive header cases := []struct { name string archive []byte }{ {name: "wrong file checksum", archive: testArchive(0, testMember{name: "a.txt", content: []byte("content"), badCRC: true})}, {name: "damaged compressed data", archive: flipped}, {name: "truncated archive", archive: good[:len(good)-300]}, {name: "damaged block header", archive: badHeader}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { r, err := NewReader(bytes.NewReader(tc.archive)) if err != nil { t.Fatalf("NewReader: %v", err) } if _, err = r.Next(); err == nil { _, err = io.ReadAll(r) } if err == nil { t.Fatal("expected an error") } }) } } // Arbitrary damage must surface as an error, never as a panic or a hang. func TestDamagedDataNeverPanics(t *testing.T) { content := testText(20_000) good := testArchive(0, testMember{ name: "a.txt", content: content, packed: new(testEncoder).compress(content, 0, 128<<10), }) dataStart := bytes.Index(good, []byte("a.txt")) + len("a.txt") seed := uint32(7) for i := 0; i < 400; i++ { seed = seed*1664525 + 1013904223 damaged := bytes.Clone(good) pos := dataStart + int(seed>>8)%(len(good)-dataStart-20) damaged[pos] ^= byte(seed>>3) | 1 r, err := NewReader(bytes.NewReader(damaged)) if err != nil { continue } if _, err := r.Next(); err != nil { continue } io.Copy(io.Discard, io.LimitReader(r, 1<<20)) } }