You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
167 lines
7.3 KiB
167 lines
7.3 KiB
using System;
|
|
using System.IO;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
|
|
namespace Swift.API.Common
|
|
{
|
|
public class EncryptDecryptUtility
|
|
{
|
|
protected static string saltValue = "K0r3@GM3";
|
|
protected static string hashAlgorithm = "SHA1";
|
|
protected static int passwordIterations = 5;
|
|
protected static string initVector = "P@s$w0rDGm3KoR3@";
|
|
protected static int keySize = 256;
|
|
|
|
/// <summary>
|
|
/// Encrypts specified plaintext using Rijndael symmetric key algorithm
|
|
/// and returns a base64-encoded result.
|
|
/// </summary>
|
|
/// <param name="plainText">Plain Text to Encrypt</param>
|
|
/// <param name="passPhrase">Pass Phrase to use in Password Generation</param>
|
|
/// <returns>Encrypted text encoded into Base 64 text format </returns>
|
|
public static string Encrypt(string plainText, string passPhrase)
|
|
{
|
|
// Convert strings into byte arrays.
|
|
// Let us assume that strings only contain ASCII codes.
|
|
// If strings include Unicode characters, use Unicode, UTF7, or UTF8
|
|
// encoding.
|
|
byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
|
|
byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);
|
|
|
|
// Convert our plaintext into a byte array.
|
|
// Let us assume that plaintext contains UTF8-encoded characters.
|
|
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
|
|
|
|
// First, we must create a password, from which the key will be derived.
|
|
// This password will be generated from the specified passphrase and
|
|
// salt value. The password will be created using the specified hash
|
|
// algorithm. Password creation can be done in several iterations.
|
|
var password = new PasswordDeriveBytes(
|
|
passPhrase,
|
|
saltValueBytes,
|
|
hashAlgorithm,
|
|
passwordIterations);
|
|
|
|
// Use the password to generate pseudo-random bytes for the encryption
|
|
// key. Specify the size of the key in bytes (instead of bits).
|
|
#pragma warning disable 618, 612
|
|
byte[] keyBytes = password.GetBytes(keySize / 8);
|
|
#pragma warning restore 618, 612
|
|
|
|
// Create uninitialized Rijndael encryption object.
|
|
var symmetricKey = new RijndaelManaged();
|
|
|
|
// It is reasonable to set encryption mode to Cipher Block Chaining
|
|
// (CBC). Use default options for other symmetric key parameters.
|
|
symmetricKey.Mode = CipherMode.CBC;
|
|
|
|
// Generate encryptor from the existing key bytes and initialization
|
|
// vector. Key size will be defined based on the number of the key
|
|
// bytes.
|
|
ICryptoTransform encryptor = symmetricKey.CreateEncryptor(
|
|
keyBytes,
|
|
initVectorBytes);
|
|
|
|
var memoryStream = new MemoryStream();
|
|
|
|
// Define memory stream which will be used to hold encrypted data.
|
|
var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write);
|
|
|
|
// Start encrypting.
|
|
cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
|
|
|
|
// Finish encrypting.
|
|
cryptoStream.FlushFinalBlock();
|
|
|
|
// Convert our encrypted data from a memory stream into a byte array.
|
|
byte[] cipherTextBytes = memoryStream.ToArray();
|
|
|
|
// Close both streams.
|
|
memoryStream.Close();
|
|
cryptoStream.Close();
|
|
|
|
// Convert encrypted data into a base64-encoded string.
|
|
string cipherText = Convert.ToBase64String(cipherTextBytes);
|
|
|
|
// Return encrypted string.
|
|
return cipherText;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Decrypts specified cipherText using Rijndael symmetric key algorithm
|
|
/// and returns a plain text result.
|
|
/// </summary>
|
|
/// <param name="cipherText">Encryted Text</param>
|
|
/// <param name="passPhrase">Pass Phrase used in Password Generation</param>
|
|
/// <returns></returns>
|
|
public static string Decrypt(string cipherText, string passPhrase)
|
|
{
|
|
// Convert strings defining encryption key characteristics into byte
|
|
// arrays. Let us assume that strings only contain ASCII codes.
|
|
// If strings include Unicode characters, use Unicode, UTF7, or UTF8
|
|
// encoding.
|
|
byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
|
|
byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);
|
|
|
|
// Convert our ciphertext into a byte array.
|
|
byte[] cipherTextBytes = Convert.FromBase64String(cipherText);
|
|
|
|
// First, we must create a password, from which the key will be
|
|
// derived. This password will be generated from the specified
|
|
// passphrase and salt value. The password will be created using
|
|
// the specified hash algorithm. Password creation can be done in
|
|
// several iterations.
|
|
var password = new PasswordDeriveBytes(
|
|
passPhrase,
|
|
saltValueBytes,
|
|
hashAlgorithm,
|
|
passwordIterations);
|
|
|
|
// Use the password to generate pseudo-random bytes for the encryption
|
|
// key. Specify the size of the key in bytes (instead of bits).
|
|
#pragma warning disable 618, 612
|
|
byte[] keyBytes = password.GetBytes(keySize / 8);
|
|
#pragma warning restore 618, 612
|
|
|
|
// Create uninitialized Rijndael encryption object.
|
|
var symmetricKey = new RijndaelManaged();
|
|
|
|
// It is reasonable to set encryption mode to Cipher Block Chaining
|
|
// (CBC). Use default options for other symmetric key parameters.
|
|
symmetricKey.Mode = CipherMode.CBC;
|
|
|
|
// Generate decryptor from the existing key bytes and initialization
|
|
// vector. Key size will be defined based on the number of the key
|
|
// bytes.
|
|
ICryptoTransform decryptor = symmetricKey.CreateDecryptor(
|
|
keyBytes,
|
|
initVectorBytes);
|
|
|
|
// Define memory stream which will be used to hold encrypted data.
|
|
var memoryStream = new MemoryStream(cipherTextBytes);
|
|
|
|
// Define cryptographic stream (always use Read mode for encryption).
|
|
var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read);
|
|
|
|
// Since at this point we don't know what the size of decrypted data
|
|
// will be, allocate the buffer long enough to hold ciphertext;
|
|
// plaintext is never longer than ciphertext.
|
|
var plainTextBytes = new byte[cipherTextBytes.Length];
|
|
|
|
// Start decrypting.
|
|
int decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
|
|
|
|
// Close both streams.
|
|
memoryStream.Close();
|
|
cryptoStream.Close();
|
|
|
|
// Convert decrypted data into a string.
|
|
// Let us assume that the original plaintext string was UTF8-encoded.
|
|
string plainText = Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);
|
|
|
|
// Return decrypted string.
|
|
return plainText;
|
|
}
|
|
}
|
|
}
|