PyPI - zipremove - Versions diffs - 0.2.0__tar.gz → 0.4.0__tar.gz - Mend

zipremove 0.2.0tar.gz → 0.4.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

{zipremove-0.2.0/src/zipremove.egg-info → zipremove-0.4.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zipremove
-Version: 0.2.0
+Version: 0.4.0
 Summary: Extend `zipfile` with `remove`-related functionalities
 Home-page: https://github.com/danny0838/zipremove
 Author: Danny Lin
@@ -10,6 +10,7 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: System :: Archiving :: Compression
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -31,6 +32,13 @@ Requires-Dist: flake8-isort>=6.0; extra == "dev"
 Requires-Dist: isort>=5.5; extra == "dev"
 Dynamic: license-file
+![PyPI version](https://img.shields.io/pypi/v/zipremove.svg)
+![Python Versions](https://img.shields.io/pypi/pyversions/zipremove)
+![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.
 ## API
@@ -54,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.2.0 → zipremove-0.4.0}/README.md RENAMED Viewed

@@ -1,3 +1,10 @@
+![PyPI version](https://img.shields.io/pypi/v/zipremove.svg)
+![Python Versions](https://img.shields.io/pypi/pyversions/zipremove)
+![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.
 ## API
@@ -21,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.2.0 → zipremove-0.4.0}/setup.cfg RENAMED Viewed

@@ -1,6 +1,6 @@
 [metadata]
 name = zipremove
-version = 0.2.0
+version = 0.4.0
 author = Danny Lin
 author_email = danny0838@gmail.com
 url = https://github.com/danny0838/zipremove
@@ -13,6 +13,7 @@ classifiers =
 	Intended Audience :: Developers
 	Topic :: System :: Archiving :: Compression
 	Programming Language :: Python :: 3
+	Programming Language :: Python :: 3 :: Only
 	Programming Language :: Python :: 3.9
 	Programming Language :: Python :: 3.10
 	Programming Language :: Python :: 3.11

{zipremove-0.2.0 → zipremove-0.4.0}/src/zipremove/__init__.py RENAMED Viewed

@@ -3,7 +3,9 @@ import io
 import os
 import struct
 from zipfile import *
-from zipfile import (  # noqa: F401
+from zipfile import __all__  # noqa: F401
+from zipfile import _get_compressor  # noqa: F401
+from zipfile import (
     _DD_SIGNATURE,
     _FH_COMPRESSED_SIZE,
     _FH_COMPRESSION_METHOD,
@@ -14,7 +16,6 @@ from zipfile import (  # noqa: F401
     _FH_SIGNATURE,
     _FH_UNCOMPRESSED_SIZE,
     LZMADecompressor,
-    _get_compressor,
     _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:
@@ -49,6 +56,18 @@ except ImportError:
             filename = filename.replace(os.altsep, "/")
         return filename
+try:
+    LZMADecompressor().unused_data
+except AttributeError:
+    # polyfill to support LZMADecompressor().unused_data
+    @property
+    def unused_data(self):
+        try:
+            return self._decomp.unused_data
+        except AttributeError:
+            return b''
+    LZMADecompressor.unused_data = unused_data
 class _ZipRepacker:
     """Class for ZipFile repacking."""
@@ -385,8 +404,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:
@@ -471,14 +493,10 @@ class _ZipRepacker:
         if decompressor is None:
             return False
-        # Current LZMADecompressor is unreliable since it's `.eof` is usually
-        # not set as expected.
-        if isinstance(decompressor, LZMADecompressor):
-            return False
         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

{zipremove-0.2.0 → zipremove-0.4.0/src/zipremove.egg-info}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zipremove
-Version: 0.2.0
+Version: 0.4.0
 Summary: Extend `zipfile` with `remove`-related functionalities
 Home-page: https://github.com/danny0838/zipremove
 Author: Danny Lin
@@ -10,6 +10,7 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: System :: Archiving :: Compression
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -31,6 +32,13 @@ Requires-Dist: flake8-isort>=6.0; extra == "dev"
 Requires-Dist: isort>=5.5; extra == "dev"
 Dynamic: license-file
+![PyPI version](https://img.shields.io/pypi/v/zipremove.svg)
+![Python Versions](https://img.shields.io/pypi/pyversions/zipremove)
+![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.
 ## API
@@ -54,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.2.0 → zipremove-0.4.0}/tests/test_zipfile.py RENAMED Viewed

@@ -6,6 +6,7 @@ import sys
 import unittest
 import unittest.mock as mock
 import warnings
+from contextlib import nullcontext
 import zipremove as zipfile
@@ -610,6 +611,32 @@ 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:
+            zi = zh.remove(zh.infolist()[0])
+            with mock.patch.object(zipfile._ZipRepacker, 'repack') as m_rp:
+                zh.repack()
+        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:
+                zh.repack([zi])
+        m_rp.assert_called_once_with(zh, [zi])
+        with zipfile.ZipFile(TESTFN, 'a', self.compression) as zh:
+            with mock.patch.object(zipfile, '_ZipRepacker') as m_rp:
+                zh.repack()
+        m_rp.assert_called_once_with()
+        with zipfile.ZipFile(TESTFN, 'a', self.compression) as zh:
+            with mock.patch.object(zipfile, '_ZipRepacker') as m_rp:
+                zh.repack(strict_descriptor=True, chunk_size=1024)
+        m_rp.assert_called_once_with(strict_descriptor=True, chunk_size=1024)
     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 +874,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 +1386,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 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_)
@@ -1624,134 +1749,176 @@ class ZipRepackerTests(unittest.TestCase):
     def test_scan_data_descriptor(self):
         repacker = zipfile._ZipRepacker()
+        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'dummyPK\x07\x08\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00'
+        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\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00'
+        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_ = b'PK\x07\x08'
+        # 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'dummPK\x07\x08\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00'
+        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'dummyPK\x07\x08\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00'
+        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'dummyPK\x07\x08\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00'
+        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'123dummyPK\x07\x08\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00'
+        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'dummyPK\x07\x08\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00'
+        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'dummyPK\x07\x08\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00123'
+        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\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00'
+        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\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00'
+        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\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00'
+        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\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00'
+        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\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00'
+        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\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00'
+        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\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00123'
+        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\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00'
+        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):
@@ -1767,7 +1934,7 @@ class ZipRepackerTests(unittest.TestCase):
     @requires_lzma()
     def test_scan_data_descriptor_no_sig_by_decompression_lzma(self):
-        self._test_scan_data_descriptor_no_sig_by_decompression_invalid(zipfile.ZIP_LZMA)
+        self._test_scan_data_descriptor_no_sig_by_decompression(zipfile.ZIP_LZMA)
     @requires_zstd()
     def test_scan_data_descriptor_no_sig_by_decompression_zstd(self):
@@ -1780,37 +1947,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)
-        comp_bytes = compressor.compress(b'dummy')
+        compressor = zipfile._get_compressor(method)
+        comp_bytes = compressor.compress(raw_bytes)
         comp_bytes += compressor.flush()
         comp_len = len(comp_bytes)
         # basic
-        bytes_ = comp_bytes + b'\x3f\xf2\xf4\x4f' + struct.pack('<L', comp_len) + b'\x05\x00\x00\x00'
+        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, 5, 12),
+            (raw_crc, comp_len, raw_len, 12),
         )
-        # return None if insufficient data length
-        bytes_ = b'\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00\x00'
+        # 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_ = b'\x3f\xf2\xf4\x4f\x05\x00\x00\x00\x05\x00\x00'
+        # 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_) + 1, False, method),
+                io.BytesIO(bytes_), 0, len(bytes_), False, method),
             None,
         )
-        # return None if compressed size not match
-        bytes_ = comp_bytes + b'\x3f\xf2\xf4\x4f' + struct.pack('<L', comp_len - 1) + b'\x05\x00\x00\x00'
+        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),
@@ -1818,41 +1988,46 @@ class ZipRepackerTests(unittest.TestCase):
         )
         # zip64
-        bytes_ = comp_bytes + b'\x3f\xf2\xf4\x4f' + struct.pack('<Q', comp_len) + b'\x05\x00\x00\x00\x00\x00\x00\x00'
+        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, 5, 20),
+            (raw_crc, comp_len, raw_len, 20),
         )
         # offset
