make IsEncryptedOfficeFile public method and add override that takes a string

Author: mikeebowen

src/DocumentFormat.OpenXml.Framework/Features/StreamPackageFeature.cs

@@ -8,7 +8,6 @@
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.IO.Packaging;
-using System.Linq;
 
 namespace DocumentFormat.OpenXml.Features;
 
@@ -57,7 +56,7 @@ public StreamPackageFeature(Stream stream, PackageOpenMode openMode, bool isOwne
         }
         catch when (isOwned)
         {
-            if (_stream is not null && IsEncryptedOfficeFile(_stream))
+            if (_stream is not null && OpenXmlPackage.IsEncryptedOfficeFile(_stream))
             {
                 _stream.Dispose();
                 throw new OpenXmlPackageException(ExceptionMessages.EncryptedPackageNotSupported);
@@ -178,54 +177,4 @@ protected override void Register(IFeatureCollection features)
         features.Set<IPackageStreamFeature>(this);
         features.GetRequired<IDisposableFeature>().Register(this);
     }
-
-    private static bool IsEncryptedOfficeFile(Stream inputStream)
-    {
-        if (!inputStream.CanSeek)
-        {
-            throw new ArgumentException("Stream must be seekable.");
-        }
-
-        long originalPosition = inputStream.Position;
-
-        try
-        {
-            byte[] header = new byte[8];
-            inputStream.Seek(0, SeekOrigin.Begin);
-            int read = inputStream.Read(header, 0, header.Length);
-            inputStream.Seek(originalPosition, SeekOrigin.Begin);
-
-            // OLE Compound File signature for encrypted Office files
-            byte[] oleSignature = { 0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1 };
-            if (read == 8 && header.SequenceEqual(oleSignature))
-            {
-                return true;
-            }
-
-            // If not OLE, try to open as package and check for encrypted part
-            try
-            {
-                using (var package = System.IO.Packaging.Package.Open(inputStream, FileMode.Open, FileAccess.Read))
-                {
-                    foreach (var part in package.GetParts())
-                    {
-                        if (part.ContentType.Equals("application/vnd.openxmlformats-officedocument.encrypted-package", StringComparison.OrdinalIgnoreCase))
-                        {
-                            return true;
-                        }
-                    }
-                }
-            }
-            catch
-            {
-                return false;
-            }
-
-            return false;
-        }
-        finally
-        {
-            inputStream.Seek(originalPosition, SeekOrigin.Begin);
-        }
-    }
 }

src/DocumentFormat.OpenXml.Framework/Packaging/OpenXmlPackage.cs

@@ -612,5 +612,97 @@ public void Save()
 
         /// <inheritdoc/>
         public override IFeatureCollection Features => _features ??= new PackageFeatureCollection(this);
