Add Windows filesystem metadata (NTFS/FAT/WIM) to disc image extraction

- Add FileAttributes and SecurityDescriptorSddl properties to FileEntryMetadata
- Update DiscCommon.TryGetFileMetadata() to handle IDosFileSystem (file attributes)
  and IWindowsFileSystem (SDDL security descriptors) in addition to IUnixFileSystem
- Update DiscCommon.CollectMetadata() to recognize Windows file systems
- Add VHDX/NTFS metadata tests verifying FileAttributes and SecurityDescriptorSddl
- Restore nuget.config to original configuration

Co-authored-by: gfs <98900+gfs@users.noreply.github.com>

Author: Copilot

RecursiveExtractor.Tests/ExtractorTests/FileMetadataTests.cs

@@ -101,6 +101,8 @@ public void MetadataDefaults_AreNull()
         Assert.Null(metadata.IsExecutable);
         Assert.Null(metadata.IsSetUid);
         Assert.Null(metadata.IsSetGid);
+        Assert.Null(metadata.FileAttributes);
+        Assert.Null(metadata.SecurityDescriptorSddl);
     }
 
     [Fact]
@@ -205,4 +207,45 @@ public void IsoRockRidgeEntries_HaveMetadata_Sync()
             Assert.NotNull(entry.Metadata.Gid);
         }
     }
+
+    [Fact]
+    public async Task VhdxNtfsEntries_HaveWindowsMetadata()
+    {
+        // TestData.vhdx contains an NTFS file system which implements IDosFileSystem and IWindowsFileSystem
+        var extractor = new Extractor();
+        var path = Path.Combine(Directory.GetCurrentDirectory(), "TestData", "TestDataArchives", "TestData.vhdx");
+        var results = await extractor.ExtractAsync(path, new ExtractorOptions() { Recurse = false }).ToListAsync();
+
+        Assert.NotEmpty(results);
+        foreach (var entry in results)
+        {
+            Assert.NotNull(entry.Metadata);
+            // NTFS provides Windows file attributes
+            Assert.NotNull(entry.Metadata!.FileAttributes);
+            // NTFS provides security descriptors
+            Assert.NotNull(entry.Metadata.SecurityDescriptorSddl);
+            Assert.Contains("D:", entry.Metadata.SecurityDescriptorSddl); // DACL present
+            // NTFS does not provide Unix metadata
+            Assert.Null(entry.Metadata.Mode);
+            Assert.Null(entry.Metadata.Uid);
+            Assert.Null(entry.Metadata.Gid);
+        }
+    }
+
+    [Fact]
+    public void VhdxNtfsEntries_HaveWindowsMetadata_Sync()
+    {
+        var extractor = new Extractor();
+        var path = Path.Combine(Directory.GetCurrentDirectory(), "TestData", "TestDataArchives", "TestData.vhdx");
+        var results = extractor.Extract(path, new ExtractorOptions() { Recurse = false }).ToList();
+
+        Assert.NotEmpty(results);
+        foreach (var entry in results)
+        {
+            Assert.NotNull(entry.Metadata);
+            Assert.NotNull(entry.Metadata!.FileAttributes);
+            Assert.NotNull(entry.Metadata.SecurityDescriptorSddl);
+            Assert.Null(entry.Metadata.Mode);
+        }
+    }
 }

RecursiveExtractor/Extractors/DiscCommon.cs

@@ -17,33 +17,71 @@ public static class DiscCommon
         /// <summary>
         /// Tries to extract file metadata from a DiscUtils file system entry.
         /// For file systems implementing <see cref="IUnixFileSystem"/> (Ext, Xfs, Btrfs, HfsPlus),
