zipremove 0.3.0__tar.gz → 0.4.1__tar.gz

{zipremove-0.3.0/src/zipremove.egg-info → zipremove-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zipremove
-Version: 0.3.0
+Version: 0.4.1
 Summary: Extend `zipfile` with `remove`-related functionalities
 Home-page: https://github.com/danny0838/zipremove
 Author: Danny Lin
@@ -37,6 +37,7 @@ Dynamic: license-file
 ![Status](https://img.shields.io/pypi/status/zipremove)
 ![License](https://img.shields.io/github/license/danny0838/zipremove)
 [![Downloads](https://static.pepy.tech/personalized-badge/zipremove?period=month&left_text=Downloads)](https://pepy.tech/project/zipremove)
+[![Pull request](https://img.shields.io/github/pulls/detail/state/python/cpython/134627)](https://github.com/python/cpython/pull/134627)
 
 This package extends `zipfile` with `remove`-related functionalities.
 
@@ -61,30 +62,32 @@ This package extends `zipfile` with `remove`-related functionalities.
 
 * `ZipFile.repack(removed=None, *, strict_descriptor=False[, chunk_size])`
 
-   Rewrites the archive to remove stale local file entries, shrinking the ZIP
-   file size.
+   Rewrites the archive to remove stale local file entries, shrinking its file
+   size.
 
    If *removed* is provided, it must be a sequence of `ZipInfo` objects
    representing removed entries; only their corresponding local file entries
    will be removed.
 
-   If *removed* is not provided, local file entries no longer referenced in the
-   central directory will be removed.  The algorithm assumes that local file
-   entries are stored consecutively:
+   If *removed* is not provided, the archive is scanned to identify and remove
+   local file entries that are no longer referenced in the central directory.
+   The algorithm assumes that local file entries (and the central directory,
+   which is mostly treated as the "last entry") are stored consecutively:
 
    1. Data before the first referenced entry is removed only when it appears to
       be a sequence of consecutive entries with no extra following bytes; extra
-      preceeding bytes are preserved.
+      preceding bytes are preserved.
    2. Data between referenced entries is removed only when it appears to
       be a sequence of consecutive entries with no extra preceding bytes; extra
       following bytes are preserved.
-
-   ``strict_descriptor=True`` can be provided to skip the slower scan for an
-   unsigned data descriptor (deprecated in the latest ZIP specification and is
-   only used by legacy tools) when checking for bytes resembling a valid local
-   file entry.  This improves performance, but may cause some stale local file
-   entries to be preserved, as any entry using an unsigned descriptor cannot
-   be detected.
+   3. Entries must not overlap. If any entry's data overlaps with another, a
+      `BadZipFile` error is raised and no changes are made.
+
+   When scanning, setting `strict_descriptor=True` disables detection of any
+   entry using an unsigned data descriptor (deprecated in the ZIP specification
+   since version 6.3.0, released on 2006-09-29, and used only by some legacy
+   tools). This improves performance, but may cause some stale entries to be
+   preserved.
 
    *chunk_size* may be specified to control the buffer size when moving
    entry data (default is 1 MiB).

{zipremove-0.3.0 → zipremove-0.4.1}/README.md

@@ -3,6 +3,7 @@
 ![Status](https://img.shields.io/pypi/status/zipremove)
 ![License](https://img.shields.io/github/license/danny0838/zipremove)
 [![Downloads](https://static.pepy.tech/personalized-badge/zipremove?period=month&left_text=Downloads)](https://pepy.tech/project/zipremove)
+[![Pull request](https://img.shields.io/github/pulls/detail/state/python/cpython/134627)](https://github.com/python/cpython/pull/134627)
 
 This package extends `zipfile` with `remove`-related functionalities.
 
@@ -27,30 +28,32 @@ This package extends `zipfile` with `remove`-related functionalities.
 
 * `ZipFile.repack(removed=None, *, strict_descriptor=False[, chunk_size])`
 
-   Rewrites the archive to remove stale local file entries, shrinking the ZIP
-   file size.
+   Rewrites the archive to remove stale local file entries, shrinking its file
+   size.
 
    If *removed* is provided, it must be a sequence of `ZipInfo` objects
    representing removed entries; only their corresponding local file entries
    will be removed.
 
-   If *removed* is not provided, local file entries no longer referenced in the
-   central directory will be removed.  The algorithm assumes that local file
-   entries are stored consecutively:
+   If *removed* is not provided, the archive is scanned to identify and remove
+   local file entries that are no longer referenced in the central directory.
+   The algorithm assumes that local file entries (and the central directory,
+   which is mostly treated as the "last entry") are stored consecutively:
 
    1. Data before the first referenced entry is removed only when it appears to
       be a sequence of consecutive entries with no extra following bytes; extra
-      preceeding bytes are preserved.
+      preceding bytes are preserved.
    2. Data between referenced entries is removed only when it appears to
       be a sequence of consecutive entries with no extra preceding bytes; extra
       following bytes are preserved.
-
-   ``strict_descriptor=True`` can be provided to skip the slower scan for an
-   unsigned data descriptor (deprecated in the latest ZIP specification and is
-   only used by legacy tools) when checking for bytes resembling a valid local
-   file entry.  This improves performance, but may cause some stale local file
-   entries to be preserved, as any entry using an unsigned descriptor cannot
-   be detected.
+   3. Entries must not overlap. If any entry's data overlaps with another, a
+      `BadZipFile` error is raised and no changes are made.
+
+   When scanning, setting `strict_descriptor=True` disables detection of any
+   entry using an unsigned data descriptor (deprecated in the ZIP specification
+   since version 6.3.0, released on 2006-09-29, and used only by some legacy
+   tools). This improves performance, but may cause some stale entries to be
+   preserved.
 
    *chunk_size* may be specified to control the buffer size when moving
    entry data (default is 1 MiB).

{zipremove-0.3.0 → zipremove-0.4.1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = zipremove
-version = 0.3.0
+version = 0.4.1
 author = Danny Lin
 author_email = danny0838@gmail.com
 url = https://github.com/danny0838/zipremove

{zipremove-0.3.0 → zipremove-0.4.1}/src/zipremove/__init__.py

@@ -15,6 +15,7 @@ from zipfile import (
     _FH_GENERAL_PURPOSE_FLAG_BITS,
     _FH_SIGNATURE,
     _FH_UNCOMPRESSED_SIZE,
+    LZMADecompressor,
     _get_decompressor,
     crc32,
     sizeFileHeader,
@@ -29,6 +30,12 @@ except NameError:
     # polyfill for Python < 3.14
     ZIP_ZSTANDARD = 93
 
+try:
+    from zipfile import _MASK_ENCRYPTED
+except ImportError:
+    # polyfill for Python < 3.11
+    _MASK_ENCRYPTED = 1 << 0
+
 try:
     from zipfile import _MASK_USE_DATA_DESCRIPTOR
 except ImportError:
@@ -50,18 +57,16 @@ except ImportError:
         return filename
 
 try:
-    import zipfile
-    zipfile.LZMADecompressor().unused_data
+    LZMADecompressor().unused_data
 except AttributeError:
     # polyfill to support LZMADecompressor().unused_data
-    class LZMADecompressor(zipfile.LZMADecompressor):
-        @property
-        def unused_data(self):
-            try:
-                return self._decomp.unused_data
-            except AttributeError:
-                return b''
-    zipfile.LZMADecompressor = LZMADecompressor
+    @property
+    def unused_data(self):
+        try:
+            return self._decomp.unused_data
+        except AttributeError:
+            return b''
+    LZMADecompressor.unused_data = unused_data
 
 
 class _ZipRepacker:
@@ -257,14 +262,11 @@ class _ZipRepacker:
                         used_entry_size,
                     )
 
-                if used_entry_size < entry_size:
-                    stale_entry_size = self._validate_local_file_entry_sequence(
-                        fp,
-                        old_header_offset + used_entry_size,
-                        old_header_offset + entry_size,
-                    )
-                else:
-                    stale_entry_size = 0
+                stale_entry_size = self._validate_local_file_entry_sequence(
+                    fp,
+                    old_header_offset + used_entry_size,
+                    old_header_offset + entry_size,
+                )
 
                 if stale_entry_size > 0:
                     self._copy_bytes(
@@ -375,8 +377,8 @@ class _ZipRepacker:
         if pos > end_offset:
             return None
 
+        # parse zip64
         try:
-            # parse zip64
             try:
                 zinfo._decodeExtra(crc32(filename))
             except TypeError:
@@ -399,8 +401,11 @@ class _ZipRepacker:
 
             dd = self._scan_data_descriptor(fp, pos, end_offset, zip64)
             if dd is None and not self.strict_descriptor:
-                dd = self._scan_data_descriptor_no_sig_by_decompression(
-                    fp, pos, end_offset, zip64, fheader[_FH_COMPRESSION_METHOD])
+                if zinfo.flag_bits & _MASK_ENCRYPTED:
+                    dd = False
+                else:
+                    dd = self._scan_data_descriptor_no_sig_by_decompression(
+                        fp, pos, end_offset, zip64, fheader[_FH_COMPRESSION_METHOD])
                 if dd is False:
                     dd = self._scan_data_descriptor_no_sig(fp, pos, end_offset, zip64)
             if dd is None:
@@ -488,6 +493,7 @@ class _ZipRepacker:
         dd_fmt = '<LQQ' if zip64 else '<LLL'
         dd_size = struct.calcsize(dd_fmt)
 
+        # early return and prevent potential `fp.read(-1)`
         if end_offset - dd_size < offset:
             return None
 
@@ -608,15 +614,16 @@ class ZipFile(ZipFile):
 
         with self._lock:
             # get the zinfo
-            # raise KeyError if arcname does not exist
             if isinstance(zinfo_or_arcname, ZipInfo):
                 zinfo = zinfo_or_arcname
-                if zinfo not in self.filelist:
-                    raise KeyError('There is no item %r in the archive' % zinfo)
             else:
+                # raise KeyError if arcname does not exist
                 zinfo = self.getinfo(zinfo_or_arcname)
 
-            self.filelist.remove(zinfo)
+            try:
+                self.filelist.remove(zinfo)
+            except ValueError:
+                raise KeyError('There is no item %r in the archive' % zinfo) from None
 
             try:
                 del self.NameToInfo[zinfo.filename]

{zipremove-0.3.0 → zipremove-0.4.1/src/zipremove.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zipremove
-Version: 0.3.0
+Version: 0.4.1
 Summary: Extend `zipfile` with `remove`-related functionalities
 Home-page: https://github.com/danny0838/zipremove
 Author: Danny Lin
@@ -37,6 +37,7 @@ Dynamic: license-file
 ![Status](https://img.shields.io/pypi/status/zipremove)
 ![License](https://img.shields.io/github/license/danny0838/zipremove)
 [![Downloads](https://static.pepy.tech/personalized-badge/zipremove?period=month&left_text=Downloads)](https://pepy.tech/project/zipremove)
+[![Pull request](https://img.shields.io/github/pulls/detail/state/python/cpython/134627)](https://github.com/python/cpython/pull/134627)
 
 This package extends `zipfile` with `remove`-related functionalities.
 
@@ -61,30 +62,32 @@ This package extends `zipfile` with `remove`-related functionalities.
 
 * `ZipFile.repack(removed=None, *, strict_descriptor=False[, chunk_size])`
 
-   Rewrites the archive to remove stale local file entries, shrinking the ZIP
-   file size.
+   Rewrites the archive to remove stale local file entries, shrinking its file
+   size.
 
    If *removed* is provided, it must be a sequence of `ZipInfo` objects
    representing removed entries; only their corresponding local file entries
    will be removed.
 
-   If *removed* is not provided, local file entries no longer referenced in the
-   central directory will be removed.  The algorithm assumes that local file
-   entries are stored consecutively:
+   If *removed* is not provided, the archive is scanned to identify and remove
+   local file entries that are no longer referenced in the central directory.
+   The algorithm assumes that local file entries (and the central directory,
+   which is mostly treated as the "last entry") are stored consecutively:
 
    1. Data before the first referenced entry is removed only when it appears to
       be a sequence of consecutive entries with no extra following bytes; extra
-      preceeding bytes are preserved.
+      preceding bytes are preserved.
    2. Data between referenced entries is removed only when it appears to
       be a sequence of consecutive entries with no extra preceding bytes; extra
       following bytes are preserved.
-
-   ``strict_descriptor=True`` can be provided to skip the slower scan for an
-   unsigned data descriptor (deprecated in the latest ZIP specification and is
-   only used by legacy tools) when checking for bytes resembling a valid local
-   file entry.  This improves performance, but may cause some stale local file
-   entries to be preserved, as any entry using an unsigned descriptor cannot
-   be detected.
+   3. Entries must not overlap. If any entry's data overlaps with another, a
+      `BadZipFile` error is raised and no changes are made.
+
+   When scanning, setting `strict_descriptor=True` disables detection of any
+   entry using an unsigned data descriptor (deprecated in the ZIP specification
+   since version 6.3.0, released on 2006-09-29, and used only by some legacy
+   tools). This improves performance, but may cause some stale entries to be
+   preserved.
 
    *chunk_size* may be specified to control the buffer size when moving
    entry data (default is 1 MiB).

{zipremove-0.3.0 → zipremove-0.4.1}/tests/test_zipfile.py

@@ -1,3 +1,4 @@
+import contextlib
 import io
 import itertools
 import os
@@ -610,6 +611,25 @@ class AbstractRepackTests(RepackHelperMixin):
                 with zipfile.ZipFile(TESTFN) as zh:
                     self.assertIsNone(zh.testzip())
 
+    def test_repack_propagation(self):
+        """Should call internal API with adequate parameters."""
+        self._prepare_zip_from_test_files(TESTFN, self.test_files)
+
+        with zipfile.ZipFile(TESTFN, 'a', self.compression) as zh:
+            with mock.patch.object(zipfile._ZipRepacker, 'repack') as m_rp, \
+                 mock.patch.object(zipfile, '_ZipRepacker', wraps=zipfile._ZipRepacker) as m_zr:
+                zh.repack()
+        m_zr.assert_called_once_with()
+        m_rp.assert_called_once_with(zh, None)
+
+        with zipfile.ZipFile(TESTFN, 'a', self.compression) as zh:
+            zi = zh.remove(zh.infolist()[0])
+            with mock.patch.object(zipfile._ZipRepacker, 'repack') as m_rp, \
+                 mock.patch.object(zipfile, '_ZipRepacker', wraps=zipfile._ZipRepacker) as m_zr:
+                zh.repack([zi], strict_descriptor=True, chunk_size=1024)
+        m_zr.assert_called_once_with(strict_descriptor=True, chunk_size=1024)
+        m_rp.assert_called_once_with(zh, [zi])
+
     def test_repack_bytes_before_first_file(self):
         """Should preserve random bytes before the first recorded local file entry."""
         for ii in ([], [0], [0, 1], [0, 1, 2]):
@@ -847,222 +867,6 @@ class AbstractRepackTests(RepackHelperMixin):
         with zipfile.ZipFile(TESTFN) as zh:
             self.assertIsNone(zh.testzip())
 
-    @requires_zip64fix()
-    def test_repack_zip64(self):
-        """Should correctly handle file entries with zip64."""
-        for ii in ([0], [0, 1], [1], [2]):
-            with self.subTest(remove=ii):
-                # calculate the expected results
-                test_files = [data for j, data in enumerate(self.test_files) if j not in ii]
-                expected_zinfos = self._prepare_zip_from_test_files(TESTFN, test_files, force_zip64=True)
-                expected_size = os.path.getsize(TESTFN)
-
-                # do the removal and check the result
-                self._prepare_zip_from_test_files(TESTFN, self.test_files, force_zip64=True)
-                with zipfile.ZipFile(TESTFN, 'a', self.compression) as zh:
-                    for i in ii:
-                        zh.remove(self.test_files[i][0])
-                    zh.repack()
-
-                    # check infolist
-                    self.assertEqual(
-                        [ComparableZipInfo(zi) for zi in zh.infolist()],
-                        expected_zinfos,
-                    )
-
-                # check file size
-                self.assertEqual(os.path.getsize(TESTFN), expected_size)
-
-                # make sure the zip file is still valid
-                with zipfile.ZipFile(TESTFN) as zh:
-                    self.assertIsNone(zh.testzip())
-
-    def test_repack_data_descriptor(self):
-        """Should correctly handle file entries using data descriptor."""
-        for ii in ([0], [0, 1], [1], [2]):
-            with self.subTest(remove=ii):
-                # calculate the expected results
-                test_files = [data for j, data in enumerate(self.test_files) if j not in ii]
-                with open(TESTFN, 'wb') as fh:
-                    expected_zinfos = self._prepare_zip_from_test_files(Unseekable(fh), test_files)
-                expected_size = os.path.getsize(TESTFN)
-
-                # do the removal and check the result
-                with open(TESTFN, 'wb') as fh:
-                    self._prepare_zip_from_test_files(Unseekable(fh), self.test_files)
-                with zipfile.ZipFile(TESTFN, 'a', self.compression) as zh:
-                    # make sure data descriptor bit is really set (by making zipfile unseekable)
-                    for zi in zh.infolist():
-                        self.assertTrue(zi.flag_bits & 8, f'data descriptor not used: {zi.filename}')
-
-                    for i in ii:
-                        zh.remove(self.test_files[i][0])
-                    zh.repack()
-
-                    # check infolist
-                    self.assertEqual(
-                        [ComparableZipInfo(zi) for zi in zh.infolist()],
-                        expected_zinfos,
-                    )
-
-                # check file size
-                self.assertEqual(os.path.getsize(TESTFN), expected_size)
-
-                # make sure the zip file is still valid
-                with zipfile.ZipFile(TESTFN) as zh:
-                    self.assertIsNone(zh.testzip())
-
-    @requires_zip64fix()
-    def test_repack_data_descriptor_and_zip64(self):
-        """Should correctly handle file entries using data descriptor and zip64."""
-        for ii in ([0], [0, 1], [1], [2]):
-            with self.subTest(remove=ii):
-                # calculate the expected results
-                test_files = [data for j, data in enumerate(self.test_files) if j not in ii]
-                with open(TESTFN, 'wb') as fh:
-                    expected_zinfos = self._prepare_zip_from_test_files(Unseekable(fh), test_files, force_zip64=True)
-                expected_size = os.path.getsize(TESTFN)
-
-                # do the removal and check the result
-                with open(TESTFN, 'wb') as fh:
-                    self._prepare_zip_from_test_files(Unseekable(fh), self.test_files, force_zip64=True)
-                with zipfile.ZipFile(TESTFN, 'a', self.compression) as zh:
-                    # make sure data descriptor bit is really set (by making zipfile unseekable)
-                    for zi in zh.infolist():
-                        self.assertTrue(zi.flag_bits & 8, f'data descriptor not used: {zi.filename}')
-
-                    for i in ii:
-                        zh.remove(self.test_files[i][0])
-                    zh.repack()
-
-                    # check infolist
-                    self.assertEqual(
-                        [ComparableZipInfo(zi) for zi in zh.infolist()],
-                        expected_zinfos,
-                    )
-
-                # check file size
-                self.assertEqual(os.path.getsize(TESTFN), expected_size)
-
-                # make sure the zip file is still valid
-                with zipfile.ZipFile(TESTFN) as zh:
-                    self.assertIsNone(zh.testzip())
-
-    def test_repack_data_descriptor_no_sig(self):
-        """Should correctly handle file entries using data descriptor without signature."""
-        for ii in ([0], [0, 1], [1], [2]):
-            with self.subTest(remove=ii):
-                # calculate the expected results
-                test_files = [data for j, data in enumerate(self.test_files) if j not in ii]
-                with open(TESTFN, 'wb') as fh:
-                    with mock.patch.object(struct, 'pack', side_effect=struct_pack_no_dd_sig):
-                        expected_zinfos = self._prepare_zip_from_test_files(Unseekable(fh), test_files)
-                expected_size = os.path.getsize(TESTFN)
-
-                # do the removal and check the result
-                with open(TESTFN, 'wb') as fh:
-                    with mock.patch.object(struct, 'pack', side_effect=struct_pack_no_dd_sig):
-                        self._prepare_zip_from_test_files(Unseekable(fh), self.test_files)
-                with zipfile.ZipFile(TESTFN, 'a', self.compression) as zh:
-                    # make sure data descriptor bit is really set (by making zipfile unseekable)
-                    for zi in zh.infolist():
-                        self.assertTrue(zi.flag_bits & 8, f'data descriptor flag not set: {zi.filename}')
-
-                    for i in ii:
-                        zh.remove(self.test_files[i][0])
-                    zh.repack()
-
-                    # check infolist
-                    self.assertEqual(
-                        [ComparableZipInfo(zi) for zi in zh.infolist()],
-                        expected_zinfos,
-                    )
-
-                # check file size
-                self.assertEqual(os.path.getsize(TESTFN), expected_size)
-
-                # make sure the zip file is still valid
-                with zipfile.ZipFile(TESTFN) as zh:
-                    self.assertIsNone(zh.testzip())
-
-    def test_repack_data_descriptor_no_sig_strict(self):
-        """Should skip data descriptor without signature when `strict_descriptor` is set."""
-        for ii in ([0], [0, 1], [1], [2]):
-            with self.subTest(remove=ii):
-                # calculate the expected results
-                with open(TESTFN, 'wb') as fh:
-                    with mock.patch.object(struct, 'pack', side_effect=struct_pack_no_dd_sig):
-                        self._prepare_zip_from_test_files(Unseekable(fh), self.test_files)
-                with zipfile.ZipFile(TESTFN, 'a') as zh:
-                    for i in ii:
-                        zh.remove(self.test_files[i][0])
-                    expected_zinfos = [ComparableZipInfo(zi) for zi in zh.infolist()]
-                expected_size = os.path.getsize(TESTFN)
-
-                # do the removal and check the result
-                with open(TESTFN, 'wb') as fh:
-                    with mock.patch.object(struct, 'pack', side_effect=struct_pack_no_dd_sig):
-                        self._prepare_zip_from_test_files(Unseekable(fh), self.test_files)
-                with zipfile.ZipFile(TESTFN, 'a', self.compression) as zh:
-                    # make sure data descriptor bit is really set (by making zipfile unseekable)
-                    for zi in zh.infolist():
-                        self.assertTrue(zi.flag_bits & 8, f'data descriptor flag not set: {zi.filename}')
-
-                    for i in ii:
-                        zh.remove(self.test_files[i][0])
-                    zh.repack(strict_descriptor=True)
-
-                    # check infolist
-                    self.assertEqual(
-                        [ComparableZipInfo(zi) for zi in zh.infolist()],
-                        expected_zinfos,
-                    )
-
-                # check file size
-                self.assertEqual(os.path.getsize(TESTFN), expected_size)
-
-                # make sure the zip file is still valid
-                with zipfile.ZipFile(TESTFN) as zh:
-                    self.assertIsNone(zh.testzip())
-
-    @requires_zip64fix()
-    def test_repack_data_descriptor_no_sig_and_zip64(self):
-        """Should correctly handle file entries using data descriptor without signature and zip64."""
-        for ii in ([0], [0, 1], [1], [2]):
-            with self.subTest(remove=ii):
-                # calculate the expected results
-                test_files = [data for j, data in enumerate(self.test_files) if j not in ii]
-                with open(TESTFN, 'wb') as fh:
-                    with mock.patch.object(struct, 'pack', side_effect=struct_pack_no_dd_sig):
-                        expected_zinfos = self._prepare_zip_from_test_files(Unseekable(fh), test_files, force_zip64=True)
-                expected_size = os.path.getsize(TESTFN)
-
-                # do the removal and check the result
-                with open(TESTFN, 'wb') as fh:
-                    with mock.patch.object(struct, 'pack', side_effect=struct_pack_no_dd_sig):
-                        self._prepare_zip_from_test_files(Unseekable(fh), self.test_files, force_zip64=True)
-                with zipfile.ZipFile(TESTFN, 'a', self.compression) as zh:
-                    # make sure data descriptor bit is really set (by making zipfile unseekable)
-                    for zi in zh.infolist():
-                        self.assertTrue(zi.flag_bits & 8, f'data descriptor flag not set: {zi.filename}')
-
-                    for i in ii:
-                        zh.remove(self.test_files[i][0])
-                    zh.repack()
-
-                    # check infolist
-                    self.assertEqual(
-                        [ComparableZipInfo(zi) for zi in zh.infolist()],
-                        expected_zinfos,
-                    )
-
-                # check file size
-                self.assertEqual(os.path.getsize(TESTFN), expected_size)
-
-                # make sure the zip file is still valid
-                with zipfile.ZipFile(TESTFN) as zh:
-                    self.assertIsNone(zh.testzip())
-
     def test_repack_prepended_bytes(self):
         for ii in ([], [0], [0, 1], [1], [2]):
             with self.subTest(remove=ii):
@@ -1575,6 +1379,320 @@ class OtherRepackTests(unittest.TestCase):
         self.assertEqual(fz.read(), expected)
 
 class ZipRepackerTests(unittest.TestCase):
+    def _generate_local_file_entry(self, arcname, raw_bytes,
+                                   compression=zipfile.ZIP_STORED,
+                                   force_zip64=False, dd=False, dd_sig=True):
+        fz = io.BytesIO()
+        f = Unseekable(fz) if dd else fz
+        cm = (mock.patch.object(struct, 'pack', side_effect=struct_pack_no_dd_sig)
+              if not dd_sig else contextlib.nullcontext())
+        with zipfile.ZipFile(f, 'w', compression=compression) as zh:
+            with cm:
+                with zh.open(arcname, 'w', force_zip64=force_zip64) as fh:
+                    fh.write(raw_bytes)
+            fz.seek(0)
+            return fz.read()
+
+    def test_validate_local_file_entry_stored(self):
+        self._test_validate_local_file_entry(method=zipfile.ZIP_STORED)
+
+    @requires_zlib()
+    def test_validate_local_file_entry_zlib(self):
+        self._test_validate_local_file_entry(method=zipfile.ZIP_DEFLATED)
+
+    @requires_bz2()
+    def test_validate_local_file_entry_bz2(self):
+        self._test_validate_local_file_entry(method=zipfile.ZIP_BZIP2)
+
+    @requires_lzma()
+    def test_validate_local_file_entry_lzma(self):
+        self._test_validate_local_file_entry(method=zipfile.ZIP_LZMA)
+
+    @requires_zstd()
+    def test_validate_local_file_entry_zstd(self):
+        self._test_validate_local_file_entry(method=zipfile.ZIP_ZSTANDARD)
+
+    def _test_validate_local_file_entry(self, method):
+        repacker = zipfile._ZipRepacker()
+
+        # basic
+        bytes_ = self._generate_local_file_entry(
+            'file.txt', b'dummy', compression=method)
+        fz = io.BytesIO(bytes_)
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 0, len(bytes_))
+        self.assertEqual(result, len(bytes_))
+        m_sdd.assert_not_called()
+        m_sddnsbd.assert_not_called()
+        m_sddns.assert_not_called()
+
+        # offset
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 0, len(bytes_) + 1)
+        self.assertEqual(result, len(bytes_))
+        m_sdd.assert_not_called()
+        m_sddnsbd.assert_not_called()
+        m_sddns.assert_not_called()
+
+        bytes_ = b'pre' + bytes_ + b'post'
+        fz = io.BytesIO(bytes_)
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 3, len(bytes_) - 4)
+        self.assertEqual(result, len(bytes_) - 7)
+        m_sdd.assert_not_called()
+        m_sddnsbd.assert_not_called()
+        m_sddns.assert_not_called()
+
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 3, len(bytes_))
+        self.assertEqual(result, len(bytes_) - 7)
+        m_sdd.assert_not_called()
+        m_sddnsbd.assert_not_called()
+        m_sddns.assert_not_called()
+
+        # return None if no match at given offset
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 2, len(bytes_) - 4)
+        self.assertEqual(result, None)
+        m_sdd.assert_not_called()
+        m_sddnsbd.assert_not_called()
+        m_sddns.assert_not_called()
+
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 4, len(bytes_) - 4)
+        self.assertEqual(result, None)
+        m_sdd.assert_not_called()
+        m_sddnsbd.assert_not_called()
+        m_sddns.assert_not_called()
+
+        # return None if no sufficient header length
+        bytes_ = self._generate_local_file_entry(
+            'file.txt', b'dummy', compression=method)
+        bytes_ = bytes_[:29]
+        fz = io.BytesIO(bytes_)
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 0, len(bytes_))
+        self.assertEqual(result, None)
+        m_sdd.assert_not_called()
+        m_sddnsbd.assert_not_called()
+        m_sddns.assert_not_called()
+
+        # data descriptor
+        bytes_ = self._generate_local_file_entry(
+            'file.txt', b'dummy', compression=method, dd=True)
+        fz = io.BytesIO(bytes_)
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 0, len(bytes_))
+        self.assertEqual(result, len(bytes_))
+        m_sdd.assert_called_once_with(fz, 38, len(bytes_), False)
+        m_sddnsbd.assert_not_called()
+        m_sddns.assert_not_called()
+
+        # data descriptor (unsigned)
+        bytes_ = self._generate_local_file_entry(
+            'file.txt', b'dummy', compression=method, dd=True, dd_sig=False)
+        fz = io.BytesIO(bytes_)
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 0, len(bytes_))
+        self.assertEqual(result, len(bytes_))
+        m_sdd.assert_called_once_with(fz, 38, len(bytes_), False)
+        m_sddnsbd.assert_called_once_with(fz, 38, len(bytes_), False, method)
+        if repacker._scan_data_descriptor_no_sig_by_decompression(fz, 38, len(bytes_), False, method):
+            m_sddns.assert_not_called()
+        else:
+            m_sddns.assert_called_once_with(fz, 38, len(bytes_), False)
+
+        # return None for data descriptor (unsigned) if `strict_descriptor=True`
+        repacker = zipfile._ZipRepacker(strict_descriptor=True)
+        bytes_ = self._generate_local_file_entry(
+            'file.txt', b'dummy', compression=method, dd=True, dd_sig=False)
+        fz = io.BytesIO(bytes_)
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 0, len(bytes_))
+        self.assertEqual(result, None)
+        m_sdd.assert_called_once_with(fz, 38, len(bytes_), False)
+        m_sddnsbd.assert_not_called()
+        m_sddns.assert_not_called()
+
+    @requires_zip64fix()
+    def test_validate_local_file_entry_zip64_stored(self):
+        self._test_validate_local_file_entry_zip64(method=zipfile.ZIP_STORED)
+
+    @requires_zip64fix()
+    @requires_zlib()
+    def test_validate_local_file_entry_zip64_zlib(self):
+        self._test_validate_local_file_entry_zip64(method=zipfile.ZIP_DEFLATED)
+
+    @requires_zip64fix()
+    @requires_bz2()
+    def test_validate_local_file_entry_zip64_bz2(self):
+        self._test_validate_local_file_entry_zip64(method=zipfile.ZIP_BZIP2)
+
+    @requires_zip64fix()
+    @requires_lzma()
+    def test_validate_local_file_entry_zip64_lzma(self):
+        self._test_validate_local_file_entry_zip64(method=zipfile.ZIP_LZMA)
+
+    @requires_zip64fix()
+    @requires_zstd()
+    def test_validate_local_file_entry_zip64_zstd(self):
+        self._test_validate_local_file_entry_zip64(method=zipfile.ZIP_ZSTANDARD)
+
+    def _test_validate_local_file_entry_zip64(self, method):
+        repacker = zipfile._ZipRepacker()
+
+        # zip64
+        bytes_ = self._generate_local_file_entry(
+            'file.txt', b'dummy', compression=method, force_zip64=True)
+        fz = io.BytesIO(bytes_)
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 0, len(bytes_))
+        self.assertEqual(result, len(bytes_))
+        m_sdd.assert_not_called()
+        m_sddnsbd.assert_not_called()
+        m_sddns.assert_not_called()
+
+        # data descriptor + zip64
+        bytes_ = self._generate_local_file_entry(
+            'file.txt', b'dummy', compression=method, force_zip64=True, dd=True)
+        fz = io.BytesIO(bytes_)
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 0, len(bytes_))
+        self.assertEqual(result, len(bytes_))
+        m_sdd.assert_called_once_with(fz, 58, len(bytes_), True)
+        m_sddnsbd.assert_not_called()
+        m_sddns.assert_not_called()
+
+        # data descriptor (unsigned) + zip64
+        bytes_ = self._generate_local_file_entry(
+            'file.txt', b'dummy', compression=method, force_zip64=True, dd=True, dd_sig=False)
+        fz = io.BytesIO(bytes_)
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 0, len(bytes_))
+        self.assertEqual(result, len(bytes_))
+        m_sdd.assert_called_once_with(fz, 58, len(bytes_), True)
+        m_sddnsbd.assert_called_once_with(fz, 58, len(bytes_), True, method)
+        if repacker._scan_data_descriptor_no_sig_by_decompression(fz, 58, len(bytes_), True, method):
+            m_sddns.assert_not_called()
+        else:
+            m_sddns.assert_called_once_with(fz, 58, len(bytes_), True)
+
+        # return None for data descriptor (unsigned) if `strict_descriptor=True`
+        repacker = zipfile._ZipRepacker(strict_descriptor=True)
+        bytes_ = self._generate_local_file_entry(
+            'file.txt', b'dummy', compression=method, force_zip64=True, dd=True, dd_sig=False)
+        fz = io.BytesIO(bytes_)
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 0, len(bytes_))
+        self.assertEqual(result, None)
+        m_sdd.assert_called_once_with(fz, 58, len(bytes_), True)
+        m_sddnsbd.assert_not_called()
+        m_sddns.assert_not_called()
+
+    def test_validate_local_file_entry_encrypted(self):
+        repacker = zipfile._ZipRepacker()
+
+        bytes_ = (
+            b'PK\x03\x04'
+            b'\x14\x00'
+            b'\x09\x00'
+            b'\x08\x00'
+            b'\xAB\x28'
+            b'\xD2\x5A'
+            b'\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00'
+            b'\x08\x00'
+            b'\x00\x00'
+            b'file.txt'
+            b'\x97\xF1\x83\x34\x9D\xC4\x8C\xD3\xED\x79\x8C\xA2\xBB\x49\xFF\x1B\x89'
+            b'\x3F\xF2\xF4\x4F'
+            b'\x11\x00\x00\x00'
+            b'\x05\x00\x00\x00'
+        )
+        fz = io.BytesIO(bytes_)
+        with mock.patch.object(repacker, '_scan_data_descriptor',
+                               wraps=repacker._scan_data_descriptor) as m_sdd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig_by_decompression',
+                               wraps=repacker._scan_data_descriptor_no_sig_by_decompression) as m_sddnsbd, \
+             mock.patch.object(repacker, '_scan_data_descriptor_no_sig',
+                               wraps=repacker._scan_data_descriptor_no_sig) as m_sddns:
+            result = repacker._validate_local_file_entry(fz, 0, len(bytes_))
+        self.assertEqual(result, len(bytes_))
+        m_sdd.assert_called_once_with(fz, 38, len(bytes_), False)
+        m_sddnsbd.assert_not_called()
+        m_sddns.assert_called_once_with(fz, 38, len(bytes_), False)
+
     def test_iter_scan_signature(self):
         bytes_ = b'sig__sig__sig__sig'
         ln = len(bytes_)
@@ -1623,136 +1741,177 @@ class ZipRepackerTests(unittest.TestCase):
 
     def test_scan_data_descriptor(self):
         repacker = zipfile._ZipRepacker()
-        SIG = zipfile._DD_SIGNATURE
+
+        sig = zipfile._DD_SIGNATURE
+        raw_bytes = comp_bytes = b'dummy'
+        raw_len = comp_len = len(raw_bytes)
+        raw_crc = zipfile.crc32(raw_bytes)
 
         # basic
-        bytes_ = b'dummy' + struct.pack('<4L', SIG, 0x4ff4f23f, 5, 5)
+        bytes_ = comp_bytes + struct.pack('<4L', sig, raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor(io.BytesIO(bytes_), 0, len(bytes_), False),
-            (0x4ff4f23f, 5, 5, 16),
+            (raw_crc, comp_len, raw_len, 16),
         )
 
         # return None if no signature
-        bytes_ = b'dummy' + struct.pack('<3L', 0x4ff4f23f, 5, 5)
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor(io.BytesIO(bytes_), 0, len(bytes_), False),
             None,
         )
 
-        # return None if not unpackable
-        bytes_ = struct.pack('<L', SIG)
+        # return None if compressed size not match
+        bytes_ = comp_bytes + struct.pack('<4L', sig, raw_crc, comp_len + 1, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor(io.BytesIO(bytes_), 0, len(bytes_), False),
             None,
         )
 
-        # return None if compressed size not match
-        bytes_ = b'dumm' + struct.pack('<4L', SIG, 0x4ff4f23f, 5, 5)
+        bytes_ = comp_bytes + struct.pack('<4L', sig, raw_crc, comp_len - 1, raw_len)
+        self.assertEqual(
+            repacker._scan_data_descriptor(io.BytesIO(bytes_), 0, len(bytes_), False),
+            None,
+        )
+
+        bytes_ = b'1' + comp_bytes + struct.pack('<4L', sig, raw_crc, comp_len, raw_len)
+        self.assertEqual(
+            repacker._scan_data_descriptor(io.BytesIO(bytes_), 0, len(bytes_), False),
+            None,
+        )
+
+        bytes_ = comp_bytes[1:] + struct.pack('<4L', sig, raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor(io.BytesIO(bytes_), 0, len(bytes_), False),
             None,
         )
 
         # zip64
-        bytes_ = b'dummy' + struct.pack('<2L2Q', SIG, 0x4ff4f23f, 5, 5)
+        bytes_ = comp_bytes + struct.pack('<2L2Q', sig, raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor(io.BytesIO(bytes_), 0, len(bytes_), True),
-            (0x4ff4f23f, 5, 5, 24),
+            (raw_crc, comp_len, raw_len, 24),
         )
 
         # offset
-        bytes_ = b'dummy' + struct.pack('<4L', SIG, 0x4ff4f23f, 5, 5)
+        bytes_ = comp_bytes + struct.pack('<4L', sig, raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor(io.BytesIO(bytes_), 1, len(bytes_), False),
             None,
         )
 
-        bytes_ = b'123dummy' + struct.pack('<4L', SIG, 0x4ff4f23f, 5, 5)
+        bytes_ = b'123' + comp_bytes + struct.pack('<4L', sig, raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor(io.BytesIO(bytes_), 0, len(bytes_), False),
             None,
         )
         self.assertEqual(
             repacker._scan_data_descriptor(io.BytesIO(bytes_), 3, len(bytes_), False),
-            (0x4ff4f23f, 5, 5, 16),
+            (raw_crc, comp_len, raw_len, 16),
         )
 
         # end_offset
-        bytes_ = b'dummy' + struct.pack('<4L', SIG, 0x4ff4f23f, 5, 5)
+        bytes_ = comp_bytes + struct.pack('<4L', sig, raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor(io.BytesIO(bytes_), 0, len(bytes_) - 1, False),
             None,
         )
 
-        bytes_ = b'dummy' + struct.pack('<4L', SIG, 0x4ff4f23f, 5, 5) + b'123'
+        bytes_ = comp_bytes + struct.pack('<4L', sig, raw_crc, comp_len, raw_len) + b'123'
         self.assertEqual(
             repacker._scan_data_descriptor(io.BytesIO(bytes_), 0, len(bytes_) - 3, False),
-            (0x4ff4f23f, 5, 5, 16),
+            (raw_crc, comp_len, raw_len, 16),
+        )
+        self.assertEqual(
+            repacker._scan_data_descriptor(io.BytesIO(bytes_), 0, len(bytes_), False),
+            (raw_crc, comp_len, raw_len, 16),
         )
 
     def test_scan_data_descriptor_no_sig(self):
         repacker = zipfile._ZipRepacker()
 
+        raw_bytes = comp_bytes = b'dummy'
+        raw_len = comp_len = len(raw_bytes)
+        raw_crc = zipfile.crc32(raw_bytes)
+
         # basic
-        bytes_ = b'dummy' + struct.pack('<3L', 0x4ff4f23f, 5, 5)
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 0, len(bytes_), False),
-            (0x4ff4f23f, 5, 5, 12),
+            (raw_crc, comp_len, raw_len, 12),
         )
 
         # return None if compressed size not match
-        bytes_ = b'dumm' + struct.pack('<3L', 0x4ff4f23f, 5, 5)
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len + 1, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 0, len(bytes_), False),
             None,
         )
 
-        # zip64
-        bytes_ = b'dummy' + struct.pack('<L2Q', 0x4ff4f23f, 5, 5)
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len - 1, raw_len)
         self.assertEqual(
-            repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 0, len(bytes_), True),
-            (0x4ff4f23f, 5, 5, 20),
+            repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 0, len(bytes_), False),
+            None,
         )
 
