Resolve #5091 final adversarial findings

Author: Widthdom

changelog.d/unreleased/5091.fixed.md

@@ -32,12 +32,16 @@ affected:
   - src/CodeIndex/Indexer/Scanning/FileIndexer.Types.cs
   - src/CodeIndex/Indexer/Symbols/SymbolExtractionWorker.cs
   - src/CodeIndex/Indexer/Symbols/SymbolExtractor.TypeScriptPathAliases.cs
+  - src/CodeIndex/Mcp/McpToolHandlers.Indexing.Execution.cs
+  - src/CodeIndex/Mcp/McpToolHandlers.Indexing.ExtractedFilePersistence.cs
+  - src/CodeIndex/Mcp/McpToolHandlers.Indexing.FileLoop.cs
   - tests/CodeIndex.Tests/ConsoleUiTests.cs
   - tests/CodeIndex.Tests/FileIndexerTests.cs
   - tests/CodeIndex.Tests/IndexCommandRunnerDryRunTests.cs
   - tests/CodeIndex.Tests/IndexCommandRunnerTests.cs
   - tests/CodeIndex.Tests/IndexCommandRunnerUpdateTests.cs
   - tests/CodeIndex.Tests/IndexWatchRunnerTests.cs
+  - tests/CodeIndex.Tests/McpServerToolsCallTests.cs
   - tests/CodeIndex.Tests/PathCasingTests.cs
 ---
 

src/CodeIndex/Cli/IndexCommandRunner.ExplicitFilesPreflight.cs

@@ -29,6 +29,15 @@ internal static ExplicitFilesIndexedPathSnapshot ReadFailure()
             => CreateExplicitFilesIndexedPathSnapshot([], readFailed: true);
     }
 
+    internal readonly record struct ExplicitFilesIndexedPathLookupMetrics(
+        int ExactQueryCount,
+        int CaseFoldScanCount,
+        long CaseFoldScannedRowCount);
+
+    internal sealed record ExplicitFilesIndexedPathLookupResult(
+        IReadOnlySet<string> Paths,
+        ExplicitFilesIndexedPathLookupMetrics Metrics);
+
     private static int? RunExplicitFilesPreflight(
         IndexCommandOptions options,
         string resolvedDbPath,
@@ -154,7 +163,9 @@ void Reject(int inputIndex, string path, string reason)
                 continue;
             }
 
