WIP KeePassLibPCL

ModernKeePass/BundleArtifacts/neutral.txt

@@ -0,0 +1,4 @@
+MainPackage=C:\Users\bg45\source\repos\ModernKeePass\ModernKeePass\bin\Release\ModernKeePass_1.1.0.6_AnyCPU.appx
+SymbolPackage=C:\Users\bg45\source\repos\ModernKeePass\ModernKeePass\AppPackages\ModernKeePass_1.1.0.6_Test\ModernKeePass_1.1.0.6_AnyCPU.appxsym
+ResourcePack=C:\Users\bg45\source\repos\ModernKeePass\ModernKeePass\bin\Release\ModernKeePass_1.1.0.6_scale-140.appx
+ResourcePack=C:\Users\bg45\source\repos\ModernKeePass\ModernKeePass\bin\Release\ModernKeePass_1.1.0.6_scale-180.appx

ModernKeePass/ModernKeePass.csproj

@@ -159,8 +159,8 @@
     </Page>
   </ItemGroup>
   <ItemGroup>
-    <Reference Include="ModernKeePassLibPCL, Version=2.28.1.32947, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\ModernKeePassLibPCL.2.28.1.32947\lib\portable46-net451+win81+wpa81\ModernKeePassLibPCL.dll</HintPath>
+    <Reference Include="ModernKeePassLibPCL, Version=2.28.1.33588, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\ModernKeePassLibPCL.2.28.1.33588\lib\portable46-net451+win81+wpa81\ModernKeePassLibPCL.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="PCLCrypto, Version=2.0.0.0, Culture=neutral, PublicKeyToken=d4421c8a4786956c, processorArchitecture=MSIL">

ModernKeePass/Package.appxmanifest

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Package xmlns="http://schemas.microsoft.com/appx/2010/manifest" xmlns:m2="http://schemas.microsoft.com/appx/2013/manifest">
-  <Identity Name="wismna.ModernKeePass" Publisher="CN=0719A91A-C322-4EE0-A257-E60733EECF06" Version="1.1.0.2" />
+  <Identity Name="wismna.ModernKeePass" Publisher="CN=0719A91A-C322-4EE0-A257-E60733EECF06" Version="1.1.0.6" />
   <Properties>
     <DisplayName>ModernKeePass</DisplayName>
     <PublisherDisplayName>wismna</PublisherDisplayName>

ModernKeePass/packages.config

@@ -4,7 +4,7 @@
   <package id="Microsoft.Bcl.Compression" version="3.9.85" targetFramework="win81" />
   <package id="Microsoft.NETCore.Platforms" version="2.0.0" targetFramework="win81" />
   <package id="Microsoft.NETCore.Portable.Compatibility" version="1.0.2" targetFramework="win81" />
-  <package id="ModernKeePassLibPCL" version="2.28.1.32947" targetFramework="win81" />
+  <package id="ModernKeePassLibPCL" version="2.28.1.33588" targetFramework="win81" />
   <package id="NETStandard.Library" version="2.0.0" targetFramework="win81" />
   <package id="PCLCrypto" version="2.0.147" targetFramework="win81" />
   <package id="PCLStorage" version="1.0.2" targetFramework="win81" />

ModernKeePassLib/Cryptography/Cipher/StandardAesEngine.cs

@@ -25,7 +25,8 @@ using System.Security;
 using System.Diagnostics;
 
 #if ModernKeePassLibPCL
-using PCLCrypto;
+using Windows.Security.Cryptography;
+using Windows.Security.Cryptography.Core;
 #else
 
 #if !KeePassRT
@@ -124,7 +125,7 @@ namespace ModernKeePassLibPCL.Cryptography.Cipher
 			Array.Copy(pbKey, pbLocalKey, 32);
 
 #if ModernKeePassLibPCL
-			var provider = WinRTCrypto.SymmetricKeyAlgorithmProvider.
+            /*var provider = WinRTCrypto.SymmetricKeyAlgorithmProvider.
                 OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7);
 			var key = provider.CreateSymmetricKey(pbLocalKey);
 			if (bEncrypt)
@@ -138,6 +139,27 @@ namespace ModernKeePassLibPCL.Cryptography.Cipher
                     key, pbLocalIV);
 				return new CryptoStream(s, decryptor, CryptoStreamMode.Read);
 			}
+            */
+            var provider = SymmetricKeyAlgorithmProvider.
+                OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7);
+            var key = provider.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(pbLocalKey));
+            using (var ms = new MemoryStream())
+            {
+                s.CopyTo(ms);
+                var data = CryptographicBuffer.CreateFromByteArray(ms.ToArray());
+                byte[] resultByteArray;
+                if (bEncrypt)
+                {
+                    var encrypted = CryptographicEngine.Encrypt(key, data, CryptographicBuffer.CreateFromByteArray(pbLocalIV));
+                    CryptographicBuffer.CopyToByteArray(encrypted, out resultByteArray);
+                }
+                else
+                {
+                    var decrypted = CryptographicEngine.Decrypt(key, data, CryptographicBuffer.CreateFromByteArray(pbLocalIV));
+                    CryptographicBuffer.CopyToByteArray(decrypted, out resultByteArray);
+                }
+                    return new MemoryStream(resultByteArray, true);
+            }
 #else
 
 #if !KeePassRT
@@ -175,7 +197,7 @@ namespace ModernKeePassLibPCL.Cryptography.Cipher
 #endif
 
 #endif