-        # offset
-        bytes_ = b'dummy' + struct.pack('<3L', 0x4ff4f23f, 5, 5)
+        bytes_ = b'1' + comp_bytes + struct.pack('<3L', raw_crc, comp_len, raw_len)
         self.assertEqual(
-            repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 1, len(bytes_), False),
+            repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 0, len(bytes_), False),
             None,
         )
 
-        bytes_ = b'123dummy' + struct.pack('<3L', 0x4ff4f23f, 5, 5)
+        bytes_ = comp_bytes[1:] + struct.pack('<3L', raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 0, len(bytes_), False),
             None,
         )
+
+        # zip64
+        bytes_ = comp_bytes + struct.pack('<L2Q', raw_crc, comp_len, raw_len)
+        self.assertEqual(
+            repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 0, len(bytes_), True),
+            (raw_crc, comp_len, raw_len, 20),
+        )
+
+        # offset
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len, raw_len)
+        self.assertEqual(
+            repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 1, len(bytes_), False),
+            None,
+        )
+
+        bytes_ = b'123' + comp_bytes + struct.pack('<3L', raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 3, len(bytes_), False),
-            (0x4ff4f23f, 5, 5, 12),
+            (raw_crc, comp_len, raw_len, 12),
         )
 
         # end_offset
