@@ -9,29 +9,28 @@
 import re
 import warnings
 
-from git.cmd import Git, handle_process_output
-from git.compat import defenc
-from git.objects.base import IndexObject
-from git.objects.blob import Blob
-from git.objects.util import mode_str_to_int
-from git.util import finalize_process, hex_to_bin
-
 # typing ------------------------------------------------------------------
-
 from typing import (
+    TYPE_CHECKING,
     Any,
     Iterator,
     List,
     Match,
     Optional,
     Sequence,
     Tuple,
-    TYPE_CHECKING,
     TypeVar,
     Union,
     cast,
 )
-from git.types import PathLike, Literal
+
+from git.cmd import Git, handle_process_output
+from git.compat import defenc
+from git.objects.base import IndexObject
+from git.objects.blob import Blob
+from git.objects.util import mode_str_to_int
+from git.types import Literal, PathLike
+from git.util import finalize_process, hex_to_bin
 
 if TYPE_CHECKING:
     from subprocess import Popen
@@ -645,19 +644,22 @@ def _same_path_in_header(names: bytes) -> Optional[bytes]:
             end = 1
             while end < len(names) and names[end : end + 1] != b'"':
                 end += 2 if names[end : end + 1] == b"\\" else 1
-            splits = [end + 1]
+            split = end + 1
         else:
-            splits = [index for index in range(len(names)) if names[index : index + 1] == b" "]
-        for split in splits:
-            if names[split : split + 1] != b" ":
-                continue
-            a_name, b_name = names[:split], names[split + 1 :]
-            if a_name.startswith(b'"'):
-                if not (a_name.endswith(b'"') and b_name.startswith(b'"') and b_name.endswith(b'"')):
-                    continue
-                a_name, b_name = _unquote_path(a_name[1:-1]), _unquote_path(b_name[1:-1])
-            if a_name.startswith(b"a/") and b_name.startswith(b"b/") and a_name[2:] == b_name[2:]:
-                return a_name[2:]
+            # Equal unquoted paths have equal-length names, so only the midpoint
+            # can separate them. Trying every space would copy the header quadratically.
+            if len(names) % 2 == 0:
+                return None
+            split = len(names) // 2
+        if names[split : split + 1] != b" ":
+            return None
+        a_name, b_name = names[:split], names[split + 1 :]
+        if a_name.startswith(b'"'):
+            if not (a_name.endswith(b'"') and b_name.startswith(b'"') and b_name.endswith(b'"')):
+                return None
+            a_name, b_name = _unquote_path(a_name[1:-1]), _unquote_path(b_name[1:-1])
+        if a_name.startswith(b"a/") and b_name.startswith(b"b/") and a_name[2:] == b_name[2:]:
+            return a_name[2:]
         return None
 
     @classmethod
 
@@ -4,23 +4,21 @@
 # 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
 
 import gc
-from io import BytesIO
 import os.path as osp
 import shutil
 import sys
 import tempfile
+from io import BytesIO
 
 import ddt
 import pytest
-
 from gitdb.base import IStream
 
-from git import NULL_TREE, Blob, Diff, DiffIndex, Diffable, GitCommandError, Repo, Submodule
+from git import NULL_TREE, Blob, Diff, Diffable, DiffIndex, GitCommandError, Repo, Submodule
 from git.cmd import Git
 from git.diff import decode_path
 from git.exc import UnsafeOptionError
 from git.index.typ import BaseIndexEntry
-
 from test.lib import StringProcessAdapter, TestBase, fixture, with_rw_directory
 
 
@@ -306,6 +304,56 @@ def test_diff_patch_paths_named_only_by_the_header_line(self, rw_dir):
             {(paths[0], paths[0], False), (paths[0], "copy b/logo.png", True)},
         )
 
+    @ddt.data(
+        (b"a/x b/x", b"x"),
+        (b"a/x  b/x ", b"x "),
+        (b"a/x b/y", None),
+        (b"a/x b/xx", None),
+        (b"a/x-b/x", None),
+        (b"", None),
+        (b'"a/x\\t" "b/x\\t"', b"x\t"),
+        (b'"a/x\\t" "b/x\\011"', b"x\t"),
+        (b'"a/x\\t" "b/y\\t"', None),
+        (b'"a/x\\t" "b/x\\t', None),
+    )
+    def test_same_path_in_header(self, case):
+        names, expected = case
+        self.assertEqual(Diff._same_path_in_header(names), expected)
+
+    def test_same_path_in_header_copies_linear_bytes(self):
+        class SliceCountingBytes(bytes):
+            sliced_bytes = 0
+
+            def __getitem__(self, key):
+                result = super().__getitem__(key)
+                if isinstance(key, slice):
+                    self.sliced_bytes += len(result)
+                return result
+
+        path = b"x " * 1000
+        names = SliceCountingBytes(b"a/" + path + b" b/" + path)
+        self.assertEqual(Diff._same_path_in_header(names), path)
+        # Count copied bytes rather than asserting a machine-dependent time limit.
+        self.assertLessEqual(names.sliced_bytes, 2 * len(names))
+
+    @with_rw_directory
+    def test_diff_patch_mode_only_with_long_space_heavy_path(self, rw_dir):
+        repo = Repo.init(rw_dir)
+        path = b"x " * 250000
+        blob = repo.odb.store(IStream(Blob.type, 0, BytesIO(b""))).binsha
+        trees = []
+        # Store trees directly: Git accepts paths longer than filesystem or index limits.
+        for mode in (b"100644", b"100755"):
+            data = mode + b" " + path + b"\0" + blob
+            tree = repo.odb.store(IStream(b"tree", len(data), BytesIO(data)))
+            trees.append(repo.tree(tree.binsha.hex()))
+
+        diffs = trees[0].diff(trees[1], create_patch=True)
+        self.assertEqual(len(diffs), 1)
+        self.assertEqual((diffs[0].a_rawpath, diffs[0].b_rawpath), (path, path))
+        self.assertEqual((diffs[0].a_mode, diffs[0].b_mode), (0o100644, 0o100755))
+        self.assertEqual(diffs[0].diff, b"")
+
     def test_empty_diff(self):
         res = []
         Diff._handle_diff_line(b"", None, res)