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); }