-        bytes_ = b'dummy' + struct.pack('<3L', 0x4ff4f23f, 5, 5)
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 0, len(bytes_) - 1, False),
             None,
         )
 
-        bytes_ = b'dummy' + struct.pack('<3L', 0x4ff4f23f, 5, 5) + b'123'
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len, raw_len) + b'123'
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 0, len(bytes_) - 3, False),
-            (0x4ff4f23f, 5, 5, 12),
+            (raw_crc, comp_len, raw_len, 12),
+        )
+        self.assertEqual(
+            repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 0, len(bytes_), False),
+            (raw_crc, comp_len, raw_len, 12),
         )
 
         # chunk_size
-        bytes_ = b'dummy' + struct.pack('<3L', 0x4ff4f23f, 5, 5)
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 0, len(bytes_), False, 12),
-            (0x4ff4f23f, 5, 5, 12),
+            (raw_crc, comp_len, raw_len, 12),
         )
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig(io.BytesIO(bytes_), 0, len(bytes_), False, 1),
-            (0x4ff4f23f, 5, 5, 12),
+            (raw_crc, comp_len, raw_len, 12),
         )
 
     def test_scan_data_descriptor_no_sig_by_decompression_stored(self):
@@ -1781,44 +1940,40 @@ class ZipRepackerTests(unittest.TestCase):
     def _test_scan_data_descriptor_no_sig_by_decompression(self, method):
         repacker = zipfile._ZipRepacker()
 