-		}
+        }
 
 		public Stream EncryptStream(Stream sPlainText, byte[] pbKey, byte[] pbIV)
 		{

ModernKeePassLib/Cryptography/CryptoRandom.cs

@@ -20,7 +20,7 @@
 using System;
 using System.Security;
 #if ModernKeePassLibPCL
-using PCLCrypto;
+using Windows.Security.Cryptography;
 #else
 using System.Security.Cryptography;
 #endif
@@ -29,6 +29,7 @@ using System.Diagnostics;
 
 using ModernKeePassLibPCL.Native;
 using ModernKeePassLibPCL.Utility;
+using Windows.Security.Cryptography.Core;
 
 namespace ModernKeePassLibPCL.Cryptography
 {
@@ -42,7 +43,7 @@ namespace ModernKeePassLibPCL.Cryptography
 		private byte[] m_pbEntropyPool = new byte[64];
 		private uint m_uCounter;
 #if ModernKeePassLibPCL
-		private IRandomNumberGenerator m_rng = NetFxCrypto.RandomNumberGenerator;
+		//private IRandomNumberGenerator m_rng = NetFxCrypto.RandomNumberGenerator;
 #else
 		private RNGCryptoServiceProvider m_rng = new RNGCryptoServiceProvider();
 #endif
@@ -107,8 +108,11 @@ namespace ModernKeePassLibPCL.Cryptography
 			if(pbEntropy.Length >= 64)
 			{
 #if ModernKeePassLibPCL
-				var shaNew = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha512);
-				pbNewData = shaNew.HashData(pbEntropy);
+                /*var shaNew = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha512);
+				pbNewData = shaNew.HashData(pbEntropy);*/
+                var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
+                var buffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(pbEntropy));
+                CryptographicBuffer.CopyToByteArray(buffer, out pbNewData);
 #else
 
 #if !KeePassLibSD
@@ -119,7 +123,7 @@ namespace ModernKeePassLibPCL.Cryptography
 				pbNewData = shaNew.ComputeHash(pbEntropy);
 
 #endif
-			}
+            }
 
 			MemoryStream ms = new MemoryStream();
 			lock(m_oSyncRoot)
@@ -129,8 +133,11 @@ namespace ModernKeePassLibPCL.Cryptography
 
 				byte[] pbFinal = ms.ToArray();
 #if ModernKeePassLibPCL
-				var shaPool = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha512);
-				m_pbEntropyPool = shaPool.HashData(pbFinal);
+                /*var shaPool = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha512);
+				m_pbEntropyPool = shaPool.HashData(pbFinal);*/
+                var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
+                var buffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(pbFinal));
+                CryptographicBuffer.CopyToByteArray(buffer, out m_pbEntropyPool);
 #else
 
 #if !KeePassLibSD
@@ -142,7 +149,7 @@ namespace ModernKeePassLibPCL.Cryptography
 				m_pbEntropyPool = shaPool.ComputeHash(pbFinal);
 
 #endif
-			}
+            }
 			ms.Dispose();
 		}
 
@@ -250,7 +257,8 @@ namespace ModernKeePassLibPCL.Cryptography
 		private byte[] GetCspData()
 		{
 			byte[] pbCspRandom = new byte[32];
-			m_rng.GetBytes(pbCspRandom);
+			//m_rng.GetBytes(pbCspRandom);
+            CryptographicBuffer.CopyToByteArray(CryptographicBuffer.GenerateRandom(32), out pbCspRandom);
 			return pbCspRandom;
 		}
 
@@ -280,13 +288,18 @@ namespace ModernKeePassLibPCL.Cryptography
 			}
 
 #if ModernKeePassLibPCL
-			var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
-			return sha256.HashData(pbFinal);
+            /*var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
+			return sha256.HashData(pbFinal);*/
+            var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
+            var buffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(pbFinal));
+            byte[] result;
+            CryptographicBuffer.CopyToByteArray(buffer, out result);
+            return result;
 #else
 			SHA256Managed sha256 = new SHA256Managed();
 			return sha256.ComputeHash(pbFinal);
 #endif
-		}
+        }
 
 		/// <summary>
 		/// Get a number of cryptographically strong random bytes.

ModernKeePassLib/Cryptography/CryptoRandomStream.cs

@@ -19,8 +19,9 @@
 
 using System;
 using System.Diagnostics;
+using Windows.Security.Cryptography.Core;
 #if ModernKeePassLibPCL
-using PCLCrypto;
+using Windows.Security.Cryptography;
 #else
 using System.Security.Cryptography;
 #endif
@@ -116,13 +117,17 @@ namespace ModernKeePassLibPCL.Cryptography
 			else if(genAlgorithm == CrsAlgorithm.Salsa20)
 			{
 #if ModernKeePassLibPCL
-				var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
-				var pbKey32 = sha256.HashData(pbKey);
+                /*var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
+				var pbKey32 = sha256.HashData(pbKey);*/
+                var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
+                var buffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(pbKey));
+                byte[] pbKey32;
+                CryptographicBuffer.CopyToByteArray(buffer, out pbKey32);
 #else
 				SHA256Managed sha256 = new SHA256Managed();
 				byte[] pbKey32 = sha256.ComputeHash(pbKey);
 #endif