-        bytes_ = comp_bytes + b'\x3f\xf2\xf4\x4f' + struct.pack('<L', comp_len) + b'\x05\x00\x00\x00'
+        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 + b'\x3f\xf2\xf4\x4f' + struct.pack('<L', comp_len) + b'\x05\x00\x00\x00'
+        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, 5, 12),
+            (raw_crc, comp_len, raw_len, 12),
         )
         # end_offset
-        bytes_ = comp_bytes + b'\x3f\xf2\xf4\x4f' + struct.pack('<L', comp_len) + b'\x05\x00\x00\x00'
+        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 + b'\x3f\xf2\xf4\x4f' + struct.pack('<L', comp_len) + b'\x05\x00\x00\x00123'
+        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, 5, 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.2.0 → zipremove-0.4.0}/tests/test_zipfile64.py RENAMED Viewed

@@ -13,10 +13,10 @@ from .test_zipfile import struct_pack_no_dd_sig
 # polyfills
 try:
-    from test.test_zipfile.test_core import Unseekable
+    from test.test_zipfile.test_core import Unseekable, requires_zlib
 except ImportError:
     # polyfill for Python < 3.12
-    from test.test_zipfile import Unseekable
+    from test.test_zipfile import Unseekable, requires_zlib
 ENABLED_RESOURCES = set(os.environ.get("TEST_RESOURCES", "").split(","))