-            if (!FileIndexer.IsFilePathSyntaxIndexable(absolutePath))
+            if (!IsExplicitFilePathComponentSyntaxValid(
+                    relativePath,
+                    useWindowsRules: OperatingSystem.IsWindows()))
             {
                 Reject(
                     inputIndex,
@@ -523,29 +534,11 @@ private static ExplicitFilesIndexedPathSnapshot ReadExplicitFilesIndexedPathSnap
             if (!DryRunTableExists(connection, "files"))
                 return ExplicitFilesIndexedPathSnapshot.Empty();
 
-            var paths = new HashSet<string>(StringComparer.Ordinal);
-            ReadExplicitFilesIndexedPathMatches(
+            var lookup = ReadExplicitFilesIndexedPathMatches(
                 connection,
                 candidates,
-                paths,
-                pathExpression: "path",
-                cancellationToken: cancellationToken);
-            var unmatched = candidates.Where(path => !paths.Contains(path)).ToArray();
-            if (unmatched.Length > 0)
-            {
-                const string collationName = "cdidx_explicit_files_path";
-                connection.CreateCollation(
-                    collationName,
-                    (left, right) => StringComparer.OrdinalIgnoreCase.Compare(left, right));
-                ReadExplicitFilesIndexedPathMatches(
-                    connection,
-                    unmatched,
-                    paths,
-                    pathExpression: $"path COLLATE {collationName}",
-                    cancellationToken: cancellationToken);
-            }
-
-            return CreateExplicitFilesIndexedPathSnapshot(paths, readFailed: false);
+                cancellationToken);
+            return CreateExplicitFilesIndexedPathSnapshot(lookup.Paths, readFailed: false);
         }
         catch (SqliteException)
         {
@@ -607,13 +600,20 @@ private static IReadOnlyCollection<string> CollectExplicitFilesIndexedPathCandid
         return candidates;
     }
 
-    private static void ReadExplicitFilesIndexedPathMatches(
+    internal static ExplicitFilesIndexedPathLookupResult
+        ReadExplicitFilesIndexedPathMatchesForTesting(
+            SqliteConnection connection,
+            IReadOnlyCollection<string> candidates,
+            CancellationToken cancellationToken = default)
+        => ReadExplicitFilesIndexedPathMatches(connection, candidates, cancellationToken);
+
+    private static ExplicitFilesIndexedPathLookupResult ReadExplicitFilesIndexedPathMatches(
         SqliteConnection connection,
-        IEnumerable<string> candidates,
-        HashSet<string> matches,
-        string pathExpression,
+        IReadOnlyCollection<string> candidates,
         CancellationToken cancellationToken)
     {
+        var matches = new HashSet<string>(StringComparer.Ordinal);
+        var exactQueryCount = 0;
         foreach (var batch in candidates.Chunk(ExplicitFilesIndexedPathQueryBatchSize))
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -626,7 +626,8 @@ private static void ReadExplicitFilesIndexedPathMatches(
                 SqliteCommandPolicy.Add(command, parameterName, batch[index]);
             }
 
-            command.CommandText = $"SELECT path FROM files WHERE {pathExpression} IN ({string.Join(", ", parameterNames)})";
+            command.CommandText = $"SELECT path FROM files WHERE path IN ({string.Join(", ", parameterNames)})";
+            exactQueryCount++;
             using var reader = command.ExecuteReader();
             while (reader.Read())
             {
@@ -635,6 +636,140 @@ private static void ReadExplicitFilesIndexedPathMatches(
                     matches.Add(FileIndexer.NormalizeIndexPath(reader.GetString(0)));
             }
         }
+
+        var unmatched = candidates
+            .Where(path => !matches.Contains(path))
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+        var caseFoldScanCount = 0;
+        long caseFoldScannedRowCount = 0;
+        if (unmatched.Count > 0)
+        {
+            // A custom collation on files.path prevents SQLite from using the ordinary
+            // binary path index. Batching that expression therefore rescanned the entire
+            // files table once per 256 candidates. Scan it at most once, retain only the
+            // case-fold candidates, and let TryGetExplicitFileIndexedPath apply the target
+            // directory namespace policy before treating a spelling as indexed.
+            using var command = connection.CreateCommand();
+            command.CommandText = "SELECT path FROM files";
+            caseFoldScanCount = 1;
+            using var reader = command.ExecuteReader();
+            while (reader.Read())
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                caseFoldScannedRowCount++;
+                if (reader.IsDBNull(0))
+                    continue;
+
+                var path = FileIndexer.NormalizeIndexPath(reader.GetString(0));
+                if (unmatched.Contains(path))
+                    matches.Add(path);
+            }
+        }
+
+        return new ExplicitFilesIndexedPathLookupResult(
+            matches,
+            new ExplicitFilesIndexedPathLookupMetrics(
+                exactQueryCount,
+                caseFoldScanCount,
+                caseFoldScannedRowCount));
+    }
+
+    internal static bool IsExplicitFilePathComponentSyntaxValid(
+        string path,
+        bool useWindowsRules)
+    {
+        if (!FileIndexer.IsFilePathSyntaxIndexable(path))
+            return false;
+        if (!useWindowsRules)
+            return true;
+
+        if (FileIndexer.IsWindowsDevicePath(path)
+            || IsExplicitFileWindowsSuperscriptDevicePath(path))
+            return false;
+
+        // Path.GetFullPath no longer rejects wildcard and other invalid filename
+        // characters on modern .NET. Check Windows filename components explicitly so a
+        // bad direct --files token cannot reach the mutation pipeline as an inconclusive
+        // filesystem probe. A drive designator is valid only as the first component; the
+        // production caller normally supplies a project-relative spelling, but accepting
+        // the rooted form here keeps the validation seam faithful to Win32 syntax.
+        var span = path.AsSpan();
+        var componentIndex = 0;
+        for (var start = 0; start < span.Length;)
+        {
+            while (start < span.Length && span[start] is '/' or '\\')
+                start++;
+            if (start >= span.Length)
+                break;
+
+            var end = start;
+            while (end < span.Length && span[end] is not ('/' or '\\'))
+                end++;
+
+            var component = span[start..end];
+            var isDriveDesignator = componentIndex == 0
+                && component.Length == 2
+                && ((component[0] >= 'A' && component[0] <= 'Z')
+                    || (component[0] >= 'a' && component[0] <= 'z'))
+                && component[1] == ':';
+            var hasInvalidCharacter = false;
+            if (!isDriveDesignator)
+            {
+                foreach (var character in component)
+                {
+                    if (character is '<' or '>' or ':' or '"' or '|' or '?' or '*')
+                    {
+                        hasInvalidCharacter = true;
+                        break;
+                    }
+                }
+            }
+            if (hasInvalidCharacter)
+                return false;
+
+            if (!component.SequenceEqual(".".AsSpan())
+                && !component.SequenceEqual("..".AsSpan())
+                && component[^1] is ' ' or '.')
+            {
+                return false;
+            }
+
+            componentIndex++;
+            start = end + 1;
+        }
+
+        return true;
+    }
+
+    private static bool IsExplicitFileWindowsSuperscriptDevicePath(string path)
+    {
+        var span = path.AsSpan();
+        for (var start = 0; start < span.Length;)
+        {
+            while (start < span.Length && span[start] is '/' or '\\')
+                start++;
+            if (start >= span.Length)
+                break;
+
+            var end = start;
+            while (end < span.Length && span[end] is not ('/' or '\\'))
+                end++;
+
+            var component = span[start..end];
+            var extensionIndex = component.IndexOf('.');
+            var name = extensionIndex >= 0 ? component[..extensionIndex] : component;
+            if (name.Length == 4
+                && (name.StartsWith("COM".AsSpan(), StringComparison.OrdinalIgnoreCase)
+                    || name.StartsWith("LPT".AsSpan(), StringComparison.OrdinalIgnoreCase))
+                && name[3] is '\u00b9' or '\u00b2' or '\u00b3')
+            {
+                return true;
+            }
+
+            start = end + 1;
+        }
+
+        return false;
     }
 
     private static int WriteExplicitFilesPreflightError(

src/CodeIndex/Mcp/McpToolHandlers.Indexing.Execution.cs

@@ -826,6 +826,7 @@ bool CanReuseCSharpPrepassTargetWithoutRead(CSharpStaticInterfacePrepass.FileTar
             CancellationToken = requestToken,
             MaxSymbolsPerFile = maxSymbolsPerFile,
             MaxReferencesPerFile = maxReferencesPerFile,
+            SymlinkPolicy = symlinkPolicy,
             Rebuild = rebuild,
             StartedWithNoIndexedFiles = startedWithNoIndexedFiles,
             UseFullRunBatchMarker = useFullRunBatchMarker,

src/CodeIndex/Mcp/McpToolHandlers.Indexing.ExtractedFilePersistence.cs

@@ -86,6 +86,10 @@ private static (List<SymbolRecord> Symbols, FileIssue? TimeoutIssue)
         using var regexTimeouts = BoundedRegex.CaptureTimeouts(
             record.Lang,
             "symbol_extraction");
+        using var typeScriptPathAliasFileSystemPolicy =
+            SymbolExtractor.EnterTypeScriptPathAliasFileSystemPolicy(
+                context.SymlinkPolicy,
+                context.ProjectPath);
         var symbols = SymbolExtractor.ExtractNormalized(
             fileId,
             record.Lang,

src/CodeIndex/Mcp/McpToolHandlers.Indexing.FileLoop.cs

@@ -24,6 +24,7 @@ private sealed class McpIndexFileLoopContext
         internal required CancellationToken CancellationToken { get; init; }
         internal required int MaxSymbolsPerFile { get; init; }
         internal required int MaxReferencesPerFile { get; init; }
+        internal required FileIndexer.SymlinkPolicy SymlinkPolicy { get; init; }
         internal required bool Rebuild { get; init; }
         internal required bool StartedWithNoIndexedFiles { get; init; }
         internal required bool UseFullRunBatchMarker { get; init; }