-        compressor = zipfile._get_compressor(method)
-
         raw_bytes = b'dummy'
         raw_len = len(raw_bytes)
+        raw_crc = zipfile.crc32(raw_bytes)
+
+        compressor = zipfile._get_compressor(method)
         comp_bytes = compressor.compress(raw_bytes)
         comp_bytes += compressor.flush()
         comp_len = len(comp_bytes)
 
         # basic
-        bytes_ = comp_bytes + struct.pack('<3L', 0x4ff4f23f, comp_len, raw_len)
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig_by_decompression(
                 io.BytesIO(bytes_), 0, len(bytes_), False, method),
-            (0x4ff4f23f, comp_len, raw_len, 12),
+            (raw_crc, comp_len, raw_len, 12),
         )
 
-        # return None if insufficient data length
-        bytes_ = comp_bytes + struct.pack('<3L', 0x4ff4f23f, comp_len, raw_len)
+        # return None if data length < DD signature
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig_by_decompression(
-                io.BytesIO(bytes_), 0, len(bytes_) - 1, False, method),
+                io.BytesIO(bytes_), 0, 11, False, method),
             None,
         )
 
-        bytes_ = comp_bytes + struct.pack('<3L', 0x4ff4f23f, comp_len, raw_len)[:-1]
+        # return None if compressed size not match
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len + 1, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig_by_decompression(
                 io.BytesIO(bytes_), 0, len(bytes_), False, method),
             None,
         )