-				byte[] pbIV = new byte[8] { 0xE8, 0x30, 0x09, 0x4B,
+                byte[] pbIV = new byte[8] { 0xE8, 0x30, 0x09, 0x4B,
 					0x97, 0x20, 0x5D, 0x2A }; // Unique constant
 
 				m_salsa20 = new Salsa20Cipher(pbKey32, pbIV);

ModernKeePassLib/Cryptography/HashingStreamEx.cs

@@ -22,13 +22,14 @@ using System.Collections.Generic;
 using System.Text;
 using System.IO;
 #if ModernKeePassLibPCL
-using PCLCrypto;
+using Windows.Security.Cryptography;
 #else
 using System.Security.Cryptography;
 #endif
 using System.Diagnostics;
 
 using ModernKeePassLibPCL.Utility;
+using Windows.Security.Cryptography.Core;
 
 namespace ModernKeePassLibPCL.Cryptography
 {
@@ -37,7 +38,8 @@ namespace ModernKeePassLibPCL.Cryptography
 		private Stream m_sBaseStream;
 		private bool m_bWriting;
 #if ModernKeePassLibPCL
-		private ICryptoTransform m_hash;
+        //private ICryptoTransform m_hash;
+        private CryptographicHash m_hash;
 #else
 		private HashAlgorithm m_hash;
 #endif
@@ -76,18 +78,20 @@ namespace ModernKeePassLibPCL.Cryptography
 		}
 
 #if ModernKeePassLibPCL
-		public HashingStreamEx(Stream sBaseStream, bool bWriting, HashAlgorithm? hashAlgorithm)
+        //public HashingStreamEx(Stream sBaseStream, bool bWriting, HashAlgorithm? hashAlgorithm)
+        public HashingStreamEx(Stream sBaseStream, bool bWriting, string hashAlgorithm)
 #else
 		public HashingStreamEx(Stream sBaseStream, bool bWriting, HashAlgorithm hashAlgorithm)
 #endif
-		{
+        {
 			if(sBaseStream == null)
                 throw new ArgumentNullException("sBaseStream");
 
 			m_sBaseStream = sBaseStream;
 			m_bWriting = bWriting;
 #if ModernKeePassLibPCL
-			m_hash = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(hashAlgorithm ?? HashAlgorithm.Sha256).CreateHash();
+            //m_hash = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(hashAlgorithm ?? HashAlgorithm.Sha256).CreateHash();
+            m_hash = HashAlgorithmProvider.OpenAlgorithm(hashAlgorithm ?? HashAlgorithmNames.Sha256).CreateHash();
 #elif !KeePassLibSD
 			m_hash = (hashAlgorithm ?? new SHA256Managed());
 #else // KeePassLibSD
@@ -98,17 +102,17 @@ namespace ModernKeePassLibPCL.Cryptography
 			try { if(m_hash == null) m_hash = HashAlgorithm.Create(); }
 			catch(Exception) { }
 #endif
-			if(m_hash == null) { Debug.Assert(false); return; }
+            if (m_hash == null) { Debug.Assert(false); return; }
 
 			// Validate hash algorithm
-			if((!m_hash.CanReuseTransform) || (!m_hash.CanTransformMultipleBlocks) ||
+			/*if((!m_hash.CanReuseTransform) || (!m_hash.CanTransformMultipleBlocks) ||
 				(m_hash.InputBlockSize != 1) || (m_hash.OutputBlockSize != 1))
 			{
 #if false && DEBUG
 				MessageService.ShowWarning("Broken HashAlgorithm object in HashingStreamEx.");
 #endif
 				m_hash = null;
-			}
+			}*/
 		}
 
 		public override void Flush()
@@ -128,13 +132,14 @@ namespace ModernKeePassLibPCL.Cryptography
 			{
 				try
 				{
-					m_hash.TransformFinalBlock(new byte[0], 0, 0);
+                    //m_hash.TransformFinalBlock(new byte[0], 0, 0);
 #if ModernKeePassLibPCL
-					m_pbFinalHash = (m_hash as CryptographicHash).GetValueAndReset ();
+                    //m_pbFinalHash = (m_hash as CryptographicHash).GetValueAndReset ();
+                    CryptographicBuffer.CopyToByteArray(m_hash.GetValueAndReset(), out m_pbFinalHash);
 #else
 					m_pbFinalHash = m_hash.Hash;
 #endif
-				}
+                }
 				catch(Exception) { Debug.Assert(false); }
 
 				m_hash = null;
@@ -172,10 +177,11 @@ namespace ModernKeePassLibPCL.Cryptography
 #endif
 
 			if((m_hash != null) && (nRead > 0))
-				m_hash.TransformBlock(pbBuffer, nOffset, nRead, pbBuffer, nOffset);
+                //m_hash.TransformBlock(pbBuffer, nOffset, nRead, pbBuffer, nOffset);
+                m_hash.Append(CryptographicBuffer.CreateFromByteArray(pbBuffer));
 
 #if DEBUG
-			Debug.Assert(MemUtil.ArraysEqual(pbBuffer, pbOrg));
+            Debug.Assert(MemUtil.ArraysEqual(pbBuffer, pbOrg));
 #endif
 
 			return nRead;
@@ -190,8 +196,9 @@ namespace ModernKeePassLibPCL.Cryptography
 			Array.Copy(pbBuffer, pbOrg, pbBuffer.Length);
 #endif
 
-			if((m_hash != null) && (nCount > 0))
-				m_hash.TransformBlock(pbBuffer, nOffset, nCount, pbBuffer, nOffset);
+            if ((m_hash != null) && (nCount > 0))
+                //m_hash.TransformBlock(pbBuffer, nOffset, nCount, pbBuffer, nOffset);
+                m_hash.Append(CryptographicBuffer.CreateFromByteArray(pbBuffer));
 
 #if DEBUG
 			Debug.Assert(MemUtil.ArraysEqual(pbBuffer, pbOrg));

ModernKeePassLib/Cryptography/HmacOtp.cs

@@ -21,13 +21,14 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 #if ModernKeePassLibPCL
-using PCLCrypto;
+using Windows.Security.Cryptography;
 #else
 using System.Security.Cryptography;
 #endif
 using System.Globalization;
 
 using ModernKeePassLibPCL.Utility;
+using Windows.Security.Cryptography.Core;
 
 #if (!KeePassLibSD && !KeePassRT)
 namespace ModernKeePassLibPCL.Cryptography
@@ -47,15 +48,19 @@ namespace ModernKeePassLibPCL.Cryptography
 			Array.Reverse(pbText); // Big-Endian
 
 #if ModernKeePassLibPCL
-			var hsha1 = WinRTCrypto.MacAlgorithmProvider.OpenAlgorithm(MacAlgorithm.HmacSha1).CreateHash(pbSecret);
+            /*var hsha1 = WinRTCrypto.MacAlgorithmProvider.OpenAlgorithm(MacAlgorithm.HmacSha1).CreateHash(pbSecret);
 			hsha1.Append(pbText);
-			var pbHash = hsha1.GetValueAndReset();
+			var pbHash = hsha1.GetValueAndReset();*/
+            var hsha1 = MacAlgorithmProvider.OpenAlgorithm(MacAlgorithmNames.HmacSha1).CreateHash(CryptographicBuffer.CreateFromByteArray(pbSecret));
+            hsha1.Append(CryptographicBuffer.CreateFromByteArray(pbText));
+            byte[] pbHash;
+            CryptographicBuffer.CopyToByteArray(hsha1.GetValueAndReset(), out pbHash);
 #else
 			HMACSHA1 hsha1 = new HMACSHA1(pbSecret);
 			byte[] pbHash = hsha1.ComputeHash(pbText);
 #endif
 
-			uint uOffset = (uint)(pbHash[pbHash.Length - 1] & 0xF);
+            uint uOffset = (uint)(pbHash[pbHash.Length - 1] & 0xF);
 			if((iTruncationOffset >= 0) && (iTruncationOffset < (pbHash.Length - 4)))
 				uOffset = (uint)iTruncationOffset;
 

ModernKeePassLib/Cryptography/SelfTest.cs

@@ -21,7 +21,7 @@ using System;
 using System.Collections.Generic;
 using System.Security;
 #if ModernKeePassLibPCL
-using PCLCrypto;
+using Windows.Security.Cryptography;
 #else
 using System.Security.Cryptography;
 #endif

ModernKeePassLib/Keys/CompositeKey.cs

@@ -23,7 +23,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 #if ModernKeePassLibPCL
-using PCLCrypto;
+using Windows.Security.Cryptography;
 #else
 using System.Security.Cryptography;
 #endif
@@ -37,6 +37,8 @@ using ModernKeePassLibPCL.Native;
 using ModernKeePassLibPCL.Resources;
 using ModernKeePassLibPCL.Security;
 using ModernKeePassLibPCL.Utility;
+using Windows.Security.Cryptography.Core;
+using Windows.Storage.Streams;
 
 namespace ModernKeePassLibPCL.Keys
 {
@@ -178,13 +180,17 @@ namespace ModernKeePassLibPCL.Keys
 			}
 
 #if ModernKeePassLibPCL
-			var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
-			var pbHash = sha256.HashData(ms.ToArray());
+            /*var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
+			var pbHash = sha256.HashData(ms.ToArray());*/
+            var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
+            var buffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(ms.ToArray()));
+            byte[] pbHash;
+            CryptographicBuffer.CopyToByteArray(buffer, out pbHash);
 #else
 			SHA256Managed sha256 = new SHA256Managed();
 			byte[] pbHash = sha256.ComputeHash(ms.ToArray());
 #endif
-			ms.Dispose();
+            ms.Dispose();
 			return pbHash;
 		}
 
@@ -284,13 +290,18 @@ namespace ModernKeePassLibPCL.Keys
 				return null;
 
 #if ModernKeePassLibPCL
-			var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
-			return sha256.HashData(pbNewKey);
+            /*var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
+			return sha256.HashData(pbNewKey);*/
+            var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
+            byte[] result;
+            var buffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(pbNewKey));
+            CryptographicBuffer.CopyToByteArray(buffer, out result);
+            return result;
 #else
 			SHA256Managed sha256 = new SHA256Managed();
 			return sha256.ComputeHash(pbNewKey);
 #endif