+
+        /// <summary>
+        /// Determines whether the provided stream represents an encrypted Office Open XML file.
+        /// </summary>
+        /// <param name="inputStream">The <see cref="Stream"/> to check. The stream must be seekable and not null.</param>
+        /// <returns>
+        /// <c>true</c> if the stream is an encrypted Office file (either OLE Compound File or contains an encrypted package part); otherwise, <c>false</c>.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">Thrown if <paramref name="inputStream"/> is null.</exception>
+        /// <exception cref="ArgumentException">Thrown if <paramref name="inputStream"/> is not seekable.</exception>
+        /// <remarks>
+        /// This method checks for the OLE Compound File signature at the start of the stream, which is used for encrypted Office files.
+        /// If not found, it attempts to open the stream as an OPC package and checks for the presence of an encrypted package part.
+        /// The stream position is restored after the check.
+        /// </remarks>
+        public static bool IsEncryptedOfficeFile(Stream inputStream)
+        {
+            if (inputStream is null)
+            {
+                throw new ArgumentNullException(nameof(inputStream));
+            }
+
+            if (!inputStream.CanSeek)
+            {
+                throw new ArgumentException("Stream must be seekable.");
+            }
+
+            long originalPosition = inputStream.Position;
+
+            try
+            {
+                byte[] header = new byte[8];
+                inputStream.Seek(0, SeekOrigin.Begin);
+                int read = inputStream.Read(header, 0, header.Length);
+                inputStream.Seek(originalPosition, SeekOrigin.Begin);
+
+                // OLE Compound File signature for encrypted Office files
+                if (read == 8 && header.SequenceEqual(new byte[] { 0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1 }))
+                {
+                    return true;
+                }
+
+                // If not OLE, try to open as package and check for encrypted part
+                try
+                {
+                    using (var package = System.IO.Packaging.Package.Open(inputStream, FileMode.Open, FileAccess.Read))
+                    {
+                        foreach (var part in package.GetParts())
+                        {
+                            if (part.ContentType.Equals("application/vnd.openxmlformats-officedocument.encrypted-package", StringComparison.OrdinalIgnoreCase))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                }
+                catch
+                {
+                    return false;
+                }
+
+                return false;
+            }
+            finally
+            {
+                inputStream.Seek(originalPosition, SeekOrigin.Begin);
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the file at the specified path is an encrypted Office Open XML file.
+        /// </summary>
+        /// <param name="filePath">The path to the file to check. Must not be null.</param>
+        /// <returns>
+        /// <c>true</c> if the file is an encrypted Office file (either OLE Compound File or contains an encrypted package part); otherwise, <c>false</c>.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">Thrown if <paramref name="filePath"/> is null.</exception>
+        /// <remarks>
+        /// This method opens the file at the specified path and checks its contents using <see cref="IsEncryptedOfficeFile(Stream)"/>.
+        /// </remarks>
+        public static bool IsEncryptedOfficeFile(string filePath)
+        {
+            if (filePath is null)
+            {
+                throw new ArgumentNullException(nameof(filePath));
+            }
+
+            using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
+            {
+                return IsEncryptedOfficeFile(fileStream);
+            }
+        }
     }
 }

src/DocumentFormat.OpenXml.Framework/PublicAPI/PublicAPI.Shipped.txt

@@ -1010,3 +1010,5 @@ DocumentFormat.OpenXml.OpenXmlPartWriterSettings.OpenXmlPartWriterSettings() ->
 DocumentFormat.OpenXml.OpenXmlPartWriter.OpenXmlPartWriter(DocumentFormat.OpenXml.Packaging.OpenXmlPart! openXmlPart, DocumentFormat.OpenXml.OpenXmlPartWriterSettings! settings) -> void
 DocumentFormat.OpenXml.OpenXmlPartWriter.OpenXmlPartWriter(System.IO.Stream! partStream, DocumentFormat.OpenXml.OpenXmlPartWriterSettings! settings) -> void
 virtual DocumentFormat.OpenXml.OpenXmlCompositeElement.IsValidChild(DocumentFormat.OpenXml.OpenXmlElement! element) -> bool
+static DocumentFormat.OpenXml.Packaging.OpenXmlPackage.IsEncryptedOfficeFile(System.IO.Stream! inputStream) -> bool
+static DocumentFormat.OpenXml.Packaging.OpenXmlPackage.IsEncryptedOfficeFile(string! filePath) -> bool

test/DocumentFormat.OpenXml.Framework.Tests/Features/StreamPackageFeatureTests.cs

@@ -10,6 +10,7 @@
 using System.IO.Packaging;
 using System.Linq;
 using Xunit;
+
 using static DocumentFormat.OpenXml.Tests.TestAssets;
 
 namespace DocumentFormat.OpenXml.Features.Tests;
@@ -441,7 +442,6 @@ public void ThrowsForEncryptedOfficeFile()
             var ex = Assert.Throws<OpenXmlPackageException>(() => new StreamPackageFeature(stream, PackageOpenMode.Read, isOwned: true));
             Assert.Equal(ExceptionMessages.EncryptedPackageNotSupported, ex.Message);
         }
-
     }
 
     private static readonly PartInfo Part1 = new(new("/part1", UriKind.Relative), "type1/content");