github.com/comwrg/go/src@v0.0.0-20220319063731-c238d0440370/archive/zip/reader_test.go (about) 1 // Copyright 2010 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package zip 6 7 import ( 8 "bytes" 9 "encoding/binary" 10 "encoding/hex" 11 "github.com/comwrg/go/src/internal/obscuretestdata" 12 "io" 13 "io/fs" 14 "os" 15 "path/filepath" 16 "reflect" 17 "regexp" 18 "strings" 19 "testing" 20 "testing/fstest" 21 "time" 22 ) 23 24 type ZipTest struct { 25 Name string 26 Source func() (r io.ReaderAt, size int64) // if non-nil, used instead of testdata/<Name> file 27 Comment string 28 File []ZipTestFile 29 Obscured bool // needed for Apple notarization (golang.org/issue/34986) 30 Error error // the error that Opening this file should return 31 } 32 33 type ZipTestFile struct { 34 Name string 35 Mode fs.FileMode 36 NonUTF8 bool 37 ModTime time.Time 38 Modified time.Time 39 40 // Information describing expected zip file content. 41 // First, reading the entire content should produce the error ContentErr. 42 // Second, if ContentErr==nil, the content should match Content. 43 // If content is large, an alternative to setting Content is to set File, 44 // which names a file in the testdata/ directory containing the 45 // uncompressed expected content. 46 // If content is very large, an alternative to setting Content or File 47 // is to set Size, which will then be checked against the header-reported size 48 // but will bypass the decompressing of the actual data. 49 // This last option is used for testing very large (multi-GB) compressed files. 50 ContentErr error 51 Content []byte 52 File string 53 Size uint64 54 } 55 56 var tests = []ZipTest{ 57 { 58 Name: "test.zip", 59 Comment: "This is a zipfile comment.", 60 File: []ZipTestFile{ 61 { 62 Name: "test.txt", 63 Content: []byte("This is a test text file.\n"), 64 Modified: time.Date(2010, 9, 5, 12, 12, 1, 0, timeZone(+10*time.Hour)), 65 Mode: 0644, 66 }, 67 { 68 Name: "gophercolor16x16.png", 69 File: "gophercolor16x16.png", 70 Modified: time.Date(2010, 9, 5, 15, 52, 58, 0, timeZone(+10*time.Hour)), 71 Mode: 0644, 72 }, 73 }, 74 }, 75 { 76 Name: "test-trailing-junk.zip", 77 Comment: "This is a zipfile comment.", 78 File: []ZipTestFile{ 79 { 80 Name: "test.txt", 81 Content: []byte("This is a test text file.\n"), 82 Modified: time.Date(2010, 9, 5, 12, 12, 1, 0, timeZone(+10*time.Hour)), 83 Mode: 0644, 84 }, 85 { 86 Name: "gophercolor16x16.png", 87 File: "gophercolor16x16.png", 88 Modified: time.Date(2010, 9, 5, 15, 52, 58, 0, timeZone(+10*time.Hour)), 89 Mode: 0644, 90 }, 91 }, 92 }, 93 { 94 Name: "r.zip", 95 Source: returnRecursiveZip, 96 File: []ZipTestFile{ 97 { 98 Name: "r/r.zip", 99 Content: rZipBytes(), 100 Modified: time.Date(2010, 3, 4, 0, 24, 16, 0, time.UTC), 101 Mode: 0666, 102 }, 103 }, 104 }, 105 { 106 Name: "symlink.zip", 107 File: []ZipTestFile{ 108 { 109 Name: "symlink", 110 Content: []byte("../target"), 111 Modified: time.Date(2012, 2, 3, 19, 56, 48, 0, timeZone(-2*time.Hour)), 112 Mode: 0777 | fs.ModeSymlink, 113 }, 114 }, 115 }, 116 { 117 Name: "readme.zip", 118 }, 119 { 120 Name: "readme.notzip", 121 Error: ErrFormat, 122 }, 123 { 124 Name: "dd.zip", 125 File: []ZipTestFile{ 126 { 127 Name: "filename", 128 Content: []byte("This is a test textfile.\n"), 129 Modified: time.Date(2011, 2, 2, 13, 6, 20, 0, time.UTC), 130 Mode: 0666, 131 }, 132 }, 133 }, 134 { 135 // created in windows XP file manager. 136 Name: "winxp.zip", 137 File: []ZipTestFile{ 138 { 139 Name: "hello", 140 Content: []byte("world \r\n"), 141 Modified: time.Date(2011, 12, 8, 10, 4, 24, 0, time.UTC), 142 Mode: 0666, 143 }, 144 { 145 Name: "dir/bar", 146 Content: []byte("foo \r\n"), 147 Modified: time.Date(2011, 12, 8, 10, 4, 50, 0, time.UTC), 148 Mode: 0666, 149 }, 150 { 151 Name: "dir/empty/", 152 Content: []byte{}, 153 Modified: time.Date(2011, 12, 8, 10, 8, 6, 0, time.UTC), 154 Mode: fs.ModeDir | 0777, 155 }, 156 { 157 Name: "readonly", 158 Content: []byte("important \r\n"), 159 Modified: time.Date(2011, 12, 8, 10, 6, 8, 0, time.UTC), 160 Mode: 0444, 161 }, 162 }, 163 }, 164 { 165 // created by Zip 3.0 under Linux 166 Name: "unix.zip", 167 File: []ZipTestFile{ 168 { 169 Name: "hello", 170 Content: []byte("world \r\n"), 171 Modified: time.Date(2011, 12, 8, 10, 4, 24, 0, timeZone(0)), 172 Mode: 0666, 173 }, 174 { 175 Name: "dir/bar", 176 Content: []byte("foo \r\n"), 177 Modified: time.Date(2011, 12, 8, 10, 4, 50, 0, timeZone(0)), 178 Mode: 0666, 179 }, 180 { 181 Name: "dir/empty/", 182 Content: []byte{}, 183 Modified: time.Date(2011, 12, 8, 10, 8, 6, 0, timeZone(0)), 184 Mode: fs.ModeDir | 0777, 185 }, 186 { 187 Name: "readonly", 188 Content: []byte("important \r\n"), 189 Modified: time.Date(2011, 12, 8, 10, 6, 8, 0, timeZone(0)), 190 Mode: 0444, 191 }, 192 }, 193 }, 194 { 195 // created by Go, before we wrote the "optional" data 196 // descriptor signatures (which are required by macOS). 197 // Use obscured file to avoid Apple’s notarization service 198 // rejecting the toolchain due to an inability to unzip this archive. 199 // See golang.org/issue/34986 200 Name: "go-no-datadesc-sig.zip.base64", 201 Obscured: true, 202 File: []ZipTestFile{ 203 { 204 Name: "foo.txt", 205 Content: []byte("foo\n"), 206 Modified: time.Date(2012, 3, 8, 16, 59, 10, 0, timeZone(-8*time.Hour)), 207 Mode: 0644, 208 }, 209 { 210 Name: "bar.txt", 211 Content: []byte("bar\n"), 212 Modified: time.Date(2012, 3, 8, 16, 59, 12, 0, timeZone(-8*time.Hour)), 213 Mode: 0644, 214 }, 215 }, 216 }, 217 { 218 // created by Go, after we wrote the "optional" data 219 // descriptor signatures (which are required by macOS) 220 Name: "go-with-datadesc-sig.zip", 221 File: []ZipTestFile{ 222 { 223 Name: "foo.txt", 224 Content: []byte("foo\n"), 225 Modified: time.Date(1979, 11, 30, 0, 0, 0, 0, time.UTC), 226 Mode: 0666, 227 }, 228 { 229 Name: "bar.txt", 230 Content: []byte("bar\n"), 231 Modified: time.Date(1979, 11, 30, 0, 0, 0, 0, time.UTC), 232 Mode: 0666, 233 }, 234 }, 235 }, 236 { 237 Name: "Bad-CRC32-in-data-descriptor", 238 Source: returnCorruptCRC32Zip, 239 File: []ZipTestFile{ 240 { 241 Name: "foo.txt", 242 Content: []byte("foo\n"), 243 Modified: time.Date(1979, 11, 30, 0, 0, 0, 0, time.UTC), 244 Mode: 0666, 245 ContentErr: ErrChecksum, 246 }, 247 { 248 Name: "bar.txt", 249 Content: []byte("bar\n"), 250 Modified: time.Date(1979, 11, 30, 0, 0, 0, 0, time.UTC), 251 Mode: 0666, 252 }, 253 }, 254 }, 255 // Tests that we verify (and accept valid) crc32s on files 256 // with crc32s in their file header (not in data descriptors) 257 { 258 Name: "crc32-not-streamed.zip", 259 File: []ZipTestFile{ 260 { 261 Name: "foo.txt", 262 Content: []byte("foo\n"), 263 Modified: time.Date(2012, 3, 8, 16, 59, 10, 0, timeZone(-8*time.Hour)), 264 Mode: 0644, 265 }, 266 { 267 Name: "bar.txt", 268 Content: []byte("bar\n"), 269 Modified: time.Date(2012, 3, 8, 16, 59, 12, 0, timeZone(-8*time.Hour)), 270 Mode: 0644, 271 }, 272 }, 273 }, 274 // Tests that we verify (and reject invalid) crc32s on files 275 // with crc32s in their file header (not in data descriptors) 276 { 277 Name: "crc32-not-streamed.zip", 278 Source: returnCorruptNotStreamedZip, 279 File: []ZipTestFile{ 280 { 281 Name: "foo.txt", 282 Content: []byte("foo\n"), 283 Modified: time.Date(2012, 3, 8, 16, 59, 10, 0, timeZone(-8*time.Hour)), 284 Mode: 0644, 285 ContentErr: ErrChecksum, 286 }, 287 { 288 Name: "bar.txt", 289 Content: []byte("bar\n"), 290 Modified: time.Date(2012, 3, 8, 16, 59, 12, 0, timeZone(-8*time.Hour)), 291 Mode: 0644, 292 }, 293 }, 294 }, 295 { 296 Name: "zip64.zip", 297 File: []ZipTestFile{ 298 { 299 Name: "README", 300 Content: []byte("This small file is in ZIP64 format.\n"), 301 Modified: time.Date(2012, 8, 10, 14, 33, 32, 0, time.UTC), 302 Mode: 0644, 303 }, 304 }, 305 }, 306 // Another zip64 file with different Extras fields. (golang.org/issue/7069) 307 { 308 Name: "zip64-2.zip", 309 File: []ZipTestFile{ 310 { 311 Name: "README", 312 Content: []byte("This small file is in ZIP64 format.\n"), 313 Modified: time.Date(2012, 8, 10, 14, 33, 32, 0, timeZone(-4*time.Hour)), 314 Mode: 0644, 315 }, 316 }, 317 }, 318 // Largest possible non-zip64 file, with no zip64 header. 319 { 320 Name: "big.zip", 321 Source: returnBigZipBytes, 322 File: []ZipTestFile{ 323 { 324 Name: "big.file", 325 Content: nil, 326 Size: 1<<32 - 1, 327 Modified: time.Date(1979, 11, 30, 0, 0, 0, 0, time.UTC), 328 Mode: 0666, 329 }, 330 }, 331 }, 332 { 333 Name: "utf8-7zip.zip", 334 File: []ZipTestFile{ 335 { 336 Name: "世界", 337 Content: []byte{}, 338 Mode: 0666, 339 Modified: time.Date(2017, 11, 6, 13, 9, 27, 867862500, timeZone(-8*time.Hour)), 340 }, 341 }, 342 }, 343 { 344 Name: "utf8-infozip.zip", 345 File: []ZipTestFile{ 346 { 347 Name: "世界", 348 Content: []byte{}, 349 Mode: 0644, 350 // Name is valid UTF-8, but format does not have UTF-8 flag set. 351 // We don't do UTF-8 detection for multi-byte runes due to 352 // false-positives with other encodings (e.g., Shift-JIS). 353 // Format says encoding is not UTF-8, so we trust it. 354 NonUTF8: true, 355 Modified: time.Date(2017, 11, 6, 13, 9, 27, 0, timeZone(-8*time.Hour)), 356 }, 357 }, 358 }, 359 { 360 Name: "utf8-osx.zip", 361 File: []ZipTestFile{ 362 { 363 Name: "世界", 364 Content: []byte{}, 365 Mode: 0644, 366 // Name is valid UTF-8, but format does not have UTF-8 set. 367 NonUTF8: true, 368 Modified: time.Date(2017, 11, 6, 13, 9, 27, 0, timeZone(-8*time.Hour)), 369 }, 370 }, 371 }, 372 { 373 Name: "utf8-winrar.zip", 374 File: []ZipTestFile{ 375 { 376 Name: "世界", 377 Content: []byte{}, 378 Mode: 0666, 379 Modified: time.Date(2017, 11, 6, 13, 9, 27, 867862500, timeZone(-8*time.Hour)), 380 }, 381 }, 382 }, 383 { 384 Name: "utf8-winzip.zip", 385 File: []ZipTestFile{ 386 { 387 Name: "世界", 388 Content: []byte{}, 389 Mode: 0666, 390 Modified: time.Date(2017, 11, 6, 13, 9, 27, 867000000, timeZone(-8*time.Hour)), 391 }, 392 }, 393 }, 394 { 395 Name: "time-7zip.zip", 396 File: []ZipTestFile{ 397 { 398 Name: "test.txt", 399 Content: []byte{}, 400 Size: 1<<32 - 1, 401 Modified: time.Date(2017, 10, 31, 21, 11, 57, 244817900, timeZone(-7*time.Hour)), 402 Mode: 0666, 403 }, 404 }, 405 }, 406 { 407 Name: "time-infozip.zip", 408 File: []ZipTestFile{ 409 { 410 Name: "test.txt", 411 Content: []byte{}, 412 Size: 1<<32 - 1, 413 Modified: time.Date(2017, 10, 31, 21, 11, 57, 0, timeZone(-7*time.Hour)), 414 Mode: 0644, 415 }, 416 }, 417 }, 418 { 419 Name: "time-osx.zip", 420 File: []ZipTestFile{ 421 { 422 Name: "test.txt", 423 Content: []byte{}, 424 Size: 1<<32 - 1, 425 Modified: time.Date(2017, 10, 31, 21, 11, 57, 0, timeZone(-7*time.Hour)), 426 Mode: 0644, 427 }, 428 }, 429 }, 430 { 431 Name: "time-win7.zip", 432 File: []ZipTestFile{ 433 { 434 Name: "test.txt", 435 Content: []byte{}, 436 Size: 1<<32 - 1, 437 Modified: time.Date(2017, 10, 31, 21, 11, 58, 0, time.UTC), 438 Mode: 0666, 439 }, 440 }, 441 }, 442 { 443 Name: "time-winrar.zip", 444 File: []ZipTestFile{ 445 { 446 Name: "test.txt", 447 Content: []byte{}, 448 Size: 1<<32 - 1, 449 Modified: time.Date(2017, 10, 31, 21, 11, 57, 244817900, timeZone(-7*time.Hour)), 450 Mode: 0666, 451 }, 452 }, 453 }, 454 { 455 Name: "time-winzip.zip", 456 File: []ZipTestFile{ 457 { 458 Name: "test.txt", 459 Content: []byte{}, 460 Size: 1<<32 - 1, 461 Modified: time.Date(2017, 10, 31, 21, 11, 57, 244000000, timeZone(-7*time.Hour)), 462 Mode: 0666, 463 }, 464 }, 465 }, 466 { 467 Name: "time-go.zip", 468 File: []ZipTestFile{ 469 { 470 Name: "test.txt", 471 Content: []byte{}, 472 Size: 1<<32 - 1, 473 Modified: time.Date(2017, 10, 31, 21, 11, 57, 0, timeZone(-7*time.Hour)), 474 Mode: 0666, 475 }, 476 }, 477 }, 478 { 479 Name: "time-22738.zip", 480 File: []ZipTestFile{ 481 { 482 Name: "file", 483 Content: []byte{}, 484 Mode: 0666, 485 Modified: time.Date(1999, 12, 31, 19, 0, 0, 0, timeZone(-5*time.Hour)), 486 ModTime: time.Date(1999, 12, 31, 19, 0, 0, 0, time.UTC), 487 }, 488 }, 489 }, 490 } 491 492 func TestReader(t *testing.T) { 493 for _, zt := range tests { 494 t.Run(zt.Name, func(t *testing.T) { 495 readTestZip(t, zt) 496 }) 497 } 498 } 499 500 func readTestZip(t *testing.T, zt ZipTest) { 501 var z *Reader 502 var err error 503 var raw []byte 504 if zt.Source != nil { 505 rat, size := zt.Source() 506 z, err = NewReader(rat, size) 507 raw = make([]byte, size) 508 if _, err := rat.ReadAt(raw, 0); err != nil { 509 t.Errorf("ReadAt error=%v", err) 510 return 511 } 512 } else { 513 path := filepath.Join("testdata", zt.Name) 514 if zt.Obscured { 515 tf, err := obscuretestdata.DecodeToTempFile(path) 516 if err != nil { 517 t.Errorf("obscuretestdata.DecodeToTempFile(%s): %v", path, err) 518 return 519 } 520 defer os.Remove(tf) 521 path = tf 522 } 523 var rc *ReadCloser 524 rc, err = OpenReader(path) 525 if err == nil { 526 defer rc.Close() 527 z = &rc.Reader 528 } 529 var err2 error 530 raw, err2 = os.ReadFile(path) 531 if err2 != nil { 532 t.Errorf("ReadFile(%s) error=%v", path, err2) 533 return 534 } 535 } 536 if err != zt.Error { 537 t.Errorf("error=%v, want %v", err, zt.Error) 538 return 539 } 540 541 // bail if file is not zip 542 if err == ErrFormat { 543 return 544 } 545 546 // bail here if no Files expected to be tested 547 // (there may actually be files in the zip, but we don't care) 548 if zt.File == nil { 549 return 550 } 551 552 if z.Comment != zt.Comment { 553 t.Errorf("comment=%q, want %q", z.Comment, zt.Comment) 554 } 555 if len(z.File) != len(zt.File) { 556 t.Fatalf("file count=%d, want %d", len(z.File), len(zt.File)) 557 } 558 559 // test read of each file 560 for i, ft := range zt.File { 561 readTestFile(t, zt, ft, z.File[i], raw) 562 } 563 if t.Failed() { 564 return 565 } 566 567 // test simultaneous reads 568 n := 0 569 done := make(chan bool) 570 for i := 0; i < 5; i++ { 571 for j, ft := range zt.File { 572 go func(j int, ft ZipTestFile) { 573 readTestFile(t, zt, ft, z.File[j], raw) 574 done <- true 575 }(j, ft) 576 n++ 577 } 578 } 579 for ; n > 0; n-- { 580 <-done 581 } 582 } 583 584 func equalTimeAndZone(t1, t2 time.Time) bool { 585 name1, offset1 := t1.Zone() 586 name2, offset2 := t2.Zone() 587 return t1.Equal(t2) && name1 == name2 && offset1 == offset2 588 } 589 590 func readTestFile(t *testing.T, zt ZipTest, ft ZipTestFile, f *File, raw []byte) { 591 if f.Name != ft.Name { 592 t.Errorf("name=%q, want %q", f.Name, ft.Name) 593 } 594 if !ft.Modified.IsZero() && !equalTimeAndZone(f.Modified, ft.Modified) { 595 t.Errorf("%s: Modified=%s, want %s", f.Name, f.Modified, ft.Modified) 596 } 597 if !ft.ModTime.IsZero() && !equalTimeAndZone(f.ModTime(), ft.ModTime) { 598 t.Errorf("%s: ModTime=%s, want %s", f.Name, f.ModTime(), ft.ModTime) 599 } 600 601 testFileMode(t, f, ft.Mode) 602 603 size := uint64(f.UncompressedSize) 604 if size == uint32max { 605 size = f.UncompressedSize64 606 } else if size != f.UncompressedSize64 { 607 t.Errorf("%v: UncompressedSize=%#x does not match UncompressedSize64=%#x", f.Name, size, f.UncompressedSize64) 608 } 609 610 // Check that OpenRaw returns the correct byte segment 611 rw, err := f.OpenRaw() 612 if err != nil { 613 t.Errorf("%v: OpenRaw error=%v", f.Name, err) 614 return 615 } 616 start, err := f.DataOffset() 617 if err != nil { 618 t.Errorf("%v: DataOffset error=%v", f.Name, err) 619 return 620 } 621 got, err := io.ReadAll(rw) 622 if err != nil { 623 t.Errorf("%v: OpenRaw ReadAll error=%v", f.Name, err) 624 return 625 } 626 end := uint64(start) + f.CompressedSize64 627 want := raw[start:end] 628 if !bytes.Equal(got, want) { 629 t.Logf("got %q", got) 630 t.Logf("want %q", want) 631 t.Errorf("%v: OpenRaw returned unexpected bytes", f.Name) 632 return 633 } 634 635 r, err := f.Open() 636 if err != nil { 637 t.Errorf("%v", err) 638 return 639 } 640 641 // For very large files, just check that the size is correct. 642 // The content is expected to be all zeros. 643 // Don't bother uncompressing: too big. 644 if ft.Content == nil && ft.File == "" && ft.Size > 0 { 645 if size != ft.Size { 646 t.Errorf("%v: uncompressed size %#x, want %#x", ft.Name, size, ft.Size) 647 } 648 r.Close() 649 return 650 } 651 652 var b bytes.Buffer 653 _, err = io.Copy(&b, r) 654 if err != ft.ContentErr { 655 t.Errorf("copying contents: %v (want %v)", err, ft.ContentErr) 656 } 657 if err != nil { 658 return 659 } 660 r.Close() 661 662 if g := uint64(b.Len()); g != size { 663 t.Errorf("%v: read %v bytes but f.UncompressedSize == %v", f.Name, g, size) 664 } 665 666 var c []byte 667 if ft.Content != nil { 668 c = ft.Content 669 } else if c, err = os.ReadFile("testdata/" + ft.File); err != nil { 670 t.Error(err) 671 return 672 } 673 674 if b.Len() != len(c) { 675 t.Errorf("%s: len=%d, want %d", f.Name, b.Len(), len(c)) 676 return 677 } 678 679 for i, b := range b.Bytes() { 680 if b != c[i] { 681 t.Errorf("%s: content[%d]=%q want %q", f.Name, i, b, c[i]) 682 return 683 } 684 } 685 } 686 687 func testFileMode(t *testing.T, f *File, want fs.FileMode) { 688 mode := f.Mode() 689 if want == 0 { 690 t.Errorf("%s mode: got %v, want none", f.Name, mode) 691 } else if mode != want { 692 t.Errorf("%s mode: want %v, got %v", f.Name, want, mode) 693 } 694 } 695 696 func TestInvalidFiles(t *testing.T) { 697 const size = 1024 * 70 // 70kb 698 b := make([]byte, size) 699 700 // zeroes 701 _, err := NewReader(bytes.NewReader(b), size) 702 if err != ErrFormat { 703 t.Errorf("zeroes: error=%v, want %v", err, ErrFormat) 704 } 705 706 // repeated directoryEndSignatures 707 sig := make([]byte, 4) 708 binary.LittleEndian.PutUint32(sig, directoryEndSignature) 709 for i := 0; i < size-4; i += 4 { 710 copy(b[i:i+4], sig) 711 } 712 _, err = NewReader(bytes.NewReader(b), size) 713 if err != ErrFormat { 714 t.Errorf("sigs: error=%v, want %v", err, ErrFormat) 715 } 716 717 // negative size 718 _, err = NewReader(bytes.NewReader([]byte("foobar")), -1) 719 if err == nil { 720 t.Errorf("archive/zip.NewReader: expected error when negative size is passed") 721 } 722 } 723 724 func messWith(fileName string, corrupter func(b []byte)) (r io.ReaderAt, size int64) { 725 data, err := os.ReadFile(filepath.Join("testdata", fileName)) 726 if err != nil { 727 panic("Error reading " + fileName + ": " + err.Error()) 728 } 729 corrupter(data) 730 return bytes.NewReader(data), int64(len(data)) 731 } 732 733 func returnCorruptCRC32Zip() (r io.ReaderAt, size int64) { 734 return messWith("go-with-datadesc-sig.zip", func(b []byte) { 735 // Corrupt one of the CRC32s in the data descriptor: 736 b[0x2d]++ 737 }) 738 } 739 740 func returnCorruptNotStreamedZip() (r io.ReaderAt, size int64) { 741 return messWith("crc32-not-streamed.zip", func(b []byte) { 742 // Corrupt foo.txt's final crc32 byte, in both 743 // the file header and TOC. (0x7e -> 0x7f) 744 b[0x11]++ 745 b[0x9d]++ 746 747 // TODO(bradfitz): add a new test that only corrupts 748 // one of these values, and verify that that's also an 749 // error. Currently, the reader code doesn't verify the 750 // fileheader and TOC's crc32 match if they're both 751 // non-zero and only the second line above, the TOC, 752 // is what matters. 753 }) 754 } 755 756 // rZipBytes returns the bytes of a recursive zip file, without 757 // putting it on disk and triggering certain virus scanners. 758 func rZipBytes() []byte { 759 s := ` 760 0000000 50 4b 03 04 14 00 00 00 08 00 08 03 64 3c f9 f4 761 0000010 89 64 48 01 00 00 b8 01 00 00 07 00 00 00 72 2f 762 0000020 72 2e 7a 69 70 00 25 00 da ff 50 4b 03 04 14 00 763 0000030 00 00 08 00 08 03 64 3c f9 f4 89 64 48 01 00 00 764 0000040 b8 01 00 00 07 00 00 00 72 2f 72 2e 7a 69 70 00 765 0000050 2f 00 d0 ff 00 25 00 da ff 50 4b 03 04 14 00 00 766 0000060 00 08 00 08 03 64 3c f9 f4 89 64 48 01 00 00 b8 767 0000070 01 00 00 07 00 00 00 72 2f 72 2e 7a 69 70 00 2f 768 0000080 00 d0 ff c2 54 8e 57 39 00 05 00 fa ff c2 54 8e 769 0000090 57 39 00 05 00 fa ff 00 05 00 fa ff 00 14 00 eb 770 00000a0 ff c2 54 8e 57 39 00 05 00 fa ff 00 05 00 fa ff 771 00000b0 00 14 00 eb ff 42 88 21 c4 00 00 14 00 eb ff 42 772 00000c0 88 21 c4 00 00 14 00 eb ff 42 88 21 c4 00 00 14 773 00000d0 00 eb ff 42 88 21 c4 00 00 14 00 eb ff 42 88 21 774 00000e0 c4 00 00 00 00 ff ff 00 00 00 ff ff 00 34 00 cb 775 00000f0 ff 42 88 21 c4 00 00 00 00 ff ff 00 00 00 ff ff 776 0000100 00 34 00 cb ff 42 e8 21 5e 0f 00 00 00 ff ff 0a 777 0000110 f0 66 64 12 61 c0 15 dc e8 a0 48 bf 48 af 2a b3 778 0000120 20 c0 9b 95 0d c4 67 04 42 53 06 06 06 40 00 06 779 0000130 00 f9 ff 6d 01 00 00 00 00 42 e8 21 5e 0f 00 00 780 0000140 00 ff ff 0a f0 66 64 12 61 c0 15 dc e8 a0 48 bf 781 0000150 48 af 2a b3 20 c0 9b 95 0d c4 67 04 42 53 06 06 782 0000160 06 40 00 06 00 f9 ff 6d 01 00 00 00 00 50 4b 01 783 0000170 02 14 00 14 00 00 00 08 00 08 03 64 3c f9 f4 89 784 0000180 64 48 01 00 00 b8 01 00 00 07 00 00 00 00 00 00 785 0000190 00 00 00 00 00 00 00 00 00 00 00 72 2f 72 2e 7a 786 00001a0 69 70 50 4b 05 06 00 00 00 00 01 00 01 00 35 00 787 00001b0 00 00 6d 01 00 00 00 00` 788 s = regexp.MustCompile(`[0-9a-f]{7}`).ReplaceAllString(s, "") 789 s = regexp.MustCompile(`\s+`).ReplaceAllString(s, "") 790 b, err := hex.DecodeString(s) 791 if err != nil { 792 panic(err) 793 } 794 return b 795 } 796 797 func returnRecursiveZip() (r io.ReaderAt, size int64) { 798 b := rZipBytes() 799 return bytes.NewReader(b), int64(len(b)) 800 } 801 802 // biggestZipBytes returns the bytes of a zip file biggest.zip 803 // that contains a zip file bigger.zip that contains a zip file 804 // big.zip that contains big.file, which contains 2³²-1 zeros. 805 // The big.zip file is interesting because it has no zip64 header, 806 // much like the innermost zip files in the well-known 42.zip. 807 // 808 // biggest.zip was generated by changing isZip64 to use > uint32max 809 // instead of >= uint32max and then running this program: 810 // 811 // package main 812 // 813 // import ( 814 // "archive/zip" 815 // "bytes" 816 // "io" 817 // "log" 818 // "os" 819 // ) 820 // 821 // type zeros struct{} 822 // 823 // func (zeros) Read(b []byte) (int, error) { 824 // for i := range b { 825 // b[i] = 0 826 // } 827 // return len(b), nil 828 // } 829 // 830 // func main() { 831 // bigZip := makeZip("big.file", io.LimitReader(zeros{}, 1<<32-1)) 832 // if err := os.WriteFile("/tmp/big.zip", bigZip, 0666); err != nil { 833 // log.Fatal(err) 834 // } 835 // 836 // biggerZip := makeZip("big.zip", bytes.NewReader(bigZip)) 837 // if err := os.WriteFile("/tmp/bigger.zip", biggerZip, 0666); err != nil { 838 // log.Fatal(err) 839 // } 840 // 841 // biggestZip := makeZip("bigger.zip", bytes.NewReader(biggerZip)) 842 // if err := os.WriteFile("/tmp/biggest.zip", biggestZip, 0666); err != nil { 843 // log.Fatal(err) 844 // } 845 // } 846 // 847 // func makeZip(name string, r io.Reader) []byte { 848 // var buf bytes.Buffer 849 // w := zip.NewWriter(&buf) 850 // wf, err := w.Create(name) 851 // if err != nil { 852 // log.Fatal(err) 853 // } 854 // if _, err = io.Copy(wf, r); err != nil { 855 // log.Fatal(err) 856 // } 857 // if err := w.Close(); err != nil { 858 // log.Fatal(err) 859 // } 860 // return buf.Bytes() 861 // } 862 // 863 // The 4 GB of zeros compresses to 4 MB, which compresses to 20 kB, 864 // which compresses to 1252 bytes (in the hex dump below). 865 // 866 // It's here in hex for the same reason as rZipBytes above: to avoid 867 // problems with on-disk virus scanners or other zip processors. 868 // 869 func biggestZipBytes() []byte { 870 s := ` 871 0000000 50 4b 03 04 14 00 08 00 08 00 00 00 00 00 00 00 872 0000010 00 00 00 00 00 00 00 00 00 00 0a 00 00 00 62 69 873 0000020 67 67 65 72 2e 7a 69 70 ec dc 6b 4c 53 67 18 07 874 0000030 f0 16 c5 ca 65 2e cb b8 94 20 61 1f 44 33 c7 cd 875 0000040 c0 86 4a b5 c0 62 8a 61 05 c6 cd 91 b2 54 8c 1b 876 0000050 63 8b 03 9c 1b 95 52 5a e3 a0 19 6c b2 05 59 44 877 0000060 64 9d 73 83 71 11 46 61 14 b9 1d 14 09 4a c3 60 878 0000070 2e 4c 6e a5 60 45 02 62 81 95 b6 94 9e 9e 77 e7 879 0000080 d0 43 b6 f8 71 df 96 3c e7 a4 69 ce bf cf e9 79 880 0000090 ce ef 79 3f bf f1 31 db b6 bb 31 76 92 e7 f3 07 881 00000a0 8b fc 9c ca cc 08 cc cb cc 5e d2 1c 88 d9 7e bb 882 00000b0 4f bb 3a 3f 75 f1 5d 7f 8f c2 68 67 77 8f 25 ff 883 00000c0 84 e2 93 2d ef a4 95 3d 71 4e 2c b9 b0 87 c3 be 884 00000d0 3d f8 a7 60 24 61 c5 ef ae 9e c8 6c 6d 4e 69 c8 885 00000e0 67 65 34 f8 37 76 2d 76 5c 54 f3 95 65 49 c7 0f 886 00000f0 18 71 4b 7e 5b 6a d1 79 47 61 41 b0 4e 2a 74 45 887 0000100 43 58 12 b2 5a a5 c6 7d 68 55 88 d4 98 75 18 6d 888 0000110 08 d1 1f 8f 5a 9e 96 ee 45 cf a4 84 4e 4b e8 50 889 0000120 a7 13 d9 06 de 52 81 97 36 b2 d7 b8 fc 2b 5f 55 890 0000130 23 1f 32 59 cf 30 27 fb e2 8a b9 de 45 dd 63 9c 891 0000140 4b b5 8b 96 4c 7a 62 62 cc a1 a7 cf fa f1 fe dd 892 0000150 54 62 11 bf 36 78 b3 c7 b1 b5 f2 61 4d 4e dd 66 893 0000160 32 2e e6 70 34 5f f4 c9 e6 6c 43 6f da 6b c6 c3 894 0000170 09 2c ce 09 57 7f d2 7e b4 23 ba 7c 1b 99 bc 22 895 0000180 3e f1 de 91 2f e3 9c 1b 82 cc c2 84 39 aa e6 de 896 0000190 b4 69 fc cc cb 72 a6 61 45 f0 d3 1d 26 19 7c 8d 897 00001a0 29 c8 66 02 be 77 6a f9 3d 34 79 17 19 c8 96 24 898 00001b0 a3 ac e4 dd 3b 1a 8e c6 fe 96 38 6b bf 67 5a 23 899 00001c0 f4 16 f4 e6 8a b4 fc c2 cd bf 95 66 1d bb 35 aa 900 00001d0 92 7d 66 d8 08 8d a5 1f 54 2a af 09 cf 61 ff d2 901 00001e0 85 9d 8f b6 d7 88 07 4a 86 03 db 64 f3 d9 92 73 902 00001f0 df ec a7 fc 23 4c 8d 83 79 63 2a d9 fd 8d b3 c8 903 0000200 8f 7e d4 19 85 e6 8d 1c 76 f0 8b 58 32 fd 9a d6 904 0000210 85 e2 48 ad c3 d5 60 6f 7e 22 dd ef 09 49 7c 7f 905 0000220 3a 45 c3 71 b7 df f3 4c 63 fb b5 d9 31 5f 6e d6 906 0000230 24 1d a4 4a fe 32 a7 5c 16 48 5c 3e 08 6b 8a d3 907 0000240 25 1d a2 12 a5 59 24 ea 20 5f 52 6d ad 94 db 6b 908 0000250 94 b9 5d eb 4b a7 5c 44 bb 1e f2 3c 6b cf 52 c9 909 0000260 e9 e5 ba 06 b9 c4 e5 0a d0 00 0d d0 00 0d d0 00 910 0000270 0d d0 00 0d d0 00 0d d0 00 0d d0 00 0d d0 00 0d 911 0000280 d0 00 0d d0 00 0d d0 00 0d d0 00 0d d0 00 0d d0 912 0000290 00 0d d0 00 0d d0 00 0d d0 00 0d d0 00 0d d0 00 913 00002a0 0d d0 00 cd ff 9e 46 86 fa a7 7d 3a 43 d7 8e 10 914 00002b0 52 e9 be e6 6e cf eb 9e 85 4d 65 ce cc 30 c1 44 915 00002c0 c0 4e af bc 9c 6c 4b a0 d7 54 ff 1d d5 5c 89 fb 916 00002d0 b5 34 7e c4 c2 9e f5 a0 f6 5b 7e 6e ca 73 c7 ef 917 00002e0 5d be de f9 e8 81 eb a5 0a a5 63 54 2c d7 1c d1 918 00002f0 89 17 85 f8 16 94 f2 8a b2 a3 f5 b6 6d df 75 cd 919 0000300 90 dd 64 bd 5d 55 4e f2 55 19 1b b7 cc ef 1b ea 920 0000310 2e 05 9c f4 aa 1e a8 cd a6 82 c7 59 0f 5e 9d e0 921 0000320 bb fc 6c d6 99 23 eb 36 ad c6 c5 e1 d8 e1 e2 3e 922 0000330 d9 90 5a f7 91 5d 6f bc 33 6d 98 47 d2 7c 2e 2f 923 0000340 99 a4 25 72 85 49 2c be 0b 5b af 8f e5 6e 81 a6 924 0000350 a3 5a 6f 39 53 3a ab 7a 8b 1e 26 f7 46 6c 7d 26 925 0000360 53 b3 22 31 94 d3 83 f2 18 4d f5 92 33 27 53 97 926 0000370 0f d3 e6 55 9c a6 c5 31 87 6f d3 f3 ae 39 6f 56 927 0000380 10 7b ab 7e d0 b4 ca f2 b8 05 be 3f 0e 6e 5a 75 928 0000390 ab 0c f5 37 0e ba 8e 75 71 7a aa ed 7a dd 6a 63 929 00003a0 be 9b a0 97 27 6a 6f e7 d3 8b c4 7c ec d3 91 56 930 00003b0 d9 ac 5e bf 16 42 2f 00 1f 93 a2 23 87 bd e2 59 931 00003c0 a0 de 1a 66 c8 62 eb 55 8f 91 17 b4 61 42 7a 50 932 00003d0 40 03 34 40 03 34 40 03 34 40 03 34 40 03 34 40 933 00003e0 03 34 40 03 34 40 03 34 40 03 34 40 03 34 40 03 934 00003f0 34 40 03 34 40 03 34 ff 85 86 90 8b ea 67 90 0d 935 0000400 e1 42 1b d2 61 d6 79 ec fd 3e 44 28 a4 51 6c 5c 936 0000410 fc d2 72 ca ba 82 18 46 16 61 cd 93 a9 0f d1 24 937 0000420 17 99 e2 2c 71 16 84 0c c8 7a 13 0f 9a 5e c5 f0 938 0000430 79 64 e2 12 4d c8 82 a1 81 19 2d aa 44 6d 87 54 939 0000440 84 71 c1 f6 d4 ca 25 8c 77 b9 08 c7 c8 5e 10 8a 940 0000450 8f 61 ed 8c ba 30 1f 79 9a c7 60 34 2b b9 8c f8 941 0000460 18 a6 83 1b e3 9f ad 79 fe fd 1b 8b f1 fc 41 6f 942 0000470 d4 13 1f e3 b8 83 ba 64 92 e7 eb e4 77 05 8f ba 943 0000480 fa 3b 00 00 ff ff 50 4b 07 08 a6 18 b1 91 5e 04 944 0000490 00 00 e4 47 00 00 50 4b 01 02 14 00 14 00 08 00 945 00004a0 08 00 00 00 00 00 a6 18 b1 91 5e 04 00 00 e4 47 946 00004b0 00 00 0a 00 00 00 00 00 00 00 00 00 00 00 00 00 947 00004c0 00 00 00 00 62 69 67 67 65 72 2e 7a 69 70 50 4b 948 00004d0 05 06 00 00 00 00 01 00 01 00 38 00 00 00 96 04 949 00004e0 00 00 00 00` 950 s = regexp.MustCompile(`[0-9a-f]{7}`).ReplaceAllString(s, "") 951 s = regexp.MustCompile(`\s+`).ReplaceAllString(s, "") 952 b, err := hex.DecodeString(s) 953 if err != nil { 954 panic(err) 955 } 956 return b 957 } 958 959 func returnBigZipBytes() (r io.ReaderAt, size int64) { 960 b := biggestZipBytes() 961 for i := 0; i < 2; i++ { 962 r, err := NewReader(bytes.NewReader(b), int64(len(b))) 963 if err != nil { 964 panic(err) 965 } 966 f, err := r.File[0].Open() 967 if err != nil { 968 panic(err) 969 } 970 b, err = io.ReadAll(f) 971 if err != nil { 972 panic(err) 973 } 974 } 975 return bytes.NewReader(b), int64(len(b)) 976 } 977 978 func TestIssue8186(t *testing.T) { 979 // Directory headers & data found in the TOC of a JAR file. 980 dirEnts := []string{ 981 "PK\x01\x02\n\x00\n\x00\x00\b\x00\x004\x9d3?\xaa\x1b\x06\xf0\x81\x02\x00\x00\x81\x02\x00\x00-\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00res/drawable-xhdpi-v4/ic_actionbar_accept.png\xfe\xca\x00\x00\x00", 982 "PK\x01\x02\n\x00\n\x00\x00\b\x00\x004\x9d3?\x90K\x89\xc7t\n\x00\x00t\n\x00\x00\x0e\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x02\x00\x00resources.arsc\x00\x00\x00", 983 "PK\x01\x02\x14\x00\x14\x00\b\b\b\x004\x9d3?\xff$\x18\xed3\x03\x00\x00\xb4\b\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00t\r\x00\x00AndroidManifest.xml", 984 "PK\x01\x02\x14\x00\x14\x00\b\b\b\x004\x9d3?\x14\xc5K\xab\x192\x02\x00\xc8\xcd\x04\x00\v\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x10\x00\x00classes.dex", 985 "PK\x01\x02\x14\x00\x14\x00\b\b\b\x004\x9d3?E\x96\nD\xac\x01\x00\x00P\x03\x00\x00&\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00:C\x02\x00res/layout/actionbar_set_wallpaper.xml", 986 "PK\x01\x02\x14\x00\x14\x00\b\b\b\x004\x9d3?Ļ\x14\xe3\xd8\x01\x00\x00\xd8\x03\x00\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00:E\x02\x00res/layout/wallpaper_cropper.xml", 987 "PK\x01\x02\x14\x00\x14\x00\b\b\b\x004\x9d3?}\xc1\x15\x9eZ\x01\x00\x00!\x02\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00`G\x02\x00META-INF/MANIFEST.MF", 988 "PK\x01\x02\x14\x00\x14\x00\b\b\b\x004\x9d3?\xe6\x98Ьo\x01\x00\x00\x84\x02\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfcH\x02\x00META-INF/CERT.SF", 989 "PK\x01\x02\x14\x00\x14\x00\b\b\b\x004\x9d3?\xbfP\x96b\x86\x04\x00\x00\xb2\x06\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9J\x02\x00META-INF/CERT.RSA", 990 } 991 for i, s := range dirEnts { 992 var f File 993 err := readDirectoryHeader(&f, strings.NewReader(s)) 994 if err != nil { 995 t.Errorf("error reading #%d: %v", i, err) 996 } 997 } 998 } 999 1000 // Verify we return ErrUnexpectedEOF when length is short. 1001 func TestIssue10957(t *testing.T) { 1002 data := []byte("PK\x03\x040000000PK\x01\x0200000" + 1003 "0000000000000000000\x00" + 1004 "\x00\x00\x00\x00\x00000000000000PK\x01" + 1005 "\x020000000000000000000" + 1006 "00000\v\x00\x00\x00\x00\x00000000000" + 1007 "00000000000000PK\x01\x0200" + 1008 "00000000000000000000" + 1009 "00\v\x00\x00\x00\x00\x00000000000000" + 1010 "00000000000PK\x01\x020000<" + 1011 "0\x00\x0000000000000000\v\x00\v" + 1012 "\x00\x00\x00\x00\x0000000000\x00\x00\x00\x00000" + 1013 "00000000PK\x01\x0200000000" + 1014 "0000000000000000\v\x00\x00\x00" + 1015 "\x00\x0000PK\x05\x06000000\x05\x000000" + 1016 "\v\x00\x00\x00\x00\x00") 1017 z, err := NewReader(bytes.NewReader(data), int64(len(data))) 1018 if err != nil { 1019 t.Fatal(err) 1020 } 1021 for i, f := range z.File { 1022 r, err := f.Open() 1023 if err != nil { 1024 continue 1025 } 1026 if f.UncompressedSize64 < 1e6 { 1027 n, err := io.Copy(io.Discard, r) 1028 if i == 3 && err != io.ErrUnexpectedEOF { 1029 t.Errorf("File[3] error = %v; want io.ErrUnexpectedEOF", err) 1030 } 1031 if err == nil && uint64(n) != f.UncompressedSize64 { 1032 t.Errorf("file %d: bad size: copied=%d; want=%d", i, n, f.UncompressedSize64) 1033 } 1034 } 1035 r.Close() 1036 } 1037 } 1038 1039 // Verify that this particular malformed zip file is rejected. 1040 func TestIssue10956(t *testing.T) { 1041 data := []byte("PK\x06\x06PK\x06\a0000\x00\x00\x00\x00\x00\x00\x00\x00" + 1042 "0000PK\x05\x06000000000000" + 1043 "0000\v\x00000\x00\x00\x00\x00\x00\x00\x000") 1044 r, err := NewReader(bytes.NewReader(data), int64(len(data))) 1045 if err == nil { 1046 t.Errorf("got nil error, want ErrFormat") 1047 } 1048 if r != nil { 1049 t.Errorf("got non-nil Reader, want nil") 1050 } 1051 } 1052 1053 // Verify we return ErrUnexpectedEOF when reading truncated data descriptor. 1054 func TestIssue11146(t *testing.T) { 1055 data := []byte("PK\x03\x040000000000000000" + 1056 "000000\x01\x00\x00\x000\x01\x00\x00\xff\xff0000" + 1057 "0000000000000000PK\x01\x02" + 1058 "0000\b0\b\x00000000000000" + 1059 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x000000PK\x05\x06\x00\x00" + 1060 "\x00\x0000\x01\x0000008\x00\x00\x00\x00\x00") 1061 z, err := NewReader(bytes.NewReader(data), int64(len(data))) 1062 if err != nil { 1063 t.Fatal(err) 1064 } 1065 r, err := z.File[0].Open() 1066 if err != nil { 1067 t.Fatal(err) 1068 } 1069 _, err = io.ReadAll(r) 1070 if err != io.ErrUnexpectedEOF { 1071 t.Errorf("File[0] error = %v; want io.ErrUnexpectedEOF", err) 1072 } 1073 r.Close() 1074 } 1075 1076 // Verify we do not treat non-zip64 archives as zip64 1077 func TestIssue12449(t *testing.T) { 1078 data := []byte{ 1079 0x50, 0x4b, 0x03, 0x04, 0x14, 0x00, 0x08, 0x00, 1080 0x00, 0x00, 0x6b, 0xb4, 0xba, 0x46, 0x00, 0x00, 1081 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1082 0x00, 0x00, 0x03, 0x00, 0x18, 0x00, 0xca, 0x64, 1083 0x55, 0x75, 0x78, 0x0b, 0x00, 0x50, 0x4b, 0x05, 1084 0x06, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 1085 0x00, 0x49, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 1086 0x00, 0x31, 0x31, 0x31, 0x32, 0x32, 0x32, 0x0a, 1087 0x50, 0x4b, 0x07, 0x08, 0x1d, 0x88, 0x77, 0xb0, 1088 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 1089 0x50, 0x4b, 0x01, 0x02, 0x14, 0x03, 0x14, 0x00, 1090 0x08, 0x00, 0x00, 0x00, 0x6b, 0xb4, 0xba, 0x46, 1091 0x1d, 0x88, 0x77, 0xb0, 0x07, 0x00, 0x00, 0x00, 1092 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x18, 0x00, 1093 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1094 0xa0, 0x81, 0x00, 0x00, 0x00, 0x00, 0xca, 0x64, 1095 0x55, 0x75, 0x78, 0x0b, 0x00, 0x50, 0x4b, 0x05, 1096 0x06, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 1097 0x00, 0x49, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 1098 0x00, 0x97, 0x2b, 0x49, 0x23, 0x05, 0xc5, 0x0b, 1099 0xa7, 0xd1, 0x52, 0xa2, 0x9c, 0x50, 0x4b, 0x06, 1100 0x07, 0xc8, 0x19, 0xc1, 0xaf, 0x94, 0x9c, 0x61, 1101 0x44, 0xbe, 0x94, 0x19, 0x42, 0x58, 0x12, 0xc6, 1102 0x5b, 0x50, 0x4b, 0x05, 0x06, 0x00, 0x00, 0x00, 1103 0x00, 0x01, 0x00, 0x01, 0x00, 0x69, 0x00, 0x00, 1104 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 1105 } 1106 // Read in the archive. 1107 _, err := NewReader(bytes.NewReader([]byte(data)), int64(len(data))) 1108 if err != nil { 1109 t.Errorf("Error reading the archive: %v", err) 1110 } 1111 } 1112 1113 func TestFS(t *testing.T) { 1114 for _, test := range []struct { 1115 file string 1116 want []string 1117 }{ 1118 { 1119 "testdata/unix.zip", 1120 []string{"hello", "dir/bar", "readonly"}, 1121 }, 1122 { 1123 "testdata/subdir.zip", 1124 []string{"a/b/c"}, 1125 }, 1126 } { 1127 t.Run(test.file, func(t *testing.T) { 1128 t.Parallel() 1129 z, err := OpenReader(test.file) 1130 if err != nil { 1131 t.Fatal(err) 1132 } 1133 defer z.Close() 1134 if err := fstest.TestFS(z, test.want...); err != nil { 1135 t.Error(err) 1136 } 1137 }) 1138 } 1139 } 1140 1141 func TestFSModTime(t *testing.T) { 1142 t.Parallel() 1143 z, err := OpenReader("testdata/subdir.zip") 1144 if err != nil { 1145 t.Fatal(err) 1146 } 1147 defer z.Close() 1148 1149 for _, test := range []struct { 1150 name string 1151 want time.Time 1152 }{ 1153 { 1154 "a", 1155 time.Date(2021, 4, 19, 12, 29, 56, 0, timeZone(-7*time.Hour)).UTC(), 1156 }, 1157 { 1158 "a/b/c", 1159 time.Date(2021, 4, 19, 12, 29, 59, 0, timeZone(-7*time.Hour)).UTC(), 1160 }, 1161 } { 1162 fi, err := fs.Stat(z, test.name) 1163 if err != nil { 1164 t.Errorf("%s: %v", test.name, err) 1165 continue 1166 } 1167 if got := fi.ModTime(); !got.Equal(test.want) { 1168 t.Errorf("%s: got modtime %v, want %v", test.name, got, test.want) 1169 } 1170 } 1171 } 1172 1173 func TestCVE202127919(t *testing.T) { 1174 // Archive containing only the file "../test.txt" 1175 data := []byte{ 1176 0x50, 0x4b, 0x03, 0x04, 0x14, 0x00, 0x08, 0x00, 1177 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1178 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1179 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x2e, 0x2e, 1180 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x74, 0x78, 1181 0x74, 0x0a, 0xc9, 0xc8, 0x2c, 0x56, 0xc8, 0x2c, 1182 0x56, 0x48, 0x54, 0x28, 0x49, 0x2d, 0x2e, 0x51, 1183 0x28, 0x49, 0xad, 0x28, 0x51, 0x48, 0xcb, 0xcc, 1184 0x49, 0xd5, 0xe3, 0x02, 0x04, 0x00, 0x00, 0xff, 1185 0xff, 0x50, 0x4b, 0x07, 0x08, 0xc0, 0xd7, 0xed, 1186 0xc3, 0x20, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 1187 0x00, 0x50, 0x4b, 0x01, 0x02, 0x14, 0x00, 0x14, 1188 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 1189 0x00, 0xc0, 0xd7, 0xed, 0xc3, 0x20, 0x00, 0x00, 1190 0x00, 0x1a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 1191 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1192 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 1193 0x2e, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x74, 1194 0x78, 0x74, 0x50, 0x4b, 0x05, 0x06, 0x00, 0x00, 1195 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x39, 0x00, 1196 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x00, 0x00, 1197 } 1198 r, err := NewReader(bytes.NewReader([]byte(data)), int64(len(data))) 1199 if err != nil { 1200 t.Fatalf("Error reading the archive: %v", err) 1201 } 1202 _, err = r.Open("test.txt") 1203 if err != nil { 1204 t.Errorf("Error reading file: %v", err) 1205 } 1206 if len(r.File) != 1 { 1207 t.Fatalf("No entries in the file list") 1208 } 1209 if r.File[0].Name != "../test.txt" { 1210 t.Errorf("Unexpected entry name: %s", r.File[0].Name) 1211 } 1212 if _, err := r.File[0].Open(); err != nil { 1213 t.Errorf("Error opening file: %v", err) 1214 } 1215 } 1216 1217 func TestReadDataDescriptor(t *testing.T) { 1218 tests := []struct { 1219 desc string 1220 in []byte 1221 zip64 bool 1222 want *dataDescriptor 1223 wantErr error 1224 }{{ 1225 desc: "valid 32 bit with signature", 1226 in: []byte{ 1227 0x50, 0x4b, 0x07, 0x08, // signature 1228 0x00, 0x01, 0x02, 0x03, // crc32 1229 0x04, 0x05, 0x06, 0x07, // compressed size 1230 0x08, 0x09, 0x0a, 0x0b, // uncompressed size 1231 }, 1232 want: &dataDescriptor{ 1233 crc32: 0x03020100, 1234 compressedSize: 0x07060504, 1235 uncompressedSize: 0x0b0a0908, 1236 }, 1237 }, { 1238 desc: "valid 32 bit without signature", 1239 in: []byte{ 1240 0x00, 0x01, 0x02, 0x03, // crc32 1241 0x04, 0x05, 0x06, 0x07, // compressed size 1242 0x08, 0x09, 0x0a, 0x0b, // uncompressed size 1243 }, 1244 want: &dataDescriptor{ 1245 crc32: 0x03020100, 1246 compressedSize: 0x07060504, 1247 uncompressedSize: 0x0b0a0908, 1248 }, 1249 }, { 1250 desc: "valid 64 bit with signature", 1251 in: []byte{ 1252 0x50, 0x4b, 0x07, 0x08, // signature 1253 0x00, 0x01, 0x02, 0x03, // crc32 1254 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size 1255 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, // uncompressed size 1256 }, 1257 zip64: true, 1258 want: &dataDescriptor{ 1259 crc32: 0x03020100, 1260 compressedSize: 0x0b0a090807060504, 1261 uncompressedSize: 0x131211100f0e0d0c, 1262 }, 1263 }, { 1264 desc: "valid 64 bit without signature", 1265 in: []byte{ 1266 0x00, 0x01, 0x02, 0x03, // crc32 1267 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size 1268 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, // uncompressed size 1269 }, 1270 zip64: true, 1271 want: &dataDescriptor{ 1272 crc32: 0x03020100, 1273 compressedSize: 0x0b0a090807060504, 1274 uncompressedSize: 0x131211100f0e0d0c, 1275 }, 1276 }, { 1277 desc: "invalid 32 bit with signature", 1278 in: []byte{ 1279 0x50, 0x4b, 0x07, 0x08, // signature 1280 0x00, 0x01, 0x02, 0x03, // crc32 1281 0x04, 0x05, // unexpected end 1282 }, 1283 wantErr: io.ErrUnexpectedEOF, 1284 }, { 1285 desc: "invalid 32 bit without signature", 1286 in: []byte{ 1287 0x00, 0x01, 0x02, 0x03, // crc32 1288 0x04, 0x05, // unexpected end 1289 }, 1290 wantErr: io.ErrUnexpectedEOF, 1291 }, { 1292 desc: "invalid 64 bit with signature", 1293 in: []byte{ 1294 0x50, 0x4b, 0x07, 0x08, // signature 1295 0x00, 0x01, 0x02, 0x03, // crc32 1296 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size 1297 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, // unexpected end 1298 }, 1299 zip64: true, 1300 wantErr: io.ErrUnexpectedEOF, 1301 }, { 1302 desc: "invalid 64 bit without signature", 1303 in: []byte{ 1304 0x00, 0x01, 0x02, 0x03, // crc32 1305 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size 1306 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, // unexpected end 1307 }, 1308 zip64: true, 1309 wantErr: io.ErrUnexpectedEOF, 1310 }} 1311 1312 for _, test := range tests { 1313 t.Run(test.desc, func(t *testing.T) { 1314 r := bytes.NewReader(test.in) 1315 1316 desc, err := readDataDescriptor(r, test.zip64) 1317 if err != test.wantErr { 1318 t.Fatalf("got err %v; want nil", err) 1319 } 1320 if test.want == nil { 1321 return 1322 } 1323 if desc == nil { 1324 t.Fatalf("got nil DataDescriptor; want non-nil") 1325 } 1326 if desc.crc32 != test.want.crc32 { 1327 t.Errorf("got CRC32 %#x; want %#x", desc.crc32, test.want.crc32) 1328 } 1329 if desc.compressedSize != test.want.compressedSize { 1330 t.Errorf("got CompressedSize %#x; want %#x", desc.compressedSize, test.want.compressedSize) 1331 } 1332 if desc.uncompressedSize != test.want.uncompressedSize { 1333 t.Errorf("got UncompressedSize %#x; want %#x", desc.uncompressedSize, test.want.uncompressedSize) 1334 } 1335 }) 1336 } 1337 } 1338 1339 func TestCVE202133196(t *testing.T) { 1340 // Archive that indicates it has 1 << 128 -1 files, 1341 // this would previously cause a panic due to attempting 1342 // to allocate a slice with 1 << 128 -1 elements. 1343 data := []byte{ 1344 0x50, 0x4b, 0x03, 0x04, 0x14, 0x00, 0x08, 0x08, 1345 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1347 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02, 1348 0x03, 0x62, 0x61, 0x65, 0x03, 0x04, 0x00, 0x00, 1349 0xff, 0xff, 0x50, 0x4b, 0x07, 0x08, 0xbe, 0x20, 1350 0x5c, 0x6c, 0x09, 0x00, 0x00, 0x00, 0x03, 0x00, 1351 0x00, 0x00, 0x50, 0x4b, 0x01, 0x02, 0x14, 0x00, 1352 0x14, 0x00, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 1353 0x00, 0x00, 0xbe, 0x20, 0x5c, 0x6c, 0x09, 0x00, 1354 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 1355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1357 0x01, 0x02, 0x03, 0x50, 0x4b, 0x06, 0x06, 0x2c, 1358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 1359 0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1360 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 1361 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 1362 0xff, 0xff, 0xff, 0x31, 0x00, 0x00, 0x00, 0x00, 1363 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x00, 1364 0x00, 0x00, 0x00, 0x50, 0x4b, 0x06, 0x07, 0x00, 1365 0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x00, 1366 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 1367 0x4b, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0xff, 1368 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 1369 0xff, 0xff, 0xff, 0x00, 0x00, 1370 } 1371 _, err := NewReader(bytes.NewReader(data), int64(len(data))) 1372 if err != ErrFormat { 1373 t.Fatalf("unexpected error, got: %v, want: %v", err, ErrFormat) 1374 } 1375 1376 // Also check that an archive containing a handful of empty 1377 // files doesn't cause an issue 1378 b := bytes.NewBuffer(nil) 1379 w := NewWriter(b) 1380 for i := 0; i < 5; i++ { 1381 _, err := w.Create("") 1382 if err != nil { 1383 t.Fatalf("Writer.Create failed: %s", err) 1384 } 1385 } 1386 if err := w.Close(); err != nil { 1387 t.Fatalf("Writer.Close failed: %s", err) 1388 } 1389 r, err := NewReader(bytes.NewReader(b.Bytes()), int64(b.Len())) 1390 if err != nil { 1391 t.Fatalf("NewReader failed: %s", err) 1392 } 1393 if len(r.File) != 5 { 1394 t.Errorf("Archive has unexpected number of files, got %d, want 5", len(r.File)) 1395 } 1396 } 1397 1398 func TestCVE202139293(t *testing.T) { 1399 // directory size is so large, that the check in Reader.init 1400 // overflows when subtracting from the archive size, causing 1401 // the pre-allocation check to be bypassed. 1402 data := []byte{ 1403 0x50, 0x4b, 0x06, 0x06, 0x05, 0x06, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x4b, 1404 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 1405 0x00, 0x00, 0x50, 0x4b, 0x05, 0x06, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x4b, 1406 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 1407 0x00, 0x00, 0x00, 0x50, 0x4b, 0x05, 0x06, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 1408 0xff, 0x50, 0xfe, 0x00, 0xff, 0x00, 0x3a, 0x00, 0x00, 0x00, 0xff, 1409 } 1410 _, err := NewReader(bytes.NewReader(data), int64(len(data))) 1411 if err != ErrFormat { 1412 t.Fatalf("unexpected error, got: %v, want: %v", err, ErrFormat) 1413 } 1414 } 1415 1416 func TestCVE202141772(t *testing.T) { 1417 // Archive contains a file whose name is exclusively made up of '/', '\' 1418 // characters, or "../", "..\" paths, which would previously cause a panic. 1419 // 1420 // Length Method Size Cmpr Date Time CRC-32 Name 1421 // -------- ------ ------- ---- ---------- ----- -------- ---- 1422 // 0 Stored 0 0% 08-05-2021 18:32 00000000 / 1423 // 0 Stored 0 0% 09-14-2021 12:59 00000000 // 1424 // 0 Stored 0 0% 09-14-2021 12:59 00000000 \ 1425 // 11 Stored 11 0% 09-14-2021 13:04 0d4a1185 /test.txt 1426 // -------- ------- --- ------- 1427 // 11 11 0% 4 files 1428 data := []byte{ 1429 0x50, 0x4b, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x08, 1430 0x00, 0x00, 0x06, 0x94, 0x05, 0x53, 0x00, 0x00, 1431 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1432 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2f, 0x50, 1433 0x4b, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 1434 0x00, 0x78, 0x67, 0x2e, 0x53, 0x00, 0x00, 0x00, 1435 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1436 0x00, 0x02, 0x00, 0x00, 0x00, 0x2f, 0x2f, 0x50, 1437 0x4b, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 1438 0x00, 0x78, 0x67, 0x2e, 0x53, 0x00, 0x00, 0x00, 1439 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1440 0x00, 0x01, 0x00, 0x00, 0x00, 0x5c, 0x50, 0x4b, 1441 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 1442 0x91, 0x68, 0x2e, 0x53, 0x85, 0x11, 0x4a, 0x0d, 1443 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 1444 0x09, 0x00, 0x00, 0x00, 0x2f, 0x74, 0x65, 0x73, 1445 0x74, 0x2e, 0x74, 0x78, 0x74, 0x68, 0x65, 0x6c, 1446 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 1447 0x50, 0x4b, 0x01, 0x02, 0x14, 0x03, 0x0a, 0x00, 1448 0x00, 0x08, 0x00, 0x00, 0x06, 0x94, 0x05, 0x53, 1449 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1450 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 1451 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 1452 0xed, 0x41, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x50, 1453 0x4b, 0x01, 0x02, 0x3f, 0x00, 0x0a, 0x00, 0x00, 1454 0x00, 0x00, 0x00, 0x78, 0x67, 0x2e, 0x53, 0x00, 1455 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1456 0x00, 0x00, 0x00, 0x02, 0x00, 0x24, 0x00, 0x00, 1457 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 1458 0x00, 0x1f, 0x00, 0x00, 0x00, 0x2f, 0x2f, 0x0a, 1459 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 1460 0x00, 0x18, 0x00, 0x93, 0x98, 0x25, 0x57, 0x25, 1461 0xa9, 0xd7, 0x01, 0x93, 0x98, 0x25, 0x57, 0x25, 1462 0xa9, 0xd7, 0x01, 0x93, 0x98, 0x25, 0x57, 0x25, 1463 0xa9, 0xd7, 0x01, 0x50, 0x4b, 0x01, 0x02, 0x3f, 1464 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 1465 0x67, 0x2e, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 1466 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 1467 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1468 0x00, 0x20, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 1469 0x00, 0x5c, 0x0a, 0x00, 0x20, 0x00, 0x00, 0x00, 1470 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x93, 0x98, 1471 0x25, 0x57, 0x25, 0xa9, 0xd7, 0x01, 0x93, 0x98, 1472 0x25, 0x57, 0x25, 0xa9, 0xd7, 0x01, 0x93, 0x98, 1473 0x25, 0x57, 0x25, 0xa9, 0xd7, 0x01, 0x50, 0x4b, 1474 0x01, 0x02, 0x3f, 0x00, 0x0a, 0x00, 0x00, 0x00, 1475 0x00, 0x00, 0x91, 0x68, 0x2e, 0x53, 0x85, 0x11, 1476 0x4a, 0x0d, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 1477 0x00, 0x00, 0x09, 0x00, 0x24, 0x00, 0x00, 0x00, 1478 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 1479 0x5e, 0x00, 0x00, 0x00, 0x2f, 0x74, 0x65, 0x73, 1480 0x74, 0x2e, 0x74, 0x78, 0x74, 0x0a, 0x00, 0x20, 1481 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 1482 0x00, 0xa9, 0x80, 0x51, 0x01, 0x26, 0xa9, 0xd7, 1483 0x01, 0x31, 0xd1, 0x57, 0x01, 0x26, 0xa9, 0xd7, 1484 0x01, 0xdf, 0x48, 0x85, 0xf9, 0x25, 0xa9, 0xd7, 1485 0x01, 0x50, 0x4b, 0x05, 0x06, 0x00, 0x00, 0x00, 1486 0x00, 0x04, 0x00, 0x04, 0x00, 0x31, 0x01, 0x00, 1487 0x00, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 1488 } 1489 r, err := NewReader(bytes.NewReader([]byte(data)), int64(len(data))) 1490 if err != nil { 1491 t.Fatalf("Error reading the archive: %v", err) 1492 } 1493 entryNames := []string{`/`, `//`, `\`, `/test.txt`} 1494 var names []string 1495 for _, f := range r.File { 1496 names = append(names, f.Name) 1497 if _, err := f.Open(); err != nil { 1498 t.Errorf("Error opening %q: %v", f.Name, err) 1499 } 1500 if _, err := r.Open(f.Name); err == nil { 1501 t.Errorf("Opening %q with fs.FS API succeeded", f.Name) 1502 } 1503 } 1504 if !reflect.DeepEqual(names, entryNames) { 1505 t.Errorf("Unexpected file entries: %q", names) 1506 } 1507 if _, err := r.Open(""); err == nil { 1508 t.Errorf("Opening %q with fs.FS API succeeded", "") 1509 } 1510 if _, err := r.Open("test.txt"); err != nil { 1511 t.Errorf("Error opening %q with fs.FS API: %v", "test.txt", err) 1512 } 1513 dirEntries, err := fs.ReadDir(r, ".") 1514 if err != nil { 1515 t.Fatalf("Error reading the root directory: %v", err) 1516 } 1517 if len(dirEntries) != 1 || dirEntries[0].Name() != "test.txt" { 1518 t.Errorf("Unexpected directory entries") 1519 for _, dirEntry := range dirEntries { 1520 _, err := r.Open(dirEntry.Name()) 1521 t.Logf("%q (Open error: %v)", dirEntry.Name(), err) 1522 } 1523 t.FailNow() 1524 } 1525 info, err := dirEntries[0].Info() 1526 if err != nil { 1527 t.Fatalf("Error reading info entry: %v", err) 1528 } 1529 if name := info.Name(); name != "test.txt" { 1530 t.Errorf("Inconsistent name in info entry: %v", name) 1531 } 1532 }