-		}
+        }
 
 		public static bool TransformKeyManaged(byte[] pbNewKey32, byte[] pbKeySeed32,
 			ulong uNumRounds)
@@ -307,9 +318,12 @@ namespace ModernKeePassLibPCL.Keys
 			}
 #else
 #if ModernKeePassLibPCL
-			var aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesEcb);
+            /*var aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesEcb);
 			var key = aes.CreateSymmetricKey(pbKeySeed32);
-			var iCrypt = WinRTCrypto.CryptographicEngine.CreateEncryptor(key);
+			var iCrypt = WinRTCrypto.CryptographicEngine.CreateEncryptor(key);*/
+            var aes = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcb);
+            var key = aes.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(pbKeySeed32));
+            
 #else
 			byte[] pbIV = new byte[16];
 			Array.Clear(pbIV, 0, pbIV.Length);
@@ -328,8 +342,8 @@ namespace ModernKeePassLibPCL.Keys
 			ICryptoTransform iCrypt = r.CreateEncryptor();
 #endif
 
-			// !iCrypt.CanReuseTransform -- doesn't work with Mono
-			if((iCrypt == null) || (iCrypt.InputBlockSize != 16) ||
+            // !iCrypt.CanReuseTransform -- doesn't work with Mono
+            if ((iCrypt == null) || (iCrypt.InputBlockSize != 16) ||
 				(iCrypt.OutputBlockSize != 16))
 			{
 				Debug.Assert(false, "Invalid ICryptoTransform.");
@@ -384,9 +398,12 @@ namespace ModernKeePassLibPCL.Keys
 			aes.Init(true, kp);
 #else
 #if ModernKeePassLibPCL
-			var aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesEcb);
+            /*var aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesEcb);
 			var key = aes.CreateSymmetricKey(pbKey);
-			var iCrypt = WinRTCrypto.CryptographicEngine.CreateEncryptor(key);
+            var iCrypt = WinRTCrypto.CryptographicEngine.CreateEncryptor(key);*/
+            var aes = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcb);
+            var key = aes.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(pbKey));
+            
 #else
 			byte[] pbIV = new byte[16];
 			Array.Clear(pbIV, 0, pbIV.Length);

