Changed test project type to WIndows 8.1

Changed test project framework from Nunit to MSTest
Changed HashAlgorithm from BouncyCastle to WinRT crypto
WIP progress bar in opendatabaseusercontrol
TextBox with button made generic
WIP implement copy on button click in Entry Page

ModernKeePassLib/Cryptography/Hash/HMAC.cs

@@ -27,8 +27,8 @@ namespace ModernKeePassLib.Cryptography.Hash
             if (value == null) throw new ArgumentNullException(nameof(value));
 
             byte[] resBuf = new byte[Hmac.GetMacSize()];
-            Hmac.BlockUpdate(value, 0, length);
-            Hmac.DoFinal(resBuf, 0);
+            Hmac.BlockUpdate(value, offset, length);
+            Hmac.DoFinal(resBuf, offset);
 
             return resBuf;
         }

ModernKeePassLib/Cryptography/Hash/HMACSHA1.cs

@@ -1,15 +1,10 @@
-using Org.BouncyCastle.Crypto.Digests;
-using Org.BouncyCastle.Crypto.Macs;
-using Org.BouncyCastle.Crypto.Parameters;
+using System.Runtime.InteropServices.WindowsRuntime;
+using Windows.Security.Cryptography.Core;
 
 namespace ModernKeePassLib.Cryptography.Hash
 {
-    public class HMACSHA1: HMAC
+    public class HMACSHA1: HashAlgorithm
     {
-        public HMACSHA1(byte[] key)
-        {
-            Hmac = new HMac(new Sha1Digest());
-            Hmac.Init(new KeyParameter(key));
-        }
+        public HMACSHA1(byte[] key) : base (MacAlgorithmProvider.OpenAlgorithm(MacAlgorithmNames.HmacSha1).CreateHash(key.AsBuffer())) {}
     }
 }

ModernKeePassLib/Cryptography/Hash/HMACSHA256.cs

@@ -1,15 +1,10 @@
-using Org.BouncyCastle.Crypto.Digests;
-using Org.BouncyCastle.Crypto.Macs;
-using Org.BouncyCastle.Crypto.Parameters;
+using System.Runtime.InteropServices.WindowsRuntime;
+using Windows.Security.Cryptography.Core;
 
 namespace ModernKeePassLib.Cryptography.Hash
 {
-    public class HMACSHA256: HMAC
+    public class HMACSHA256: HashAlgorithm
     {
-        public HMACSHA256(byte[] key)
-        {
-            Hmac = new HMac(new Sha256Digest());
-            Hmac.Init(new KeyParameter(key));
-        }
+        public HMACSHA256(byte[] key) : base (MacAlgorithmProvider.OpenAlgorithm(MacAlgorithmNames.HmacSha256).CreateHash(key.AsBuffer())) {}
     }
 }

ModernKeePassLib/Cryptography/Hash/HashAlgorithm.cs

@@ -1,25 +1,78 @@
 using System;
