Source file
src/archive/zip/reader_test.go
1
2
3
4
5 package zip
6
7 import (
8 "bytes"
9 "encoding/binary"
10 "encoding/hex"
11 "internal/obscuretestdata"
12 "io"
13 "io/fs"
14 "os"
15 "path/filepath"
16 "regexp"
17 "slices"
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)
27 Comment string
28 File []ZipTestFile
29 Obscured bool
30 Error error
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
41
42
43
44
45
46
47
48
49
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: "test-prefix.zip",
95 Comment: "This is a zipfile comment.",
96 File: []ZipTestFile{
97 {
98 Name: "test.txt",
99 Content: []byte("This is a test text file.\n"),
100 Modified: time.Date(2010, 9, 5, 12, 12, 1, 0, timeZone(+10*time.Hour)),
101 Mode: 0644,
102 },
103 {
104 Name: "gophercolor16x16.png",
105 File: "gophercolor16x16.png",
106 Modified: time.Date(2010, 9, 5, 15, 52, 58, 0, timeZone(+10*time.Hour)),
107 Mode: 0644,
108 },
109 },
110 },
111 {
112 Name: "test-baddirsz.zip",
113 Comment: "This is a zipfile comment.",
114 File: []ZipTestFile{
115 {
116 Name: "test.txt",
117 Content: []byte("This is a test text file.\n"),
118 Modified: time.Date(2010, 9, 5, 12, 12, 1, 0, timeZone(+10*time.Hour)),
119 Mode: 0644,
120 },
121 {
122 Name: "gophercolor16x16.png",
123 File: "gophercolor16x16.png",
124 Modified: time.Date(2010, 9, 5, 15, 52, 58, 0, timeZone(+10*time.Hour)),
125 Mode: 0644,
126 },
127 },
128 },
129 {
130 Name: "test-badbase.zip",
131 Comment: "This is a zipfile comment.",
132 File: []ZipTestFile{
133 {
134 Name: "test.txt",
135 Content: []byte("This is a test text file.\n"),
136 Modified: time.Date(2010, 9, 5, 12, 12, 1, 0, timeZone(+10*time.Hour)),
137 Mode: 0644,
138 },
139 {
140 Name: "gophercolor16x16.png",
141 File: "gophercolor16x16.png",
142 Modified: time.Date(2010, 9, 5, 15, 52, 58, 0, timeZone(+10*time.Hour)),
143 Mode: 0644,
144 },
145 },
146 },
147 {
148 Name: "r.zip",
149 Source: returnRecursiveZip,
150 File: []ZipTestFile{
151 {
152 Name: "r/r.zip",
153 Content: rZipBytes(),
154 Modified: time.Date(2010, 3, 4, 0, 24, 16, 0, time.UTC),
155 Mode: 0666,
156 },
157 },
158 },
159 {
160 Name: "symlink.zip",
161 File: []ZipTestFile{
162 {
163 Name: "symlink",
164 Content: []byte("../target"),
165 Modified: time.Date(2012, 2, 3, 19, 56, 48, 0, timeZone(-2*time.Hour)),
166 Mode: 0777 | fs.ModeSymlink,
167 },
168 },
169 },
170 {
171 Name: "readme.zip",
172 },
173 {
174 Name: "readme.notzip",
175 Error: ErrFormat,
176 },
177 {
178 Name: "dd.zip",
179 File: []ZipTestFile{
180 {
181 Name: "filename",
182 Content: []byte("This is a test textfile.\n"),
183 Modified: time.Date(2011, 2, 2, 13, 6, 20, 0, time.UTC),
184 Mode: 0666,
185 },
186 },
187 },
188 {
189
190 Name: "winxp.zip",
191 File: []ZipTestFile{
192 {
193 Name: "hello",
194 Content: []byte("world \r\n"),
195 Modified: time.Date(2011, 12, 8, 10, 4, 24, 0, time.UTC),
196 Mode: 0666,
197 },
198 {
199 Name: "dir/bar",
200 Content: []byte("foo \r\n"),
201 Modified: time.Date(2011, 12, 8, 10, 4, 50, 0, time.UTC),
202 Mode: 0666,
203 },
204 {
205 Name: "dir/empty/",
206 Content: []byte{},
207 Modified: time.Date(2011, 12, 8, 10, 8, 6, 0, time.UTC),
208 Mode: fs.ModeDir | 0777,
209 },
210 {
211 Name: "readonly",
212 Content: []byte("important \r\n"),
213 Modified: time.Date(2011, 12, 8, 10, 6, 8, 0, time.UTC),
214 Mode: 0444,
215 },
216 },
217 },
218 {
219
220 Name: "unix.zip",
221 File: []ZipTestFile{
222 {
223 Name: "hello",
224 Content: []byte("world \r\n"),
225 Modified: time.Date(2011, 12, 8, 10, 4, 24, 0, timeZone(0)),
226 Mode: 0666,
227 },
228 {
229 Name: "dir/bar",
230 Content: []byte("foo \r\n"),
231 Modified: time.Date(2011, 12, 8, 10, 4, 50, 0, timeZone(0)),
232 Mode: 0666,
233 },
234 {
235 Name: "dir/empty/",
236 Content: []byte{},
237 Modified: time.Date(2011, 12, 8, 10, 8, 6, 0, timeZone(0)),
238 Mode: fs.ModeDir | 0777,
239 },
240 {
241 Name: "readonly",
242 Content: []byte("important \r\n"),
243 Modified: time.Date(2011, 12, 8, 10, 6, 8, 0, timeZone(0)),
244 Mode: 0444,
245 },
246 },
247 },
248 {
249
250
251
252
253
254 Name: "go-no-datadesc-sig.zip.base64",
255 Obscured: true,
256 File: []ZipTestFile{
257 {
258 Name: "foo.txt",
259 Content: []byte("foo\n"),
260 Modified: time.Date(2012, 3, 8, 16, 59, 10, 0, timeZone(-8*time.Hour)),
261 Mode: 0644,
262 },
263 {
264 Name: "bar.txt",
265 Content: []byte("bar\n"),
266 Modified: time.Date(2012, 3, 8, 16, 59, 12, 0, timeZone(-8*time.Hour)),
267 Mode: 0644,
268 },
269 },
270 },
271 {
272
273
274 Name: "go-with-datadesc-sig.zip",
275 File: []ZipTestFile{
276 {
277 Name: "foo.txt",
278 Content: []byte("foo\n"),
279 Modified: time.Date(1979, 11, 30, 0, 0, 0, 0, time.UTC),
280 Mode: 0666,
281 },
282 {
283 Name: "bar.txt",
284 Content: []byte("bar\n"),
285 Modified: time.Date(1979, 11, 30, 0, 0, 0, 0, time.UTC),
286 Mode: 0666,
287 },
288 },
289 },
290 {
291 Name: "Bad-CRC32-in-data-descriptor",
292 Source: returnCorruptCRC32Zip,
293 File: []ZipTestFile{
294 {
295 Name: "foo.txt",
296 Content: []byte("foo\n"),
297 Modified: time.Date(1979, 11, 30, 0, 0, 0, 0, time.UTC),
298 Mode: 0666,
299 ContentErr: ErrChecksum,
300 },
301 {
302 Name: "bar.txt",
303 Content: []byte("bar\n"),
304 Modified: time.Date(1979, 11, 30, 0, 0, 0, 0, time.UTC),
305 Mode: 0666,
306 },
307 },
308 },
309
310
311 {
312 Name: "crc32-not-streamed.zip",
313 File: []ZipTestFile{
314 {
315 Name: "foo.txt",
316 Content: []byte("foo\n"),
317 Modified: time.Date(2012, 3, 8, 16, 59, 10, 0, timeZone(-8*time.Hour)),
318 Mode: 0644,
319 },
320 {
321 Name: "bar.txt",
322 Content: []byte("bar\n"),
323 Modified: time.Date(2012, 3, 8, 16, 59, 12, 0, timeZone(-8*time.Hour)),
324 Mode: 0644,
325 },
326 },
327 },
328
329
330 {
331 Name: "crc32-not-streamed.zip",
332 Source: returnCorruptNotStreamedZip,
333 File: []ZipTestFile{
334 {
335 Name: "foo.txt",
336 Content: []byte("foo\n"),
337 Modified: time.Date(2012, 3, 8, 16, 59, 10, 0, timeZone(-8*time.Hour)),
338 Mode: 0644,
339 ContentErr: ErrChecksum,
340 },
341 {
342 Name: "bar.txt",
343 Content: []byte("bar\n"),
344 Modified: time.Date(2012, 3, 8, 16, 59, 12, 0, timeZone(-8*time.Hour)),
345 Mode: 0644,
346 },
347 },
348 },
349 {
350 Name: "zip64.zip",
351 File: []ZipTestFile{
352 {
353 Name: "README",
354 Content: []byte("This small file is in ZIP64 format.\n"),
355 Modified: time.Date(2012, 8, 10, 14, 33, 32, 0, time.UTC),
356 Mode: 0644,
357 },
358 },
359 },
360
361 {
362 Name: "zip64-2.zip",
363 File: []ZipTestFile{
364 {
365 Name: "README",
366 Content: []byte("This small file is in ZIP64 format.\n"),
367 Modified: time.Date(2012, 8, 10, 14, 33, 32, 0, timeZone(-4*time.Hour)),
368 Mode: 0644,
369 },
370 },
371 },
372
373 {
374 Name: "big.zip",
375 Source: returnBigZipBytes,
376 File: []ZipTestFile{
377 {
378 Name: "big.file",
379 Content: nil,
380 Size: 1<<32 - 1,
381 Modified: time.Date(1979, 11, 30, 0, 0, 0, 0, time.UTC),
382 Mode: 0666,
383 },
384 },
385 },
386 {
387 Name: "utf8-7zip.zip",
388 File: []ZipTestFile{
389 {
390 Name: "世界",
391 Content: []byte{},
392 Mode: 0666,
393 Modified: time.Date(2017, 11, 6, 13, 9, 27, 867862500, timeZone(-8*time.Hour)),
394 },
395 },
396 },
397 {
398 Name: "utf8-infozip.zip",
399 File: []ZipTestFile{
400 {
401 Name: "世界",
402 Content: []byte{},
403 Mode: 0644,
404
405
406
407
408 NonUTF8: true,
409 Modified: time.Date(2017, 11, 6, 13, 9, 27, 0, timeZone(-8*time.Hour)),
410 },
411 },
412 },
413 {
414 Name: "utf8-osx.zip",
415 File: []ZipTestFile{
416 {
417 Name: "世界",
418 Content: []byte{},
419 Mode: 0644,
420
421 NonUTF8: true,
422 Modified: time.Date(2017, 11, 6, 13, 9, 27, 0, timeZone(-8*time.Hour)),
423 },
424 },
425 },
426 {
427 Name: "utf8-winrar.zip",
428 File: []ZipTestFile{
429 {
430 Name: "世界",
431 Content: []byte{},
432 Mode: 0666,
433 Modified: time.Date(2017, 11, 6, 13, 9, 27, 867862500, timeZone(-8*time.Hour)),
434 },
435 },
436 },
437 {
438 Name: "utf8-winzip.zip",
439 File: []ZipTestFile{
440 {
441 Name: "世界",
442 Content: []byte{},
443 Mode: 0666,
444 Modified: time.Date(2017, 11, 6, 13, 9, 27, 867000000, timeZone(-8*time.Hour)),
445 },
446 },
447 },
448 {
449 Name: "time-7zip.zip",
450 File: []ZipTestFile{
451 {
452 Name: "test.txt",
453 Content: []byte{},
454 Size: 1<<32 - 1,
455 Modified: time.Date(2017, 10, 31, 21, 11, 57, 244817900, timeZone(-7*time.Hour)),
456 Mode: 0666,
457 },
458 },
459 },
460 {
461 Name: "time-infozip.zip",
462 File: []ZipTestFile{
463 {
464 Name: "test.txt",
465 Content: []byte{},
466 Size: 1<<32 - 1,
467 Modified: time.Date(2017, 10, 31, 21, 11, 57, 0, timeZone(-7*time.Hour)),
468 Mode: 0644,
469 },
470 },
471 },
472 {
473 Name: "time-osx.zip",
474 File: []ZipTestFile{
475 {
476 Name: "test.txt",
477 Content: []byte{},
478 Size: 1<<32 - 1,
479 Modified: time.Date(2017, 10, 31, 21, 11, 57, 0, timeZone(-7*time.Hour)),
480 Mode: 0644,
481 },
482 },
483 },
484 {
485 Name: "time-win7.zip",
486 File: []ZipTestFile{
487 {
488 Name: "test.txt",
489 Content: []byte{},
490 Size: 1<<32 - 1,
491 Modified: time.Date(2017, 10, 31, 21, 11, 58, 0, time.UTC),
492 Mode: 0666,
493 },
494 },
495 },
496 {
497 Name: "time-winrar.zip",
498 File: []ZipTestFile{
499 {
500 Name: "test.txt",
501 Content: []byte{},
502 Size: 1<<32 - 1,
503 Modified: time.Date(2017, 10, 31, 21, 11, 57, 244817900, timeZone(-7*time.Hour)),
504 Mode: 0666,
505 },
506 },
507 },
508 {
509 Name: "time-winzip.zip",
510 File: []ZipTestFile{
511 {
512 Name: "test.txt",
513 Content: []byte{},
514 Size: 1<<32 - 1,
515 Modified: time.Date(2017, 10, 31, 21, 11, 57, 244000000, timeZone(-7*time.Hour)),
516 Mode: 0666,
517 },
518 },
519 },
520 {
521 Name: "time-go.zip",
522 File: []ZipTestFile{
523 {
524 Name: "test.txt",
525 Content: []byte{},
526 Size: 1<<32 - 1,
527 Modified: time.Date(2017, 10, 31, 21, 11, 57, 0, timeZone(-7*time.Hour)),
528 Mode: 0666,
529 },
530 },
531 },
532 {
533 Name: "time-22738.zip",
534 File: []ZipTestFile{
535 {
536 Name: "file",
537 Content: []byte{},
538 Mode: 0666,
539 Modified: time.Date(1999, 12, 31, 19, 0, 0, 0, timeZone(-5*time.Hour)),
540 ModTime: time.Date(1999, 12, 31, 19, 0, 0, 0, time.UTC),
541 },
542 },
543 },
544 {
545 Name: "dupdir.zip",
546 File: []ZipTestFile{
547 {
548 Name: "a/",
549 Content: []byte{},
550 Mode: fs.ModeDir | 0666,
551 Modified: time.Date(2021, 12, 29, 0, 0, 0, 0, timeZone(0)),
552 },
553 {
554 Name: "a/b",
555 Content: []byte{},
556 Mode: 0666,
557 Modified: time.Date(2021, 12, 29, 0, 0, 0, 0, timeZone(0)),
558 },
559 {
560 Name: "a/b/",
561 Content: []byte{},
562 Mode: fs.ModeDir | 0666,
563 Modified: time.Date(2021, 12, 29, 0, 0, 0, 0, timeZone(0)),
564 },
565 {
566 Name: "a/b/c",
567 Content: []byte{},
568 Mode: 0666,
569 Modified: time.Date(2021, 12, 29, 0, 0, 0, 0, timeZone(0)),
570 },
571 },
572 },
573
574
575
576
577 {
578 Name: "comment-truncated.zip",
579 Error: ErrFormat,
580 },
581 }
582
583 func TestReader(t *testing.T) {
584 for _, zt := range tests {
585 t.Run(zt.Name, func(t *testing.T) {
586 readTestZip(t, zt)
587 })
588 }
589 }
590
591 func readTestZip(t *testing.T, zt ZipTest) {
592 var z *Reader
593 var err error
594 var raw []byte
595 if zt.Source != nil {
596 rat, size := zt.Source()
597 z, err = NewReader(rat, size)
598 raw = make([]byte, size)
599 if _, err := rat.ReadAt(raw, 0); err != nil {
600 t.Errorf("ReadAt error=%v", err)
601 return
602 }
603 } else {
604 path := filepath.Join("testdata", zt.Name)
605 if zt.Obscured {
606 tf, err := obscuretestdata.DecodeToTempFile(path)
607 if err != nil {
608 t.Errorf("obscuretestdata.DecodeToTempFile(%s): %v", path, err)
609 return
610 }
611 defer os.Remove(tf)
612 path = tf
613 }
614 var rc *ReadCloser
615 rc, err = OpenReader(path)
616 if err == nil {
617 defer rc.Close()
618 z = &rc.Reader
619 }
620 var err2 error
621 raw, err2 = os.ReadFile(path)
622 if err2 != nil {
623 t.Errorf("ReadFile(%s) error=%v", path, err2)
624 return
625 }
626 }
627 if err != zt.Error {
628 t.Errorf("error=%v, want %v", err, zt.Error)
629 return
630 }
631
632
633 if err == ErrFormat {
634 return
635 }
636
637
638
639 if zt.File == nil {
640 return
641 }
642
643 if z.Comment != zt.Comment {
644 t.Errorf("comment=%q, want %q", z.Comment, zt.Comment)
645 }
646 if len(z.File) != len(zt.File) {
647 t.Fatalf("file count=%d, want %d", len(z.File), len(zt.File))
648 }
649
650
651 for i, ft := range zt.File {
652 readTestFile(t, zt, ft, z.File[i], raw)
653 }
654 if t.Failed() {
655 return
656 }
657
658
659 n := 0
660 done := make(chan bool)
661 for i := 0; i < 5; i++ {
662 for j, ft := range zt.File {
663 go func(j int, ft ZipTestFile) {
664 readTestFile(t, zt, ft, z.File[j], raw)
665 done <- true
666 }(j, ft)
667 n++
668 }
669 }
670 for ; n > 0; n-- {
671 <-done
672 }
673 }
674
675 func equalTimeAndZone(t1, t2 time.Time) bool {
676 name1, offset1 := t1.Zone()
677 name2, offset2 := t2.Zone()
678 return t1.Equal(t2) && name1 == name2 && offset1 == offset2
679 }
680
681 func readTestFile(t *testing.T, zt ZipTest, ft ZipTestFile, f *File, raw []byte) {
682 if f.Name != ft.Name {
683 t.Errorf("name=%q, want %q", f.Name, ft.Name)
684 }
685 if !ft.Modified.IsZero() && !equalTimeAndZone(f.Modified, ft.Modified) {
686 t.Errorf("%s: Modified=%s, want %s", f.Name, f.Modified, ft.Modified)
687 }
688 if !ft.ModTime.IsZero() && !equalTimeAndZone(f.ModTime(), ft.ModTime) {
689 t.Errorf("%s: ModTime=%s, want %s", f.Name, f.ModTime(), ft.ModTime)
690 }
691
692 testFileMode(t, f, ft.Mode)
693
694 size := uint64(f.UncompressedSize)
695 if size == uint32max {
696 size = f.UncompressedSize64
697 } else if size != f.UncompressedSize64 {
698 t.Errorf("%v: UncompressedSize=%#x does not match UncompressedSize64=%#x", f.Name, size, f.UncompressedSize64)
699 }
700
701
702 rw, err := f.OpenRaw()
703 if err != nil {
704 t.Errorf("%v: OpenRaw error=%v", f.Name, err)
705 return
706 }
707 start, err := f.DataOffset()
708 if err != nil {
709 t.Errorf("%v: DataOffset error=%v", f.Name, err)
710 return
711 }
712 got, err := io.ReadAll(rw)
713 if err != nil {
714 t.Errorf("%v: OpenRaw ReadAll error=%v", f.Name, err)
715 return
716 }
717 end := uint64(start) + f.CompressedSize64
718 want := raw[start:end]
719 if !bytes.Equal(got, want) {
720 t.Logf("got %q", got)
721 t.Logf("want %q", want)
722 t.Errorf("%v: OpenRaw returned unexpected bytes", f.Name)
723 return
724 }
725
726 r, err := f.Open()
727 if err != nil {
728 t.Errorf("%v", err)
729 return
730 }
731
732
733
734
735 if ft.Content == nil && ft.File == "" && ft.Size > 0 {
736 if size != ft.Size {
737 t.Errorf("%v: uncompressed size %#x, want %#x", ft.Name, size, ft.Size)
738 }
739 r.Close()
740 return
741 }
742
743 var b bytes.Buffer
744 _, err = io.Copy(&b, r)
745 if err != ft.ContentErr {
746 t.Errorf("copying contents: %v (want %v)", err, ft.ContentErr)
747 }
748 if err != nil {
749 return
750 }
751 r.Close()
752
753 if g := uint64(b.Len()); g != size {
754 t.Errorf("%v: read %v bytes but f.UncompressedSize == %v", f.Name, g, size)
755 }
756
757 var c []byte
758 if ft.Content != nil {
759 c = ft.Content
760 } else if c, err = os.ReadFile("testdata/" + ft.File); err != nil {
761 t.Error(err)
762 return
763 }
764
765 if b.Len() != len(c) {
766 t.Errorf("%s: len=%d, want %d", f.Name, b.Len(), len(c))
767 return
768 }
769
770 for i, b := range b.Bytes() {
771 if b != c[i] {
772 t.Errorf("%s: content[%d]=%q want %q", f.Name, i, b, c[i])
773 return
774 }
775 }
776 }
777
778 func testFileMode(t *testing.T, f *File, want fs.FileMode) {
779 mode := f.Mode()
780 if want == 0 {
781 t.Errorf("%s mode: got %v, want none", f.Name, mode)
782 } else if mode != want {
783 t.Errorf("%s mode: want %v, got %v", f.Name, want, mode)
784 }
785 }
786
787 func TestInvalidFiles(t *testing.T) {
788 const size = 1024 * 70
789 b := make([]byte, size)
790
791
792 _, err := NewReader(bytes.NewReader(b), size)
793 if err != ErrFormat {
794 t.Errorf("zeroes: error=%v, want %v", err, ErrFormat)
795 }
796
797
798 sig := make([]byte, 4)
799 binary.LittleEndian.PutUint32(sig, directoryEndSignature)
800 for i := 0; i < size-4; i += 4 {
801 copy(b[i:i+4], sig)
802 }
803 _, err = NewReader(bytes.NewReader(b), size)
804 if err != ErrFormat {
805 t.Errorf("sigs: error=%v, want %v", err, ErrFormat)
806 }
807
808
809 _, err = NewReader(bytes.NewReader([]byte("foobar")), -1)
810 if err == nil {
811 t.Errorf("archive/zip.NewReader: expected error when negative size is passed")
812 }
813 }
814
815 func messWith(fileName string, corrupter func(b []byte)) (r io.ReaderAt, size int64) {
816 data, err := os.ReadFile(filepath.Join("testdata", fileName))
817 if err != nil {
818 panic("Error reading " + fileName + ": " + err.Error())
819 }
820 corrupter(data)
821 return bytes.NewReader(data), int64(len(data))
822 }
823
824 func returnCorruptCRC32Zip() (r io.ReaderAt, size int64) {
825 return messWith("go-with-datadesc-sig.zip", func(b []byte) {
826
827 b[0x2d]++
828 })
829 }
830
831 func returnCorruptNotStreamedZip() (r io.ReaderAt, size int64) {
832 return messWith("crc32-not-streamed.zip", func(b []byte) {
833
834
835 b[0x11]++
836 b[0x9d]++
837
838
839
840
841
842
843
844 })
845 }
846
847
848
849 func rZipBytes() []byte {
850 s := `
851 0000000 50 4b 03 04 14 00 00 00 08 00 08 03 64 3c f9 f4
852 0000010 89 64 48 01 00 00 b8 01 00 00 07 00 00 00 72 2f
853 0000020 72 2e 7a 69 70 00 25 00 da ff 50 4b 03 04 14 00
854 0000030 00 00 08 00 08 03 64 3c f9 f4 89 64 48 01 00 00
855 0000040 b8 01 00 00 07 00 00 00 72 2f 72 2e 7a 69 70 00
856 0000050 2f 00 d0 ff 00 25 00 da ff 50 4b 03 04 14 00 00
857 0000060 00 08 00 08 03 64 3c f9 f4 89 64 48 01 00 00 b8
858 0000070 01 00 00 07 00 00 00 72 2f 72 2e 7a 69 70 00 2f
859 0000080 00 d0 ff c2 54 8e 57 39 00 05 00 fa ff c2 54 8e
860 0000090 57 39 00 05 00 fa ff 00 05 00 fa ff 00 14 00 eb
861 00000a0 ff c2 54 8e 57 39 00 05 00 fa ff 00 05 00 fa ff
862 00000b0 00 14 00 eb ff 42 88 21 c4 00 00 14 00 eb ff 42
863 00000c0 88 21 c4 00 00 14 00 eb ff 42 88 21 c4 00 00 14
864 00000d0 00 eb ff 42 88 21 c4 00 00 14 00 eb ff 42 88 21
865 00000e0 c4 00 00 00 00 ff ff 00 00 00 ff ff 00 34 00 cb
866 00000f0 ff 42 88 21 c4 00 00 00 00 ff ff 00 00 00 ff ff
867 0000100 00 34 00 cb ff 42 e8 21 5e 0f 00 00 00 ff ff 0a
868 0000110 f0 66 64 12 61 c0 15 dc e8 a0 48 bf 48 af 2a b3
869 0000120 20 c0 9b 95 0d c4 67 04 42 53 06 06 06 40 00 06
870 0000130 00 f9 ff 6d 01 00 00 00 00 42 e8 21 5e 0f 00 00
871 0000140 00 ff ff 0a f0 66 64 12 61 c0 15 dc e8 a0 48 bf
872 0000150 48 af 2a b3 20 c0 9b 95 0d c4 67 04 42 53 06 06
873 0000160 06 40 00 06 00 f9 ff 6d 01 00 00 00 00 50 4b 01
874 0000170 02 14 00 14 00 00 00 08 00 08 03 64 3c f9 f4 89
875 0000180 64 48 01 00 00 b8 01 00 00 07 00 00 00 00 00 00
876 0000190 00 00 00 00 00 00 00 00 00 00 00 72 2f 72 2e 7a
877 00001a0 69 70 50 4b 05 06 00 00 00 00 01 00 01 00 35 00
878 00001b0 00 00 6d 01 00 00 00 00`
879 s = regexp.MustCompile(`[0-9a-f]{7}`).ReplaceAllString(s, "")
880 s = regexp.MustCompile(`\s+`).ReplaceAllString(s, "")
881 b, err := hex.DecodeString(s)
882 if err != nil {
883 panic(err)
884 }
885 return b
886 }
887
888 func returnRecursiveZip() (r io.ReaderAt, size int64) {
889 b := rZipBytes()
890 return bytes.NewReader(b), int64(len(b))
891 }
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957 func biggestZipBytes() []byte {
958 s := `
959 0000000 50 4b 03 04 14 00 08 00 08 00 00 00 00 00 00 00
960 0000010 00 00 00 00 00 00 00 00 00 00 0a 00 00 00 62 69
961 0000020 67 67 65 72 2e 7a 69 70 ec dc 6b 4c 53 67 18 07
962 0000030 f0 16 c5 ca 65 2e cb b8 94 20 61 1f 44 33 c7 cd
963 0000040 c0 86 4a b5 c0 62 8a 61 05 c6 cd 91 b2 54 8c 1b
964 0000050 63 8b 03 9c 1b 95 52 5a e3 a0 19 6c b2 05 59 44
965 0000060 64 9d 73 83 71 11 46 61 14 b9 1d 14 09 4a c3 60
966 0000070 2e 4c 6e a5 60 45 02 62 81 95 b6 94 9e 9e 77 e7
967 0000080 d0 43 b6 f8 71 df 96 3c e7 a4 69 ce bf cf e9 79
968 0000090 ce ef 79 3f bf f1 31 db b6 bb 31 76 92 e7 f3 07
969 00000a0 8b fc 9c ca cc 08 cc cb cc 5e d2 1c 88 d9 7e bb
970 00000b0 4f bb 3a 3f 75 f1 5d 7f 8f c2 68 67 77 8f 25 ff
971 00000c0 84 e2 93 2d ef a4 95 3d 71 4e 2c b9 b0 87 c3 be
972 00000d0 3d f8 a7 60 24 61 c5 ef ae 9e c8 6c 6d 4e 69 c8
973 00000e0 67 65 34 f8 37 76 2d 76 5c 54 f3 95 65 49 c7 0f
974 00000f0 18 71 4b 7e 5b 6a d1 79 47 61 41 b0 4e 2a 74 45
975 0000100 43 58 12 b2 5a a5 c6 7d 68 55 88 d4 98 75 18 6d
976 0000110 08 d1 1f 8f 5a 9e 96 ee 45 cf a4 84 4e 4b e8 50
977 0000120 a7 13 d9 06 de 52 81 97 36 b2 d7 b8 fc 2b 5f 55
978 0000130 23 1f 32 59 cf 30 27 fb e2 8a b9 de 45 dd 63 9c
979 0000140 4b b5 8b 96 4c 7a 62 62 cc a1 a7 cf fa f1 fe dd
980 0000150 54 62 11 bf 36 78 b3 c7 b1 b5 f2 61 4d 4e dd 66
981 0000160 32 2e e6 70 34 5f f4 c9 e6 6c 43 6f da 6b c6 c3
982 0000170 09 2c ce 09 57 7f d2 7e b4 23 ba 7c 1b 99 bc 22
983 0000180 3e f1 de 91 2f e3 9c 1b 82 cc c2 84 39 aa e6 de
984 0000190 b4 69 fc cc cb 72 a6 61 45 f0 d3 1d 26 19 7c 8d
985 00001a0 29 c8 66 02 be 77 6a f9 3d 34 79 17 19 c8 96 24
986 00001b0 a3 ac e4 dd 3b 1a 8e c6 fe 96 38 6b bf 67 5a 23
987 00001c0 f4 16 f4 e6 8a b4 fc c2 cd bf 95 66 1d bb 35 aa
988 00001d0 92 7d 66 d8 08 8d a5 1f 54 2a af 09 cf 61 ff d2
989 00001e0 85 9d 8f b6 d7 88 07 4a 86 03 db 64 f3 d9 92 73
990 00001f0 df ec a7 fc 23 4c 8d 83 79 63 2a d9 fd 8d b3 c8
991 0000200 8f 7e d4 19 85 e6 8d 1c 76 f0 8b 58 32 fd 9a d6
992 0000210 85 e2 48 ad c3 d5 60 6f 7e 22 dd ef 09 49 7c 7f
993 0000220 3a 45 c3 71 b7 df f3 4c 63 fb b5 d9 31 5f 6e d6
994 0000230 24 1d a4 4a fe 32 a7 5c 16 48 5c 3e 08 6b 8a d3
995 0000240 25 1d a2 12 a5 59 24 ea 20 5f 52 6d ad 94 db 6b
996 0000250 94 b9 5d eb 4b a7 5c 44 bb 1e f2 3c 6b cf 52 c9
997 0000260 e9 e5 ba 06 b9 c4 e5 0a d0 00 0d d0 00 0d d0 00
998 0000270 0d d0 00 0d d0 00 0d d0 00 0d d0 00 0d d0 00 0d
999 0000280 d0 00 0d d0 00 0d d0 00 0d d0 00 0d d0 00 0d d0
1000 0000290 00 0d d0 00 0d d0 00 0d d0 00 0d d0 00 0d d0 00
1001 00002a0 0d d0 00 cd ff 9e 46 86 fa a7 7d 3a 43 d7 8e 10
1002 00002b0 52 e9 be e6 6e cf eb 9e 85 4d 65 ce cc 30 c1 44
1003 00002c0 c0 4e af bc 9c 6c 4b a0 d7 54 ff 1d d5 5c 89 fb
1004 00002d0 b5 34 7e c4 c2 9e f5 a0 f6 5b 7e 6e ca 73 c7 ef
1005 00002e0 5d be de f9 e8 81 eb a5 0a a5 63 54 2c d7 1c d1
1006 00002f0 89 17 85 f8 16 94 f2 8a b2 a3 f5 b6 6d df 75 cd
1007 0000300 90 dd 64 bd 5d 55 4e f2 55 19 1b b7 cc ef 1b ea
1008 0000310 2e 05 9c f4 aa 1e a8 cd a6 82 c7 59 0f 5e 9d e0
1009 0000320 bb fc 6c d6 99 23 eb 36 ad c6 c5 e1 d8 e1 e2 3e
1010 0000330 d9 90 5a f7 91 5d 6f bc 33 6d 98 47 d2 7c 2e 2f
1011 0000340 99 a4 25 72 85 49 2c be 0b 5b af 8f e5 6e 81 a6
1012 0000350 a3 5a 6f 39 53 3a ab 7a 8b 1e 26 f7 46 6c 7d 26
1013 0000360 53 b3 22 31 94 d3 83 f2 18 4d f5 92 33 27 53 97
1014 0000370 0f d3 e6 55 9c a6 c5 31 87 6f d3 f3 ae 39 6f 56
1015 0000380 10 7b ab 7e d0 b4 ca f2 b8 05 be 3f 0e 6e 5a 75
1016 0000390 ab 0c f5 37 0e ba 8e 75 71 7a aa ed 7a dd 6a 63
1017 00003a0 be 9b a0 97 27 6a 6f e7 d3 8b c4 7c ec d3 91 56
1018 00003b0 d9 ac 5e bf 16 42 2f 00 1f 93 a2 23 87 bd e2 59
1019 00003c0 a0 de 1a 66 c8 62 eb 55 8f 91 17 b4 61 42 7a 50
1020 00003d0 40 03 34 40 03 34 40 03 34 40 03 34 40 03 34 40
1021 00003e0 03 34 40 03 34 40 03 34 40 03 34 40 03 34 40 03
1022 00003f0 34 40 03 34 40 03 34 ff 85 86 90 8b ea 67 90 0d
1023 0000400 e1 42 1b d2 61 d6 79 ec fd 3e 44 28 a4 51 6c 5c
1024 0000410 fc d2 72 ca ba 82 18 46 16 61 cd 93 a9 0f d1 24
1025 0000420 17 99 e2 2c 71 16 84 0c c8 7a 13 0f 9a 5e c5 f0
1026 0000430 79 64 e2 12 4d c8 82 a1 81 19 2d aa 44 6d 87 54
1027 0000440 84 71 c1 f6 d4 ca 25 8c 77 b9 08 c7 c8 5e 10 8a
1028 0000450 8f 61 ed 8c ba 30 1f 79 9a c7 60 34 2b b9 8c f8
1029 0000460 18 a6 83 1b e3 9f ad 79 fe fd 1b 8b f1 fc 41 6f
1030 0000470 d4 13 1f e3 b8 83 ba 64 92 e7 eb e4 77 05 8f ba
1031 0000480 fa 3b 00 00 ff ff 50 4b 07 08 a6 18 b1 91 5e 04
1032 0000490 00 00 e4 47 00 00 50 4b 01 02 14 00 14 00 08 00
1033 00004a0 08 00 00 00 00 00 a6 18 b1 91 5e 04 00 00 e4 47
1034 00004b0 00 00 0a 00 00 00 00 00 00 00 00 00 00 00 00 00
1035 00004c0 00 00 00 00 62 69 67 67 65 72 2e 7a 69 70 50 4b
1036 00004d0 05 06 00 00 00 00 01 00 01 00 38 00 00 00 96 04
1037 00004e0 00 00 00 00`
1038 s = regexp.MustCompile(`[0-9a-f]{7}`).ReplaceAllString(s, "")
1039 s = regexp.MustCompile(`\s+`).ReplaceAllString(s, "")
1040 b, err := hex.DecodeString(s)
1041 if err != nil {
1042 panic(err)
1043 }
1044 return b
1045 }
1046
1047 func returnBigZipBytes() (r io.ReaderAt, size int64) {
1048 b := biggestZipBytes()
1049 for i := 0; i < 2; i++ {
1050 r, err := NewReader(bytes.NewReader(b), int64(len(b)))
1051 if err != nil {
1052 panic(err)
1053 }
1054 f, err := r.File[0].Open()
1055 if err != nil {
1056 panic(err)
1057 }
1058 b, err = io.ReadAll(f)
1059 if err != nil {
1060 panic(err)
1061 }
1062 }
1063 return bytes.NewReader(b), int64(len(b))
1064 }
1065
1066 func TestIssue8186(t *testing.T) {
1067
1068 dirEnts := []string{
1069 "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",
1070 "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",
1071 "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",
1072 "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",
1073 "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",
1074 "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",
1075 "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",
1076 "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",
1077 "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",
1078 }
1079 for i, s := range dirEnts {
1080 var f File
1081 err := readDirectoryHeader(&f, strings.NewReader(s))
1082 if err != nil {
1083 t.Errorf("error reading #%d: %v", i, err)
1084 }
1085 }
1086 }
1087
1088
1089 func TestIssue10957(t *testing.T) {
1090 data := []byte("PK\x03\x040000000PK\x01\x0200000" +
1091 "0000000000000000000\x00" +
1092 "\x00\x00\x00\x00\x00000000000000PK\x01" +
1093 "\x020000000000000000000" +
1094 "00000\v\x00\x00\x00\x00\x00000000000" +
1095 "00000000000000PK\x01\x0200" +
1096 "00000000000000000000" +
1097 "00\v\x00\x00\x00\x00\x00000000000000" +
1098 "00000000000PK\x01\x020000<" +
1099 "0\x00\x0000000000000000\v\x00\v" +
1100 "\x00\x00\x00\x00\x0000000000\x00\x00\x00\x00000" +
1101 "00000000PK\x01\x0200000000" +
1102 "0000000000000000\v\x00\x00\x00" +
1103 "\x00\x0000PK\x05\x06000000\x05\x00\xfd\x00\x00\x00" +
1104 "\v\x00\x00\x00\x00\x00")
1105 z, err := NewReader(bytes.NewReader(data), int64(len(data)))
1106 if err != nil {
1107 t.Fatal(err)
1108 }
1109 for i, f := range z.File {
1110 r, err := f.Open()
1111 if err != nil {
1112 continue
1113 }
1114 if f.UncompressedSize64 < 1e6 {
1115 n, err := io.Copy(io.Discard, r)
1116 if i == 3 && err != io.ErrUnexpectedEOF {
1117 t.Errorf("File[3] error = %v; want io.ErrUnexpectedEOF", err)
1118 }
1119 if err == nil && uint64(n) != f.UncompressedSize64 {
1120 t.Errorf("file %d: bad size: copied=%d; want=%d", i, n, f.UncompressedSize64)
1121 }
1122 }
1123 r.Close()
1124 }
1125 }
1126
1127
1128 func TestIssue10956(t *testing.T) {
1129 data := []byte("PK\x06\x06PK\x06\a0000\x00\x00\x00\x00\x00\x00\x00\x00" +
1130 "0000PK\x05\x06000000000000" +
1131 "0000\v\x00000\x00\x00\x00\x00\x00\x00\x000")
1132 r, err := NewReader(bytes.NewReader(data), int64(len(data)))
1133 if err == nil {
1134 t.Errorf("got nil error, want ErrFormat")
1135 }
1136 if r != nil {
1137 t.Errorf("got non-nil Reader, want nil")
1138 }
1139 }
1140
1141
1142 func TestIssue11146(t *testing.T) {
1143 data := []byte("PK\x03\x040000000000000000" +
1144 "000000\x01\x00\x00\x000\x01\x00\x00\xff\xff0000" +
1145 "0000000000000000PK\x01\x02" +
1146 "0000\b0\b\x00000000000000" +
1147 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x000000PK\x05\x06\x00\x00" +
1148 "\x00\x0000\x01\x00\x26\x00\x00\x008\x00\x00\x00\x00\x00")
1149 z, err := NewReader(bytes.NewReader(data), int64(len(data)))
1150 if err != nil {
1151 t.Fatal(err)
1152 }
1153 r, err := z.File[0].Open()
1154 if err != nil {
1155 t.Fatal(err)
1156 }
1157 _, err = io.ReadAll(r)
1158 if err != io.ErrUnexpectedEOF {
1159 t.Errorf("File[0] error = %v; want io.ErrUnexpectedEOF", err)
1160 }
1161 r.Close()
1162 }
1163
1164
1165 func TestIssue12449(t *testing.T) {
1166 data := []byte{
1167 0x50, 0x4b, 0x03, 0x04, 0x14, 0x00, 0x08, 0x00,
1168 0x00, 0x00, 0x6b, 0xb4, 0xba, 0x46, 0x00, 0x00,
1169 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1170 0x00, 0x00, 0x03, 0x00, 0x18, 0x00, 0xca, 0x64,
1171 0x55, 0x75, 0x78, 0x0b, 0x00, 0x50, 0x4b, 0x05,
1172 0x06, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01,
1173 0x00, 0x49, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00,
1174 0x00, 0x31, 0x31, 0x31, 0x32, 0x32, 0x32, 0x0a,
1175 0x50, 0x4b, 0x07, 0x08, 0x1d, 0x88, 0x77, 0xb0,
1176 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
1177 0x50, 0x4b, 0x01, 0x02, 0x14, 0x03, 0x14, 0x00,
1178 0x08, 0x00, 0x00, 0x00, 0x6b, 0xb4, 0xba, 0x46,
1179 0x1d, 0x88, 0x77, 0xb0, 0x07, 0x00, 0x00, 0x00,
1180 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x18, 0x00,
1181 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1182 0xa0, 0x81, 0x00, 0x00, 0x00, 0x00, 0xca, 0x64,
1183 0x55, 0x75, 0x78, 0x0b, 0x00, 0x50, 0x4b, 0x05,
1184 0x06, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01,
1185 0x00, 0x49, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00,
1186 0x00, 0x97, 0x2b, 0x49, 0x23, 0x05, 0xc5, 0x0b,
1187 0xa7, 0xd1, 0x52, 0xa2, 0x9c, 0x50, 0x4b, 0x06,
1188 0x07, 0xc8, 0x19, 0xc1, 0xaf, 0x94, 0x9c, 0x61,
1189 0x44, 0xbe, 0x94, 0x19, 0x42, 0x58, 0x12, 0xc6,
1190 0x5b, 0x50, 0x4b, 0x05, 0x06, 0x00, 0x00, 0x00,
1191 0x00, 0x01, 0x00, 0x01, 0x00, 0x69, 0x00, 0x00,
1192 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00,
1193 }
1194
1195 _, err := NewReader(bytes.NewReader(data), int64(len(data)))
1196 if err != nil {
1197 t.Errorf("Error reading the archive: %v", err)
1198 }
1199 }
1200
1201 func TestFS(t *testing.T) {
1202 for _, test := range []struct {
1203 file string
1204 want []string
1205 }{
1206 {
1207 "testdata/unix.zip",
1208 []string{"hello", "dir/bar", "readonly"},
1209 },
1210 {
1211 "testdata/subdir.zip",
1212 []string{"a/b/c"},
1213 },
1214 } {
1215 test := test
1216 t.Run(test.file, func(t *testing.T) {
1217 t.Parallel()
1218 z, err := OpenReader(test.file)
1219 if err != nil {
1220 t.Fatal(err)
1221 }
1222 defer z.Close()
1223 if err := fstest.TestFS(z, test.want...); err != nil {
1224 t.Error(err)
1225 }
1226 })
1227 }
1228 }
1229
1230 func TestFSWalk(t *testing.T) {
1231 for _, test := range []struct {
1232 file string
1233 want []string
1234 wantErr bool
1235 }{
1236 {
1237 file: "testdata/unix.zip",
1238 want: []string{".", "dir", "dir/bar", "dir/empty", "hello", "readonly"},
1239 },
1240 {
1241 file: "testdata/subdir.zip",
1242 want: []string{".", "a", "a/b", "a/b/c"},
1243 },
1244 {
1245 file: "testdata/dupdir.zip",
1246 wantErr: true,
1247 },
1248 } {
1249 test := test
1250 t.Run(test.file, func(t *testing.T) {
1251 t.Parallel()
1252 z, err := OpenReader(test.file)
1253 if err != nil {
1254 t.Fatal(err)
1255 }
1256 var files []string
1257 sawErr := false
1258 err = fs.WalkDir(z, ".", func(path string, d fs.DirEntry, err error) error {
1259 if err != nil {
1260 if !test.wantErr {
1261 t.Errorf("%s: %v", path, err)
1262 }
1263 sawErr = true
1264 return nil
1265 }
1266 files = append(files, path)
1267 return nil
1268 })
1269 if err != nil {
1270 t.Errorf("fs.WalkDir error: %v", err)
1271 }
1272 if test.wantErr && !sawErr {
1273 t.Error("succeeded but want error")
1274 } else if !test.wantErr && sawErr {
1275 t.Error("unexpected error")
1276 }
1277 if test.want != nil && !slices.Equal(files, test.want) {
1278 t.Errorf("got %v want %v", files, test.want)
1279 }
1280 })
1281 }
1282 }
1283
1284 func TestFSModTime(t *testing.T) {
1285 t.Parallel()
1286 z, err := OpenReader("testdata/subdir.zip")
1287 if err != nil {
1288 t.Fatal(err)
1289 }
1290 defer z.Close()
1291
1292 for _, test := range []struct {
1293 name string
1294 want time.Time
1295 }{
1296 {
1297 "a",
1298 time.Date(2021, 4, 19, 12, 29, 56, 0, timeZone(-7*time.Hour)).UTC(),
1299 },
1300 {
1301 "a/b/c",
1302 time.Date(2021, 4, 19, 12, 29, 59, 0, timeZone(-7*time.Hour)).UTC(),
1303 },
1304 } {
1305 fi, err := fs.Stat(z, test.name)
1306 if err != nil {
1307 t.Errorf("%s: %v", test.name, err)
1308 continue
1309 }
1310 if got := fi.ModTime(); !got.Equal(test.want) {
1311 t.Errorf("%s: got modtime %v, want %v", test.name, got, test.want)
1312 }
1313 }
1314 }
1315
1316 func TestCVE202127919(t *testing.T) {
1317 t.Setenv("GODEBUG", "zipinsecurepath=0")
1318
1319 data := []byte{
1320 0x50, 0x4b, 0x03, 0x04, 0x14, 0x00, 0x08, 0x00,
1321 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1322 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1323 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x2e, 0x2e,
1324 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x74, 0x78,
1325 0x74, 0x0a, 0xc9, 0xc8, 0x2c, 0x56, 0xc8, 0x2c,
1326 0x56, 0x48, 0x54, 0x28, 0x49, 0x2d, 0x2e, 0x51,
1327 0x28, 0x49, 0xad, 0x28, 0x51, 0x48, 0xcb, 0xcc,
1328 0x49, 0xd5, 0xe3, 0x02, 0x04, 0x00, 0x00, 0xff,
1329 0xff, 0x50, 0x4b, 0x07, 0x08, 0xc0, 0xd7, 0xed,
1330 0xc3, 0x20, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00,
1331 0x00, 0x50, 0x4b, 0x01, 0x02, 0x14, 0x00, 0x14,
1332 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
1333 0x00, 0xc0, 0xd7, 0xed, 0xc3, 0x20, 0x00, 0x00,
1334 0x00, 0x1a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00,
1335 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1336 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e,
1337 0x2e, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x74,
1338 0x78, 0x74, 0x50, 0x4b, 0x05, 0x06, 0x00, 0x00,
1339 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x39, 0x00,
1340 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x00, 0x00,
1341 }
1342 r, err := NewReader(bytes.NewReader(data), int64(len(data)))
1343 if err != ErrInsecurePath {
1344 t.Fatalf("Error reading the archive: %v", err)
1345 }
1346 _, err = r.Open("test.txt")
1347 if err != nil {
1348 t.Errorf("Error reading file: %v", err)
1349 }
1350 if len(r.File) != 1 {
1351 t.Fatalf("No entries in the file list")
1352 }
1353 if r.File[0].Name != "../test.txt" {
1354 t.Errorf("Unexpected entry name: %s", r.File[0].Name)
1355 }
1356 if _, err := r.File[0].Open(); err != nil {
1357 t.Errorf("Error opening file: %v", err)
1358 }
1359 }
1360
1361 func TestOpenReaderInsecurePath(t *testing.T) {
1362 t.Setenv("GODEBUG", "zipinsecurepath=0")
1363
1364 data := []byte{
1365 0x50, 0x4b, 0x03, 0x04, 0x14, 0x00, 0x08, 0x00,
1366 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1367 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1368 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x2e, 0x2e,
1369 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x74, 0x78,
1370 0x74, 0x0a, 0xc9, 0xc8, 0x2c, 0x56, 0xc8, 0x2c,
1371 0x56, 0x48, 0x54, 0x28, 0x49, 0x2d, 0x2e, 0x51,
1372 0x28, 0x49, 0xad, 0x28, 0x51, 0x48, 0xcb, 0xcc,
1373 0x49, 0xd5, 0xe3, 0x02, 0x04, 0x00, 0x00, 0xff,
1374 0xff, 0x50, 0x4b, 0x07, 0x08, 0xc0, 0xd7, 0xed,
1375 0xc3, 0x20, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00,
1376 0x00, 0x50, 0x4b, 0x01, 0x02, 0x14, 0x00, 0x14,
1377 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
1378 0x00, 0xc0, 0xd7, 0xed, 0xc3, 0x20, 0x00, 0x00,
1379 0x00, 0x1a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00,
1380 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1381 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e,
1382 0x2e, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x74,
1383 0x78, 0x74, 0x50, 0x4b, 0x05, 0x06, 0x00, 0x00,
1384 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x39, 0x00,
1385 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x00, 0x00,
1386 }
1387
1388
1389 name := filepath.Join(t.TempDir(), "test.zip")
1390 err := os.WriteFile(name, data, 0644)
1391 if err != nil {
1392 t.Fatalf("Unable to write out the bugos zip entry")
1393 }
1394 r, err := OpenReader(name)
1395 if r != nil {
1396 defer r.Close()
1397 }
1398
1399 if err != ErrInsecurePath {
1400 t.Fatalf("Error reading the archive, we expected ErrInsecurePath but got: %v", err)
1401 }
1402 _, err = r.Open("test.txt")
1403 if err != nil {
1404 t.Errorf("Error reading file: %v", err)
1405 }
1406 if len(r.File) != 1 {
1407 t.Fatalf("No entries in the file list")
1408 }
1409 if r.File[0].Name != "../test.txt" {
1410 t.Errorf("Unexpected entry name: %s", r.File[0].Name)
1411 }
1412 if _, err := r.File[0].Open(); err != nil {
1413 t.Errorf("Error opening file: %v", err)
1414 }
1415 }
1416
1417 func TestCVE202133196(t *testing.T) {
1418
1419
1420
1421 data := []byte{
1422 0x50, 0x4b, 0x03, 0x04, 0x14, 0x00, 0x08, 0x08,
1423 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1424 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1425 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02,
1426 0x03, 0x62, 0x61, 0x65, 0x03, 0x04, 0x00, 0x00,
1427 0xff, 0xff, 0x50, 0x4b, 0x07, 0x08, 0xbe, 0x20,
1428 0x5c, 0x6c, 0x09, 0x00, 0x00, 0x00, 0x03, 0x00,
1429 0x00, 0x00, 0x50, 0x4b, 0x01, 0x02, 0x14, 0x00,
1430 0x14, 0x00, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00,
1431 0x00, 0x00, 0xbe, 0x20, 0x5c, 0x6c, 0x09, 0x00,
1432 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
1433 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1434 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1435 0x01, 0x02, 0x03, 0x50, 0x4b, 0x06, 0x06, 0x2c,
1436 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d,
1437 0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1438 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
1439 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
1440 0xff, 0xff, 0xff, 0x31, 0x00, 0x00, 0x00, 0x00,
1441 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x00,
1442 0x00, 0x00, 0x00, 0x50, 0x4b, 0x06, 0x07, 0x00,
1443 0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x00,
1444 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50,
1445 0x4b, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0xff,
1446 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1447 0xff, 0xff, 0xff, 0x00, 0x00,
1448 }
1449 _, err := NewReader(bytes.NewReader(data), int64(len(data)))
1450 if err != ErrFormat {
1451 t.Fatalf("unexpected error, got: %v, want: %v", err, ErrFormat)
1452 }
1453
1454
1455
1456 b := bytes.NewBuffer(nil)
1457 w := NewWriter(b)
1458 for i := 0; i < 5; i++ {
1459 _, err := w.Create("")
1460 if err != nil {
1461 t.Fatalf("Writer.Create failed: %s", err)
1462 }
1463 }
1464 if err := w.Close(); err != nil {
1465 t.Fatalf("Writer.Close failed: %s", err)
1466 }
1467 r, err := NewReader(bytes.NewReader(b.Bytes()), int64(b.Len()))
1468 if err != nil {
1469 t.Fatalf("NewReader failed: %s", err)
1470 }
1471 if len(r.File) != 5 {
1472 t.Errorf("Archive has unexpected number of files, got %d, want 5", len(r.File))
1473 }
1474 }
1475
1476 func TestCVE202139293(t *testing.T) {
1477
1478
1479
1480 data := []byte{
1481 0x50, 0x4b, 0x06, 0x06, 0x05, 0x06, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x4b,
1482 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
1483 0x00, 0x00, 0x50, 0x4b, 0x05, 0x06, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x4b,
1484 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
1485 0x00, 0x00, 0x00, 0x50, 0x4b, 0x05, 0x06, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
1486 0xff, 0x50, 0xfe, 0x00, 0xff, 0x00, 0x3a, 0x00, 0x00, 0x00, 0xff,
1487 }
1488 _, err := NewReader(bytes.NewReader(data), int64(len(data)))
1489 if err != ErrFormat {
1490 t.Fatalf("unexpected error, got: %v, want: %v", err, ErrFormat)
1491 }
1492 }
1493
1494 func TestCVE202141772(t *testing.T) {
1495 t.Setenv("GODEBUG", "zipinsecurepath=0")
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507 data := []byte{
1508 0x50, 0x4b, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x08,
1509 0x00, 0x00, 0x06, 0x94, 0x05, 0x53, 0x00, 0x00,
1510 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1511 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2f, 0x50,
1512 0x4b, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00,
1513 0x00, 0x78, 0x67, 0x2e, 0x53, 0x00, 0x00, 0x00,
1514 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1515 0x00, 0x02, 0x00, 0x00, 0x00, 0x2f, 0x2f, 0x50,
1516 0x4b, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00,
1517 0x00, 0x78, 0x67, 0x2e, 0x53, 0x00, 0x00, 0x00,
1518 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1519 0x00, 0x01, 0x00, 0x00, 0x00, 0x5c, 0x50, 0x4b,
1520 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00,
1521 0x91, 0x68, 0x2e, 0x53, 0x85, 0x11, 0x4a, 0x0d,
1522 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
1523 0x09, 0x00, 0x00, 0x00, 0x2f, 0x74, 0x65, 0x73,
1524 0x74, 0x2e, 0x74, 0x78, 0x74, 0x68, 0x65, 0x6c,
1525 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64,
1526 0x50, 0x4b, 0x01, 0x02, 0x14, 0x03, 0x0a, 0x00,
1527 0x00, 0x08, 0x00, 0x00, 0x06, 0x94, 0x05, 0x53,
1528 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1529 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
1530 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
1531 0xed, 0x41, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x50,
1532 0x4b, 0x01, 0x02, 0x3f, 0x00, 0x0a, 0x00, 0x00,
1533 0x00, 0x00, 0x00, 0x78, 0x67, 0x2e, 0x53, 0x00,
1534 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1535 0x00, 0x00, 0x00, 0x02, 0x00, 0x24, 0x00, 0x00,
1536 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
1537 0x00, 0x1f, 0x00, 0x00, 0x00, 0x2f, 0x2f, 0x0a,
1538 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
1539 0x00, 0x18, 0x00, 0x93, 0x98, 0x25, 0x57, 0x25,
1540 0xa9, 0xd7, 0x01, 0x93, 0x98, 0x25, 0x57, 0x25,
1541 0xa9, 0xd7, 0x01, 0x93, 0x98, 0x25, 0x57, 0x25,
1542 0xa9, 0xd7, 0x01, 0x50, 0x4b, 0x01, 0x02, 0x3f,
1543 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78,
1544 0x67, 0x2e, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00,
1545 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
1546 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1547 0x00, 0x20, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00,
1548 0x00, 0x5c, 0x0a, 0x00, 0x20, 0x00, 0x00, 0x00,
1549 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x93, 0x98,
1550 0x25, 0x57, 0x25, 0xa9, 0xd7, 0x01, 0x93, 0x98,
1551 0x25, 0x57, 0x25, 0xa9, 0xd7, 0x01, 0x93, 0x98,
1552 0x25, 0x57, 0x25, 0xa9, 0xd7, 0x01, 0x50, 0x4b,
1553 0x01, 0x02, 0x3f, 0x00, 0x0a, 0x00, 0x00, 0x00,
1554 0x00, 0x00, 0x91, 0x68, 0x2e, 0x53, 0x85, 0x11,
1555 0x4a, 0x0d, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
1556 0x00, 0x00, 0x09, 0x00, 0x24, 0x00, 0x00, 0x00,
1557 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
1558 0x5e, 0x00, 0x00, 0x00, 0x2f, 0x74, 0x65, 0x73,
1559 0x74, 0x2e, 0x74, 0x78, 0x74, 0x0a, 0x00, 0x20,
1560 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18,
1561 0x00, 0xa9, 0x80, 0x51, 0x01, 0x26, 0xa9, 0xd7,
1562 0x01, 0x31, 0xd1, 0x57, 0x01, 0x26, 0xa9, 0xd7,
1563 0x01, 0xdf, 0x48, 0x85, 0xf9, 0x25, 0xa9, 0xd7,
1564 0x01, 0x50, 0x4b, 0x05, 0x06, 0x00, 0x00, 0x00,
1565 0x00, 0x04, 0x00, 0x04, 0x00, 0x31, 0x01, 0x00,
1566 0x00, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00,
1567 }
1568 r, err := NewReader(bytes.NewReader(data), int64(len(data)))
1569 if err != ErrInsecurePath {
1570 t.Fatalf("Error reading the archive: %v", err)
1571 }
1572 entryNames := []string{`/`, `//`, `\`, `/test.txt`}
1573 var names []string
1574 for _, f := range r.File {
1575 names = append(names, f.Name)
1576 if _, err := f.Open(); err != nil {
1577 t.Errorf("Error opening %q: %v", f.Name, err)
1578 }
1579 if _, err := r.Open(f.Name); err == nil {
1580 t.Errorf("Opening %q with fs.FS API succeeded", f.Name)
1581 }
1582 }
1583 if !slices.Equal(names, entryNames) {
1584 t.Errorf("Unexpected file entries: %q", names)
1585 }
1586 if _, err := r.Open(""); err == nil {
1587 t.Errorf("Opening %q with fs.FS API succeeded", "")
1588 }
1589 if _, err := r.Open("test.txt"); err != nil {
1590 t.Errorf("Error opening %q with fs.FS API: %v", "test.txt", err)
1591 }
1592 dirEntries, err := fs.ReadDir(r, ".")
1593 if err != nil {
1594 t.Fatalf("Error reading the root directory: %v", err)
1595 }
1596 if len(dirEntries) != 1 || dirEntries[0].Name() != "test.txt" {
1597 t.Errorf("Unexpected directory entries")
1598 for _, dirEntry := range dirEntries {
1599 _, err := r.Open(dirEntry.Name())
1600 t.Logf("%q (Open error: %v)", dirEntry.Name(), err)
1601 }
1602 t.FailNow()
1603 }
1604 info, err := dirEntries[0].Info()
1605 if err != nil {
1606 t.Fatalf("Error reading info entry: %v", err)
1607 }
1608 if name := info.Name(); name != "test.txt" {
1609 t.Errorf("Inconsistent name in info entry: %v", name)
1610 }
1611 }
1612
1613 func TestUnderSize(t *testing.T) {
1614 z, err := OpenReader("testdata/readme.zip")
1615 if err != nil {
1616 t.Fatal(err)
1617 }
1618 defer z.Close()
1619
1620 for _, f := range z.File {
1621 f.UncompressedSize64 = 1
1622 }
1623
1624 for _, f := range z.File {
1625 t.Run(f.Name, func(t *testing.T) {
1626 rd, err := f.Open()
1627 if err != nil {
1628 t.Fatal(err)
1629 }
1630 defer rd.Close()
1631
1632 _, err = io.Copy(io.Discard, rd)
1633 if err != ErrFormat {
1634 t.Fatalf("Error mismatch\n\tGot: %v\n\tWant: %v", err, ErrFormat)
1635 }
1636 })
1637 }
1638 }
1639
1640 func TestIssue54801(t *testing.T) {
1641 for _, input := range []string{"testdata/readme.zip", "testdata/dd.zip"} {
1642 z, err := OpenReader(input)
1643 if err != nil {
1644 t.Fatal(err)
1645 }
1646 defer z.Close()
1647
1648 for _, f := range z.File {
1649
1650 f.Name += "/"
1651
1652 t.Run(f.Name, func(t *testing.T) {
1653 t.Logf("CompressedSize64: %d, Flags: %#x", f.CompressedSize64, f.Flags)
1654
1655 rd, err := f.Open()
1656 if err != nil {
1657 t.Fatal(err)
1658 }
1659 defer rd.Close()
1660
1661 n, got := io.Copy(io.Discard, rd)
1662 if n != 0 || got != ErrFormat {
1663 t.Fatalf("Error mismatch, got: %d, %v, want: %v", n, got, ErrFormat)
1664 }
1665 })
1666 }
1667 }
1668 }
1669
1670 func TestInsecurePaths(t *testing.T) {
1671 t.Setenv("GODEBUG", "zipinsecurepath=0")
1672 for _, path := range []string{
1673 "../foo",
1674 "/foo",
1675 "a/b/../../../c",
1676 `a\b`,
1677 } {
1678 var buf bytes.Buffer
1679 zw := NewWriter(&buf)
1680 _, err := zw.Create(path)
1681 if err != nil {
1682 t.Errorf("zw.Create(%q) = %v", path, err)
1683 continue
1684 }
1685 zw.Close()
1686
1687 zr, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
1688 if err != ErrInsecurePath {
1689 t.Errorf("NewReader for archive with file %q: got err %v, want ErrInsecurePath", path, err)
1690 continue
1691 }
1692 var gotPaths []string
1693 for _, f := range zr.File {
1694 gotPaths = append(gotPaths, f.Name)
1695 }
1696 if !slices.Equal(gotPaths, []string{path}) {
1697 t.Errorf("NewReader for archive with file %q: got files %q", path, gotPaths)
1698 continue
1699 }
1700 }
1701 }
1702
1703 func TestDisableInsecurePathCheck(t *testing.T) {
1704 t.Setenv("GODEBUG", "zipinsecurepath=1")
1705 var buf bytes.Buffer
1706 zw := NewWriter(&buf)
1707 const name = "/foo"
1708 _, err := zw.Create(name)
1709 if err != nil {
1710 t.Fatalf("zw.Create(%q) = %v", name, err)
1711 }
1712 zw.Close()
1713 zr, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
1714 if err != nil {
1715 t.Fatalf("NewReader with zipinsecurepath=1: got err %v, want nil", err)
1716 }
1717 var gotPaths []string
1718 for _, f := range zr.File {
1719 gotPaths = append(gotPaths, f.Name)
1720 }
1721 if want := []string{name}; !slices.Equal(gotPaths, want) {
1722 t.Errorf("NewReader with zipinsecurepath=1: got files %q, want %q", gotPaths, want)
1723 }
1724 }
1725
1726 func TestCompressedDirectory(t *testing.T) {
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736 data := []byte{
1737 0x50, 0x4b, 0x03, 0x04, 0x14, 0x00, 0x08, 0x08,
1738 0x08, 0x00, 0x49, 0x86, 0x81, 0x55, 0x00, 0x00,
1739 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1740 0x00, 0x00, 0x09, 0x00, 0x04, 0x00, 0x4d, 0x45,
1741 0x54, 0x41, 0x2d, 0x49, 0x4e, 0x46, 0x2f, 0xfe,
1742 0xca, 0x00, 0x00, 0x03, 0x00, 0x50, 0x4b, 0x07,
1743 0x08, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
1744 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x4b, 0x03,
1745 0x04, 0x14, 0x00, 0x08, 0x08, 0x08, 0x00, 0x49,
1746 0x86, 0x81, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00,
1747 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14,
1748 0x00, 0x00, 0x00, 0x4d, 0x45, 0x54, 0x41, 0x2d,
1749 0x49, 0x4e, 0x46, 0x2f, 0x4d, 0x41, 0x4e, 0x49,
1750 0x46, 0x45, 0x53, 0x54, 0x2e, 0x4d, 0x46, 0xf3,
1751 0x4d, 0xcc, 0xcb, 0x4c, 0x4b, 0x2d, 0x2e, 0xd1,
1752 0x0d, 0x4b, 0x2d, 0x2a, 0xce, 0xcc, 0xcf, 0xb3,
1753 0x52, 0x30, 0xd4, 0x33, 0xe0, 0xe5, 0x72, 0x2e,
1754 0x4a, 0x4d, 0x2c, 0x49, 0x4d, 0xd1, 0x75, 0xaa,
1755 0x04, 0x0a, 0x00, 0x45, 0xf4, 0x0c, 0x8d, 0x15,
1756 0x34, 0xdc, 0xf3, 0xf3, 0xd3, 0x73, 0x52, 0x15,
1757 0x3c, 0xf3, 0x92, 0xf5, 0x34, 0x79, 0xb9, 0x78,
1758 0xb9, 0x00, 0x50, 0x4b, 0x07, 0x08, 0x93, 0x7e,
1759 0x93, 0xaf, 0x3b, 0x00, 0x00, 0x00, 0x3c, 0x00,
1760 0x00, 0x00, 0x50, 0x4b, 0x01, 0x02, 0x14, 0x00,
1761 0x14, 0x00, 0x08, 0x08, 0x08, 0x00, 0x49, 0x86,
1762 0x81, 0x55, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00,
1763 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
1764 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1765 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1766 0x4d, 0x45, 0x54, 0x41, 0x2d, 0x49, 0x4e, 0x46,
1767 0x2f, 0xfe, 0xca, 0x00, 0x00, 0x50, 0x4b, 0x01,
1768 0x02, 0x14, 0x00, 0x14, 0x00, 0x08, 0x08, 0x08,
1769 0x00, 0x49, 0x86, 0x81, 0x55, 0x93, 0x7e, 0x93,
1770 0xaf, 0x3b, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00,
1771 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1772 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d,
1773 0x00, 0x00, 0x00, 0x4d, 0x45, 0x54, 0x41, 0x2d,
1774 0x49, 0x4e, 0x46, 0x2f, 0x4d, 0x41, 0x4e, 0x49,
1775 0x46, 0x45, 0x53, 0x54, 0x2e, 0x4d, 0x46, 0x50,
1776 0x4b, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x02,
1777 0x00, 0x02, 0x00, 0x7d, 0x00, 0x00, 0x00, 0xba,
1778 0x00, 0x00, 0x00, 0x00, 0x00,
1779 }
1780 r, err := NewReader(bytes.NewReader(data), int64(len(data)))
1781 if err != nil {
1782 t.Fatalf("unexpected error: %v", err)
1783 }
1784 for _, f := range r.File {
1785 r, err := f.Open()
1786 if err != nil {
1787 t.Fatalf("unexpected error: %v", err)
1788 }
1789 if _, err := io.Copy(io.Discard, r); err != nil {
1790 t.Fatalf("unexpected error: %v", err)
1791 }
1792 }
1793 }
1794
1795 func TestBaseOffsetPlusOverflow(t *testing.T) {
1796
1797 data := []byte{
1798 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1799 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1800 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1801 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1802 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1803 0xff, 0xff, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1804 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1805 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1806 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1807 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1808 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1809 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1810 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1811 0x20, 0x20, 0x20, 0x50, 0x4b, 0x06, 0x06, 0x20,
1812 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1813 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1814 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1815 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1816 0x20, 0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x00,
1817 0x00, 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0x00,
1818 0x00, 0x00, 0x80, 0x50, 0x4b, 0x06, 0x07, 0x00,
1819 0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x00,
1820 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50,
1821 0x4b, 0x05, 0x06, 0x20, 0x20, 0x20, 0x20, 0xff,
1822 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1823 0xff, 0xff, 0xff, 0x20, 0x00,
1824 }
1825 defer func() {
1826 if r := recover(); r != nil {
1827 t.Fatalf("NewReader panicked: %s", r)
1828 }
1829 }()
1830
1831
1832
1833 NewReader(bytes.NewReader(data), int64(len(data))+1875)
1834 }
1835
View as plain text