public IBuffer Decrypt(IBuffer toDecryptBuffer, string key)
{
try
{
// Get the MD5 key hash (you can as well use the binary of the key string)
var keyHash = GetMD5Hash(key);
// Create a buffer that contains the encoded message to be decrypted.
// Open a symmetric algorithm provider for the specified algorithm.
SymmetricKeyAlgorithmProvider aes = SymmetricKeyAlgorithmProvider.OpenAlgorithm(AlgName);
// Create a symmetric key.
var symetricKey = aes.CreateSymmetricKey(keyHash);
IBuffer buffDecrypted = CryptographicEngine.Decrypt(symetricKey, toDecryptBuffer, null);
return(buffDecrypted);
}
catch (Exception)
{
throw;
}
}
public Task <byte[]> AesDecryptAsync(byte[] data, byte[] iv, byte[] key)
{
var provider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7);
var cryptoKey = provider.CreateSymmetricKey(key);
return(Task.FromResult(CryptographicEngine.Decrypt(cryptoKey, data, iv)));
}
internal static string DecryptThisCipher(string input, string pass)
{
SymmetricKeyAlgorithmProvider SAP = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7);
CryptographicKey AES;
HashAlgorithmProvider HAP = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
CryptographicHash Hash_AES = HAP.CreateHash();
string decrypted = "";
try
{
byte[] hash = new byte[32];
Hash_AES.Append(CryptographicBuffer.CreateFromByteArray(Encoding.UTF8.GetBytes(pass)));
byte[] temp;
CryptographicBuffer.CopyToByteArray(Hash_AES.GetValueAndReset(), out temp);
Array.Copy(temp, 0, hash, 0, 16);
Array.Copy(temp, 0, hash, 15, 16);
AES = SAP.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(hash));
IBuffer Buffer = CryptographicBuffer.DecodeFromBase64String(input);
byte[] Decrypted;
CryptographicBuffer.CopyToByteArray(CryptographicEngine.Decrypt(AES, Buffer, null), out Decrypted);
decrypted = Encoding.UTF8.GetString(Decrypted, 0, Decrypted.Length);
return(decrypted);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
return(null);
}
}
private string AesDecrypt(string encryptionKey, string value)
{
if (string.IsNullOrEmpty(value))
{
return(value);
}
IBuffer passwordBuffer = CryptographicBuffer.ConvertStringToBinary(encryptionKey, BinaryStringEncoding.Utf8);
IBuffer saltBuffer = CryptographicBuffer.CreateFromByteArray(new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 });
KeyDerivationAlgorithmProvider keyDerivationProvider = KeyDerivationAlgorithmProvider.OpenAlgorithm(KeyDerivationAlgorithmNames.Pbkdf2Sha1);
KeyDerivationParameters pbkdf2Parms = KeyDerivationParameters.BuildForPbkdf2(saltBuffer, 1000);
CryptographicKey keyOriginal = keyDerivationProvider.CreateKey(passwordBuffer);
IBuffer keyMaterial = CryptographicEngine.DeriveKeyMaterial(keyOriginal, pbkdf2Parms, 32);
CryptographicKey derivedPwKey = keyDerivationProvider.CreateKey(passwordBuffer);
IBuffer ivBuffer = CryptographicEngine.DeriveKeyMaterial(derivedPwKey, pbkdf2Parms, 16);
SymmetricKeyAlgorithmProvider aes = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7);
CryptographicKey aesKey = aes.CreateSymmetricKey(keyMaterial);
IBuffer decryptedContentBuffer = CryptographicEngine.Decrypt(aesKey, CryptographicBuffer.DecodeFromBase64String(value), ivBuffer);
return(CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, decryptedContentBuffer));
}
public static string AesDecrypt(this byte[] encrypted, string password, string salt)
{
IBuffer pwBuffer = CryptographicBuffer.ConvertStringToBinary(password, BinaryStringEncoding.Utf8);
IBuffer saltBuffer = CryptographicBuffer.ConvertStringToBinary(salt, BinaryStringEncoding.Utf16LE);
IBuffer cipherBuffer = CryptographicBuffer.CreateFromByteArray(encrypted);
// Derive key material for password size 32 bytes for AES256 algorithm
KeyDerivationAlgorithmProvider keyDerivationProvider = Windows.Security.Cryptography.Core.KeyDerivationAlgorithmProvider.OpenAlgorithm("PBKDF2_SHA1");
// using salt and 1000 iterations
KeyDerivationParameters pbkdf2Parms = KeyDerivationParameters.BuildForPbkdf2(saltBuffer, 1000);
// create a key based on original key and derivation parmaters
CryptographicKey keyOriginal = keyDerivationProvider.CreateKey(pwBuffer);
IBuffer keyMaterial = CryptographicEngine.DeriveKeyMaterial(keyOriginal, pbkdf2Parms, 32);
CryptographicKey derivedPwKey = keyDerivationProvider.CreateKey(pwBuffer);
// derive buffer to be used for encryption salt from derived password key
IBuffer saltMaterial = CryptographicEngine.DeriveKeyMaterial(derivedPwKey, pbkdf2Parms, 16);
// display the keys – because KeyDerivationProvider always gets cleared after each use, they are very similar unforunately
string keyMaterialString = CryptographicBuffer.EncodeToBase64String(keyMaterial);
string saltMaterialString = CryptographicBuffer.EncodeToBase64String(saltMaterial);
SymmetricKeyAlgorithmProvider symProvider = SymmetricKeyAlgorithmProvider.OpenAlgorithm("AES_CBC_PKCS7");
// create symmetric key from derived password material
CryptographicKey symmKey = symProvider.CreateSymmetricKey(keyMaterial);
// encrypt data buffer using symmetric key and derived salt material
IBuffer resultBuffer = CryptographicEngine.Decrypt(symmKey, cipherBuffer, saltMaterial);
string result = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf16LE, resultBuffer);
return(result);
}
public static byte[] AES_Decrypt(byte[] input, byte[] pass)
{
SymmetricKeyAlgorithmProvider SAP = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7);
CryptographicKey AES;
HashAlgorithmProvider HAP = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
CryptographicHash Hash_AES = HAP.CreateHash();
//string decrypted = "";
//try
//{
byte[] hash = new byte[32];
Hash_AES.Append(CryptographicBuffer.CreateFromByteArray(pass));
byte[] temp;
CryptographicBuffer.CopyToByteArray(Hash_AES.GetValueAndReset(), out temp);
Array.Copy(temp, 0, hash, 0, 16); //key1
Array.Copy(temp, 0, hash, 15, 16); //key2
AES = SAP.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(hash));
//IBuffer Buffer = CryptographicBuffer.DecodeFromBase64String(input);
IBuffer Buffer = CryptographicBuffer.CreateFromByteArray(input);
byte[] Decrypted;
CryptographicBuffer.CopyToByteArray(CryptographicEngine.Decrypt(AES, Buffer, null), out Decrypted);
//decrypted = System.Text.Encoding.UTF8.GetString(Decrypted, 0, Decrypted.Length);
return(Decrypted);
//}
//catch (Exception ex)
//{
// return null;
//}
}
// method to decrypt ciphertext of AES key
public async void asymmetricDecryptAESKeySender(
String strAsymmetricAlgName,
IBuffer buffEncryptedAESKey)
{
// Open the algorithm provider for the specified asymmetric algorithm.
AsymmetricKeyAlgorithmProvider objAsymmAlgProv = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(strAsymmetricAlgName);
CryptographicKey pair = objAsymmAlgProv.ImportKeyPair(DataContainer.senderKeyPair);
try
{
// Use the private key embedded in the key pair to decrypt the session key.
keyMaterialSender = CryptographicEngine.Decrypt(pair, buffEncryptedAESKey, null);
}
catch (System.ArgumentException ar)
{
Debug.WriteLine(ar.ToString());
var dialog = new MessageDialog("Error: Key Mismatch. Unable to display new messages.");
await dialog.ShowAsync();
// CoreApplication.Exit();
}
//convert to string
keyMaterialStringSender = CryptographicBuffer.EncodeToBase64String(keyMaterialSender);
}
/***
* This function decrypts the encrypted text to plain text using the key
* provided. You'll have to use the same key which you used during
* encryption
*
* @param _encryptedText
* Encrypted/Cipher text to be decrypted
* @param _key
* Encryption key which you used during encryption
*/
private string encryptDecrypt(string _inputText, string _encryptionKey, EncryptMode _mode, string _initVector)
{
SymmetricKeyAlgorithmProvider aesCbcPkcs7 = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7);
// Creata a 16 byte initialization vector
IBuffer iv = CryptographicBuffer.ConvertStringToBinary(_initVector, BinaryStringEncoding.Utf8);
// Create an AES 128-bit (16 byte) key
IBuffer keyMaterial = CryptographicBuffer.ConvertStringToBinary(_encryptionKey, BinaryStringEncoding.Utf8);
CryptographicKey key = aesCbcPkcs7.CreateSymmetricKey(keyMaterial);
if (_mode.Equals(EncryptMode.ENCRYPT))
{
// Encrypt the data
IBuffer plainText = CryptographicBuffer.ConvertStringToBinary(_inputText, BinaryStringEncoding.Utf8);
IBuffer cipherText = CryptographicEngine.Encrypt(key, plainText, iv);
string strEncrypted64 = CryptographicBuffer.EncodeToBase64String(cipherText);
return(strEncrypted64);
}
else
{
// Decrypt the data
IBuffer cipherText = CryptographicBuffer.DecodeFromBase64String(_inputText);
IBuffer decryptedText = CryptographicEngine.Decrypt(key, cipherText, iv);
return(CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, decryptedText));
}
}
async public void Decrypt()
{
CryptographicKey cryptographicKey = null;
FileOpenPicker fileOpenPicker = new FileOpenPicker();
fileOpenPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
fileOpenPicker.FileTypeFilter.Add("*");
StorageFile file = await fileOpenPicker.PickSingleFileAsync();
IBuffer bufferPrivateKey = await FileIO.ReadBufferAsync(file);
AsymmetricKeyAlgorithmProvider provider = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithmNames.RsaPkcs1);
try { cryptographicKey = provider.ImportKeyPair(bufferPrivateKey); }
catch (Exception er) {
}
try { decryptedkey = CryptographicEngine.Decrypt(cryptographicKey, buffEncryptedSessionKey, null); }
catch (Exception er)
{
ContentDialog contentDialog = new ContentDialog();
contentDialog.Title = "Wrong private key";
contentDialog.Content = "Try another private key";
contentDialog.CloseButtonText = "Ok";
await contentDialog.ShowAsync();
}
T8.Text = "Decrypted Key Base64: " + CryptographicBuffer.EncodeToBase64String(decryptedkey);
T9.Text = "Decrypted Key BaseHex: " + CryptographicBuffer.EncodeToHexString(decryptedkey);
}
/// <summary>
/// WPRT的RSA私钥解密
/// </summary>
/// <param name="rawData"></param>
/// <returns></returns>
public static string PrivateDecrypt(string rawData)
{
try
{
/*将文本转换成IBuffer*/
IBuffer bufferRawData = CryptographicBuffer.ConvertStringToBinary(rawData, BinaryStringEncoding.Utf8);
/*加密算法提供程序*/
AsymmetricKeyAlgorithmProvider provider = AsymmetricKeyAlgorithmProvider.OpenAlgorithm
(AsymmetricAlgorithmNames.RsaPkcs1);
/*导入私钥*/
string PRIVATE_KEY = "MIICXAIBAAKBgQCJIYvV7IEzHOm4vdgu8RWc9it09ggXCKNAMEtcQM4kXT1mQyEnbEeGVYOyJWTd2jVhpToxMQ4r9p9EKd1bMClAA/KhUjQC/l9YdS3MFAZC65V47Bx6CTad4bZo1E1D6x1rOjQe4lANxWnApwY4QPYGFxEmQD3yNyErh38VlNL2GQIDAQABAoGAFxGmpZFI1uFpTCPbx2HVQfeDrgRprf5NAFJfiyB3zVRGLPrkC+7CRY4DPqfdxRidXFTgakAXYzv05RGp5FpAxf1GBAR6HQxVcntBpNqJUo2UBP+IrXgPFDPdodAl9SWgaHKwc79pCARVdJutm86kRRsy5rjcWpR8HQCYWzk/lmUCQQDcRnenz6CAhMvztS04APlly3uhvLGIVsXkGdsmv7JltRvFmZ/1MqpvAbC6WrzFMlWeFgYz6EyBiqfH6m4CbdJbAkEAn18K40E3r9WzPlbhIAEs2SiY68iZGCmzR/0n6PR48NtFSGsSDRIR632oeftBPfN7W4+kUIehL2gt9RgnRH8bmwJBAJMYK4dQSyoHg/q2nf+sBt9HRsP2sccNyxBLg+EYWhU5H9aQhBTFRLLkOhP3y98TgcETjAjVs2E+KlSB4/yTQckCQH4axVG23CptDQyp0C7z3xnh7sa7DrC45lxzK25Aa6YhyruXxUvEXZuZ7YK/1gsAKz7y9RCnkVoitCK4vvGLJjsCQBbzsW7HwZVe5RMiRsjxX7v0Ng4NnM85tnX0GUmkpuixOpfcq3PsZo7ujcBvJ5IJvbXo4QuuIRKSmxItHI26tkI=";
CryptographicKey privateKey = provider.ImportKeyPair(CryptographicBuffer.DecodeFromBase64String(PRIVATE_KEY));
//解密
IBuffer result = CryptographicEngine.Decrypt(privateKey, bufferRawData, null);
byte[] res;
CryptographicBuffer.CopyToByteArray(result, out res);
return(Encoding.UTF8.GetString(res, 0, res.Length));
}
catch (Exception)
{
return(rawData);
}
}
/// <summary>
/// Aes解密函数
/// </summary>
/// <param name="str">密文</param>
/// <param name="key">密钥</param>
/// <returns>解密结果</returns>
public static string DecryptString(string str, string key)
{
if (string.IsNullOrEmpty(str))
{
return(null);
}
if (string.IsNullOrEmpty(key))
{
return(null);
}
if (key.Length != 32)
{
return(null);
}
try
{
SymmetricKeyAlgorithmProvider provider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7);
IBuffer buffDecrypt = CryptographicBuffer.DecodeFromBase64String(str);
IBuffer buffKey = CryptographicBuffer.ConvertStringToBinary(key, BinaryStringEncoding.Utf8);
CryptographicKey cKey = provider.CreateSymmetricKey(buffKey);
IBuffer buffResult = CryptographicEngine.Decrypt(cKey, buffDecrypt, null);
string strResult = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, buffResult);
return(strResult);
}
catch (Exception)
{
return(null);
}
}
public static byte[] DecryptAES(byte[] source, string publicKey)
{
if (source == null || source.Length == 0)
{
throw new ArgumentNullException("source");
}
if (string.IsNullOrEmpty(publicKey))
{
throw new ArgumentNullException("publicKey");
}
try
{
var str = Convert.ToBase64String(source);
IBuffer toDecryptBuffer = CryptographicBuffer.DecodeFromBase64String(str);
SymmetricKeyAlgorithmProvider aes = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7);
var symetricKey = aes.CreateSymmetricKey(GetMD5Hash(publicKey));
var buffDecrypted = CryptographicEngine.Decrypt(symetricKey, toDecryptBuffer, null);
byte[] result;
CryptographicBuffer.CopyToByteArray(buffDecrypted, out result);
return(result);
}
catch (Exception ex)
{
return(null);
}
}
private static string Decrypt(String strMsg)
{
Byte[] bb = Convert.FromBase64String(strMsg);
IBuffer buffEncrypt = CryptographicEngine.Decrypt(Key, bb.AsBuffer(), IV.AsBuffer());
return(CryptographicBuffer.ConvertBinaryToString(encoding, buffEncrypt));
}
private void GetTokenResponse(object Sender, IqResultEventArgs e)
{
object[] P = (object[])e.State;
#if WINDOWS_UWP
Certificate Certificate = (Certificate)P[0];
#else
X509Certificate2 Certificate = (X509Certificate2)P[0];
#endif
XmlElement E = e.FirstElement;
if (e.Ok && E != null && E.LocalName == "getTokenChallenge" && E.NamespaceURI == NamespaceProvisioningToken)
{
int SeqNr = XML.Attribute(E, "seqnr", 0);
string Challenge = E.InnerText;
byte[] Bin = System.Convert.FromBase64String(Challenge);
#if WINDOWS_UWP
CryptographicKey Key = PersistedKeyProvider.OpenPublicKeyFromCertificate(Certificate,
Certificate.SignatureHashAlgorithmName, CryptographicPadding.RsaPkcs1V15);
IBuffer Buffer = CryptographicBuffer.CreateFromByteArray(Bin);
Buffer = CryptographicEngine.Decrypt(Key, Buffer, null);
CryptographicBuffer.CopyToByteArray(Buffer, out Bin);
string Response = System.Convert.ToBase64String(Bin);
#else
Bin = Certificate.GetRSAPrivateKey().Decrypt(Bin, RSAEncryptionPadding.Pkcs1);
string Response = System.Convert.ToBase64String(Bin);
#endif
this.client.SendIqGet(this.provisioningServerAddress, "<getTokenChallengeResponse xmlns='" + NamespaceProvisioningToken + "' seqnr='" +
SeqNr.ToString() + "'>" + Response + "</getTokenChallengeResponse>",
this.GetTokenChallengeResponse, P);
}
}
/// <summary>
/// Decrypts a message using a symmetric algorithm.
/// </summary>
private static void SymmetricDecrypt(
TcpChannelToken token,
ArraySegment <byte> dataToDecrypt,
bool useClientKeys)
{
// get the decrypting key.
CryptographicKey decryptingKey = (useClientKeys) ? token.ClientEncryptor : token.ServerEncryptor;
IBuffer IV = (useClientKeys) ? CryptographicBuffer.CreateFromByteArray(token.ClientInitializationVector) : CryptographicBuffer.CreateFromByteArray(token.ServerInitializationVector);
if (decryptingKey == null)
{
throw ServiceResultException.Create(StatusCodes.BadSecurityChecksFailed, "Token missing symmetric key object.");
}
SymmetricKeyAlgorithmProvider AesCbcProvider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbc);
if (dataToDecrypt.Count % AesCbcProvider.BlockLength != 0)
{
throw ServiceResultException.Create(StatusCodes.BadSecurityChecksFailed, "Input data is not an even number of encryption blocks.");
}
byte[] blockToDecrypt = new byte[dataToDecrypt.Count];
Array.ConstrainedCopy(dataToDecrypt.Array, dataToDecrypt.Offset, blockToDecrypt, 0, dataToDecrypt.Count);
IBuffer block = CryptographicBuffer.CreateFromByteArray(blockToDecrypt);
IBuffer encryptedBuffer = CryptographicEngine.Decrypt(decryptingKey, block, IV);
CryptographicBuffer.CopyToByteArray(encryptedBuffer, out blockToDecrypt);
Array.ConstrainedCopy(blockToDecrypt, 0, dataToDecrypt.Array, dataToDecrypt.Offset, dataToDecrypt.Count);
}
public byte[] Decrypt(byte[] buffer)
{
#if WINDOWS_STORE
SymmetricKeyAlgorithmProvider provider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7);
CryptographicKey aes = provider.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(this.key));
IBuffer result = CryptographicEngine.Decrypt(aes, CryptographicBuffer.CreateFromByteArray(buffer), CryptographicBuffer.CreateFromByteArray(this.iv));
byte[] decrypted;
CryptographicBuffer.CopyToByteArray(result, out decrypted);
return(decrypted);
#else
using (System.Security.Cryptography.Aes aes = AesManaged.Create())
{
aes.KeySize = 256;
aes.Mode = CipherMode.CBC;
aes.IV = iv;
aes.Key = key;
using (ICryptoTransform decryptor = aes.CreateDecryptor())
{
return(decryptor.TransformFinalBlock(buffer, 0, buffer.Length));
}
}
#endif
}
public int dbEncrypt(String partition, int size, String data, out String dataOut)
{
SymmetricKeyAlgorithmProvider SAP = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7);
CryptographicKey AES;
HashAlgorithmProvider HAP = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
CryptographicHash Hash_AES = HAP.CreateHash();
try{
byte[] hash = new byte[32];
Hash_AES.Append(CryptographicBuffer.CreateFromByteArray(System.Text.Encoding.UTF8.GetBytes(partition)));
byte[] temp;
CryptographicBuffer.CopyToByteArray(Hash_AES.GetValueAndReset(), out temp);
Array.Copy(temp, 0, hash, 0, 16);
Array.Copy(temp, 0, hash, 15, 16);
AES = SAP.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(hash));
Windows.Storage.Streams.IBuffer Buffer = CryptographicBuffer.DecodeFromBase64String(data);
byte[] Decrypted;
CryptographicBuffer.CopyToByteArray(CryptographicEngine.Decrypt(AES, Buffer, null), out Decrypted);
dataOut = System.Text.Encoding.UTF8.GetString(Decrypted, 0, Decrypted.Length);
}
catch (Exception ex)
{
dataOut = "";
return(getErrorCode() == 0 ? 1 : 0);
}
return(getErrorCode() == 0 ? 1 : 0);
}
private byte[] DecryptBytesInternal(string data, byte[] iv)
{
var algo = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7);
var key = algo.CreateSymmetricKey(TextEncoding.GetBytes(_secretKey));
return(CryptographicEngine.Decrypt(key, Convert.FromBase64String(data), iv));
}
/// <summary>
/// Decrypts a string in Unicode
/// </summary>
/// <param name="encryptedData">An encrypted string in Unicode</param>
/// <returns>The decrypted string in Unicode</returns>
public string Decrypt(string encryptedData)
{
var encryptedBinaryData = Encoding.Unicode.GetBytes(encryptedData).AsBuffer();
var decryptedData = CryptographicEngine.Decrypt(cryptographicKey, encryptedBinaryData, null);
return(Encoding.Unicode.GetString(decryptedData.ToArray()));
}
//Decrypts Data (Always using private key)
public static string Decrypt(String strAsymmetricAlgName, IBuffer buffPrivateKeyStorage, string encryptedMessage)
{
// Open the algorithm provider for the specified asymmetric algorithm.
AsymmetricKeyAlgorithmProvider objAsymmAlgProv = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(strAsymmetricAlgName);
// Import the public key from a buffer. You should keep your private key
// secure. For the purposes of this example, however, the private key is
// just stored in a static class variable.
CryptographicKey keyPair = objAsymmAlgProv.ImportKeyPair(buffPrivateKeyStorage);
//Convert message String to IBuffer
IBuffer convertedString = CryptographicBuffer.DecodeFromBase64String(encryptedMessage);
IBuffer buffDecryptedMessage;
try {
// Use the private key embedded in the key pair to decrypt the session key.
buffDecryptedMessage = CryptographicEngine.Decrypt(keyPair, convertedString, null);
} catch (System.ArgumentException) {
string invalidDecryptionMessage = "INVALID DECRYPTION KEY";
return(invalidDecryptionMessage);
}
//Return decrpyted message as a string
string decryptedMessage = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, buffDecryptedMessage);
return(decryptedMessage);
}
public static string AES_Decrypt(string input, string pass)
{
SymmetricKeyAlgorithmProvider sap = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7);
CryptographicKey aes;
HashAlgorithmProvider hap = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
CryptographicHash hash_AES = hap.CreateHash();
string decrypted = "";
try
{
byte[] hash = new byte[32];
hash_AES.Append(CryptographicBuffer.CreateFromByteArray(System.Text.Encoding.UTF8.GetBytes(pass)));
byte[] temp;
CryptographicBuffer.CopyToByteArray(hash_AES.GetValueAndReset(), out temp);
Array.Copy(temp, 0, hash, 0, 16);
Array.Copy(temp, 0, hash, 15, 16);
aes = sap.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(hash));
IBuffer Buffer = CryptographicBuffer.DecodeFromBase64String(input);
byte[] Decrypted;
CryptographicBuffer.CopyToByteArray(CryptographicEngine.Decrypt(aes, Buffer, null), out Decrypted);
decrypted = Encoding.UTF8.GetString(Decrypted, 0, Decrypted.Length);
return(decrypted);
}
catch
{
return(null);
}
}
public async Task <byte[]> DecryptBytes(byte[] cipherText, byte[] key, byte[] iv)
{
// Check arguments.
if (cipherText == null || cipherText.Length <= 0)
{
throw new ArgumentNullException(Constants.SCipherText);
}
if (key == null || key.Length <= 0)
{
throw new ArgumentNullException(Constants.Key);
}
if (iv == null || iv.Length <= 0)
{
throw new ArgumentNullException(Constants.IV);
}
IBuffer keyBuffer = key.AsBuffer(0, key.Length);
IBuffer ivBuffer = iv.AsBuffer(0, iv.Length);
IBuffer encrypted = cipherText.AsBuffer(0, cipherText.Length);
SymmetricKeyAlgorithmProvider symmetricAlgorithm = SymmetricKeyAlgorithmProvider.OpenAlgorithm("AES_CBC_PKCS7");
CryptographicKey cryptoKey2 = symmetricAlgorithm.CreateSymmetricKey(keyBuffer);
IBuffer decrypted = CryptographicEngine.Decrypt(cryptoKey2, encrypted, ivBuffer);
byte[] decryptedBytes = decrypted.ToArray(0, (int)decrypted.Length);
return(await Task.Run(() => decryptedBytes));
}
/// <summary>
/// The decrypt asymmetric.
/// </summary>
/// <param name="message">
/// The message.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
private string DecryptAsymmetric(string message)
{
IBuffer messageData = CryptographicBuffer.DecodeFromBase64String(message);
var decryptedMessage = CryptographicEngine.Decrypt(this.keyPair, messageData, null);
return(CryptographicBuffer.ConvertBinaryToString(Encoding, decryptedMessage));
}
public string Decrypt(string metaStr)
{
#region metaStr_buffer
var metaStr_buffer = CryptographicBuffer.DecodeFromHexString(metaStr);
#endregion
#region _Key
var _SymmetricKeyAlgorithmProvider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbc);
var _Key = _SymmetricKeyAlgorithmProvider.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(this._key));
#endregion
#region IV_buffer
var IV_buffer = CryptographicBuffer.CreateFromByteArray(_iv);
#endregion
IBuffer _result_buffer = CryptographicEngine.Decrypt(_Key, metaStr_buffer, IV_buffer);
byte[] dat = new byte[256];
CryptographicBuffer.CopyToByteArray(_result_buffer, out dat);
#region rebuild string
List <byte> list_byte = new List <byte>();
for (int i = 0; i < dat.Count(); i++)
{
if (dat[i] != 0)
{
list_byte.Add(dat[i]);
}
}
#endregion
return(Encoding.UTF8.GetString(list_byte.ToArray()));
}
/// <summary>
/// Decrypts a data buffer.
/// </summary>
/// <param name="buffer">
/// The data buffer to decrypt.
/// </param>
/// <returns>
/// Returns the decrypted data.
/// </returns>
public async Task <IBuffer> DecryptAsync(IBuffer buffer)
{
if (this.KeyBuffer == null)
{
throw new InvalidOperationException("Cannot encrypt data before Initialize has been called.");
}
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
return(await Task.Run(
() =>
{
try
{
var aes = SymmetricKeyAlgorithmProvider.OpenAlgorithm(this.encryptionAlgorithm);
var key = this.KeyBuffer;
var cryptoKey = aes.CreateSymmetricKey(key);
var decrypted = CryptographicEngine.Decrypt(cryptoKey, buffer, null);
return decrypted;
}
catch (Exception ex)
{
throw new DataEncryptException("Failed to decrypt data.", ex);
}
}));
}
public static string AES_Decrypt(String EncryptedText, String DecryptionKey)
{
string decrypted = "";
SymmetricKeyAlgorithmProvider SAP = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7);
HashAlgorithmProvider HAP = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
CryptographicHash Hash_AES = HAP.CreateHash();
try
{
//byte[] KeyBytes = System.Text.Encoding.UTF8.GetBytes(password);
byte[] KeyBytes16 = new byte[16];
Hash_AES.Append(CryptographicBuffer.CreateFromByteArray(System.Text.Encoding.UTF8.GetBytes(DecryptionKey)));
byte[] KeyBytes;
CryptographicBuffer.CopyToByteArray(Hash_AES.GetValueAndReset(), out KeyBytes);
for (int i = 0; i < KeyBytes.Length; i++)
{
KeyBytes16[i] = KeyBytes[i];
}
CryptographicKey key = SAP.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(KeyBytes16));
IBuffer Buffer = CryptographicBuffer.DecodeFromBase64String(EncryptedText);
byte[] Decrypted;
CryptographicBuffer.CopyToByteArray(CryptographicEngine.Decrypt(key, Buffer, null), out Decrypted);
decrypted = System.Text.Encoding.UTF8.GetString(Decrypted, 0, Decrypted.Length);
return(decrypted);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
return("Error in Decryption:With Aes ");
}
}
public Task <byte[]> RsaDecryptAsync(byte[] data, byte[] privateKey, CryptoHashAlgorithm algorithm)
{
var provider = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(ToAsymmetricAlgorithm(algorithm));
var cryptoKey = provider.ImportKeyPair(privateKey, CryptographicPrivateKeyBlobType.Pkcs8RawPrivateKeyInfo);
return(Task.FromResult(CryptographicEngine.Decrypt(cryptoKey, data)));
}
public static string CipherDecryption(
string strAlgName,
IBuffer buffEncrypt,
IBuffer iv,
BinaryStringEncoding encoding,
CryptographicKey key)
{
// Declare a buffer to contain the decrypted data.
IBuffer buffDecrypted;
// Open an symmetric algorithm provider for the specified algorithm.
SymmetricKeyAlgorithmProvider objAlg = SymmetricKeyAlgorithmProvider.OpenAlgorithm(strAlgName);
// The input key must be securely shared between the sender of the encrypted message
// and the recipient. The initialization vector must also be shared but does not
// need to be shared in a secure manner. If the sender encodes a message string
// to a buffer, the binary encoding method must also be shared with the recipient.
buffDecrypted = CryptographicEngine.Decrypt(key, buffEncrypt, iv);
// Convert the decrypted buffer to a string (for display). If the sender created the
// original message buffer from a string, the sender must tell the recipient what
// BinaryStringEncoding value was used. Here, BinaryStringEncoding.Utf8 is used to
// convert the message to a buffer before encryption and to convert the decrypted
// buffer back to the original plaintext.
return(CryptographicBuffer.ConvertBinaryToString(encoding, buffDecrypted));
}
/// <summary>
/// Decrypt a string using dual encryption method. Return a Decrypted clear string
/// </summary>
/// <param name="cipherString">Encrypted string</param>
/// <param name="key">Unique key for encryption/decryption</param>
/// <returns>Returns decrypted text.</returns>
public static string DecryptString(string cipherString, string key)
{
try
{
// Get the MD5 key hash (you can as well use the binary of the key string)
var keyHash = GetMD5HashKey(key);
// Create a buffer that contains the encoded message to be decrypted.
IBuffer toDecryptBuffer = CryptographicBuffer.DecodeFromBase64String(cipherString);
// Open a symmetric algorithm provider for the specified algorithm.
SymmetricKeyAlgorithmProvider aes = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7);
// Create a symmetric key.
var symetricKey = aes.CreateSymmetricKey(keyHash);
var buffDecrypted = CryptographicEngine.Decrypt(symetricKey, toDecryptBuffer, null);
string strDecrypted = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, buffDecrypted);
return(strDecrypted);
}
catch (Exception ex)
{
// MetroEventSource.Log.Error(ex.Message);
//throw;
return("");
}
}
/// <summary>
/// Used internally to handle the decryption
/// </summary>
/// <param name="buffEncrypt"></param>
/// <returns></returns>
private string CipherDecryption(IBuffer buffEncrypt)
{
IBuffer buffDecrypted;
buffDecrypted = CryptographicEngine.Decrypt(key, buffEncrypt, iv);
return(CryptographicBuffer.ConvertBinaryToString(encoding, buffDecrypted));
}