ModernKeePassLib/Keys/KcpCustomKey.cs

@@ -22,13 +22,14 @@ using System.Collections.Generic;
 using System.Text;
 using System.Diagnostics;
 #if ModernKeePassLibPCL
-using PCLCrypto;
+using Windows.Security.Cryptography;
 #else
 using System.Security.Cryptography;
 #endif
 
 using ModernKeePassLibPCL.Security;
 using ModernKeePassLibPCL.Utility;
+using Windows.Security.Cryptography.Core;
 
 namespace ModernKeePassLibPCL.Keys
 {
@@ -60,13 +61,17 @@ namespace ModernKeePassLibPCL.Keys
 			if(bPerformHash)
 			{
 #if ModernKeePassLibPCL
-				var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
-				var pbRaw = sha256.HashData(pbKeyData);
+                /*var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
+				var pbRaw = sha256.HashData(pbKeyData);*/
+                var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
+                var buffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(pbKeyData));
+                byte[] pbRaw;
+                CryptographicBuffer.CopyToByteArray(buffer, out pbRaw);
 #else
 				SHA256Managed sha256 = new SHA256Managed();
 				byte[] pbRaw = sha256.ComputeHash(pbKeyData);
 #endif
-				m_pbKey = new ProtectedBinary(true, pbRaw);
+                m_pbKey = new ProtectedBinary(true, pbRaw);
 			}
 			else m_pbKey = new ProtectedBinary(true, pbKeyData);
 		}

ModernKeePassLib/Keys/KcpKeyFile.cs

@@ -26,7 +26,7 @@ using System.Security;
 using System.Collections.Generic;
 using System.Linq;
 using System.Xml.Linq;
-using PCLCrypto;
+using Windows.Security.Cryptography;
 #else
 using System.Security.Cryptography;
 #endif
@@ -37,6 +37,7 @@ using ModernKeePassLibPCL.Resources;
 using ModernKeePassLibPCL.Security;
 using ModernKeePassLibPCL.Serialization;
 using ModernKeePassLibPCL.Utility;
+using Windows.Security.Cryptography.Core;
 
 namespace ModernKeePassLibPCL.Keys
 {
@@ -139,13 +140,16 @@ namespace ModernKeePassLibPCL.Keys
 			if(pbKey == null)
 			{
 #if ModernKeePassLibPCL
-				var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
-				pbKey = sha256.HashData(pbFileData);
+                /*var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
+				pbKey = sha256.HashData(pbFileData);*/
+                var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
+                var buffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(pbFileData));
+                CryptographicBuffer.CopyToByteArray(buffer, out pbKey);
 #else
 				SHA256Managed sha256 = new SHA256Managed();
 				pbKey = sha256.ComputeHash(pbFileData);
 #endif
-			}
+            }
 
 			return pbKey;
 		}
@@ -203,13 +207,16 @@ namespace ModernKeePassLibPCL.Keys
 				ms.Write(pbKey32, 0, 32);
 
 #if ModernKeePassLibPCL
-				var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
-				pbFinalKey32 = sha256.HashData(ms.ToArray());
+                /*var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
+				pbFinalKey32 = sha256.HashData(ms.ToArray());*/
+                var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
+                var buffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(ms.ToArray()));
+                CryptographicBuffer.CopyToByteArray(buffer, out pbFinalKey32);
 #else
 				SHA256Managed sha256 = new SHA256Managed();
 				pbFinalKey32 = sha256.ComputeHash(ms.ToArray());
 #endif
-				ms.Dispose();
+                ms.Dispose();
 			}
 
 			CreateXmlKeyFile(strFilePath, pbFinalKey32);

ModernKeePassLib/Keys/KcpPassword.cs

@@ -21,13 +21,14 @@ using System;
 using System.Text;
 using System.Diagnostics;
 #if ModernKeePassLibPCL
-using PCLCrypto;
+using Windows.Security.Cryptography;
 #else
 using System.Security.Cryptography;
 #endif
 
 using ModernKeePassLibPCL.Security;
 using ModernKeePassLibPCL.Utility;
+using Windows.Security.Cryptography.Core;
 
 namespace ModernKeePassLibPCL.Keys
 {
@@ -73,14 +74,18 @@ namespace ModernKeePassLibPCL.Keys
 			if(pbPasswordUtf8 == null) throw new ArgumentNullException("pbPasswordUtf8");
 
 #if ModernKeePassLibPCL
-			var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
-			var pbRaw = sha256.HashData(pbPasswordUtf8);
+            /*var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
+			var pbRaw = sha256.HashData(pbPasswordUtf8);*/
+            var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
+            var buffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(pbPasswordUtf8));
+            byte[] pbRaw;
+            CryptographicBuffer.CopyToByteArray(buffer, out pbRaw);
 #else
 			SHA256Managed sha256 = new SHA256Managed();
 			byte[] pbRaw = sha256.ComputeHash(pbPasswordUtf8);
 #endif
 
