Tar: restore directory permissions while extracting.

src/libraries/System.Formats.Tar/src/System.Formats.Tar.csproj

@@ -38,6 +38,7 @@
  <!-- Windows specific files -->
  <ItemGroup Condition="'$(TargetPlatformIdentifier)' == 'windows'">
  <Compile Include="System\Formats\Tar\TarEntry.Windows.cs" />
+ <Compile Include="System\Formats\Tar\TarHelpers.Windows.cs" />
  <Compile Include="System\Formats\Tar\TarWriter.Windows.cs" />
  <Compile Include="$(CommonPath)Interop\Windows\Interop.Errors.cs" Link="Common\Interop\Windows\Interop.Errors.cs" />
  <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs" Link="Common\Interop\Windows\Interop.Libraries.cs" />
@@ -51,6 +52,7 @@
  <!-- Unix specific files -->
  <ItemGroup Condition="'$(TargetPlatformIdentifier)' == 'Unix'">
  <Compile Include="System\Formats\Tar\TarEntry.Unix.cs" />
+ <Compile Include="System\Formats\Tar\TarHelpers.Unix.cs" />
  <Compile Include="System\Formats\Tar\TarWriter.Unix.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\Interop.IOErrors.cs" Link="Common\Interop\Unix\Interop.IOErrors.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\Interop.Libraries.cs" Link="Common\Interop\Unix\Interop.Libraries.cs" />

src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarEntry.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Threading;
@@ -312,24 +313,24 @@ public Stream? DataStream
  internal abstract bool IsDataStreamSetterSupported();
 
  // Extracts the current entry to a location relative to the specified directory.
- internal void ExtractRelativeToDirectory(string destinationDirectoryPath, bool overwrite)
+ internal void ExtractRelativeToDirectory(string destinationDirectoryPath, bool overwrite, SortedDictionary<string, UnixFileMode>? pendingModes)
  {
  (string fileDestinationPath, string? linkTargetPath) = GetDestinationAndLinkPaths(destinationDirectoryPath);
 
  if (EntryType == TarEntryType.Directory)
  {
-Directory.CreateDirectory(fileDestinationPath);
+TarHelpers.CreateDirectory(fileDestinationPath, Mode, overwrite, pendingModes);
  }
  else
  {
  // If it is a file, create containing directory.
-Directory.CreateDirectory(Path.GetDirectoryName(fileDestinationPath)!);
+TarHelpers.CreateDirectory(Path.GetDirectoryName(fileDestinationPath)!, mode: null, overwrite, pendingModes);
  ExtractToFileInternal(fileDestinationPath, linkTargetPath, overwrite);
  }
  }
 
  // Asynchronously extracts the current entry to a location relative to the specified directory.