@@ -172,5 +172,39 @@ class TestRepack(unittest.TestCase):
             zh.repack()
             self.assertIsNone(zh.testzip())
+    @requires_zlib()
+    def test_strip_removed_large_file_with_dd_no_sig_by_decompression(self):
+        """Should scan for the data descriptor (without signature) of a removed
+        large file without causing a memory issue."""
+        # Try the temp file.  If we do TESTFN2, then it hogs
+        # gigabytes of disk space for the duration of the test.
+        with TemporaryFile() as f:
+            tracemalloc.start()
+            self._test_strip_removed_large_file_with_dd_no_sig_by_decompression(
+                f, zipfile.ZIP_DEFLATED)
+            self.assertFalse(f.closed)
+            current, peak = tracemalloc.get_traced_memory()
+            tracemalloc.stop()
+            self.assertLess(peak, self.allowed_memory)
+    def _test_strip_removed_large_file_with_dd_no_sig_by_decompression(self, f, method):
+        file = 'file.txt'
+        file1 = 'largefile.txt'
+        data = b'Sed ut perspiciatis unde omnis iste natus error sit voluptatem'
+        with mock.patch('zipfile.struct.pack', side_effect=struct_pack_no_dd_sig):
+            with zipfile.ZipFile(Unseekable(f), 'w', compression=method) as zh:
+                with zh.open(file1, 'w', force_zip64=True) as fh:
+                    self._write_large_file(fh)
+                zh.writestr(file, data)
+        with zipfile.ZipFile(f, 'a') as zh:
+            # make sure data descriptor bit is really set (by making zip file unseekable)
+            for zi in zh.infolist():
+                self.assertTrue(zi.flag_bits & 8, f'data descriptor flag not set: {zi.filename}')
+            zh.remove(file1)
+            zh.repack()
+            self.assertIsNone(zh.testzip())
 if __name__ == "__main__":
     unittest.main()

{zipremove-0.2.0 → zipremove-0.4.0}/LICENSE.txt RENAMED Viewed

File without changes

{zipremove-0.2.0 → zipremove-0.4.0}/pyproject.toml RENAMED Viewed

File without changes

{zipremove-0.2.0 → zipremove-0.4.0}/setup.py RENAMED Viewed

File without changes

{zipremove-0.2.0 → zipremove-0.4.0}/src/zipremove.egg-info/SOURCES.txt RENAMED Viewed

File without changes

{zipremove-0.2.0 → zipremove-0.4.0}/src/zipremove.egg-info/dependency_links.txt RENAMED Viewed

File without changes

{zipremove-0.2.0 → zipremove-0.4.0}/src/zipremove.egg-info/requires.txt RENAMED Viewed

File without changes

{zipremove-0.2.0 → zipremove-0.4.0}/src/zipremove.egg-info/top_level.txt RENAMED Viewed

File without changes

zipremove 0.2.0__tar.gz → 0.4.0__tar.gz

zipremove 0.2.0tar.gz → 0.4.0tar.gz