-        self.assertEqual(
-            repacker._scan_data_descriptor_no_sig_by_decompression(
-                io.BytesIO(bytes_), 0, len(bytes_) + 1, False, method),
-            None,
-        )
 
-        # return None if compressed size not match
-        bytes_ = comp_bytes + struct.pack('<3L', 0x4ff4f23f, comp_len - 1, raw_len)
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len - 1, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig_by_decompression(
                 io.BytesIO(bytes_), 0, len(bytes_), False, method),
@@ -1826,41 +1981,46 @@ class ZipRepackerTests(unittest.TestCase):
         )
 
         # zip64
-        bytes_ = comp_bytes + struct.pack('<L2Q', 0x4ff4f23f, comp_len, raw_len)
+        bytes_ = comp_bytes + struct.pack('<L2Q', raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig_by_decompression(
                 io.BytesIO(bytes_), 0, len(bytes_), True, method),
-            (0x4ff4f23f, comp_len, raw_len, 20),
+            (raw_crc, comp_len, raw_len, 20),
         )
 
         # offset
-        bytes_ = comp_bytes + struct.pack('<3L', 0x4ff4f23f, comp_len, raw_len)
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig_by_decompression(
                 io.BytesIO(bytes_), 1, len(bytes_), False, method),
             None,
         )
 