-using Org.BouncyCastle.Crypto;
+using System.Runtime.InteropServices.WindowsRuntime;
+using Windows.Security.Cryptography.Core;
+using Validation;
 
 namespace ModernKeePassLib.Cryptography.Hash
 {
     public abstract class HashAlgorithm: IDisposable
     {
-        protected IDigest Digest;
+        /// <summary>
+        /// The platform-specific hash object.
+        /// </summary>
+        private readonly CryptographicHash _hash;
 
-        public byte[] Hash
+        /// <summary>
+        /// Initializes a new instance of the <see cref="HashAlgorithm"/> class.
+        /// </summary>
+        /// <param name="hash">The platform hash.</param>
+        internal HashAlgorithm(CryptographicHash hash)
         {
-            get
-            {
-                var result = new byte[Digest.GetDigestSize()];
-                Digest.DoFinal(result, 0);
-                return result;
-            }
+            Requires.NotNull(hash, "Hash");
+            _hash = hash;
         }
-
+        
         public bool CanReuseTransform => true;
         public bool CanTransformMultipleBlocks => true;
 
+        public byte[] Hash => _hash.GetValueAndReset().ToArray();
+
+        public  void Append(byte[] data)
+        {
+            _hash.Append(data.AsBuffer());
+        }
+        
+        public  byte[] GetValueAndReset()
+        {
+            return _hash.GetValueAndReset().ToArray();
+        }
+
+        #region ICryptoTransform methods
+        
+        public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
+        {
+            byte[] buffer;
+            if (inputCount < inputBuffer.Length)
+            {
+                buffer = new byte[inputCount];
+                Array.Copy(inputBuffer, inputOffset, buffer, 0, inputCount);
+            }
+            else
+            {
+                buffer = inputBuffer;
+            }
+
+            Append(buffer);
+            if (outputBuffer != null)
+            {
+                Array.Copy(inputBuffer, inputOffset, outputBuffer, outputOffset, inputCount);
+            }
+
+            return inputCount;
+        }
+        
+        public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount)
+        {
+            this.TransformBlock(inputBuffer, inputOffset, inputCount, null, 0);
+            if (inputCount == inputBuffer.Length)
+            {
+                return inputBuffer;
+            }
+            var buffer = new byte[inputCount];
+            Array.Copy(inputBuffer, inputOffset, buffer, 0, inputCount);
+            return buffer;
+        }
+
         public byte[] ComputeHash(byte[] value)
         {
             return ComputeHash(value, 0, value.Length);
@@ -29,33 +82,19 @@ namespace ModernKeePassLib.Cryptography.Hash
         {
             if (value == null) throw new ArgumentNullException(nameof(value));
 
-            byte[] resBuf = new byte[Digest.GetDigestSize()];
-            Digest.BlockUpdate(value, 0, length);
-            Digest.DoFinal(resBuf, 0);
+            TransformFinalBlock(value, offset, length);
+            var resBuf = GetValueAndReset();
 
             return resBuf;
         }
-
-
-        public void TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
+        public void Initialize()
         {
-            Digest.BlockUpdate(inputBuffer, inputOffset, inputCount);
-            if ((outputBuffer != null) && ((inputBuffer != outputBuffer) || (inputOffset != outputOffset)))
-                Buffer.BlockCopy(inputBuffer, inputOffset, outputBuffer, outputOffset, inputCount);
-        }
-
-        public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount)
-        {
-            Digest.BlockUpdate(inputBuffer, inputOffset, inputCount);
-            byte[] outputBytes = new byte[inputCount];
-            if (inputCount != 0)
-                Buffer.BlockCopy(inputBuffer, inputOffset, outputBytes, 0, inputCount);
-            return outputBytes;
         }
 
         public void Dispose()
         {
-            Digest.Reset();
         }
+
+        #endregion
     }
 }

ModernKeePassLib/Cryptography/Hash/SHA256Managed.cs

@@ -1,12 +1,9 @@
-using Org.BouncyCastle.Crypto.Digests;
+using Windows.Security.Cryptography.Core;
 
 namespace ModernKeePassLib.Cryptography.Hash
 {
     public class SHA256Managed : HashAlgorithm
     {
-        public SHA256Managed()
-        {
-            Digest = new Sha256Digest();
-        }
+        public SHA256Managed() : base(HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256).CreateHash()) {}
     }
 }

ModernKeePassLib/Cryptography/Hash/SHA512Managed.cs

@@ -1,12 +1,9 @@
-using Org.BouncyCastle.Crypto.Digests;
+using Windows.Security.Cryptography.Core;
 
 namespace ModernKeePassLib.Cryptography.Hash
 {
     public class SHA512Managed: HashAlgorithm
     {
-        public SHA512Managed()
-        {
-            Digest = new Sha512Digest();
-        }
+        public SHA512Managed() : base(HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha512).CreateHash()) {}
     }
 }