-			m_psPassword = new ProtectedString(true, pbPasswordUtf8);
+            m_psPassword = new ProtectedString(true, pbPasswordUtf8);
 			m_pbKeyData = new ProtectedBinary(true, pbRaw);
 		}
 

ModernKeePassLib/ModernKeePassLibPCL.csproj

@@ -15,12 +15,13 @@
     <OldToolsVersion>2.0</OldToolsVersion>
     <UpgradeBackupLocation>
     </UpgradeBackupLocation>
-    <TargetFrameworkProfile>Profile151</TargetFrameworkProfile>
-    <TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
+    <TargetFrameworkVersion>v5.0</TargetFrameworkVersion>
     <AssemblyOriginatorKeyFile>KeePassLib.pfx</AssemblyOriginatorKeyFile>
     <NuGetPackageImportStamp>
     </NuGetPackageImportStamp>
-    <MinimumVisualStudioVersion>10.0</MinimumVisualStudioVersion>
+    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -120,8 +121,8 @@
     <None Include="KeePassLib.pfx" />
     <None Include="Libs\Windows.winmd" />
     <None Include="ModernKeePassLibPCL.nuspec" />
+    <None Include="project.json" />
     <None Include="Utility\MessageService.cs" />
-    <None Include="packages.config" />
     <None Include="Native\NativeLib.cs" />
     <None Include="Native\NativeMethods.cs" />
     <None Include="Native\NativeMethods.Unix.cs" />
@@ -148,33 +149,6 @@
     </MonoDevelop>
   </ProjectExtensions>
   <ItemGroup>
-    <Reference Include="PCLCrypto, Version=2.0.0.0, Culture=neutral, PublicKeyToken=d4421c8a4786956c, processorArchitecture=MSIL">
-      <HintPath>..\packages\PCLCrypto.2.0.147\lib\portable-net45+win+wpa81+wp80+MonoAndroid10+xamarinios10+MonoTouch10\PCLCrypto.dll</HintPath>
-    </Reference>
-    <Reference Include="PCLStorage">
-      <HintPath>..\packages\PCLStorage.1.0.2\lib\portable-net45+wp8+wpa81+win8+monoandroid+monotouch+Xamarin.iOS+Xamarin.Mac\PCLStorage.dll</HintPath>
-    </Reference>
-    <Reference Include="PCLStorage.Abstractions">
-      <HintPath>..\packages\PCLStorage.1.0.2\lib\portable-net45+wp8+wpa81+win8+monoandroid+monotouch+Xamarin.iOS+Xamarin.Mac\PCLStorage.Abstractions.dll</HintPath>
-    </Reference>
-    <Reference Include="PInvoke.BCrypt, Version=0.5.0.0, Culture=neutral, PublicKeyToken=9e300f9f87f04a7a, processorArchitecture=MSIL">
-      <HintPath>..\packages\PInvoke.BCrypt.0.5.97\lib\portable-net45+win8+wpa81\PInvoke.BCrypt.dll</HintPath>
-    </Reference>
-    <Reference Include="PInvoke.Kernel32, Version=0.5.0.0, Culture=neutral, PublicKeyToken=9e300f9f87f04a7a, processorArchitecture=MSIL">
-      <HintPath>..\packages\PInvoke.Kernel32.0.5.97\lib\portable-net45+win8+wpa81\PInvoke.Kernel32.dll</HintPath>
-    </Reference>
-    <Reference Include="PInvoke.NCrypt, Version=0.5.0.0, Culture=neutral, PublicKeyToken=9e300f9f87f04a7a, processorArchitecture=MSIL">
-      <HintPath>..\packages\PInvoke.NCrypt.0.5.97\lib\portable-net45+win8+wpa81\PInvoke.NCrypt.dll</HintPath>
-    </Reference>
-    <Reference Include="PInvoke.Windows.Core, Version=0.5.0.0, Culture=neutral, PublicKeyToken=9e300f9f87f04a7a, processorArchitecture=MSIL">
-      <HintPath>..\packages\PInvoke.Windows.Core.0.5.97\lib\portable-net45+win8+wpa81\PInvoke.Windows.Core.dll</HintPath>
-    </Reference>
-    <Reference Include="Splat, Version=2.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\Splat.2.0.0\lib\netstandard1.1\Splat.dll</HintPath>
-    </Reference>
-    <Reference Include="Validation, Version=2.4.0.0, Culture=neutral, PublicKeyToken=2fc06f0d701809a7, processorArchitecture=MSIL">
-      <HintPath>..\packages\Validation.2.4.15\lib\portable-net45+win8+wp8+wpa81\Validation.dll</HintPath>
-    </Reference>
     <Reference Include="Windows, Version=255.255.255.255, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>Libs\Windows.winmd</HintPath>

ModernKeePassLib/ModernKeePassLibPCL.nuget.targets

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Condition="'$(NuGetPackageRoot)' == ''">
+    <NuGetPackageRoot>$(UserProfile)\.nuget\packages\</NuGetPackageRoot>
+  </PropertyGroup>
+  <ImportGroup>
+    <Import Project="$(NuGetPackageRoot)\Microsoft.Bcl.Build\1.0.21\build\Microsoft.Bcl.Build.targets" Condition="Exists('$(NuGetPackageRoot)\Microsoft.Bcl.Build\1.0.21\build\Microsoft.Bcl.Build.targets')" />
+  </ImportGroup>
+</Project>

ModernKeePassLib/Serialization/HashedBlockStream.cs

@@ -21,7 +21,7 @@ using System;
 using System.IO;
 #if ModernKeePassLibPCL
 using System.Linq;
-using PCLCrypto;
+using Windows.Security.Cryptography;
 #else
 using System.Security.Cryptography;
 #endif
