/// <summary>
/// Decrypt the result received and retrieve it.
/// </summary>
/// <param name="idAlgo"></param>
/// <param name="result"></param>
/// <param name="key"></param>
/// <param name="size"></param>
/// <returns></returns>
public static string GetDecryptedResultManual(string idAlgo, string result, string key, int size)
{
if (result == ClassSeedNodeStatus.SeedNone || result == ClassSeedNodeStatus.SeedError)
{
return(result);
}
try
{
switch (idAlgo)
{
case ClassAlgoEnumeration.Rijndael:
if (ClassUtils.IsBase64String(result))
{
return(Rijndael.DecryptStringManual(result, key, size));
}
break;
case ClassAlgoEnumeration.Xor:
break;
}
}
catch (Exception erreur)
{
#if DEBUG
Debug.WriteLine("Error Decrypt of " + result + " with key: " + key + " : " + erreur.Message);
#endif
return(ClassAlgoErrorEnumeration.AlgoError);
}
return(ClassAlgoErrorEnumeration.AlgoError);
}
/// <summary>
/// Decrypt the result received and retrieve it.
/// </summary>
/// <param name="idAlgo"></param>
/// <param name="result"></param>
/// <param name="size"></param>
/// <param name="AesIv"></param>
/// <param name="AesSalt"></param>
/// <returns></returns>
public static string GetDecryptedResult(string idAlgo, string result, int size, byte[] AesIv, byte[] AesSalt)
{
if (result == ClassSeedNodeStatus.SeedNone || result == ClassSeedNodeStatus.SeedError)
{
return(result);
}
try
{
switch (idAlgo)
{
case ClassAlgoEnumeration.Rijndael:
if (ClassUtils.IsBase64String(result))
{
return(Rijndael.DecryptString(result, size, AesIv, AesSalt));
}
break;
case ClassAlgoEnumeration.Xor:
break;
}
}
catch (Exception erreur)
{
return(ClassAlgoErrorEnumeration.AlgoError);
}
return(ClassAlgoErrorEnumeration.AlgoError);
}
public static string CompressData(string data)
{
var byteData = ClassUtils.GetByteArrayFromString(data);
using (MemoryStream output = new MemoryStream())
{
using (DeflateStream dstream = new DeflateStream(output, CompressionMode.Compress))
{
dstream.Write(byteData, 0, byteData.Length);
}
return(Convert.ToBase64String(output.ToArray()));
}
}
public static string DecompressData(string data)
{
using (MemoryStream input = new MemoryStream(Convert.FromBase64String(data)))
{
using (MemoryStream output = new MemoryStream())
{
using (DeflateStream dstream = new DeflateStream(input, CompressionMode.Decompress))
{
dstream.CopyTo(output);
}
var outputData = output.ToArray();
return(ClassUtils.GetStringFromByteArray(outputData, outputData.Length));
}
}
}
public static string ConvertStringtoSHA512(string str)
{
var bytes = ClassUtils.GetByteArrayFromString(str);
using (var hash = SHA512.Create())
{
var hashedInputBytes = hash.ComputeHash(bytes);
var hashedInputStringBuilder = new StringBuilder(128);
foreach (var b in hashedInputBytes)
{
hashedInputStringBuilder.Append(b.ToString("X2"));
}
string hashToReturn = hashedInputStringBuilder.ToString();
hashedInputStringBuilder.Clear();
return(hashToReturn);
}
}
public static string FromHex(string hex)
{
var ba = ClassUtils.GetByteArrayFromString(hex);
return(BitConverter.ToString(ba).Replace("-", ""));
}
/// <summary>
/// Decrypt string with Rijndael.
/// </summary>
/// <param name="cipherText"></param>
/// <param name="passPhrase"></param>
/// <param name="keysize"></param>
/// <returns></returns>
public static string DecryptStringManual(string cipherText, string passPhrase, int keysize)
{
using (PasswordDeriveBytes password = new PasswordDeriveBytes(passPhrase, Encoding.UTF8.GetBytes(ClassUtils.FromHex(passPhrase.Substring(0, 8)))))
{
byte[] keyBytes = password.GetBytes(keysize / 8);
using (var symmetricKey = new AesCryptoServiceProvider()
{
Mode = CipherMode.CFB
})
{
byte[] initVectorBytes = password.GetBytes(16);
symmetricKey.BlockSize = 128;
symmetricKey.KeySize = keysize;
symmetricKey.Padding = PaddingMode.PKCS7;
symmetricKey.Key = keyBytes;
using (ICryptoTransform decryptor = symmetricKey.CreateDecryptor(keyBytes, initVectorBytes))
{
byte[] cipherTextBytes = Convert.FromBase64String(cipherText);
using (MemoryStream memoryStream = new MemoryStream(cipherTextBytes))
{
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
{
byte[] plainTextBytes = new byte[cipherTextBytes.Length];
int decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
return(Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount));
}
}
}
}
}
}
/// <summary>
/// Encrypt string from Rijndael.
/// </summary>
/// <param name="plainText"></param>
/// <param name="passPhrase"></param>
/// <param name="keysize"></param>
/// <returns></returns>
public static string EncryptStringManual(string plainText, string passPhrase, int keysize)
{
using (PasswordDeriveBytes password = new PasswordDeriveBytes(passPhrase, Encoding.UTF8.GetBytes(ClassUtils.FromHex(passPhrase.Substring(0, 8)))))
{
byte[] keyBytes = password.GetBytes(keysize / 8);
using (var symmetricKey = new AesCryptoServiceProvider()
{
Mode = CipherMode.CFB
})
{
byte[] initVectorBytes = password.GetBytes(16);
symmetricKey.BlockSize = 128;
symmetricKey.KeySize = keysize;
symmetricKey.Padding = PaddingMode.PKCS7;
symmetricKey.Key = keyBytes;
using (ICryptoTransform encryptor = symmetricKey.CreateEncryptor(keyBytes, initVectorBytes))
{
using (MemoryStream memoryStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
{
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
cryptoStream.FlushFinalBlock();
byte[] cipherTextBytes = memoryStream.ToArray();
return(Convert.ToBase64String(cipherTextBytes));
}
}
}
}
}
}
