Merge pull request #7 from icarus-consulting/i6-ZipPassword

I6 zip password

Author: Meerow

README.md

@@ -5,6 +5,8 @@ Object oriented tools for handling ZIP archives. Based on [Yaapii.Atoms](https:/
 
 It follows all the rules suggested in the two "[Elegant Objects](https://www.amazon.de/Elegant-Objects-Yegor-Bugayenko/dp/1519166915)" books.
 
+For password protected ZIPs it uses "[DotNetZip](https://github.com/DinoChiesa/DotNetZip)".
+
 ## Usage
 
 There are different Decorator classes which accept a input. A input might come from a file or a memorystream or any other stream. You can use Atoms ```InputOf``` to get an input which you can use with this library.
@@ -85,4 +87,36 @@ var isZip =
     new IsZipArchive(
         new InputOf(File.OpenRead("c:/some-zip-archive.zip"))
     ).Value();
+```
+
+Test if a file in a zip is protected with a password:
+
+```csharp
+var hasPassword =
+    new HasPassword(
+        new InputOf(File.OpenRead("c:/some-zip-archive.zip")),
+        "someFileInTheZip.txt")
+    ).Value();
+```
+
+Extract a file with a password in the zip:
+
+```csharp
+var extracted =
+    new ZipPasswordExtracted(
+        new InputOf(File.OpenRead("c:/some-zip-archive.zip")),
+        "root/dir/some-file.txt",
+        "password"
+    ).Stream();
+```
+
+Create a file with a password in a zip:
+
+```csharp
+var zipArchiveWithPassword =
+    new ZipWithPassword(
+        "small.dat",
+        new InputOf("I feel so compressed"),
+        "password"
+    );
 ```

build.cake

@@ -3,7 +3,7 @@
 #tool nuget:?package=xunit.runner.console
 #tool nuget:?package=Codecov
 #tool nuget:?package=ReportGenerator
-#addin nuget:?package=Cake.Codecov
+#addin nuget:?package=Cake.Codecov&version=0.5.0
 
 var target = Argument("target", "Default");
 var configuration   = Argument<string>("configuration", "Release");

src/Yaapii.Zip/HasPassword.cs

@@ -0,0 +1,45 @@
+using System;
+using Yaapii.Atoms;
+using Ionic.Zip;
+using Yaapii.Atoms.Error;
+using System.IO;
+
+namespace Yaapii.Zip
+{
+    /// <summary>
+    /// Checks if the file in a zip has a password
+    /// </summary>
+    public sealed class HasPassword : IScalar<bool>
+    {
+        private readonly IInput zip;
+        private readonly string virtualPath;
+
+        /// <summary>
+        /// Checks if the file in a zip has a password
+        /// </summary>
+        public HasPassword(IInput zip, string virtualPath)
+        {
+            this.zip = zip;
+            this.virtualPath = virtualPath;
+        }
+
+        public bool Value()
+        {
+            var stream = zip.Stream();
+            stream.Seek(0, SeekOrigin.Begin);
+            new FailWhen(
+                () => !new IsZipArchive(this.zip).Value(),
+                new ArgumentException(
+                    "Can not extract zip because no zip was provided."
+                )
+            ).Go();
+            stream.Seek(0, SeekOrigin.Begin);
+            bool result;
+            using (var zip = ZipFile.Read(this.zip.Stream()))
+            {
+                result = zip[virtualPath].UsesEncryption;
+            }
+            return result;
+        }
+    }
+}

src/Yaapii.Zip/Yaapii.Zip.csproj

@@ -9,6 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="DotNetZip" Version="1.13.3" />
     <PackageReference Include="Yaapii.Atoms" Version="0.26.0" />
     <PackageReference Include="Yaapii.Xml" Version="0.16.0" />
   </ItemGroup>

src/Yaapii.Zip/ZipExtracted.cs

@@ -3,6 +3,7 @@
 using System.IO.Compression;
 using Yaapii.Atoms;
 using Yaapii.Atoms.Enumerable;
+using Yaapii.Atoms.Error;
 using Yaapii.Atoms.Scalar;
 
 namespace Yaapii.Zip
@@ -32,6 +33,12 @@ public Stream Stream()
         {
             lock (zip)
             {
+                new FailWhen(
+                    () => new HasPassword(this.zip, filePath).Value(),
+                    new InvalidOperationException(
+                        "Can not read content of the zip because the file is password protected"
+                    )
+                ).Go();
                 Stream content;
                 using (var archive = new ZipArchive(this.zip.Stream(), ZipArchiveMode.Read, leaveOpen))
                 {

src/Yaapii.Zip/ZipPasswordExtracted.cs

@@ -0,0 +1,61 @@
+using Ionic.Zip;
+using System;
+using System.IO;
+using Yaapii.Atoms;
+using Yaapii.Atoms.Error;
+using Yaapii.Atoms.IO;
+
+namespace Yaapii.Zip
+{
+    /// <summary>
+    /// Extracted file in a zip that ís protected with a password
+    /// </summary>
+    public sealed class ZipPasswordExtracted : IInput
+    {
+        private readonly IInput zip;
+        private readonly string virtualPath;
+        private readonly string password;
+
+        /// <summary>
+        /// Extracted file in a zip that ís protected with a password
+        /// </summary>
+        public ZipPasswordExtracted(IInput zip, string virtualPath, string password)
+        {
+            this.zip = zip;
+            this.virtualPath = virtualPath;
+            this.password = password;
+        }
+
+        public Stream Stream()
+        {
+            new FailWhen(
+                () => !new IsZipArchive(this.zip).Value(),
+                new ArgumentException(
+                    "Can not extract zip because no zip was provided."
+                )
+            ).Go();
+            new FailWhen(
+                () => !new HasPassword(this.zip, this.virtualPath).Value(),
+                new InvalidOperationException(
+                    "Can not extract zip because the file is not protected with a password."
+                )
+            ).Go();
+            zip.Stream().Seek(0, SeekOrigin.Begin);
+            IInput result;
+            using (var stream = new MemoryStream())
+            using (var zip = ZipFile.Read(this.zip.Stream()))
+            {
+                try
+                {
+                    zip[virtualPath].ExtractWithPassword(stream, this.password);
+                }
+                catch (BadPasswordException)
+                {
+                    throw new ArgumentException("Can not extract zip because the provided password is not correct.");
+                }
+                result = new InputOf(stream.ToArray());
+            }
+            return result.Stream();
+        }
+    }
+}

src/Yaapii.Zip/ZipWithPassword.cs

@@ -0,0 +1,45 @@
+using Ionic.Zip;
+using System.IO;
+using Yaapii.Atoms;
+using Yaapii.Atoms.IO;
+using Yaapii.Atoms.Scalar;
+
+namespace Yaapii.Zip
+{
+    /// <summary>
+    /// A Zip which input is saved with a password
+    /// </summary>
+    public sealed class ZipWithPassword : IInput
+    {
+        private readonly IScalar<IInput> zip;
+
+        /// <summary>
+        /// A Zip which input is saved with a password
+        /// </summary>
+        public ZipWithPassword(string name, string password, IInput origin) : this(
+            new Sticky<IInput>(() =>
+            {
+                IInput output;
+                using (var stream = new MemoryStream())
+                using (var zip = new ZipFile())
+                {
+                    zip.Password = password;
+                    zip.AddEntry(name, origin.Stream());
+                    zip.Save(stream);
+                    output = new InputOf(stream.ToArray());
+                }
+                return output;
+            }))
+        { }
+
+        private ZipWithPassword(IScalar<IInput> zip)
+        {
+            this.zip = zip;
+        }
+
+        public Stream Stream()
+        {
+            return zip.Value().Stream();
+        }
+    }
+}

tests/Test.Yaapii.Zip/HasPasswordTests.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+using Yaapii.Atoms.IO;
+
+namespace Yaapii.Zip.Test
+{
+    public class HasPasswordTests
+    {
+        [Fact]
+        public void ReturnsTrueOnPassword()
+        {
+            Assert.True(
+                new HasPassword(
+                    new ZipWithPassword(
+                        "filename.txt",
+                        "aPassword",
+                        new InputOf("a input")
+                    ),
+                    "filename.txt"
+                ).Value()
+            );
+        }
+
+        [Fact]
+        public void ReturnsFalseOnNoPassword()
+        {
+            Assert.False(
+                new HasPassword(
+                    new Zipped(
+                        "filename.txt",
+                        new InputOf("a input")
+                    ),
+                    "filename.txt"
+                ).Value()
+            );
+        }
+
+        [Fact]
+        public void ThrowsOnNoZip()
+        {
+            Assert.Throws<ArgumentException>(() =>
+                new HasPassword(new InputOf("test"), "a path").Value()
+            );
+        }
+    }
+}

tests/Test.Yaapii.Zip/ZipPasswordExtractedTests.cs

@@ -0,0 +1,62 @@
+using System;
+using Xunit;
+using Yaapii.Atoms.IO;
+using Yaapii.Atoms.Text;
+
+namespace Yaapii.Zip.Test
+{
+    public class ZipPasswordExtractedTests
+    {
+        [Fact]
+        public void FailsOnWrongPassword()
+        {
+            Assert.Throws<ArgumentException>(() =>
+                new ZipPasswordExtracted(
+                    new ZipWithPassword(
+                        "text.txt",
+                        "password",
+                        new InputOf("safe")
+                    ),
+                    "text.txt",
+                    "noPassword"
+                ).Stream()
+            );
+        }
+
+        [Fact]
+        public void ReturnsExtractedInput()
+        {
+            Assert.Equal(
+                "safe",
+                new TextOf(
+                    new ZipPasswordExtracted(
+                        new ZipWithPassword(
+                            "text.txt",
+                            "password",
+                            new InputOf("safe")
+                        ),
+                        "text.txt",
+                        "password"
+                    )
+                ).AsString()
+            );
+        }
+
+        [Fact]
+        public void FailsOnNoPassword()
+        {
+            Assert.Throws<InvalidOperationException>(() =>
+                new TextOf(
+                    new ZipPasswordExtracted(
+                        new Zipped(
+                            "text.txt",
+                            new InputOf("safe")
+                        ),
+                        "text.txt",
+                        "password"
+                    )
+                ).AsString()
+            );
+        }
+    }
+}

tests/Test.Yaapii.Zip/ZipWithPasswordTests.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+using Yaapii.Atoms.IO;
+using Yaapii.Atoms.Scalar;
+using Yaapii.Atoms.Text;
+
+namespace Yaapii.Zip.Test
+{
+    public class ZipWithPasswordTests
+    {
+        [Fact]
+        public void HasFileName()
+        {
+            var name = new FirstOf<string>(
+                new Yaapii.Zip.ZipFiles(
+                    new ZipWithPassword(
+                        "input.txt",
+                        "pass",
+                        new InputOf("mechiko")
+                    )
+                )
+            ).Value();
+            Assert.Equal("input.txt", name);
+        }
+
+        [Fact]
+        public void HasPassword()
+        {
+            Assert.Throws<InvalidOperationException>(() =>
+            {
+                new TextOf(
+                    new ZipExtracted(
+                        new ZipWithPassword("input.txt", "pass", new InputOf("mechiko")),
+                        "input.txt"
+                    )
+                ).AsString();
+            });
+        }
+    }
+}