@@ -30,6 +30,7 @@ using System.Text;
 
 using ModernKeePassLibPCL.Native;
 using ModernKeePassLibPCL.Utility;
+using Windows.Security.Cryptography.Core;
 
 #if KeePassLibSD
 using KeePassLibSD;
@@ -251,13 +252,17 @@ namespace ModernKeePassLibPCL.Serialization
 			if(m_bVerify)
 			{
 #if ModernKeePassLibPCL
-				var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
-				var pbComputedHash = sha256.HashData(m_pbBuffer);
+                /*var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
+				var pbComputedHash = sha256.HashData(m_pbBuffer);*/
+                var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
+                var buffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(m_pbBuffer));
+                byte[] pbComputedHash;
+                CryptographicBuffer.CopyToByteArray(buffer, out pbComputedHash);
 #else
 				SHA256Managed sha256 = new SHA256Managed();
 				byte[] pbComputedHash = sha256.ComputeHash(m_pbBuffer);
 #endif
-				if((pbComputedHash == null) || (pbComputedHash.Length != 32))
+                if ((pbComputedHash == null) || (pbComputedHash.Length != 32))
 					throw new InvalidOperationException();
 
 				for(int iHashPos = 0; iHashPos < 32; ++iHashPos)
@@ -298,8 +303,12 @@ namespace ModernKeePassLibPCL.Serialization
 			if(m_nBufferPos > 0)
 			{
 #if ModernKeePassLibPCL
-				var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
-				var pbHash = sha256.HashData(m_pbBuffer.Where((x, i) => i < m_nBufferPos).ToArray());
+                /*var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
+				var pbHash = sha256.HashData(m_pbBuffer.Where((x, i) => i < m_nBufferPos).ToArray());*/
+                var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
+                var buffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(m_pbBuffer.Where((x, i) => i < m_nBufferPos).ToArray()));
+                byte[] pbHash;
+                CryptographicBuffer.CopyToByteArray(buffer, out pbHash);
 #else
 
 				SHA256Managed sha256 = new SHA256Managed();
@@ -320,7 +329,7 @@ namespace ModernKeePassLibPCL.Serialization
 
 #endif
 
-				m_bwOutput.Write(pbHash);
+                m_bwOutput.Write(pbHash);
 			}
 			else
 			{

ModernKeePassLib/Serialization/IOConnection.cs

@@ -34,7 +34,7 @@ using System.Security.Cryptography.X509Certificates;
 
 #if ModernKeePassLibPCL
 using Windows.Storage;
-using PCLStorage;
+//using PCLStorage;
 #endif
 using ModernKeePassLibPCL.Utility;
 
@@ -432,12 +432,12 @@ namespace ModernKeePassLibPCL.Serialization
 		private static Stream OpenReadLocal(IOConnectionInfo ioc)
 		{
 #if ModernKeePassLibPCL
-		    if (ioc.StorageFile != null)
-		    {
+		    /*if (ioc.StorageFile != null)
+		    {*/
 		        return ioc.StorageFile.OpenAsync(FileAccessMode.Read).GetResults().AsStream();
-		    }
+		    /*}
 		    var file = FileSystem.Current.GetFileFromPathAsync(ioc.Path).Result;
-			return file.OpenAsync(PCLStorage.FileAccess.Read).Result;
+			return file.OpenAsync(PCLStorage.FileAccess.Read).Result;*/
 #else
 			return new FileStream(ioc.Path, FileMode.Open, FileAccess.Read,
 				FileShare.Read);
@@ -478,12 +478,12 @@ namespace ModernKeePassLibPCL.Serialization
 		private static Stream OpenWriteLocal(IOConnectionInfo ioc)
 		{
 #if ModernKeePassLibPCL
-		    if (ioc.StorageFile != null)
-		    {
+		    /*if (ioc.StorageFile != null)
+		    {*/
 		        return ioc.StorageFile.OpenAsync(FileAccessMode.ReadWrite).GetResults().AsStream();
-		    }
+		    /*}
             var file = FileSystem.Current.GetFileFromPathAsync(ioc.Path).Result;
-			return file.OpenAsync(FileAccess.ReadAndWrite).Result;
+			return file.OpenAsync(FileAccess.ReadAndWrite).Result;*/
 #else
 			return new FileStream(ioc.Path, FileMode.Create, FileAccess.Write,
 				FileShare.None);
@@ -502,8 +502,9 @@ namespace ModernKeePassLibPCL.Serialization
 			RaiseIOAccessPreEvent(ioc, IOAccessType.Exists);
 
 #if ModernKeePassLibPCL
-			if(ioc.IsLocalFile())
-				return (FileSystem.Current.GetFileFromPathAsync(ioc.Path).Result != null);
+            /*if(ioc.IsLocalFile())
+				return (FileSystem.Current.GetFileFromPathAsync(ioc.Path).Result != null);*/
+            return ioc.StorageFile.IsAvailable;
 #else
 			if(ioc.IsLocalFile()) return File.Exists(ioc.Path);
 #endif
@@ -546,8 +547,8 @@ namespace ModernKeePassLibPCL.Serialization
 #if ModernKeePassLibPCL
 		    if (!ioc.IsLocalFile()) return;
 		    ioc.StorageFile?.DeleteAsync().GetResults();
-		    var file = FileSystem.Current.GetFileFromPathAsync(ioc.Path).Result;
-		    file.DeleteAsync().RunSynchronously();
+		    /*var file = FileSystem.Current.GetFileFromPathAsync(ioc.Path).Result;
+		    file.DeleteAsync().RunSynchronously();*/
 #else
 			if(ioc.IsLocalFile()) { File.Delete(ioc.Path); return; }
 #endif
@@ -587,8 +588,8 @@ namespace ModernKeePassLibPCL.Serialization
 #if ModernKeePassLibPCL
 		    if (!iocFrom.IsLocalFile()) return;
 		    iocFrom.StorageFile?.RenameAsync(iocTo.Path).GetResults();
-		    var file = FileSystem.Current.GetFileFromPathAsync(iocFrom.Path).Result;
-		    file.MoveAsync(iocTo.Path).RunSynchronously();
+            /*var file = FileSystem.Current.GetFileFromPathAsync(iocFrom.Path).Result;
+		    file.MoveAsync(iocTo.Path).RunSynchronously();*/
 #else
 			if(iocFrom.IsLocalFile()) { File.Move(iocFrom.Path, iocTo.Path); return; }
 #endif
@@ -629,18 +630,18 @@ namespace ModernKeePassLibPCL.Serialization
 			}
 #endif
 
-			// using(Stream sIn = IOConnection.OpenRead(iocFrom))
-			// {
-			//	using(Stream sOut = IOConnection.OpenWrite(iocTo))
-			//	{
-			//		MemUtil.CopyStream(sIn, sOut);
-			//		sOut.Close();
-			//	}
-			//
-			//	sIn.Close();
-			// }
-			// DeleteFile(iocFrom);
-		}
+            // using(Stream sIn = IOConnection.OpenRead(iocFrom))
+            // {
+            //	using(Stream sOut = IOConnection.OpenWrite(iocTo))
+            //	{
+            //		MemUtil.CopyStream(sIn, sOut);
+            //		sOut.Close();
+            //	}
+            //
+            //	sIn.Close();
+            // }
+            // DeleteFile(iocFrom);
+        }
 
 #if (!ModernKeePassLibPCL && !KeePassLibSD && !KeePassRT)
 		private static bool SendCommand(IOConnectionInfo ioc, string strMethod)
