diff --git a/README.md b/README.md index f4fdcde..b66028e 100644 --- a/README.md +++ b/README.md @@ -27,7 +27,7 @@ import ( "log" "os" - "github.com/yeka/zip" + "github.com/Match-Made/zip" ) func main() { @@ -60,7 +60,7 @@ import ( "io/ioutil" "log" - "github.com/yeka/zip" + "github.com/Match-Made/zip" ) func main() { diff --git a/example_test.go b/example_test.go index dce27ee..8762e7d 100644 --- a/example_test.go +++ b/example_test.go @@ -11,7 +11,7 @@ import ( "log" "os" - "github.com/yeka/zip" + "github.com/Match-Made/zip" ) func ExampleWriter() { diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..51e7b9e --- /dev/null +++ b/go.mod @@ -0,0 +1,8 @@ +module github.com/Match-Made/zip + +go 1.25.5 + +require ( + go4.org v0.0.0-20260112195520-a5071408f32f + golang.org/x/crypto v0.50.0 +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..ebbd6fa --- /dev/null +++ b/go.sum @@ -0,0 +1,4 @@ +go4.org v0.0.0-20260112195520-a5071408f32f h1:ziUVAjmTPwQMBmYR1tbdRFJPtTcQUI12fH9QQjfb0Sw= +go4.org v0.0.0-20260112195520-a5071408f32f/go.mod h1:ZRJnO5ZI4zAwMFp+dS1+V6J6MSyAowhRqAE+DPa1Xp0= +golang.org/x/crypto v0.50.0 h1:zO47/JPrL6vsNkINmLoo/PH1gcxpls50DNogFvB5ZGI= +golang.org/x/crypto v0.50.0/go.mod h1:3muZ7vA7PBCE6xgPX7nkzzjiUq87kRItoJQM1Yo8S+Q= diff --git a/reader.go b/reader.go index 48a7c17..ed1eb3b 100644 --- a/reader.go +++ b/reader.go @@ -13,79 +13,128 @@ import ( "hash/crc32" "io" "os" + "strings" + + "go4.org/readerutil" ) var ( - ErrFormat = errors.New("zip: not a valid zip file") - ErrAlgorithm = errors.New("zip: unsupported compression algorithm") - ErrChecksum = errors.New("zip: checksum error") + ErrFormat = errors.New("zip: not a valid zip file") + ErrAlgorithm = errors.New("zip: unsupported compression algorithm") + ErrChecksum = errors.New("zip: checksum error") + ErrPartCountMismatch = errors.New("zip: part count mismatch") + ErrNoSuchFile = errors.New("zip: no such file") ) type Reader struct { - r io.ReaderAt + r []readerutil.SizeReaderAt File []*File Comment string } type ReadCloser struct { - f *os.File + f []io.Closer Reader } type File struct { FileHeader - zipr io.ReaderAt - zipsize int64 + zipr readerutil.SizeReaderAt headerOffset int64 + diskNb int32 } func (f *File) hasDataDescriptor() bool { return f.Flags&0x8 != 0 } -// OpenReader will open the Zip file specified by name and return a ReadCloser. -func OpenReader(name string) (*ReadCloser, error) { +func openPart(name string, idx int) (*os.File, int64, error) { + if idx > 0 { + name = fmt.Sprintf("%s.z%02d", strings.TrimSuffix(name, ".zip"), idx) + } f, err := os.Open(name) if err != nil { - return nil, err + return nil, 0, err } fi, err := f.Stat() if err != nil { - f.Close() - return nil, err + _ = f.Close() + return nil, 0, err } - r := new(ReadCloser) - if err := r.init(f, fi.Size()); err != nil { - f.Close() - return nil, err + return f, fi.Size(), nil +} + +// OpenReader will open the Zip file specified by name and return a ReadCloser. +func OpenReader(name string) (r *ReadCloser, err error) { + part := 0 + closers := make([]io.Closer, 0) + parts := make([]readerutil.SizeReaderAt, 0) + for { + f, size, e := openPart(name, part) + if e != nil { + err = e + break + } + part += 1 + closers = append(closers, f) + parts = append(parts, io.NewSectionReader(f, 0, size)) } - r.f = f - return r, nil + if part == 0 { + err = ErrNoSuchFile + return + } else if part > 1 { + closers = append(closers[1:], closers[0]) + parts = append(parts[1:], parts[0]) + } + r = new(ReadCloser) + r.f = closers + if err = r.init(parts); err != nil { + _ = r.Close() + r = nil + } + return } // NewReader returns a new Reader reading from r, which is assumed to // have the given size in bytes. func NewReader(r io.ReaderAt, size int64) (*Reader, error) { zr := new(Reader) - if err := zr.init(r, size); err != nil { + single := []readerutil.SizeReaderAt{io.NewSectionReader(r, 0, size)} + if err := zr.init(single); err != nil { return nil, err } return zr, nil } -func (z *Reader) init(r io.ReaderAt, size int64) error { - end, err := readDirectoryEnd(r, size) +func NewMultipartReader(r []readerutil.SizeReaderAt) (*Reader, error) { + zr := new(Reader) + if err := zr.init(r); err != nil { + return nil, err + } + return zr, nil +} + +func (z *Reader) init(r []readerutil.SizeReaderAt) error { + if len(r) == 0 { + return ErrNoSuchFile + } + lastPart := r[len(r)-1] + lastPartSize := lastPart.Size() + end, err := readDirectoryEnd(lastPart, lastPartSize) if err != nil { return err } - if end.directoryRecords > uint64(size)/fileHeaderLen { - return fmt.Errorf("archive/zip: TOC declares impossible %d files in %d byte zip", end.directoryRecords, size) + if len(r) > 1 && int(end.diskNbr) != len(r)-1 { + return ErrPartCountMismatch + } + if end.directoryRecords > uint64(lastPart.Size())/fileHeaderLen { + return fmt.Errorf("archive/zip: TOC declares impossible %d files in %d byte zip", end.directoryRecords, lastPartSize) } z.r = r z.File = make([]*File, 0, end.directoryRecords) z.Comment = end.comment - rs := io.NewSectionReader(r, 0, size) - if _, err = rs.Seek(int64(end.directoryOffset), os.SEEK_SET); err != nil { + rs := io.NewSectionReader(lastPart, 0, lastPartSize) + if _, err = rs.Seek(int64(end.directoryOffset), io.SeekStart); err != nil { return err } buf := bufio.NewReader(rs) @@ -95,14 +144,22 @@ func (z *Reader) init(r io.ReaderAt, size int64) error { // a bad one, and then only report a ErrFormat or UnexpectedEOF if // the file count modulo 65536 is incorrect. for { - f := &File{zipr: r, zipsize: size} + f := &File{zipr: readerutil.NewMultiReaderAt(r...)} err = readDirectoryHeader(f, buf) - if err == ErrFormat || err == io.ErrUnexpectedEOF { + if errors.Is(err, ErrFormat) || errors.Is(err, io.ErrUnexpectedEOF) { break } if err != nil { return err } + if len(r) > 1 { + if int(f.diskNb) >= len(r) { + return ErrPartCountMismatch + } + for i := int32(0); i < f.diskNb; i++ { + f.headerOffset += r[i].Size() + } + } z.File = append(z.File, f) } if uint16(len(z.File)) != uint16(end.directoryRecords) { // only compare 16 bits here @@ -115,7 +172,11 @@ func (z *Reader) init(r io.ReaderAt, size int64) error { // Close closes the Zip file, rendering it unusable for I/O. func (rc *ReadCloser) Close() error { - return rc.f.Close() + var err error + for _, fp := range rc.f { + err = errors.Join(err, fp.Close()) + } + return err } // DataOffset returns the offset of the file's possibly-compressed @@ -145,7 +206,10 @@ func (f *File) Open() (rc io.ReadCloser, err error) { rr := io.NewSectionReader(f.zipr, f.headerOffset+bodyOffset, size) // check for encryption if f.IsEncrypted() { - + if f.password == nil { + err = ErrPassword + return + } if f.ae == 0 { if r, err = ZipCryptoDecryptor(rr, f.password()); err != nil { return @@ -270,7 +334,8 @@ func readDirectoryHeader(f *File, r io.Reader) error { filenameLen := int(b.uint16()) extraLen := int(b.uint16()) commentLen := int(b.uint16()) - b = b[4:] // skipped start disk number and internal attributes (2x uint16) + f.diskNb = int32(b.uint16()) + b = b[2:] // skipped internal attributes (2x uint16) f.ExternalAttrs = b.uint32() f.headerOffset = int64(b.uint32()) d := make([]byte, filenameLen+extraLen+commentLen) @@ -292,14 +357,26 @@ func readDirectoryHeader(f *File, r io.Reader) error { eb := readBuf(b[:size]) switch tag { case zip64ExtraId: - // update directory values from the zip64 extra block - if len(eb) >= 8 { + // Per APPNOTE 4.5.3, the zip64 extra block contains only + // fields whose 32-bit counterpart was sentinel-promoted + // (0xFFFFFFFF). Reading in fixed order regardless of + // promotion misparses asymmetric archives. + if f.UncompressedSize == uint32max { + if len(eb) < 8 { + return ErrFormat + } f.UncompressedSize64 = eb.uint64() } - if len(eb) >= 8 { + if f.CompressedSize == uint32max { + if len(eb) < 8 { + return ErrFormat + } f.CompressedSize64 = eb.uint64() } - if len(eb) >= 8 { + if uint32(f.headerOffset) == uint32max { + if len(eb) < 8 { + return ErrFormat + } f.headerOffset = int64(eb.uint64()) } case winzipAesExtraId: diff --git a/reader_test.go b/reader_test.go index 547dd39..02eb160 100644 --- a/reader_test.go +++ b/reader_test.go @@ -8,6 +8,7 @@ import ( "bytes" "encoding/binary" "encoding/hex" + "hash/crc32" "io" "io/ioutil" "os" @@ -16,6 +17,8 @@ import ( "strings" "testing" "time" + + "go4.org/readerutil" ) type ZipTest struct { @@ -432,6 +435,181 @@ func TestInvalidFiles(t *testing.T) { } } +func TestNewMultipartReader(t *testing.T) { + expectedFilesPng := map[string]int{ + "Users/nikko/Downloads/HeaderRight.png": 152499, + } + testCases := []struct { + name string + // the order of the path matters, .zip should be last + paths []string + password string + // key val of filename and content len + files map[string]int + expectedReadErr string + expectedOpenErr string + }{ + { + name: "success non-protected", + paths: []string{ + "./testdata/multipart/datasplit.z01", + "./testdata/multipart/datasplit.z02", + "./testdata/multipart/datasplit.zip", + }, + files: expectedFilesPng, + }, + { + name: "success non-protected - z64", + paths: []string{ + "./testdata/multipart/datasplit-z64.z01", + "./testdata/multipart/datasplit-z64.z02", + "./testdata/multipart/datasplit-z64.zip", + }, + files: expectedFilesPng, + }, + { + name: "success protected", + paths: []string{ + "./testdata/multipart/datasplit-protected.z01", + "./testdata/multipart/datasplit-protected.z02", + "./testdata/multipart/datasplit-protected.zip", + }, + password: "test123", + files: expectedFilesPng, + }, + { + name: "success protected - z64", + paths: []string{ + "./testdata/multipart/datasplit-protected-z64.z01", + "./testdata/multipart/datasplit-protected-z64.z02", + "./testdata/multipart/datasplit-protected-z64.zip", + }, + password: "test123", + files: expectedFilesPng, + }, + { + name: "success protected - multifiles multipart", + paths: []string{ + "./testdata/multipart/datasplit-protected-multifiles.z01", + "./testdata/multipart/datasplit-protected-multifiles.z02", + "./testdata/multipart/datasplit-protected-multifiles.zip", + }, + files: map[string]int{ + "file1.txt": 53337, + "file2.txt": 53337, + "file3.txt": 53337, + }, + password: "golang", + }, + { + name: "success non-protected - multifiles multipart", + paths: []string{ + "./testdata/multipart/datasplit-multifiles.z01", + "./testdata/multipart/datasplit-multifiles.z02", + "./testdata/multipart/datasplit-multifiles.zip", + }, + files: map[string]int{ + "file1.txt": 53337, + "file2.txt": 53337, + "file3.txt": 53337, + }, + }, + { + name: "failed protected - incorrect password", + paths: []string{ + "./testdata/multipart/datasplit-protected.z01", + "./testdata/multipart/datasplit-protected.z02", + "./testdata/multipart/datasplit-protected.zip", + }, + password: "wrong", + files: expectedFilesPng, + expectedReadErr: "flate: corrupt input before offset 1", + }, + { + name: "failed protected - no password supplied", + paths: []string{ + "./testdata/multipart/datasplit-protected.z01", + "./testdata/multipart/datasplit-protected.z02", + "./testdata/multipart/datasplit-protected.zip", + }, + files: expectedFilesPng, + expectedOpenErr: "zip: invalid password", + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + parts := []readerutil.SizeReaderAt{} + for _, path := range tc.paths { + f, err := os.Open(path) + if err != nil { + t.Fatalf("Failed to open multipart zip part %s: %v", path, err) + } + defer f.Close() + stat, err := f.Stat() + if err != nil { + t.Fatalf("Failed to stat multipart zip file: %v", err) + } + parts = append(parts, io.NewSectionReader(f, 0, stat.Size())) + } + + zr, err := NewMultipartReader(parts) + if err != nil { + t.Fatalf("Failed to create multipart reader: %v", err) + } + + if got, want := len(zr.File), len(tc.files); got != want { + t.Fatalf("multipart reader returned %d files, want %d", got, want) + } + + for _, f := range zr.File { + if _, ok := tc.files[f.Name]; !ok { + t.Fatalf("unexpected entry name: got %q", f.Name) + } + + if tc.password != "" { + if !f.IsEncrypted() { + t.Fatalf("expected file %q to be encrypted", f.Name) + } + f.SetPassword(tc.password) + } + + r, err := f.Open() + + if tc.expectedOpenErr != "" { + if err.Error() != tc.expectedOpenErr { + t.Fatalf("expected error %q, got %q", tc.expectedOpenErr, err) + } + return + } + + if err != nil { + t.Fatalf("Failed to open %s: %v", f.Name, err) + } + defer r.Close() + + buf, err := io.ReadAll(r) + + if tc.expectedReadErr != "" { + if err.Error() != tc.expectedReadErr { + t.Fatalf("expected error %q, got %q", tc.expectedReadErr, err) + } + return + } + + if got, want := len(buf), int(f.UncompressedSize64); got != want { + t.Fatalf("read %d bytes, want %d", got, want) + } + + if got, want := len(buf), tc.files[f.Name]; got != want { + t.Fatalf("unexpected size for %s: got %d, want %d", f.Name, got, want) + } + + } + }) + } +} + func messWith(fileName string, corrupter func(b []byte)) (r io.ReaderAt, size int64) { data, err := ioutil.ReadFile(filepath.Join("testdata", fileName)) if err != nil { @@ -578,7 +756,7 @@ func TestIssue10956(t *testing.T) { "0000\v\x00000\x00\x00\x00\x00\x00\x00\x000") _, err := NewReader(bytes.NewReader(data), int64(len(data))) const want = "TOC declares impossible 3472328296227680304 files in 57 byte" - if err == nil && !strings.Contains(err.Error(), want) { + if err == nil || !strings.Contains(err.Error(), want) { t.Errorf("error = %v; want %q", err, want) } } @@ -605,3 +783,181 @@ func TestIssue11146(t *testing.T) { } r.Close() } + +func writeLocalFileHeader(buf *bytes.Buffer, name, content string) { + binary.Write(buf, binary.LittleEndian, uint32(fileHeaderSignature)) + binary.Write(buf, binary.LittleEndian, uint16(20)) // version needed + binary.Write(buf, binary.LittleEndian, uint16(0)) // flags + binary.Write(buf, binary.LittleEndian, uint16(Store)) // method + binary.Write(buf, binary.LittleEndian, uint16(0)) // mod time + binary.Write(buf, binary.LittleEndian, uint16(0)) // mod date + binary.Write(buf, binary.LittleEndian, crc32.ChecksumIEEE([]byte(content))) // CRC-32 + binary.Write(buf, binary.LittleEndian, uint32(len(content))) // compressed size + binary.Write(buf, binary.LittleEndian, uint32(len(content))) // uncompressed size + binary.Write(buf, binary.LittleEndian, uint16(len(name))) // filename length + binary.Write(buf, binary.LittleEndian, uint16(0)) // extra length + buf.WriteString(name) +} + +func writeCentralDirHeaderAsymmetric(buf *bytes.Buffer, name, content string, realOffset uint64) { + const extraLen = 4 + 8 // tag+size header + 8-byte offset only + + binary.Write(buf, binary.LittleEndian, uint32(directoryHeaderSignature)) + binary.Write(buf, binary.LittleEndian, uint16(20)) // version made by + binary.Write(buf, binary.LittleEndian, uint16(45)) // version needed (zip64) + binary.Write(buf, binary.LittleEndian, uint16(0)) // flags + binary.Write(buf, binary.LittleEndian, uint16(Store)) // method + binary.Write(buf, binary.LittleEndian, uint16(0)) // mod time + binary.Write(buf, binary.LittleEndian, uint16(0)) // mod date + binary.Write(buf, binary.LittleEndian, crc32.ChecksumIEEE([]byte(content))) // CRC-32 + binary.Write(buf, binary.LittleEndian, uint32(len(content))) // compressed size (NOT sentinel) + binary.Write(buf, binary.LittleEndian, uint32(len(content))) // uncompressed size (NOT sentinel) + binary.Write(buf, binary.LittleEndian, uint16(len(name))) // filename length + binary.Write(buf, binary.LittleEndian, uint16(extraLen)) // extra length + binary.Write(buf, binary.LittleEndian, uint16(0)) // comment length + binary.Write(buf, binary.LittleEndian, uint16(0)) // disk number start + binary.Write(buf, binary.LittleEndian, uint16(0)) // internal attrs + binary.Write(buf, binary.LittleEndian, uint32(0)) // external attrs + binary.Write(buf, binary.LittleEndian, uint32(uint32max)) // header offset = SENTINEL + buf.WriteString(name) + + // Zip64 extra block: only the 8-byte offset. + binary.Write(buf, binary.LittleEndian, uint16(zip64ExtraId)) + binary.Write(buf, binary.LittleEndian, uint16(8)) + binary.Write(buf, binary.LittleEndian, realOffset) +} + +func writeCentralDirHeaderTruncatedExtra(buf *bytes.Buffer, name, content string, realOffset uint64) { + const extraLen = 4 // tag+size header only, no payload + + binary.Write(buf, binary.LittleEndian, uint32(directoryHeaderSignature)) + binary.Write(buf, binary.LittleEndian, uint16(20)) + binary.Write(buf, binary.LittleEndian, uint16(45)) + binary.Write(buf, binary.LittleEndian, uint16(0)) + binary.Write(buf, binary.LittleEndian, uint16(Store)) + binary.Write(buf, binary.LittleEndian, uint16(0)) + binary.Write(buf, binary.LittleEndian, uint16(0)) + binary.Write(buf, binary.LittleEndian, crc32.ChecksumIEEE([]byte(content))) + binary.Write(buf, binary.LittleEndian, uint32(len(content))) + binary.Write(buf, binary.LittleEndian, uint32(len(content))) + binary.Write(buf, binary.LittleEndian, uint16(len(name))) + binary.Write(buf, binary.LittleEndian, uint16(extraLen)) + binary.Write(buf, binary.LittleEndian, uint16(0)) + binary.Write(buf, binary.LittleEndian, uint16(0)) + binary.Write(buf, binary.LittleEndian, uint16(0)) + binary.Write(buf, binary.LittleEndian, uint32(0)) + binary.Write(buf, binary.LittleEndian, uint32(uint32max)) + buf.WriteString(name) + + binary.Write(buf, binary.LittleEndian, uint16(zip64ExtraId)) + binary.Write(buf, binary.LittleEndian, uint16(0)) // claims promotion, supplies nothing +} + +func writeEOCD(buf *bytes.Buffer, cdOffset, cdSize uint64, entries uint16) { + binary.Write(buf, binary.LittleEndian, uint32(directoryEndSignature)) + binary.Write(buf, binary.LittleEndian, uint16(0)) // disk number + binary.Write(buf, binary.LittleEndian, uint16(0)) // disk with start of CD + binary.Write(buf, binary.LittleEndian, uint16(entries)) // entries on this disk + binary.Write(buf, binary.LittleEndian, uint16(entries)) // total entries + binary.Write(buf, binary.LittleEndian, uint32(cdSize)) // CD size + binary.Write(buf, binary.LittleEndian, uint32(cdOffset)) // CD offset + binary.Write(buf, binary.LittleEndian, uint16(0)) // comment length +} + +// TestZip64AsymmetricPromotion verifies that the central-directory zip64 +// extra-block parser honors APPNOTE 4.5.3: only the fields whose 32-bit +// counterpart was sentinel-promoted (0xFFFFFFFF) appear in the extra +// block, in field order. +// +// The fixture is a hand-rolled archive with one stored entry "asym" +// containing "hi", where the 32-bit local-header offset is set to the +// sentinel and the zip64 extra contains *only* the 8-byte real offset. +// Sizes stay in 32-bit form. Before the sentinel-aware fix, the parser +// would consume the offset bytes as UncompressedSize64 and leave +// headerOffset stuck at 0xFFFFFFFF. +func TestZip64AsymmetricPromotion(t *testing.T) { + const ( + filename = "asym" + content = "hi" + ) + + var buf bytes.Buffer + + // Local file header at offset 0. + localHeaderOffset := uint64(buf.Len()) + writeLocalFileHeader(&buf, filename, content) + buf.WriteString(content) + + // Central directory header. headerOffset field is sentinel; real + // offset goes in the zip64 extra. Sizes are NOT sentinel. + cdOffset := uint64(buf.Len()) + writeCentralDirHeaderAsymmetric(&buf, filename, content, localHeaderOffset) + cdSize := uint64(buf.Len()) - cdOffset + + // EOCD. No zip64 EOCD needed — only the offset field was promoted, + // and the EOCD itself records cdOffset which fits in 32 bits. + writeEOCD(&buf, cdOffset, cdSize, 1) + + zr, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len())) + if err != nil { + t.Fatalf("NewReader: %v", err) + } + if got := len(zr.File); got != 1 { + t.Fatalf("entry count: got %d, want 1", got) + } + f := zr.File[0] + if f.Name != filename { + t.Errorf("Name: got %q, want %q", f.Name, filename) + } + // The bug under test would leave headerOffset at uint32max. + if f.headerOffset != int64(localHeaderOffset) { + t.Errorf("headerOffset: got %d, want %d (still sentinel? %v)", + f.headerOffset, localHeaderOffset, f.headerOffset == int64(uint32max)) + } + if f.UncompressedSize64 != uint64(len(content)) { + t.Errorf("UncompressedSize64: got %d, want %d", f.UncompressedSize64, len(content)) + } + + rc, err := f.Open() + if err != nil { + t.Fatalf("Open: %v", err) + } + got, err := io.ReadAll(rc) + if cerr := rc.Close(); cerr != nil && err == nil { + err = cerr + } + if err != nil { + t.Fatalf("read: %v", err) + } + if string(got) != content { + t.Errorf("contents: got %q, want %q", got, content) + } +} + +// TestZip64AsymmetricPromotion_TruncatedExtra verifies that a malformed +// archive — one that claims sentinel promotion but provides too few +// bytes in the zip64 extra — is rejected with ErrFormat instead of +// silently corrupting the parsed offsets. +func TestZip64AsymmetricPromotion_TruncatedExtra(t *testing.T) { + const ( + filename = "trunc" + content = "hi" + ) + + var buf bytes.Buffer + localHeaderOffset := uint64(buf.Len()) + writeLocalFileHeader(&buf, filename, content) + buf.WriteString(content) + + // Central directory entry with sentinel offset but a zip64 extra + // of size 0 — i.e. it claims promotion but supplies no offset. + cdOffset := uint64(buf.Len()) + writeCentralDirHeaderTruncatedExtra(&buf, filename, content, localHeaderOffset) + cdSize := uint64(buf.Len()) - cdOffset + writeEOCD(&buf, cdOffset, cdSize, 1) + + _, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len())) + if err != ErrFormat { + t.Fatalf("got %v, want ErrFormat", err) + } +} diff --git a/testdata/multipart/datasplit-multifiles.z01 b/testdata/multipart/datasplit-multifiles.z01 new file mode 100644 index 0000000..53eff9a Binary files /dev/null and b/testdata/multipart/datasplit-multifiles.z01 differ diff --git a/testdata/multipart/datasplit-multifiles.z02 b/testdata/multipart/datasplit-multifiles.z02 new file mode 100644 index 0000000..f18c657 --- /dev/null +++ b/testdata/multipart/datasplit-multifiles.z02 @@ -0,0 +1,3 @@ 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 +PK +~\lB-MYY file3.txtUT AiAiux 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 \ No newline at end of file diff --git a/testdata/multipart/datasplit-multifiles.zip b/testdata/multipart/datasplit-multifiles.zip new file mode 100644 index 0000000..2817f9c --- /dev/null +++ b/testdata/multipart/datasplit-multifiles.zip @@ -0,0 +1,5 @@ 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 +PK +~\YY file1.txtUTAiux PK +~\%^-YY file2.txtUTAiux PK +~\lB-MYY <file3.txtUTAiux PKq \ No newline at end of file diff --git a/testdata/multipart/datasplit-protected-multifiles.z01 b/testdata/multipart/datasplit-protected-multifiles.z01 new file mode 100644 index 0000000..158a561 Binary files /dev/null and b/testdata/multipart/datasplit-protected-multifiles.z01 differ diff --git a/testdata/multipart/datasplit-protected-multifiles.z02 b/testdata/multipart/datasplit-protected-multifiles.z02 new file mode 100644 index 0000000..abb5bfb Binary files /dev/null and b/testdata/multipart/datasplit-protected-multifiles.z02 differ diff --git a/testdata/multipart/datasplit-protected-multifiles.zip b/testdata/multipart/datasplit-protected-multifiles.zip new file mode 100644 index 0000000..c8e712f Binary files /dev/null and b/testdata/multipart/datasplit-protected-multifiles.zip differ diff --git a/testdata/multipart/datasplit-protected-z64.z01 b/testdata/multipart/datasplit-protected-z64.z01 new file mode 100644 index 0000000..5fcae2d Binary files /dev/null and b/testdata/multipart/datasplit-protected-z64.z01 differ diff --git a/testdata/multipart/datasplit-protected-z64.z02 b/testdata/multipart/datasplit-protected-z64.z02 new file mode 100644 index 0000000..3b7ec84 Binary files /dev/null and b/testdata/multipart/datasplit-protected-z64.z02 differ diff --git a/testdata/multipart/datasplit-protected-z64.zip b/testdata/multipart/datasplit-protected-z64.zip new file mode 100644 index 0000000..ce02f7c Binary files /dev/null and b/testdata/multipart/datasplit-protected-z64.zip differ diff --git a/testdata/multipart/datasplit-protected.z01 b/testdata/multipart/datasplit-protected.z01 new file mode 100644 index 0000000..b5225fa Binary files /dev/null and b/testdata/multipart/datasplit-protected.z01 differ diff --git a/testdata/multipart/datasplit-protected.z02 b/testdata/multipart/datasplit-protected.z02 new file mode 100644 index 0000000..1590ad7 Binary files /dev/null and b/testdata/multipart/datasplit-protected.z02 differ diff --git a/testdata/multipart/datasplit-protected.zip b/testdata/multipart/datasplit-protected.zip new file mode 100644 index 0000000..0946a0e Binary files /dev/null and b/testdata/multipart/datasplit-protected.zip differ diff --git a/testdata/multipart/datasplit-z64.z01 b/testdata/multipart/datasplit-z64.z01 new file mode 100644 index 0000000..9f0a050 Binary files /dev/null and b/testdata/multipart/datasplit-z64.z01 differ diff --git a/testdata/multipart/datasplit-z64.z02 b/testdata/multipart/datasplit-z64.z02 new file mode 100644 index 0000000..2580080 Binary files /dev/null and b/testdata/multipart/datasplit-z64.z02 differ diff --git a/testdata/multipart/datasplit-z64.zip b/testdata/multipart/datasplit-z64.zip new file mode 100644 index 0000000..d22a95a Binary files /dev/null and b/testdata/multipart/datasplit-z64.zip differ diff --git a/testdata/multipart/datasplit.z01 b/testdata/multipart/datasplit.z01 new file mode 100644 index 0000000..18b1af5 Binary files /dev/null and b/testdata/multipart/datasplit.z01 differ diff --git a/testdata/multipart/datasplit.z02 b/testdata/multipart/datasplit.z02 new file mode 100644 index 0000000..2d0492e Binary files /dev/null and b/testdata/multipart/datasplit.z02 differ diff --git a/testdata/multipart/datasplit.zip b/testdata/multipart/datasplit.zip new file mode 100644 index 0000000..a31bf11 Binary files /dev/null and b/testdata/multipart/datasplit.zip differ