public void Does_Hybrid_RSA_SHA512_AES_MasterKey_and_HmacSha256()
{
var request = new HelloSecure {
Name = "World"
};
var msgBytes = request.ToJson().ToUtf8Bytes();
byte[] masterKey, iv;
AesUtils.CreateKeyAndIv(out masterKey, out iv);
var sha512KeyBytes = masterKey.ToSha512HashBytes();
var cryptKey = new byte[sha512KeyBytes.Length / 2];
var authKey = new byte[sha512KeyBytes.Length / 2];
Buffer.BlockCopy(sha512KeyBytes, 0, cryptKey, 0, cryptKey.Length);
Buffer.BlockCopy(sha512KeyBytes, cryptKey.Length, authKey, 0, authKey.Length);
var encryptedBytes = AesUtils.Encrypt(msgBytes, cryptKey, iv);
var authEncryptedBytes = HmacUtils.Authenticate(encryptedBytes, authKey, iv);
var aesKeyNonceBytes = iv.Combine(masterKey);
var rsaEncAesKeyNonceBytes = RsaUtils.Encrypt(aesKeyNonceBytes, SecureConfig.PublicKeyXml);
var json = ValidateAndDecryptWithMasterKey(rsaEncAesKeyNonceBytes, authEncryptedBytes);
var fromJson = json.FromJson <HelloSecure>();
Assert.That(fromJson.Name, Is.EqualTo(request.Name));
}
public void Can_Send_Encrypted_Message()
{
var client = CreateClient();
var request = new HelloSecure {
Name = "World"
};
var aes = new AesManaged {
KeySize = AesUtils.KeySize
};
var aesKeyBytes = aes.Key.Combine(aes.IV);
var rsaEncAesKeyBytes = RsaUtils.Encrypt(aesKeyBytes, SecureConfig.PublicKeyXml);
var timestamp = DateTime.UtcNow.ToUnixTime();
var requestBody = timestamp + " POST " + typeof(HelloSecure).Name + " " + request.ToJson();
var encryptedMessage = new EncryptedMessage
{
EncryptedSymmetricKey = Convert.ToBase64String(rsaEncAesKeyBytes),
EncryptedBody = AesUtils.Encrypt(requestBody, aes.Key, aes.IV)
};
var encResponse = client.Post(encryptedMessage);
var responseJson = AesUtils.Decrypt(encResponse.EncryptedBody, aes.Key, aes.IV);
var response = responseJson.FromJson <HelloSecureResponse>();
Assert.That(response.Result, Is.EqualTo("Hello, World!"));
}
public void RsaTestFunction()
{
RsaKeys keys = RsaUtils.GenerateRsaKeys();
RsaTestObj obj = new RsaTestObj()
{
MyProperty = 9527,
MyPropertyList = new List <string> {
"9527", "HelloWorld"
}
};
var text = RsaUtils.Encrypt(keys.PublicKey, obj);
var newObj = RsaUtils.Decrypt <RsaTestObj>(keys.PrivateKey, text);
bool result = newObj != null &&
newObj.MyProperty == obj.MyProperty &&
newObj.MyPropertyList != null &&
newObj.MyPropertyList.Count == obj.MyPropertyList.Count;
if (result)
{
for (int i = 0; i < obj.MyPropertyList.Count; ++i)
{
var left = obj.MyPropertyList[i];
var right = newObj.MyPropertyList[i];
if (left != right)
{
result = false;
}
}
}
Assert.IsTrue(result);
}
public Reminder Encrypt(Reminder reminder)
{
reminder.UserName = RsaUtils.Encrypt(reminder.UserName);
reminder.Email = RsaUtils.Encrypt(reminder.Email);
reminder.CellPhone = RsaUtils.Encrypt(reminder.CellPhone);
return(reminder);
}
private Contact Encrypt(Contact contact)
{
contact.Name = RsaUtils.Encrypt(contact.Name);
contact.Email = RsaUtils.Encrypt(contact.Email);
contact.CellPhone = RsaUtils.Encrypt(contact.CellPhone);
return(contact);
}
public override void Configure(Container container)
{
RequestConverters.Add((req, requestDto) => {
var encRequest = requestDto as BasicEncryptedMessage;
if (encRequest == null)
{
return(null);
}
var requestType = Metadata.GetOperationType(encRequest.OperationName);
var decryptedJson = RsaUtils.Decrypt(encRequest.EncryptedBody, SecureConfig.PrivateKeyXml);
var request = JsonSerializer.DeserializeFromString(decryptedJson, requestType);
req.Items["_encrypt"] = encRequest;
return(request);
});
ResponseConverters.Add((req, response) => {
if (!req.Items.ContainsKey("_encrypt"))
{
return(null);
}
var encResponse = RsaUtils.Encrypt(response.ToJson(), SecureConfig.PublicKeyXml);
return(new BasicEncryptedMessageResponse
{
OperationName = response.GetType().Name,
EncryptedBody = encResponse
});
});
}
public void Does_throw_on_replayed_messages()
{
var client = CreateClient();
var request = new HelloSecure {
Name = "World"
};
byte[] cryptKey, iv;
AesUtils.CreateKeyAndIv(out cryptKey, out iv);
byte[] authKey = AesUtils.CreateKey();
var cryptAuthKeys = cryptKey.Combine(authKey);
var rsaEncCryptAuthKeys = RsaUtils.Encrypt(cryptAuthKeys, SecureConfig.PublicKeyXml);
var authRsaEncCryptAuthKeys = HmacUtils.Authenticate(rsaEncCryptAuthKeys, authKey, iv);
var timestamp = DateTime.UtcNow.ToUnixTime();
var requestBody = timestamp + " POST " + typeof(HelloSecure).Name + " " + request.ToJson();
var encryptedBytes = AesUtils.Encrypt(requestBody.ToUtf8Bytes(), cryptKey, iv);
var authEncryptedBytes = HmacUtils.Authenticate(encryptedBytes, authKey, iv);
var encryptedMessage = new EncryptedMessage
{
EncryptedSymmetricKey = Convert.ToBase64String(authRsaEncCryptAuthKeys),
EncryptedBody = Convert.ToBase64String(authEncryptedBytes),
};
var encResponse = client.Post(encryptedMessage);
try
{
client.Post(encryptedMessage);
Assert.Fail("Should throw");
}
catch (WebServiceException ex)
{
ex.StatusDescription.Print();
var errorResponse = (EncryptedMessageResponse)ex.ResponseDto;
authEncryptedBytes = Convert.FromBase64String(errorResponse.EncryptedBody);
if (!HmacUtils.Verify(authEncryptedBytes, authKey))
{
throw new Exception("EncryptedBody is Invalid");
}
var responseBytes = HmacUtils.DecryptAuthenticated(authEncryptedBytes, cryptKey);
var responseJson = responseBytes.FromUtf8Bytes();
var response = responseJson.FromJson <ErrorResponse>();
Assert.That(response.ResponseStatus.Message, Is.EqualTo("Nonce already seen"));
}
}
public void Can_Encryt_and_Decrypt_String()
{
var request = new HelloSecure {
Name = "World"
};
var requestJson = request.ToJson();
var encRequest = RsaUtils.Encrypt(requestJson, SecureConfig.PublicKeyXml);
var decJson = RsaUtils.Decrypt(encRequest, SecureConfig.PrivateKeyXml);
Assert.That(decJson, Is.EqualTo(requestJson));
}
private Account Encrypt(Account account)
{
account.Name = RsaUtils.Encrypt(account.Name);
if (account.IssuerBank != null && account.IssuerBank != "")
{
account.IssuerBank = RsaUtils.Encrypt(account.IssuerBank);
}
if (account.BankAccount != null && account.BankAccount != "")
{
account.BankAccount = RsaUtils.Encrypt(account.BankAccount);
}
return(account);
}
public void Can_Send_Encrypted_Message()
{
var client = CreateClient();
var request = new HelloSecure {
Name = "World"
};
byte[] cryptKey, authKey, iv;
AesUtils.CreateCryptAuthKeysAndIv(out cryptKey, out authKey, out iv);
var cryptAuthKeys = cryptKey.Combine(authKey);
var rsaEncCryptAuthKeys = RsaUtils.Encrypt(cryptAuthKeys, SecureConfig.PublicKeyXml);
var authRsaEncCryptAuthKeys = HmacUtils.Authenticate(rsaEncCryptAuthKeys, authKey, iv);
var timestamp = DateTime.UtcNow.ToUnixTime();
var requestBody = timestamp + " POST " + typeof(HelloSecure).Name + " " + request.ToJson();
var encryptedBytes = AesUtils.Encrypt(requestBody.ToUtf8Bytes(), cryptKey, iv);
var authEncryptedBytes = HmacUtils.Authenticate(encryptedBytes, authKey, iv);
var encryptedMessage = new EncryptedMessage
{
EncryptedSymmetricKey = Convert.ToBase64String(authRsaEncCryptAuthKeys),
EncryptedBody = Convert.ToBase64String(authEncryptedBytes),
};
var encResponse = client.Post(encryptedMessage);
authEncryptedBytes = Convert.FromBase64String(encResponse.EncryptedBody);
if (!HmacUtils.Verify(authEncryptedBytes, authKey))
{
throw new Exception("Invalid EncryptedBody");
}
var decryptedBytes = HmacUtils.DecryptAuthenticated(authEncryptedBytes, cryptKey);
var responseJson = decryptedBytes.FromUtf8Bytes();
var response = responseJson.FromJson <HelloSecureResponse>();
Assert.That(response.Result, Is.EqualTo("Hello, World!"));
}
public void Does_Hybrid_RSA_Crypt_and_Auth_AES_with_HMAC_SHA256()
{
var request = new HelloSecure {
Name = "World"
};
var timestamp = DateTime.UtcNow.ToUnixTime();
var msg = timestamp + " POST " + request.GetType().Name + " " + request.ToJson();
var msgBytes = msg.ToUtf8Bytes();
byte[] cryptKey, authKey, iv;
AesUtils.CreateCryptAuthKeysAndIv(out cryptKey, out authKey, out iv);
var encryptedBytes = AesUtils.Encrypt(msgBytes, cryptKey, iv);
var decryptedBytes = AesUtils.Decrypt(encryptedBytes, cryptKey, iv);
Assert.That(decryptedBytes, Is.EquivalentTo(msgBytes));
var authEncryptedBytes = HmacUtils.Authenticate(encryptedBytes, authKey, iv);
var cryptAuthKeys = cryptKey.Combine(authKey);
var rsaEncCryptAuthKeys = RsaUtils.Encrypt(cryptAuthKeys, SecureConfig.PublicKeyXml);
var authRsaEncCryptAuthKeys = HmacUtils.Authenticate(rsaEncCryptAuthKeys, authKey, iv);
var decryptedMsg = ValidateAndDecrypt(authRsaEncCryptAuthKeys, authEncryptedBytes);
var parts = decryptedMsg.SplitOnFirst(' ');
Assert.That(long.Parse(parts[0]), Is.EqualTo(timestamp));
parts = parts[1].SplitOnFirst(' ');
Assert.That(parts[0], Is.EqualTo("POST"));
parts = parts[1].SplitOnFirst(' ');
Assert.That(parts[0], Is.EqualTo(request.GetType().Name));
var decryptedJson = parts[1];
var decryptedRequest = decryptedJson.FromJson <HelloSecure>();
Assert.That(decryptedRequest.Name, Is.EqualTo(request.Name));
}
public void Can_Send_Encrypted_Message()
{
var client = new JsonServiceClient(Config.AbsoluteBaseUri);
var request = new HelloSecure {
Name = "World"
};
var encRequest = RsaUtils.Encrypt(request.ToJson(), SecureConfig.PublicKeyXml);
var encResponse = client.Post(new BasicEncryptedMessage
{
OperationName = typeof(HelloSecure).Name,
EncryptedBody = encRequest
});
var responseJson = RsaUtils.Decrypt(encResponse.EncryptedBody, SecureConfig.PrivateKeyXml);
var response = responseJson.FromJson <HelloSecureResponse>();
Assert.That(response.Result, Is.EqualTo("Hello, World!"));
}
public void Does_throw_on_replayed_messages()
{
var client = CreateClient();
var request = new HelloSecure {
Name = "World"
};
var aes = new AesManaged {
KeySize = AesUtils.KeySize
};
var aesKeyBytes = aes.Key.Combine(aes.IV);
var rsaEncAesKeyBytes = RsaUtils.Encrypt(aesKeyBytes, SecureConfig.PublicKeyXml);
var timestamp = DateTime.UtcNow.ToUnixTime();
var requestBody = timestamp + " POST " + typeof(HelloSecure).Name + " " + request.ToJson();
var encryptedMessage = new EncryptedMessage
{
EncryptedSymmetricKey = Convert.ToBase64String(rsaEncAesKeyBytes),
EncryptedBody = AesUtils.Encrypt(requestBody, aes.Key, aes.IV)
};
var encResponse = client.Post(encryptedMessage);
try
{
client.Post(encryptedMessage);
Assert.Fail("Should throw");
}
catch (WebServiceException ex)
{
ex.StatusDescription.Print();
var errorResponse = (EncryptedMessageResponse)ex.ResponseDto;
var responseJson = AesUtils.Decrypt(errorResponse.EncryptedBody, aes.Key, aes.IV);
var response = responseJson.FromJson <ErrorResponse>();
Assert.That(response.ResponseStatus.Message, Is.EqualTo("Nonce already seen"));
}
}
/// <summary>Check if the encryption was correct</summary>
/// <param name="file">The file to decrypt</param>
/// <param name="key">The key file</param>
/// <param name="error">A error to return</param>
/// <param name="path">The path for the new file</param>
/// <returns>True if is correct, otherwise false</returns>
private bool DidEncryption(HttpPostedFileBase file, HttpPostedFileBase key, ref string error, ref string path)
{
if (fileUtils.IsFileTypeCorrect(file, ".txt", ref error) && fileUtils.IsFileTypeCorrect(key, ".key", ref error))
{
string uploadedFile = fileUtils.SaveFile(file, "~/App_Data/Uploads");
string uploadedKey = fileUtils.SaveFile(key, "~/App_Data/Uploads");
RsaUtils rsa = new RsaUtils();
if (rsa.Encrypt(uploadedFile, uploadedKey, ref path))
{
return(true);
}
else
{
error = "Bad Encryption";
return(false);
}
}
else
{
return(false);
}
}
public void TestSign()
{
//2048 ¹«Ô¿
string publicKey =
"MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAoQh0wEqx/R2H1v00IU12Oc30fosRC/frhH89L6G+fzeaqI19MYQhEPMU13wpeqRONCUta+2iC1sgCNQ9qGGf19yGdZUfueaB1Nu9rdueQKXgVurGHJ+5N71UFm+OP1XcnFUCK4wT5d7ZIifXxuqLehP9Ts6sNjhVfa+yU+VjF5HoIe69OJEPo7OxRZcRTe17khc93Ic+PfyqswQJJlY/bgpcLJQnM+QuHmxNtF7/FpAx9YEQsShsGpVo7JaKgLo+s6AFoJ4QldQKir2vbN9vcKRbG3piElPilWDpjXQkOJZhUloh/jd7QrKFimZFldJ1r6Q59QYUyGKZARUe0KZpMQIDAQAB";
//2048 ˽Կ
string privateKey =
"MIIEpAIBAAKCAQEAoQh0wEqx/R2H1v00IU12Oc30fosRC/frhH89L6G+fzeaqI19MYQhEPMU13wpeqRONCUta+2iC1sgCNQ9qGGf19yGdZUfueaB1Nu9rdueQKXgVurGHJ+5N71UFm+OP1XcnFUCK4wT5d7ZIifXxuqLehP9Ts6sNjhVfa+yU+VjF5HoIe69OJEPo7OxRZcRTe17khc93Ic+PfyqswQJJlY/bgpcLJQnM+QuHmxNtF7/FpAx9YEQsShsGpVo7JaKgLo+s6AFoJ4QldQKir2vbN9vcKRbG3piElPilWDpjXQkOJZhUloh/jd7QrKFimZFldJ1r6Q59QYUyGKZARUe0KZpMQIDAQABAoIBAQCRZLUlOUvjIVqYvhznRK1OG6p45s8JY1r+UnPIId2Bt46oSLeUkZvZVeCnfq9k0Bzb8AVGwVPhtPEDh73z3dEYcT/lwjLXAkyPB6gG5ZfI/vvC/k7JYV01+neFmktw2/FIJWjEMMF2dvLNZ/Pm4bX1Dz9SfD/45Hwr8wqrvRzvFZsj5qqOxv9RPAudOYwCwZskKp/GF+L+3Ycod1Wu98imzMZUH+L5dQuDGg3kvf3ljIAegTPoqYBg0imNPYY/EGoFKnbxlK5S5/5uAFb16dGJqAz3XQCz9Is/IWrOTu0etteqV2Ncs8uqPdjed+b0j8CMsr4U1xjwPQ8WwdaJtTkRAoGBANAndgiGZkCVcc9975/AYdgFp35W6D+hGQAZlL6DmnucUFdXbWa/x2rTSEXlkvgk9X/PxOptUYsLJkzysTgfDywZwuIXLm9B3oNmv3bVgPXsgDsvDfaHYCgz0nHK6NSrX2AeX3yO/dFuoZsuk+J+UyRigMqYj0wjmxUlqj183hinAoGBAMYMOBgF77OXRII7GAuEut/nBeh2sBrgyzR7FmJMs5kvRh6Ck8wp3ysgMvX4lxh1ep8iCw1R2cguqNATr1klOdsCTOE9RrhuvOp3JrYzuIAK6MpH/uBICy4w1rW2+gQySsHcH40r+tNaTFQ7dQ1tef//iy/IW8v8i0t+csztE1JnAoGABdtWYt8FOYP688+jUmdjWWSvVcq0NjYeMfaGTOX/DsNTL2HyXhW/Uq4nNnBDNmAz2CjMbZwt0y+5ICkj+2REVQVUinAEinTcAe5+LKXNPx4sbX3hcrJUbk0m+rSu4G0B/f5cyXBsi9wFCAzDdHgBduCepxSr04Sc9Hde1uQQi7kCgYB0U20HP0Vh+TG2RLuE2HtjVDD2L/CUeQEiXEHzjxXWnhvTg+MIAnggvpLwQwmMxkQ2ACr5sd/3YuCpB0bxV5o594nsqq9FWVYBaecFEjAGlWHSnqMoXWijwu/6X/VOTbP3VjH6G6ECT4GR4DKKpokIQrMgZ9DzaezvdOA9WesFdQKBgQCWfeOQTitRJ0NZACFUn3Fs3Rvgc9eN9YSWj4RtqkmGPMPvguWo+SKhlk3IbYjrRBc5WVOdoX8JXb2/+nAGhPCuUZckWVmZe5pMSr4EkNQdYeY8kOXGSjoTOUH34ZdKeS+e399BkBWIiXUejX/Srln0H4KoHnTWgxwNpTsBCgXu8Q==";
var rsa = new RsaUtils(RSAType.RSA2, Encoding.UTF8, privateKey, publicKey);
string str = "²©¿ÍÔ° http://www.cnblogs.com/";
Console.WriteLine("Ôʼ×Ö·û´®£º" + str);
//¼ÓÃÜ
string enStr = rsa.Encrypt(str);
Console.WriteLine("¼ÓÃÜ×Ö·û´®£º" + enStr);
//½âÃÜ
string deStr = rsa.Decrypt(enStr);
Console.WriteLine("½âÃÜ×Ö·û´®£º" + deStr);
//˽ԿǩÃû
string signStr = rsa.Sign(str);
Console.WriteLine("×Ö·û´®Ç©Ãû£º" + signStr);
//¹«Ô¿Ñé֤ǩÃû
bool signVerify = rsa.Verify(str, signStr);
Console.WriteLine("Ñé֤ǩÃû£º" + signVerify);
Console.ReadKey();
Console.ReadKey(true);
}
public static string CreateEncryptedJweToken(JsonObject jwtPayload, RSAParameters publicKey)
{
//From: http://self-issued.info/docs/draft-ietf-jose-json-web-encryption-09.html#RSACBCExample
var jweHeader = new JsonObject
{
{ "alg", "RSA-OAEP" },
{ "enc", "A128CBC-HS256" },
{ "kid", Convert.ToBase64String(publicKey.Modulus).Substring(0, 3) },
};
var jweHeaderBase64Url = jweHeader.ToJson().ToUtf8Bytes().ToBase64UrlSafe();
var authKey = new byte[128 / 8];
var cryptKey = new byte[128 / 8];
var cryptAuthKeys256 = AesUtils.CreateKey();
Buffer.BlockCopy(cryptAuthKeys256, 0, authKey, 0, authKey.Length);
Buffer.BlockCopy(cryptAuthKeys256, authKey.Length, cryptKey, 0, cryptKey.Length);
var aes = Aes.Create();
aes.KeySize = 128;
aes.BlockSize = 128;
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
using (aes)
{
aes.GenerateIV();
var iv = aes.IV;
aes.Key = cryptKey;
var jweEncKey = RsaUtils.Encrypt(cryptAuthKeys256, publicKey, UseRsaKeyLength);
var jweEncKeyBase64Url = jweEncKey.ToBase64UrlSafe();
var ivBase64Url = iv.ToBase64UrlSafe();
var aad = jweHeaderBase64Url + "." + jweEncKeyBase64Url;
var aadBytes = aad.ToUtf8Bytes();
var payloadBytes = jwtPayload.ToJson().ToUtf8Bytes();
using (var cipherStream = MemoryStreamFactory.GetStream())
using (var encrypter = aes.CreateEncryptor(cryptKey, iv))
using (var cryptoStream = new CryptoStream(cipherStream, encrypter, CryptoStreamMode.Write))
using (var writer = new BinaryWriter(cryptoStream))
{
writer.Write(payloadBytes);
cryptoStream.FlushFinalBlock();
using (var hmac = new HMACSHA256(authKey))
using (var encryptedStream = MemoryStreamFactory.GetStream())
using (var bw = new BinaryWriter(encryptedStream))
{
bw.Write(aadBytes);
bw.Write(iv);
bw.Write(cipherStream.GetBuffer(), 0, (int)cipherStream.Length);
bw.Flush();
var tag = hmac.ComputeHash(encryptedStream.GetBuffer(), 0, (int)encryptedStream.Length);
var cipherTextBase64Url = cipherStream.ToBase64UrlSafe();
var tagBase64Url = tag.ToBase64UrlSafe();
var jweToken = jweHeaderBase64Url + "."
+ jweEncKeyBase64Url + "."
+ ivBase64Url + "."
+ cipherTextBase64Url + "."
+ tagBase64Url;
return(jweToken);
}
}
}
}
public static string Encrypt(string plainText, IDictionary <string, object> options)
{
var toEncrypt = plainText;
var encryptedText = string.Empty;
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
var decodeFromBase64 = options.ContainsKey("DecodeFromBase64") &&
Convert.ToBoolean(options["DecodeFromBase64"], CultureInfo.InvariantCulture);
var encodeToBase64 = options.ContainsKey("EncodeToBase64") && Convert.ToBoolean(options["EncodeToBase64"], CultureInfo.InvariantCulture);
var method = options.ContainsKey("Method") ? options["Method"].ToString() : string.Empty;
switch (method)
{
// RSA
case "RSA":
var publicKeyPath = options["PublicKeyPath"].ToString();
if (publicKeyPath.StartsWith("\"", StringComparison.InvariantCulture))
{
publicKeyPath = publicKeyPath.Substring(1, publicKeyPath.Length - 1);
}
if (publicKeyPath.EndsWith("\"", StringComparison.InvariantCulture))
{
publicKeyPath = publicKeyPath.Substring(0, publicKeyPath.Length - 1);
}
if (decodeFromBase64)
{
toEncrypt = GeneralUtils.Base64Decode(toEncrypt);
}
encryptedText = encodeToBase64 ? RsaUtils.EncryptAndBase64Encode(toEncrypt, publicKeyPath) : RsaUtils.Encrypt(toEncrypt, publicKeyPath);
break;
// AES
case "AES":
var key = options["key"].ToString();
var initializationValue = options["iniValue"].ToString();
encryptedText = encodeToBase64 ? AesUtils.EncryptAndBase64Encode(toEncrypt, key, initializationValue) : AesUtils.Encrypt(toEncrypt, key, initializationValue);
break;
// Base64
case "Base64":
encryptedText = GeneralUtils.Base64Encode(toEncrypt);
break;
// Hashing
case "Hashing":
switch (options["hashMethod"].ToString())
{
case "MD5":
// create new instance of MD5
var md5 = MD5.Create();
try
{
// convert the input text to array of bytes
var hashDataMd5 = md5.ComputeHash(Encoding.Default.GetBytes(toEncrypt));
// return hexadecimal string
encryptedText = BitConverter.ToString(hashDataMd5).Replace("-", string.Empty);
}
finally
{
md5.Dispose();
}
break;
case "SHA1":
// create new instance of SHA1
var sha1 = SHA1.Create();
try
{
// convert the input text to array of bytes
var hashDataSha1 = sha1.ComputeHash(Encoding.Default.GetBytes(toEncrypt));
// return hexadecimal string
encryptedText = BitConverter.ToString(hashDataSha1).Replace("-", string.Empty);
}
finally
{
sha1.Dispose();
}
break;
case "SHA2":
case "SHA256":
// create new instance of SHA256
var sha2 = SHA256.Create();
try
{
// convert the input text to array of bytes
var hashDataSha2 = sha2.ComputeHash(Encoding.Default.GetBytes(toEncrypt));
// return hexadecimal string
encryptedText = BitConverter.ToString(hashDataSha2).Replace("-", string.Empty);
}
finally
{
sha2.Dispose();
}
break;
}
break;
}
return(encryptedText);
}
