fix(permissions): treat Windows \\?\ verbatim paths as equivalent (#35096)

On Windows, requesting a path through its `\\?\` verbatim
(extended-length) form — e.g. `\\?\C:\foo` — was permission-checked as a
*distinct* path from the regular `C:\foo`. As a result, a directory
already granted read/write access would unexpectedly trigger a new
permission prompt:

```
> deno repl --allow-read=.
> Array.from(Deno.readDirSync(Deno.cwd()))            // no prompt
[]
> Array.from(Deno.readDirSync('\\\\?\\' + Deno.cwd())) // unexpected prompt
✅ Granted read access to "\\?\C:\Users\Student\Empty".
[]
```

This also breaks node polyfills that hand `\\?\`-prefixed paths to fs
ops (e.g. `_fs_chmod.ts`, see wojpawlik/deno2node#39).

### Cause

The path descriptors in `deno_permissions` build their comparison key
with `deno_path_util::normalize_path`, which walks `path.components()`.
Rust parses `\\?\C:\foo` as a `Component::Prefix(VerbatimDisk)`, and
`normalize_path` preserves that verbatim prefix, so `\\?\C:\foo` and
`C:\foo` never compare equal. The existing `is_windows_device_path`
branch only handled `\\.\` device-namespace paths.

### Fix

Strip the verbatim prefix via `dunce::simplified` before normalization,
at the three path-descriptor construction sites
(`PathQueryDescriptor::new`, `PathQueryDescriptor::new_known_absolute`,
`PathDescriptor::new_known_cwd`).

`dunce::simplified` only strips the prefix when the regular form is
genuinely equivalent — it refuses paths containing `.`/`..` components
(taken literally in verbatim mode), reserved DOS device names (`CON`,
`NUL`, `COM1`, …), or paths that exceed the legacy length limit. Those
forms are *not* the same file as their stripped counterpart, so this
conservative behavior avoids over-granting. On non-Windows platforms the
helper is a no-op, so behavior there is unchanged.

A `#[cfg(windows)]` unit test (`check_path_verbatim_prefix`) covers both
directions (grant regular → request verbatim, and grant verbatim →
request regular) plus a negative case.

Closes #18597

Closes denoland/divybot#553

---------

Co-authored-by: divybot <divybot@users.noreply.github.com>
Co-authored-by: Divy Srivastava <me@littledivy.com>

Author: divybot

Cargo.lock

@@ -352,6 +352,7 @@ dprint-plugin-json = "=0.21.3"
 dprint-plugin-jupyter = "=0.2.2"
 dprint-plugin-markdown = "=0.20.0"
 dprint-plugin-typescript = "=0.96.1"
+dunce = "1.0.5"
 env_logger = { version = "=0.11.6", default-features = false, features = ["regex"] }
 imara-diff = "=0.2.0"
 libsui = "0.12.6"

Cargo.toml

@@ -37,6 +37,7 @@ which.workspace = true
 unicode-normalization = { workspace = true }
 
 [target.'cfg(windows)'.dependencies]
+dunce.workspace = true
 windows-sys = { workspace = true, features = ["Win32_Foundation", "Win32_Storage_FileSystem", "Win32_System_Console", "Win32_UI_Input_KeyboardAndMouse"] }
 
 [target.'cfg(unix)'.dependencies]

runtime/permissions/Cargo.toml

@@ -1345,6 +1345,34 @@ fn comparison_path(path: &Path) -> PathBuf {
   path.to_path_buf()
 }
 
+/// On Windows, strips a `\\?\` verbatim (extended-length) prefix from a path
+/// when it can be losslessly represented without it, so that the permission
+/// system treats `\\?\C:\foo` and `C:\foo` as the same path. The two forms
+/// refer to the same file, so a grant for one must apply to the other (see
+/// denoland/deno#18597).
+///
+/// `dunce::simplified` only strips the prefix when it is actually safe to do
+/// so: it leaves verbatim paths that contain `.`/`..` components (taken
+/// literally in verbatim mode), reserved device names (e.g. `CON`), or that
+/// are too long to be expressed as a regular path, because those forms are
+/// *not* equivalent to their stripped counterparts.
+#[cfg(windows)]
+#[inline]
+fn strip_verbatim_prefix(path: Cow<'_, Path>) -> Cow<'_, Path> {
+  let simplified = dunce::simplified(path.as_ref());
+  if simplified.as_os_str().len() == path.as_os_str().len() {
+    path
+  } else {
+    Cow::Owned(simplified.to_path_buf())
+  }
+}
+
+#[cfg(not(windows))]
+#[inline]
+fn strip_verbatim_prefix(path: Cow<'_, Path>) -> Cow<'_, Path> {
+  path
+}
+
 impl<'a> PathQueryDescriptor<'a> {
   pub fn new(
     sys: &impl sys_traits::EnvCurrentDir,
@@ -1354,6 +1382,8 @@ impl<'a> PathQueryDescriptor<'a> {
     if path_bytes.is_empty() {
       return Err(PathResolveError::EmptyPath);
     }
+    let path = strip_verbatim_prefix(path);
+    let path_bytes = path.as_os_str().as_encoded_bytes();
     let is_windows_device_path = cfg!(windows)
       && path_bytes.starts_with(br"\\.\")
       && !path_bytes.contains(&b':');
@@ -1382,6 +1412,7 @@ impl<'a> PathQueryDescriptor<'a> {
   }
 
   pub fn new_known_absolute(path: Cow<'a, Path>) -> Self {
+    let path = strip_verbatim_prefix(path);
     let path_bytes = path.as_os_str().as_encoded_bytes();
     let is_windows_device_path = cfg!(windows)
       && path_bytes.starts_with(br"\\.\")
@@ -1546,6 +1577,7 @@ impl PathDescriptor {
   }
 
   pub fn new_known_cwd(path: Cow<'_, Path>, cwd: &Path) -> Self {
+    let path = strip_verbatim_prefix(path);
     let path_bytes = path.as_os_str().as_encoded_bytes();
     let is_windows_device_path = cfg!(windows)
       && path_bytes.starts_with(br"\\.\")
@@ -9822,6 +9854,40 @@ mod tests {
     );
   }
 
+  #[test]
+  #[cfg(windows)]
+  fn path_descriptor_verbatim_prefix_equivalent() {
+    // A `\\?\` verbatim (extended-length) path and its regular form refer to
+    // the same file, so the permission system must treat them as equal
+    // (denoland/deno#18597).
+    let regular = PathDescriptor::new_known_absolute(Cow::Borrowed(Path::new(
+      "C:\\Users\\Admin",
+    )));
+    let verbatim = PathDescriptor::new_known_absolute(Cow::Borrowed(
+      Path::new("\\\\?\\C:\\Users\\Admin"),
+    ));
+    assert_eq!(regular, verbatim);
+    // The stored path is the simplified form, not the verbatim one.
+    assert_eq!(verbatim.path, PathBuf::from("C:\\Users\\Admin"));
+
+    // A `\\?\` query is contained by a grant made with the regular path...
+    let query = PathQueryDescriptor::new_known_absolute(Cow::Borrowed(
+      Path::new("\\\\?\\C:\\Users\\Admin\\file.txt"),
+    ));
+    assert!(query.starts_with(&regular));
+    // ...and a regular query is contained by a grant made with a `\\?\` path.
+    let query = PathQueryDescriptor::new_known_absolute(Cow::Borrowed(
+      Path::new("C:\\Users\\Admin\\file.txt"),
+    ));
+    assert!(query.starts_with(&verbatim));
+
+    // An unrelated verbatim path is not contained.
+    let query = PathQueryDescriptor::new_known_absolute(Cow::Borrowed(
+      Path::new("\\\\?\\C:\\Other\\file.txt"),
+    ));
+    assert!(!query.starts_with(&regular));
+  }
+
   #[test]
   fn test_is_allow_all_edge_cases() {
     let parser = TestPermissionDescriptorParser;