-        bytes_ = b'123' + comp_bytes + struct.pack('<3L', 0x4ff4f23f, comp_len, raw_len)
+        bytes_ = b'123' + comp_bytes + struct.pack('<3L', raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig_by_decompression(
                 io.BytesIO(bytes_), 3, len(bytes_), False, method),
-            (0x4ff4f23f, comp_len, raw_len, 12),
+            (raw_crc, comp_len, raw_len, 12),
         )
 
         # end_offset
-        bytes_ = comp_bytes + struct.pack('<3L', 0x4ff4f23f, comp_len, raw_len)
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len, raw_len)
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig_by_decompression(
-                io.BytesIO(bytes_), 0, len(bytes_) - 2, False, method),
+                io.BytesIO(bytes_), 0, len(bytes_) - 1, False, method),
             None,
         )
 
-        bytes_ = comp_bytes + struct.pack('<3L', 0x4ff4f23f, comp_len, raw_len) + b'123'
+        bytes_ = comp_bytes + struct.pack('<3L', raw_crc, comp_len, raw_len) + b'123'
         self.assertEqual(
             repacker._scan_data_descriptor_no_sig_by_decompression(
-                io.BytesIO(bytes_), 0, len(bytes_) - 2, False, method),
-            (0x4ff4f23f, comp_len, raw_len, 12),
+                io.BytesIO(bytes_), 0, len(bytes_) - 3, False, method),
+            (raw_crc, comp_len, raw_len, 12),
+        )
+        self.assertEqual(
+            repacker._scan_data_descriptor_no_sig_by_decompression(
+                io.BytesIO(bytes_), 0, len(bytes_), False, method),
+            (raw_crc, comp_len, raw_len, 12),
         )
 
     def _test_scan_data_descriptor_no_sig_by_decompression_invalid(self, method):

{zipremove-0.3.0 → zipremove-0.4.1}/tests/test_zipfile64.py

@@ -18,16 +18,19 @@ except ImportError:
     # polyfill for Python < 3.12
     from test.test_zipfile import Unseekable, requires_zlib
 
-ENABLED_RESOURCES = set(os.environ.get("TEST_RESOURCES", "").split(","))
-
-def requires(resource_name):
+def requires_resource(res):
+    if not hasattr(requires_resource, '_resources'):
+        requires_resource._resources = set(os.environ.get("TEST_RESOURCES", "").split(","))
     return unittest.skipUnless(
-        resource_name in ENABLED_RESOURCES,
-        f"requires resource: {resource_name!r} (set envvar TEST_RESOURCES)"
+        res in requires_resource._resources,
+        f"requires resource {res!r} in envvar TEST_RESOURCES"
     )
 
+@requires_resource('extralargefile')
+def setUpModule():
+    pass
+
 
-@requires('extralargefile')
 class TestRepack(unittest.TestCase):
     def setUp(self):
         # Create test data.