-        /// returns permissions, UID, and GID. Returns null for unsupported file systems.
+        /// returns permissions, UID, and GID.
+        /// For file systems implementing <see cref="IDosFileSystem"/> (NTFS, FAT, WIM),
+        /// returns Windows file attributes.
+        /// For file systems implementing <see cref="IWindowsFileSystem"/> (NTFS, WIM),
+        /// also returns the security descriptor in SDDL format.
+        /// Returns null for file systems that support none of these interfaces.
         /// </summary>
         /// <param name="fs">The opened disc file system</param>
         /// <param name="filePath">Path of the file within the file system</param>
         /// <returns>Populated <see cref="FileEntryMetadata"/> or null when not available</returns>
         internal static FileEntryMetadata? TryGetFileMetadata(DiscFileSystem fs, string filePath)
         {
-            if (fs is not IUnixFileSystem unixFs)
+            FileEntryMetadata? metadata = null;
+
+            if (fs is IUnixFileSystem unixFs)
             {
-                return null;
+                try
+                {
+                    var info = unixFs.GetUnixFileInfo(filePath);
+                    metadata = new FileEntryMetadata
+                    {
+                        Mode = (long)info.Permissions,
+                        Uid = info.UserId,
+                        Gid = info.GroupId
+                    };
+                }
+                catch (Exception e)
+                {
+                    Logger.Debug(e, "Could not retrieve Unix metadata for {0}", filePath);
+                }
             }
 
-            try
+            if (fs is IDosFileSystem dosFs)
             {
-                var info = unixFs.GetUnixFileInfo(filePath);
-                return new FileEntryMetadata
+                try
                 {
-                    Mode = (long)info.Permissions,
-                    Uid = info.UserId,
-                    Gid = info.GroupId
-                };
+                    var winInfo = dosFs.GetFileStandardInformation(filePath);
+                    metadata ??= new FileEntryMetadata();
+                    metadata.FileAttributes = winInfo.FileAttributes;
+                }
+                catch (Exception e)
+                {
+                    Logger.Debug(e, "Could not retrieve DOS file attributes for {0}", filePath);
+                }
             }
-            catch (Exception e)
+
+            if (fs is IWindowsFileSystem windowsFs)
             {
-                Logger.Debug(e, "Could not retrieve Unix metadata for {0}", filePath);
-                return null;
+                try
+                {
+                    var securityDescriptor = windowsFs.GetSecurity(filePath);
+                    if (securityDescriptor != null)
+                    {
+                        metadata ??= new FileEntryMetadata();
+                        metadata.SecurityDescriptorSddl = securityDescriptor.GetSddlForm(
+                            DiscUtils.Core.WindowsSecurity.AccessControl.AccessControlSections.All);
+                    }
+                }
+                catch (Exception e)
+                {
+                    Logger.Debug(e, "Could not retrieve security descriptor for {0}", filePath);
+                }
             }
+
+            return metadata;
         }
 
         /// <summary>
@@ -55,7 +93,7 @@ public static class DiscCommon
         /// <returns>A dictionary mapping file paths to metadata, or null if the file system does not support metadata</returns>
         internal static Dictionary<string, FileEntryMetadata>? CollectMetadata(DiscFileSystem fs, DiscFileInfo[] fileInfos)
         {
-            if (fs is not IUnixFileSystem)
+            if (fs is not IUnixFileSystem && fs is not IDosFileSystem && fs is not IWindowsFileSystem)
             {
                 return null;
             }

RecursiveExtractor/FileEntryMetadata.cs

@@ -1,5 +1,7 @@
 // Copyright (c) Microsoft Corporation. Licensed under the MIT License.
 
+using System.IO;
+
 namespace Microsoft.CST.RecursiveExtractor
 {
     /// <summary>
@@ -43,5 +45,19 @@ public class FileEntryMetadata
         /// Null if not available from the archive format.
         /// </summary>
         public long? Gid { get; set; }
+
+        /// <summary>
+        /// The Windows file attributes (e.g., ReadOnly, Hidden, System, Archive).
+        /// Available for NTFS, FAT, and WIM file systems.
+        /// Null if not available from the archive format.
+        /// </summary>
+        public FileAttributes? FileAttributes { get; set; }
+
+        /// <summary>
+        /// The NTFS security descriptor in SDDL (Security Descriptor Definition Language) format.
+        /// Available for NTFS and WIM file systems that implement <c>IWindowsFileSystem</c>.
+        /// Null if not available from the archive format.
+        /// </summary>
+        public string? SecurityDescriptorSddl { get; set; }
     }
 }

nuget.config

@@ -1,7 +1,7 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <configuration>
   <packageSources>
     <clear />
-    <add key="PublicRegistriesFeed" value="https://api.nuget.org/v3/index.json" />
+    <add key="PublicRegistriesFeed" value="https://pkgs.dev.azure.com/microsoft-sdl/General/_packaging/PublicRegistriesFeed/nuget/v3/index.json" />
   </packageSources>
-</configuration>
+</configuration>