@@ -656,8 +657,8 @@ namespace ModernKeePassLibPCL.Serialization
 			return true;
 		}
 #endif
-
-		internal static void DisposeResponse(WebResponse wr, bool bGetStream)
+#if !ModernKeePassLibPCL
+        internal static void DisposeResponse(WebResponse wr, bool bGetStream)
 		{
 			if(wr == null) return;
 
@@ -674,8 +675,8 @@ namespace ModernKeePassLibPCL.Serialization
 			try { wr.Dispose(); }
 			catch(Exception) { Debug.Assert(false); }
 		}
-
-		public static byte[] ReadFile(IOConnectionInfo ioc)
+#endif
+        public static byte[] ReadFile(IOConnectionInfo ioc)
 		{
 			Stream sIn = null;
 			MemoryStream ms = null;

ModernKeePassLib/Serialization/IOConnectionInfo.cs

@@ -25,9 +25,9 @@ using System.Net;
 using System.ComponentModel;
 using System.Xml.Serialization;
 using System.Diagnostics;
-using Windows.Storage;
 #if ModernKeePassLibPCL
-using PCLStorage;
+using Windows.Storage;
+//using PCLStorage;
 #endif
 
 using ModernKeePassLibPCL.Interfaces;

ModernKeePassLib/Serialization/KdbxFile.Read.cs

@@ -24,7 +24,7 @@ using System.IO;
 using System.Diagnostics;
 using System.Security;
 #if ModernKeePassLibPCL
-using PCLCrypto;
+using Windows.Security.Cryptography;
 #else
 using System.Security.Cryptography;
 #endif
@@ -42,6 +42,7 @@ using ModernKeePassLibPCL.Interfaces;
 using ModernKeePassLibPCL.Keys;
 using ModernKeePassLibPCL.Resources;
 using ModernKeePassLibPCL.Utility;
+using Windows.Security.Cryptography.Core;
 
 namespace ModernKeePassLibPCL.Serialization
 {
@@ -221,13 +222,16 @@ namespace ModernKeePassLibPCL.Serialization
 			msHeader.Dispose();
 
 #if ModernKeePassLibPCL
-			var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
-			m_pbHashOfHeader = sha256.HashData(pbHeader);
+            /*var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
+			m_pbHashOfHeader = sha256.HashData(pbHeader);*/
+            var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
+            var buffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(pbHeader));
+            CryptographicBuffer.CopyToByteArray(buffer, out m_pbHashOfHeader);
 #else
 			SHA256Managed sha256 = new SHA256Managed();
 			m_pbHashOfHeader = sha256.ComputeHash(pbHeader);
 #endif
-		}
+        }
 
 		private bool ReadHeaderField(BinaryReaderEx brSource)
 		{
@@ -348,14 +352,18 @@ namespace ModernKeePassLibPCL.Serialization
 			ms.Write(pKey32, 0, 32);
 
 #if ModernKeePassLibPCL
-			var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
-			var aesKey = sha256.HashData(ms.ToArray());
+            /*var sha256 = WinRTCrypto.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithm.Sha256);
+			var aesKey = sha256.HashData(ms.ToArray());*/
+            var sha256 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
+            var buffer = sha256.HashData(CryptographicBuffer.CreateFromByteArray(ms.ToArray()));
+            byte[] aesKey;
+            CryptographicBuffer.CopyToByteArray(buffer, out aesKey);
 #else
 			SHA256Managed sha256 = new SHA256Managed();
 			byte[] aesKey = sha256.ComputeHash(ms.ToArray());
 #endif
 
-			ms.Dispose();
+            ms.Dispose();
 			Array.Clear(pKey32, 0, 32);
 
 			if((aesKey == null) || (aesKey.Length != 32))