- internal Task ExtractRelativeToDirectoryAsync(string destinationDirectoryPath, bool overwrite, CancellationToken cancellationToken)
+ internal Task ExtractRelativeToDirectoryAsync(string destinationDirectoryPath, bool overwrite, SortedDictionary<string, UnixFileMode>? pendingModes, CancellationToken cancellationToken)
  {
  if (cancellationToken.IsCancellationRequested)
  {
@@ -340,13 +341,13 @@ internal Task ExtractRelativeToDirectoryAsync(string destinationDirectoryPath, b
 
  if (EntryType == TarEntryType.Directory)
  {
-Directory.CreateDirectory(fileDestinationPath);
+TarHelpers.CreateDirectory(fileDestinationPath, Mode, overwrite, pendingModes);
  return Task.CompletedTask;
  }
  else
  {
  // If it is a file, create containing directory.
-Directory.CreateDirectory(Path.GetDirectoryName(fileDestinationPath)!);
+TarHelpers.CreateDirectory(Path.GetDirectoryName(fileDestinationPath)!, mode: null, overwrite, pendingModes);
  return ExtractToFileInternalAsync(fileDestinationPath, linkTargetPath, overwrite, cancellationToken);
  }
  }
@@ -435,7 +436,19 @@ private void CreateNonRegularFile(string filePath, string? linkTargetPath)
  {
  case TarEntryType.Directory:
  case TarEntryType.DirectoryList:
- Directory.CreateDirectory(filePath);
+ // Mode must only be used for the leaf directory.
+ // VerifyPathsForEntryType ensures we're only creating a leaf.
+ Debug.Assert(Directory.Exists(Path.GetDirectoryName(filePath)));
+ Debug.Assert(!Directory.Exists(filePath));
+
+ if (!OperatingSystem.IsWindows())
+ {
+ Directory.CreateDirectory(filePath, Mode);
+ }
+ else
+ {
+ Directory.CreateDirectory(filePath);
+ }
  break;
 
  case TarEntryType.SymbolicLink:

src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarFile.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Buffers;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Threading;
@@ -279,23 +280,21 @@ private static void CreateFromDirectoryInternal(string sourceDirectoryName, Stre
 
  using (TarWriter writer = new TarWriter(destination, TarEntryFormat.Pax, leaveOpen))
  {
- bool baseDirectoryIsEmpty = true;
  DirectoryInfo di = new(sourceDirectoryName);
  string basePath = GetBasePathForCreateFromDirectory(di, includeBaseDirectory);
 
  char[] entryNameBuffer = ArrayPool<char>.Shared.Rent(DefaultCapacity);
 
  try
  {
-foreach (FileSystemInfo file in di.EnumerateFileSystemInfos("*", SearchOption.AllDirectories))
+if (includeBaseDirectory)
  {
- baseDirectoryIsEmpty = false;
- writer.WriteEntry(file.FullName, GetEntryNameForFileSystemInfo(file, basePath.Length, ref entryNameBuffer));
+ writer.WriteEntry(di.FullName, GetEntryNameForBaseDirectory(di.Name, ref entryNameBuffer));
  }
 
-if (includeBaseDirectory && baseDirectoryIsEmpty)
+foreach (FileSystemInfo file in di.EnumerateFileSystemInfos("*", SearchOption.AllDirectories))
  {
- writer.WriteEntry(GetEntryForBaseDirectory(di.Name, ref entryNameBuffer));
+ writer.WriteEntry(file.FullName, GetEntryNameForFileSystemInfo(file, basePath.Length, ref entryNameBuffer));
  }
  }
  finally
@@ -337,23 +336,21 @@ private static async Task CreateFromDirectoryInternalAsync(string sourceDirector
  TarWriter writer = new TarWriter(destination, TarEntryFormat.Pax, leaveOpen);
  await using (writer.ConfigureAwait(false))
  {
- bool baseDirectoryIsEmpty = true;
  DirectoryInfo di = new(sourceDirectoryName);
  string basePath = GetBasePathForCreateFromDirectory(di, includeBaseDirectory);
 
  char[] entryNameBuffer = ArrayPool<char>.Shared.Rent(DefaultCapacity);
 
  try
  {
-foreach (FileSystemInfo file in di.EnumerateFileSystemInfos("*", SearchOption.AllDirectories))
+if (includeBaseDirectory)
  {
- baseDirectoryIsEmpty = false;
- await writer.WriteEntryAsync(file.FullName, GetEntryNameForFileSystemInfo(file, basePath.Length, ref entryNameBuffer), cancellationToken).ConfigureAwait(false);
+ await writer.WriteEntryAsync(di.FullName, GetEntryNameForBaseDirectory(di.Name, ref entryNameBuffer), cancellationToken).ConfigureAwait(false);
  }
 
-if (includeBaseDirectory && baseDirectoryIsEmpty)
+foreach (FileSystemInfo file in di.EnumerateFileSystemInfos("*", SearchOption.AllDirectories))
  {
- await writer.WriteEntryAsync(GetEntryForBaseDirectory(di.Name, ref entryNameBuffer), cancellationToken).ConfigureAwait(false);
+ await writer.WriteEntryAsync(file.FullName, GetEntryNameForFileSystemInfo(file, basePath.Length, ref entryNameBuffer), cancellationToken).ConfigureAwait(false);
  }
  }
  finally
@@ -377,11 +374,9 @@ private static string GetEntryNameForFileSystemInfo(FileSystemInfo file, int bas
  return ArchivingUtils.EntryFromPath(file.FullName, basePathLength, entryNameLength, ref entryNameBuffer, appendPathSeparator: isDirectory);
  }
 
- // Constructs a PaxTarEntry for a base directory entry when creating an archive.
- private static PaxTarEntry GetEntryForBaseDirectory(string name, ref char[] entryNameBuffer)
+ private static string GetEntryNameForBaseDirectory(string name, ref char[] entryNameBuffer)
  {
- string entryName = ArchivingUtils.EntryFromPath(name, 0, name.Length, ref entryNameBuffer, appendPathSeparator: true);
- return new PaxTarEntry(TarEntryType.Directory, entryName);
+ return ArchivingUtils.EntryFromPath(name, 0, name.Length, ref entryNameBuffer, appendPathSeparator: true);
  }
 
  // Extracts an archive into the specified directory.
@@ -392,14 +387,16 @@ private static void ExtractToDirectoryInternal(Stream source, string destination
 
  using TarReader reader = new TarReader(source, leaveOpen);
 
+ SortedDictionary<string, UnixFileMode>? pendingModes = TarHelpers.CreatePendingModesDictionary();
  TarEntry? entry;
  while ((entry = reader.GetNextEntry()) != null)
  {
  if (entry.EntryType is not TarEntryType.GlobalExtendedAttributes)
  {
- entry.ExtractRelativeToDirectory(destinationDirectoryPath, overwriteFiles);
+ entry.ExtractRelativeToDirectory(destinationDirectoryPath, overwriteFiles, pendingModes);
  }
  }
+ TarHelpers.SetPendingModes(pendingModes);
  }
 
  // Asynchronously extracts the contents of a tar file into the specified directory.
@@ -430,6 +427,7 @@ private static async Task ExtractToDirectoryInternalAsync(Stream source, string
  VerifyExtractToDirectoryArguments(source, destinationDirectoryPath);
  cancellationToken.ThrowIfCancellationRequested();
 
+ SortedDictionary<string, UnixFileMode>? pendingModes = TarHelpers.CreatePendingModesDictionary();
  TarReader reader = new TarReader(source, leaveOpen);
  await using (reader.ConfigureAwait(false))
  {
@@ -438,10 +436,11 @@ private static async Task ExtractToDirectoryInternalAsync(Stream source, string
  {
  if (entry.EntryType is not TarEntryType.GlobalExtendedAttributes)
  {
- await entry.ExtractRelativeToDirectoryAsync(destinationDirectoryPath, overwriteFiles, cancellationToken).ConfigureAwait(false);
+ await entry.ExtractRelativeToDirectoryAsync(destinationDirectoryPath, overwriteFiles, pendingModes, cancellationToken).ConfigureAwait(false);
  }
  }
  }
+ TarHelpers.SetPendingModes(pendingModes);
  }
 
  [Conditional("DEBUG")]

src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarHelpers.Unix.cs

@@ -0,0 +1,149 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.IO;
+using System.Diagnostics;
+
+namespace System.Formats.Tar
+{
+ internal static partial class TarHelpers
+ {
+ private static readonly Lazy<UnixFileMode> s_umask = new Lazy<UnixFileMode>(DetermineUMask);
+
+ private static UnixFileMode DetermineUMask()
+ {
+ // To determine the umask, we'll create a file with full permissions and see
+ // what gets filtered out.
+ // note: only the owner of a file, and root can change file permissions.
+
+ const UnixFileMode OwnershipPermissions =
+ UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute |
+ UnixFileMode.GroupRead | UnixFileMode.GroupWrite | UnixFileMode.GroupExecute |
+ UnixFileMode.OtherRead | UnixFileMode.OtherWrite | UnixFileMode.OtherExecute;
+
+ string filename = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
+ FileStreamOptions options = new()
+ {
+ Mode = FileMode.CreateNew,
+ UnixCreateMode = OwnershipPermissions,
+ Options = FileOptions.DeleteOnClose,
+ Access = FileAccess.Write,
+ BufferSize = 0
+ };
+ using var fs = new FileStream(filename, options);
+ UnixFileMode actual = File.GetUnixFileMode(fs.SafeFileHandle);
+
+ return OwnershipPermissions & ~actual;
+ }
+
+ private sealed class ReverseStringComparer : IComparer<string>
+ {
+ public int Compare (string? x, string? y)
+ => StringComparer.Ordinal.Compare(y, x);
+ }
+
+ private static readonly ReverseStringComparer s_reverseStringComparer = new();
+
+ private static UnixFileMode UMask => s_umask.Value;
+
+ /*
+ Tar files are usually ordered: parent directories come before their child entries.
+
+ They may be unordered. In that case we need to create parent directories before
+ we know the proper permissions for these directories.
+
+ We create these directories with restrictive permissions. If we encounter an entry for
+ the directory later, we store the mode to apply it later.
+
+ If the archive doesn't have an entry for the parent directory, we use the default mask.
+
+ The pending modes to be applied are tracked through a reverse-sorted dictionary.
+ The reverse order is needed to apply permissions to children before their parent.
+ Otherwise we may apply a restrictive mask to the parent, that prevents us from
+ changing a child.
+ */
+
+ internal static SortedDictionary<string, UnixFileMode>? CreatePendingModesDictionary()
+ => new SortedDictionary<string, UnixFileMode>(s_reverseStringComparer);
+
+ internal static void CreateDirectory(string fullPath, UnixFileMode? mode, bool overwriteMetadata, SortedDictionary<string, UnixFileMode>? pendingModes)
+ {
+ // Restrictive mask for creating the missing parent directories while extracting.
+ const UnixFileMode ExtractPermissions = UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute;
+
+ Debug.Assert(pendingModes is not null);
+
+ if (Directory.Exists(fullPath))
+ {
+ // Apply permissions to an existing directory when we're overwriting metadata
+ // or the directory was created as a missing parent (stored in pendingModes).
+ if (mode.HasValue)
+ {
+ bool hasExtractPermissions = (mode.Value & ExtractPermissions) == ExtractPermissions;
+ if (hasExtractPermissions)
+ {
+ bool removed = pendingModes.Remove(fullPath);
+ if (overwriteMetadata || removed)
+ {
+ UnixFileMode umask = UMask;
+ File.SetUnixFileMode(fullPath, mode.Value & ~umask);
+ }
+ }
+ else if (overwriteMetadata || pendingModes.ContainsKey(fullPath))
+ {
+ pendingModes[fullPath] = mode.Value;
+ }
+ }
+ return;
+ }
+
+ if (mode.HasValue)
+ {
+ // Ensure we have sufficient permissions to extract in the directory.
+ if ((mode.Value & ExtractPermissions) != ExtractPermissions)
+ {
+ pendingModes[fullPath] = mode.Value;
+ mode = ExtractPermissions;
+ }
+ }
+ else
+ {
+ pendingModes.Add(fullPath, DefaultDirectoryMode);
+ mode = ExtractPermissions;
+ }
+
+ string parentDir = Path.GetDirectoryName(fullPath)!;
+ string rootDir = Path.GetPathRoot(parentDir)!;
+ bool hasMissingParents = false;
+ for (string dir = parentDir; dir != rootDir && !Directory.Exists(dir); dir = Path.GetDirectoryName(dir)!)
+ {
+ pendingModes.Add(dir, DefaultDirectoryMode);
+ hasMissingParents = true;
+ }
+
+ if (hasMissingParents)
+ {
+ Directory.CreateDirectory(parentDir, ExtractPermissions);
+ }
+
+ Directory.CreateDirectory(fullPath, mode.Value);
+ }
+
+ internal static void SetPendingModes(SortedDictionary<string, UnixFileMode>? pendingModes)
+ {
+ Debug.Assert(pendingModes is not null);
+
+ if (pendingModes.Count == 0)
+ {
+ return;
+ }
+
+ UnixFileMode umask = UMask;
+ foreach (KeyValuePair<string, UnixFileMode> dir in pendingModes)
+ {
+ File.SetUnixFileMode(dir.Key, dir.Value & ~umask);
+ }
+ }
+ }
+}

src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarHelpers.Windows.cs

@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Diagnostics;
+
+namespace System.Formats.Tar
+{
+ internal static partial class TarHelpers
+ {
+ internal static SortedDictionary<string, UnixFileMode>? CreatePendingModesDictionary()
+ => null;
+
+ internal static void CreateDirectory(string fullPath, UnixFileMode? mode, bool overwriteMetadata, SortedDictionary<string, UnixFileMode>? pendingModes)
+ => Directory.CreateDirectory(fullPath);
+
+ internal static void SetPendingModes(SortedDictionary<string, UnixFileMode>? pendingModes)
+ => Debug.Assert(pendingModes is null);
+ }
+}