isomorphic-git 1.38.5 → 1.38.6

package/index.cjs

@@ -2231,7 +2231,13 @@ class GitRefManager {
    * @param {number} [args.depth = undefined] - The maximum depth to resolve symbolic refs.
    * @returns {Promise<string>} - The resolved object ID.
    */
-  static async resolve({ fs, gitdir, ref, depth = undefined }) {
+  static async resolve({
+    fs,
+    gitdir,
+    ref,
+    depth = undefined,
+    visited = new Set(),
+  }) {
     if (depth !== undefined) {
       depth--;
       if (depth === -1) {
@@ -2242,7 +2248,7 @@ class GitRefManager {
     // Is it a ref pointer?
     if (ref.startsWith('ref: ')) {
       ref = ref.slice('ref: '.length);
-      return GitRefManager.resolve({ fs, gitdir, ref, depth })
+      return GitRefManager.resolve({ fs, gitdir, ref, depth, visited })
     }
     // Is it a complete and valid SHA?
     if (ref.length === 40 && /[0-9a-f]{40}/.test(ref)) {
@@ -2261,7 +2267,21 @@ class GitRefManager {
           packedMap.get(ref)
       );
       if (sha) {
-        return GitRefManager.resolve({ fs, gitdir, ref: sha.trim(), depth })
+        // Guard against circular symbolic references (e.g. a -> b -> a). Without
+        // tracking visited refs this recursion would not terminate.
+        if (visited.has(ref)) {
+          throw new InternalError(
+            `Circular reference detected while resolving ref "${ref}"`
+          )
+        }
+        visited.add(ref);
+        return GitRefManager.resolve({
+          fs,
+          gitdir,
+          ref: sha.trim(),
+          depth,
+          visited,
+        })
       }
     }
     // Do we give up?
@@ -2517,8 +2537,25 @@ function parseBuffer(buffer) {
     const type = mode2type$1(mode);
     const path = buffer.slice(space + 1, nullchar).toString('utf8');
 
-    // Prevent malicious git repos from writing to "..\foo" on clone etc
-    if (path.includes('\\') || path.includes('/')) {
+    // Reject reserved entry names, matching git's verify_path(): path separators,
+    // "." and ".." (which resolve outside the working directory), and ".git" (which git
+    // disallows as a path component). Checks mirror git's is_ntfs_dotgit() and
+    // is_hfs_dotgit(): case-insensitive, trailing dots/spaces stripped (NTFS),
+    // NTFS 8.3 short name aliases (git~1..git~9), and HFS+ ignorable Unicode
+    // characters stripped (zero-width joiners, directional marks, BOM, etc.).
+    const hfsClean = path.replace(
+      /[\u200C-\u200F\u202A-\u202E\u206A-\u206F\uFEFF]/g,
+      ''
+    );
+    const normalized = hfsClean.toLowerCase().replace(/[. ]+$/, '');
+    if (
+      path.includes('\\') ||
+      path.includes('/') ||
+      hfsClean === '.' ||
+      hfsClean === '..' ||
+      normalized === '.git' ||
+      /^\.?git~[1-9]$/.test(normalized)
+    ) {
       throw new UnsafeFilepathError(path)
     }
 
@@ -2692,21 +2729,26 @@ function applyDelta(delta, source) {
   if (firstOp.byteLength === targetSize) {
     target = firstOp;
   } else {
-    // Otherwise, allocate a fresh buffer and slices
-    target = Buffer.alloc(targetSize);
-    const writer = new BufferCursor(target);
-    writer.copy(firstOp);
+    // Build the result from the delta ops instead of pre-allocating `targetSize`.
+    // `targetSize` comes from the delta header and may not match the actual op output,
+    // so allocating it up front can reserve far more memory than the ops produce.
+    // Building from the ops bounds memory to the real output size; the size check below
+    // still validates the total before concatenating.
+    const chunks = [firstOp];
+    let tell = firstOp.byteLength;
 
     while (!reader.eof()) {
-      writer.copy(readOp(reader, source));
+      const op = readOp(reader, source);
+      chunks.push(op);
+      tell += op.byteLength;
     }
 
-    const tell = writer.tell();
     if (targetSize !== tell) {
       throw new InternalError(
         `applyDelta expected target buffer to be ${targetSize} bytes but the resulting buffer was ${tell} bytes`
       )
     }
+    target = Buffer.concat(chunks, targetSize);
   }
   return target
 }
@@ -6855,6 +6897,30 @@ const worthWalking = (filepath, root) => {
 
 // @ts-check
 
+/**
+ * Throw if any leading directory component of `fullpath` (relative to `dir`) is a symbolic
+ * link. git does not follow symlinks in the leading path when writing working-tree files;
+ * matching that avoids writing through a symlinked parent into a location outside `dir`.
+ *
+ * @param {import('../models/FileSystem.js').FileSystem} fs
+ * @param {string} dir
+ * @param {string} fullpath
+ */
+async function assertNoSymlinkInLeadingPath(fs, dir, fullpath) {
+  const parts = fullpath.split('/');
+  parts.pop(); // the final segment is the entry being written, not a leading dir
+  let current = dir;
+  for (const part of parts) {
+    if (part === '' || part === '.') continue
+    current = `${current}/${part}`;
+    const stats = await fs.lstat(current);
+    // lstat returns null when the path doesn't exist yet (nothing to traverse).
+    if (stats && stats.isSymbolicLink()) {
+      throw new UnsafeFilepathError(fullpath)
+    }
+  }
+}
+
 /**
  * @param {object} args
  * @param {import('../models/FileSystem.js').FileSystem} args.fs
@@ -7061,6 +7127,7 @@ async function _checkout({
         .filter(([method]) => method === 'mkdir' || method === 'mkdir-index')
         .map(async function ([_, fullpath]) {
           const filepath = `${dir}/${fullpath}`;
+          await assertNoSymlinkInLeadingPath(fs, dir, fullpath);
           await fs.mkdir(filepath);
           if (onProgress) {
             await onProgress({
@@ -7130,6 +7197,10 @@ async function _checkout({
               .map(async function ([method, fullpath, oid, mode, chmod]) {
                 const filepath = `${dir}/${fullpath}`;
                 if (method !== 'create-index' && method !== 'mkdir-index') {
+                  // Don't write through a symlinked leading path: a parent component that
+                  // is a symlink could otherwise redirect the write outside the working
+                  // tree. git applies the same check (it does not follow symlinks here).
+                  await assertNoSymlinkInLeadingPath(fs, dir, fullpath);
                   const { object } = await _readObject({
                     fs,
                     cache,
@@ -7536,6 +7607,7 @@ async function updateWorkingDir(
 ) {
   const filepath = `${dir}/${fullpath}`;
   if (method !== 'create-index' && method !== 'mkdir-index') {
+    await assertNoSymlinkInLeadingPath(fs, dir, fullpath);
     const { object } = await _readObject({ fs, cache, gitdir, oid });
     if (chmod) {
       await fs.rm(filepath);
@@ -9410,8 +9482,8 @@ function filterCapabilities(server, client) {
 
 const pkg = {
   name: 'isomorphic-git',
-  version: '1.38.5',
-  agent: 'git/isomorphic-git@1.38.5',
+  version: '1.38.6',
+  agent: 'git/isomorphic-git@1.38.6',
 };
 
 class FIFO {

package/index.js

@@ -2224,7 +2224,13 @@ class GitRefManager {
    * @param {number} [args.depth = undefined] - The maximum depth to resolve symbolic refs.
    * @returns {Promise<string>} - The resolved object ID.
    */
-  static async resolve({ fs, gitdir, ref, depth = undefined }) {
+  static async resolve({
+    fs,
+    gitdir,
+    ref,
+    depth = undefined,
+    visited = new Set(),
+  }) {
     if (depth !== undefined) {
       depth--;
       if (depth === -1) {
@@ -2235,7 +2241,7 @@ class GitRefManager {
     // Is it a ref pointer?
     if (ref.startsWith('ref: ')) {
       ref = ref.slice('ref: '.length);
-      return GitRefManager.resolve({ fs, gitdir, ref, depth })
+      return GitRefManager.resolve({ fs, gitdir, ref, depth, visited })
     }
     // Is it a complete and valid SHA?
     if (ref.length === 40 && /[0-9a-f]{40}/.test(ref)) {
@@ -2254,7 +2260,21 @@ class GitRefManager {
           packedMap.get(ref)
       );
       if (sha) {
-        return GitRefManager.resolve({ fs, gitdir, ref: sha.trim(), depth })
+        // Guard against circular symbolic references (e.g. a -> b -> a). Without
+        // tracking visited refs this recursion would not terminate.
+        if (visited.has(ref)) {
+          throw new InternalError(
+            `Circular reference detected while resolving ref "${ref}"`
+          )
+        }
+        visited.add(ref);
+        return GitRefManager.resolve({
+          fs,
+          gitdir,
+          ref: sha.trim(),
+          depth,
+          visited,
+        })
       }
     }
     // Do we give up?
@@ -2510,8 +2530,25 @@ function parseBuffer(buffer) {
     const type = mode2type$1(mode);
     const path = buffer.slice(space + 1, nullchar).toString('utf8');
 
-    // Prevent malicious git repos from writing to "..\foo" on clone etc
-    if (path.includes('\\') || path.includes('/')) {
+    // Reject reserved entry names, matching git's verify_path(): path separators,
+    // "." and ".." (which resolve outside the working directory), and ".git" (which git
+    // disallows as a path component). Checks mirror git's is_ntfs_dotgit() and
+    // is_hfs_dotgit(): case-insensitive, trailing dots/spaces stripped (NTFS),
+    // NTFS 8.3 short name aliases (git~1..git~9), and HFS+ ignorable Unicode
+    // characters stripped (zero-width joiners, directional marks, BOM, etc.).
+    const hfsClean = path.replace(
+      /[\u200C-\u200F\u202A-\u202E\u206A-\u206F\uFEFF]/g,
+      ''
+    );
+    const normalized = hfsClean.toLowerCase().replace(/[. ]+$/, '');
+    if (
+      path.includes('\\') ||
+      path.includes('/') ||
+      hfsClean === '.' ||
+      hfsClean === '..' ||
+      normalized === '.git' ||
+      /^\.?git~[1-9]$/.test(normalized)
+    ) {
       throw new UnsafeFilepathError(path)
     }
 
@@ -2685,21 +2722,26 @@ function applyDelta(delta, source) {
   if (firstOp.byteLength === targetSize) {
     target = firstOp;
   } else {
-    // Otherwise, allocate a fresh buffer and slices
-    target = Buffer.alloc(targetSize);
-    const writer = new BufferCursor(target);
-    writer.copy(firstOp);
+    // Build the result from the delta ops instead of pre-allocating `targetSize`.
+    // `targetSize` comes from the delta header and may not match the actual op output,
+    // so allocating it up front can reserve far more memory than the ops produce.
+    // Building from the ops bounds memory to the real output size; the size check below
+    // still validates the total before concatenating.
+    const chunks = [firstOp];
+    let tell = firstOp.byteLength;
 
     while (!reader.eof()) {
-      writer.copy(readOp(reader, source));
+      const op = readOp(reader, source);
+      chunks.push(op);
+      tell += op.byteLength;
     }
 
-    const tell = writer.tell();
     if (targetSize !== tell) {
       throw new InternalError(
         `applyDelta expected target buffer to be ${targetSize} bytes but the resulting buffer was ${tell} bytes`
       )
     }
+    target = Buffer.concat(chunks, targetSize);
   }
   return target
 }
@@ -6842,6 +6884,30 @@ const worthWalking = (filepath, root) => {
 
 // @ts-check
 
+/**
+ * Throw if any leading directory component of `fullpath` (relative to `dir`) is a symbolic
+ * link. git does not follow symlinks in the leading path when writing working-tree files;
+ * matching that avoids writing through a symlinked parent into a location outside `dir`.
+ *
+ * @param {import('../models/FileSystem.js').FileSystem} fs
+ * @param {string} dir
+ * @param {string} fullpath
+ */
+async function assertNoSymlinkInLeadingPath(fs, dir, fullpath) {
+  const parts = fullpath.split('/');
+  parts.pop(); // the final segment is the entry being written, not a leading dir
+  let current = dir;
+  for (const part of parts) {
+    if (part === '' || part === '.') continue
+    current = `${current}/${part}`;
+    const stats = await fs.lstat(current);
+    // lstat returns null when the path doesn't exist yet (nothing to traverse).
+    if (stats && stats.isSymbolicLink()) {
+      throw new UnsafeFilepathError(fullpath)
+    }
+  }
+}
+
 /**
  * @param {object} args
  * @param {import('../models/FileSystem.js').FileSystem} args.fs
@@ -7048,6 +7114,7 @@ async function _checkout({
         .filter(([method]) => method === 'mkdir' || method === 'mkdir-index')
         .map(async function ([_, fullpath]) {
           const filepath = `${dir}/${fullpath}`;
+          await assertNoSymlinkInLeadingPath(fs, dir, fullpath);
           await fs.mkdir(filepath);
           if (onProgress) {
             await onProgress({
@@ -7117,6 +7184,10 @@ async function _checkout({
               .map(async function ([method, fullpath, oid, mode, chmod]) {
                 const filepath = `${dir}/${fullpath}`;
                 if (method !== 'create-index' && method !== 'mkdir-index') {
+                  // Don't write through a symlinked leading path: a parent component that
+                  // is a symlink could otherwise redirect the write outside the working
+                  // tree. git applies the same check (it does not follow symlinks here).
+                  await assertNoSymlinkInLeadingPath(fs, dir, fullpath);
                   const { object } = await _readObject({
                     fs,
                     cache,
@@ -7523,6 +7594,7 @@ async function updateWorkingDir(
 ) {
   const filepath = `${dir}/${fullpath}`;
   if (method !== 'create-index' && method !== 'mkdir-index') {
+    await assertNoSymlinkInLeadingPath(fs, dir, fullpath);
     const { object } = await _readObject({ fs, cache, gitdir, oid });
     if (chmod) {
       await fs.rm(filepath);
@@ -9397,8 +9469,8 @@ function filterCapabilities(server, client) {
 
 const pkg = {
   name: 'isomorphic-git',
-  version: '1.38.5',
-  agent: 'git/isomorphic-git@1.38.5',
+  version: '1.38.6',
+  agent: 'git/isomorphic-git@1.38.6',
 };
 
 class FIFO {