Field bundles from ad-hoc service scripts (first sample: Giga G894-SD3 .rar with dmidecode/lscpu/lspci/nvme/lsblk output, no fixed layout). ADL-078: - linux-generic: recognizes utility output by content, merges records by stable key, low detect confidence (20-30) below all vendor parsers - pciids.LookupByDescription: resolve a textual lspci description back to vendor/device IDs and manufacturer/model - archive: accept .rar via the in-repo internal/rar5 reader (RAR 5 / RAR 7, single volume, solid; encrypted, multi-volume, SFX and RAR 4.x rejected), same per-file and total limits as tar/zip - UI: .rar in the upload accept list Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
383 lines
11 KiB
Go
383 lines
11 KiB
Go
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 <file>`).
|
|
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))
|
|
}
|
|
}
|