// Use this for initialization
void Start () {
Rfc2898DeriveBytes PBKDF2_hash = new Rfc2898DeriveBytes("qwerty", Encoding.ASCII.GetBytes("rm4fSDh0sofK"), 20000);
HMACSHA256 HMACSHA256_hash = new HMACSHA256();
//System.Text.Encoding.UTF8.GetString(bytes);
string hPassword = Convert.ToBase64String(PBKDF2_hash.GetBytes(32));
Debug.Log("Hash = " + hPassword);
//Debug.Log("Password hash" + Encoding.ASCII.GetString(PBKDF2.GetBytes(256)));
//PBKDF2.Salt =
/*string password = "******";
string hPassword = ComputeHash(password, new SHA256CryptoServiceProvider());
Debug.Log("Hash from: " + password + " = " + hPassword);*/
}
public static string GenerateUrlToken(string controllerName, string actionName, RouteValueDictionary argumentParams, string password)
{
//// The URL hash is dynamic by assign a dynamic key in each session. So
//// eventhough your URL is stolen, it will not work in other session
if (HttpContext.Current.Session["url_dynamickey"] == null)
{
HttpContext.Current.Session["url_dynamickey"] = RandomString();
}
// The salt include the dynamic session key and valid for an hour.
var salt = HttpContext.Current.Session["url_dynamickey"] + DateTime.Now.ToShortDateString() + " " + DateTime.Now.Hour;
// generating the partial url
var stringToToken = controllerName + "/" + actionName + "/";
stringToToken = argumentParams.Where(item => item.Key != "controller" && item.Key != "action" && item.Key != "urltoken").Aggregate(stringToToken, (current, item) => current + (item.Value));
// Converting the salt in to a byte array
var saltValueBytes = System.Text.Encoding.ASCII.GetBytes(salt);
// Encrypt the salt bytes with the password
var key = new Rfc2898DeriveBytes(password, saltValueBytes);
// get the key bytes from the above process
var secretKey = key.GetBytes(16);
// generate the hash
var tokenHash = new HMACSHA1(secretKey);
tokenHash.ComputeHash(System.Text.Encoding.ASCII.GetBytes(stringToToken));
// convert the hash to a base64string
var token = Convert.ToBase64String(tokenHash.Hash).Replace("/", "_");
return token;
}
public static byte[] Encrypt(byte[] data, string password)
{
byte[] result = null;
byte[] passwordBytes = Encoding.Default.GetBytes(password);
using (MemoryStream ms = new MemoryStream())
{
using (RijndaelManaged AES = new RijndaelManaged())
{
AES.KeySize = keySize;
AES.BlockSize = 128;
var key = new Rfc2898DeriveBytes(passwordBytes, salt, 1000);
AES.Key = key.GetBytes(AES.KeySize / 8);
AES.IV = key.GetBytes(AES.BlockSize / 8);
AES.Mode = CipherMode.CBC;
using (var cs = new CryptoStream(ms, AES.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(data, 0, data.Length);
cs.Close();
}
result = ms.ToArray();
}
}
return result;
}
public static byte[] AES_Encrypt(byte[] bytesToBeEncrypted, byte[] passwordBytes)
{
byte[] encryptedBytes = null;
// Set your salt here, change it to meet your flavor:
// The salt bytes must be at least 8 bytes.
byte[] saltBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
using (MemoryStream ms = new MemoryStream())
{
using (RijndaelManaged AES = new RijndaelManaged())
{
AES.KeySize = 256;
AES.BlockSize = 128;
var key = new Rfc2898DeriveBytes(passwordBytes, saltBytes, 1000);
AES.Key = key.GetBytes(AES.KeySize / 8);
AES.IV = key.GetBytes(AES.BlockSize / 8);
AES.Mode = CipherMode.CBC;
using (var cs = new CryptoStream(ms, AES.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(bytesToBeEncrypted, 0, bytesToBeEncrypted.Length);
cs.Close();
}
encryptedBytes = ms.ToArray();
}
}
return encryptedBytes;
//end public byte[] AES_Encrypt
}
public static string Encrypt(string clearText)
{
byte[] clearBytes = System.Text.Encoding.Unicode.GetBytes(clearText);
Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(_Pwd, _Salt);
byte[] encryptedData = Encrypt(clearBytes, pdb.GetBytes(32), pdb.GetBytes(16));
return Convert.ToBase64String(encryptedData);
}
//This method is to decrypt the password given by user.
public static string Decrypt(string data, string password)
{
if (String.IsNullOrEmpty(data))
throw new ArgumentException("No data given");
if (String.IsNullOrEmpty(password))
throw new ArgumentException("No password given");
byte[] rawData = Convert.FromBase64String(data.Replace(" ", "+"));
if (rawData.Length < 8)
throw new ArgumentException("Invalid input data");
// setup the decryption algorithm
byte[] salt = new byte[8];
for (int i = 0; i < salt.Length; i++)
salt[i] = rawData[i];
Rfc2898DeriveBytes keyGenerator = new Rfc2898DeriveBytes(password, salt);
TripleDES tdes = TripleDES.Create();
//Rijndael aes = Rijndael.Create();
tdes.IV = keyGenerator.GetBytes(tdes.BlockSize / 8);
tdes.Key = keyGenerator.GetBytes(tdes.KeySize / 8);
// decrypt the data
using (MemoryStream memoryStream = new MemoryStream())
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, tdes.CreateDecryptor(), CryptoStreamMode.Write))
{
cryptoStream.Write(rawData, 8, rawData.Length - 8);
cryptoStream.Close();
byte[] decrypted = memoryStream.ToArray();
return Encoding.Unicode.GetString(decrypted);
}
}
public static string Encrypt(this string text, string lKey)
{
try
{
using (Aes aes = new AesManaged())
{
Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(Encoding.UTF8.GetString(IVa, 0, IVa.Length), Encoding.UTF8.GetBytes(lKey));
aes.Key = deriveBytes.GetBytes(128 / 8);
aes.IV = aes.Key;
using (MemoryStream encryptionStream = new MemoryStream())
{
using (CryptoStream encrypt = new CryptoStream(encryptionStream, aes.CreateEncryptor(), CryptoStreamMode.Write))
{
byte[] cleanText = Encoding.UTF8.GetBytes(text);
encrypt.Write(cleanText, 0, cleanText.Length);
encrypt.FlushFinalBlock();
}
byte[] encryptedData = encryptionStream.ToArray();
string encryptedText = Convert.ToBase64String(encryptedData);
return encryptedText;
}
}
}
catch
{
return String.Empty;
}
}
internal static SecurePassword GetSaltHash(string password) {
Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(password, 20);
byte[] salt = deriveBytes.Salt;
byte[] pass = deriveBytes.GetBytes(20);
return new SecurePassword(Convert.ToBase64String(pass), Convert.ToBase64String(salt));
}
public static string Decrypt(string cipherText)
{
byte[] cipherBytes = Convert.FromBase64String(cipherText);
Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(_Pwd, _Salt);
byte[] decryptedData = Decrypt(cipherBytes, pdb.GetBytes(32), pdb.GetBytes(16));
return System.Text.Encoding.Unicode.GetString(decryptedData);
}
internal static bool DecryptFile(string inputPath, string outputPath, string password)
{
var input = new FileStream(inputPath, FileMode.Open, FileAccess.Read);
var output = new FileStream(outputPath, FileMode.OpenOrCreate, FileAccess.Write);
// Essentially, if you want to use RijndaelManaged as AES you need to make sure that:
// 1.The block size is set to 128 bits
// 2.You are not using CFB mode, or if you are the feedback size is also 128 bits
RijndaelManaged algorithm = new RijndaelManaged {KeySize = 256, BlockSize = 128};
algorithm.Mode = CipherMode.CBC;
var key = new Rfc2898DeriveBytes(password, Encoding.ASCII.GetBytes(Salt));
algorithm.Key = key.GetBytes(algorithm.KeySize/8);
algorithm.IV = key.GetBytes(algorithm.BlockSize/8);
try
{
using (var decryptedStream = new CryptoStream(output, algorithm.CreateDecryptor(), CryptoStreamMode.Write))
{
CopyStream(input, decryptedStream);
return true;
}
}
catch (CryptographicException)
{
throw new InvalidDataException("Please supply a correct password");
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private static byte[] PBKDF2(string password, byte[] salt, int interations,
int outputBytes)
{
Rfc2898DeriveBytes pbkdf2 = new Rfc2898DeriveBytes(password, salt);
pbkdf2.IterationCount = interations;
return pbkdf2.GetBytes(outputBytes);
}
//This method is to encrypt the password given by user.
public static string Encrypt(string data, string password)
{
if (String.IsNullOrEmpty(data))
throw new ArgumentException("No data given");
if (String.IsNullOrEmpty(password))
throw new ArgumentException("No password given");
// setup the encryption algorithm
Rfc2898DeriveBytes keyGenerator = new Rfc2898DeriveBytes(password, 8);
TripleDES tdes = TripleDES.Create();
//Rijndael aes = Rijndael.Create();
tdes.IV = keyGenerator.GetBytes(tdes.BlockSize / 8);
tdes.Key = keyGenerator.GetBytes(tdes.KeySize / 8);
// encrypt the data
byte[] rawData = Encoding.Unicode.GetBytes(data);
using (MemoryStream memoryStream = new MemoryStream())
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, tdes.CreateEncryptor(), CryptoStreamMode.Write))
{
memoryStream.Write(keyGenerator.Salt, 0, keyGenerator.Salt.Length);
cryptoStream.Write(rawData, 0, rawData.Length);
cryptoStream.Close();
byte[] encrypted = memoryStream.ToArray();
return Convert.ToBase64String(encrypted);
}
}
public static string Decrypt(this string text, string lKey)
{
try
{
using (Aes aes = new AesManaged())
{
Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(Encoding.UTF8.GetString(IVa, 0, IVa.Length), Encoding.UTF8.GetBytes(lKey));
aes.Key = deriveBytes.GetBytes(128 / 8);
aes.IV = aes.Key;
using (MemoryStream decryptionStream = new MemoryStream())
{
using (CryptoStream decrypt = new CryptoStream(decryptionStream, aes.CreateDecryptor(), CryptoStreamMode.Write))
{
byte[] encryptedData = Convert.FromBase64String(text);
decrypt.Write(encryptedData, 0, encryptedData.Length);
decrypt.Flush();
}
byte[] decryptedData = decryptionStream.ToArray();
string decryptedText = Encoding.UTF8.GetString(decryptedData, 0, decryptedData.Length);
return decryptedText;
}
}
}
catch
{
return String.Empty;
}
}
public bool TryDecrypt(string encryptedItem, string password, out string decryptedItem)
{
if (string.IsNullOrEmpty (encryptedItem) ||
string.IsNullOrEmpty (password)) {
decryptedItem = "";
return false;
}
try {
byte[] cipherBytes = Convert.FromBase64String (encryptedItem);
using (var memoryStream = new MemoryStream(cipherBytes)) {
var des = new DESCryptoServiceProvider ();
byte[] iv = new byte[8];
memoryStream.Read (iv, 0, iv.Length);
var rfc2898DeriveBytes = new Rfc2898DeriveBytes (password, iv, ITERATIONS);
byte[] key = rfc2898DeriveBytes.GetBytes (8);
using (var cryptoStream = new CryptoStream(memoryStream, des.CreateDecryptor(key, iv), CryptoStreamMode.Read))
using (var streamReader = new StreamReader(cryptoStream)) {
decryptedItem = streamReader.ReadToEnd ();
return true;
}
}
} catch (Exception ex) {
Logger.instance.Log (new Logger.Message (this, ex));
decryptedItem = "";
return false;
}
}
public string Encrypt(string item, string password)
{
if (item == null) {
throw new ArgumentNullException ("item");
}
if (string.IsNullOrEmpty (password)) {
throw new ArgumentNullException ("password");
}
var des = new DESCryptoServiceProvider ();
des.GenerateIV ();
var rfc2898DeriveBytes = new Rfc2898DeriveBytes (password, des.IV, ITERATIONS);
byte[] key = rfc2898DeriveBytes.GetBytes (8);
using (var memoryStream = new MemoryStream()) {
using (var cryptoStream = new CryptoStream(memoryStream, des.CreateEncryptor(key, des.IV), CryptoStreamMode.Write)) {
memoryStream.Write (des.IV, 0, des.IV.Length);
byte[] bytes = Encoding.UTF8.GetBytes (item);
cryptoStream.Write (bytes, 0, bytes.Length);
cryptoStream.FlushFinalBlock ();
return Convert.ToBase64String (memoryStream.ToArray ());
}
}
}
public byte[] encrypt(string plainText, string ivCode16, string pass8, string salt8)
{
var num = 256;
var bytes = Encoding.ASCII.GetBytes(ivCode16);
var rfc2898DeriveBytes = new Rfc2898DeriveBytes(pass8, Encoding.ASCII.GetBytes(salt8));
var bytes2 = rfc2898DeriveBytes.GetBytes(num/8);
return encryptStringToBytes_AES(plainText, bytes2, bytes);
}
public string decrypt(byte[] cipherText, string ivCode16, string pass8, string salt8)
{
var num = 256;
var bytes = Encoding.ASCII.GetBytes(ivCode16);
var rfc2898DeriveBytes = new Rfc2898DeriveBytes(pass8, Encoding.ASCII.GetBytes(salt8));
var bytes2 = rfc2898DeriveBytes.GetBytes(num/8);
return decryptStringFromBytes_AES(cipherText, bytes2, bytes);
}
public static string DecryptPasswordMD5(string cipherText, string p_strSaltValue)
{
string strReturn = string.Empty;
try
{
byte[] initVectorBytes = null;
initVectorBytes = System.Text.Encoding.ASCII.GetBytes(m_strInitVector);
byte[] saltValueBytes = null;
saltValueBytes = System.Text.Encoding.ASCII.GetBytes(p_strSaltValue);
byte[] cipherTextBytes = null;
cipherTextBytes = Convert.FromBase64String(cipherText.ToString());
Rfc2898DeriveBytes password = default(Rfc2898DeriveBytes);
password = new Rfc2898DeriveBytes(m_strPassPhrase, saltValueBytes, m_strPasswordIterations);
//
byte[] keyBytes = null;
int intKeySize = 0;
//Integer
intKeySize = Convert.ToInt32((m_intKeySize / 8));
keyBytes = password.GetBytes(intKeySize);
System.Security.Cryptography.RijndaelManaged symmetricKey = null;
symmetricKey = new System.Security.Cryptography.RijndaelManaged();
symmetricKey.Mode = System.Security.Cryptography.CipherMode.CBC;
System.Security.Cryptography.ICryptoTransform decryptor = null;
decryptor = symmetricKey.CreateDecryptor(keyBytes, initVectorBytes);
System.IO.MemoryStream memoryStream = null;
memoryStream = new System.IO.MemoryStream(cipherTextBytes);
System.Security.Cryptography.CryptoStream cryptoStream = null;
cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, decryptor, System.Security.Cryptography.CryptoStreamMode.Read);
byte[] plainTextBytes = null;
plainTextBytes = new byte[cipherTextBytes.Length + 1];
int decryptedByteCount = 0;
decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
memoryStream.Close();
cryptoStream.Close();
string plainText = null;
plainText = System.Text.Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);
strReturn = plainText;
}
catch (Exception ex)
{
strReturn = null;
}
return strReturn;
}
static KeyGen()
{
//We create the Rfc2898DerveBytes once as Rfc2898DeriveBytes uses a pseudo-random number generator based on HMACSHA1.
rfcKeyGen = new Rfc2898DeriveBytes(seedToUse, SALT);
//When calling GetBytes it initializes a new instance of HMAC, Later calls to GetBytes does not need to do this.
key = rfcKeyGen.GetBytes(32);
//Generate Initialization Vector - This will be less expensive as we have already intialized Rfc2898DeriveBytes
initVector = rfcKeyGen.GetBytes(16);
}
static MyHelper()
{
//We create the Rfc2898DerveBytes once as
//Rfc2898DeriveBytes uses a pseudo-random number generator based on HMACSHA1.
//When calling GetBytes it initializes a new instance of HMAC which takes some time.
//Subsequent calls to GetBytes does not need to do this initialization.
keyGenerator = new Rfc2898DeriveBytes(ENCRYPTION_KEY, SALT);
key = keyGenerator.GetBytes(32);
//Generate Initialization Vector - This will be less expensive as we have already intialized Rfc2898DeriveBytes
iv = keyGenerator.GetBytes(16);
}
private ICryptoTransform InitDecrypt(string a_key)
{
byte[] keyBytes = Encoding.Unicode.GetBytes(a_key);
Rfc2898DeriveBytes derivedKey = new Rfc2898DeriveBytes(a_key, keyBytes);
RijndaelManaged rijndaelCSP = new RijndaelManaged();
rijndaelCSP.Key = derivedKey.GetBytes(rijndaelCSP.KeySize / 8);
rijndaelCSP.IV = derivedKey.GetBytes(rijndaelCSP.BlockSize / 8);
ICryptoTransform decryptor = rijndaelCSP.CreateDecryptor();
rijndaelCSP.Clear();
return decryptor;
}
/// <summary>
/// Decrypt the given string. Assumes the string was encrypted using
/// EncryptStringAES(), using an identical sharedSecret.
/// </summary>
/// <param name="cipherText">The text to decrypt.</param>
/// <param name="sharedSecret">A password used to generate a key for decryption.</param>
public static string DecryptStringAES( string cipherText, string sharedSecret )
{
if ( string.IsNullOrEmpty( cipherText ) )
throw new ArgumentNullException( "cipherText" );
if ( string.IsNullOrEmpty( sharedSecret ) )
throw new ArgumentNullException( "sharedSecret" );
// Declare the RijndaelManaged object
// used to decrypt the data.
RijndaelManaged aesAlg = null;
// Declare the string used to hold
// the decrypted text.
string plaintext = null;
try
{
// generate the key from the shared secret and the salt
Rfc2898DeriveBytes key = new Rfc2898DeriveBytes( sharedSecret, _salt );
// Create the streams used for decryption.
byte[] bytes = Convert.FromBase64String( cipherText );
using ( MemoryStream msDecrypt = new MemoryStream( bytes ) )
{
// Create a RijndaelManaged object
// with the specified key and IV.
aesAlg = new RijndaelManaged();
aesAlg.Key = key.GetBytes( aesAlg.KeySize / 8 );
// Get the initialization vector from the encrypted stream
aesAlg.IV = ReadByteArray( msDecrypt );
// Create a decrytor to perform the stream transform.
ICryptoTransform decryptor = aesAlg.CreateDecryptor( aesAlg.Key, aesAlg.IV );
using ( CryptoStream csDecrypt = new CryptoStream( msDecrypt, decryptor, CryptoStreamMode.Read ) )
{
using ( StreamReader srDecrypt = new StreamReader( csDecrypt ) )
// Read the decrypted bytes from the decrypting stream
// and place them in a string.
plaintext = srDecrypt.ReadToEnd();
}
}
}
finally
{
// Clear the RijndaelManaged object.
if ( aesAlg != null )
aesAlg.Clear();
}
return plaintext;
}
public static SqlString HashPassword(string password)
{
if (password == null) throw new ArgumentNullException("password");
byte[] salt;
byte[] bytes;
Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, 16, 1000);
salt = rfc2898DeriveBytes.Salt;
bytes = rfc2898DeriveBytes.GetBytes(32);
byte[] array = new byte[49];
Buffer.BlockCopy(salt, 0, array, 1, 16);
Buffer.BlockCopy(bytes, 0, array, 17, 32);
return new SqlString(Convert.ToBase64String(array));
}
public static string Decrypt(string encryptedText)
{
byte[] cipherTextBytes = Convert.FromBase64String(encryptedText);
byte[] keyBytes = new Rfc2898DeriveBytes(PasswordHash, Encoding.ASCII.GetBytes(SaltKey)).GetBytes(256 / 8);
var symmetricKey = new RijndaelManaged() { Mode = CipherMode.CBC, Padding = PaddingMode.None };
var decryptor = symmetricKey.CreateDecryptor(keyBytes, Encoding.ASCII.GetBytes(VIKey));
var memoryStream = new MemoryStream(cipherTextBytes);
var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read);
byte[] plainTextBytes = new byte[cipherTextBytes.Length];
int decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
memoryStream.Close();
cryptoStream.Close();
return Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount).TrimEnd("\0".ToCharArray());
}
public bool TryDecrypt(string cipherText, string password, out string plainText)
{
// its pointless trying to decrypt if the cipher text
// or password has not been supplied
if (string.IsNullOrEmpty(cipherText) ||
string.IsNullOrEmpty(password))
{
plainText = "";
return false;
}
try
{
byte[] cipherBytes = Convert.FromBase64String(cipherText);
using (var memoryStream = new MemoryStream(cipherBytes))
{
// create instance of the DES crypto provider
var des = new DESCryptoServiceProvider();
// get the IV
byte[] iv = new byte[8];
memoryStream.Read(iv, 0, iv.Length);
// use derive bytes to generate key from password and IV
var rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, iv, Iterations);
byte[] key = rfc2898DeriveBytes.GetBytes(8);
using (var cryptoStream = new CryptoStream(memoryStream, des.CreateDecryptor(key, iv), CryptoStreamMode.Read))
using (var streamReader = new StreamReader(cryptoStream))
{
plainText = streamReader.ReadToEnd();
return true;
}
}
}
catch (Exception ex)
{
// TODO: log exception
Console.WriteLine(ex);
plainText = "";
return false;
}
}
public string Encrypt(string plainText, string password)
{
if (plainText == null)
{
throw new ArgumentNullException("plainText");
}
if (string.IsNullOrEmpty(password))
{
throw new ArgumentNullException("password");
}
// generate a random IV will be used a salt value for generating key
cryptoProvider.GenerateIV();
// use derive bytes to generate a key from the password and IV
var rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, cryptoProvider.IV, Iterations);
// generate a key from the password provided
if (SecurePlayerPrefs.useAES)
{
keyBytes = 16;
}
else
{
keyBytes = 8;
}
byte[] key = rfc2898DeriveBytes.GetBytes(keyBytes);
// encrypt the plainText
using (var memoryStream = new MemoryStream())
using (var cryptoStream = new CryptoStream(memoryStream, cryptoProvider.CreateEncryptor(key, cryptoProvider.IV), CryptoStreamMode.Write))
{
// write the salt first not encrypted
memoryStream.Write(cryptoProvider.IV, 0, cryptoProvider.IV.Length);
// convert the plain text string into a byte array
byte[] bytes = Encoding.UTF8.GetBytes(plainText);
// write the bytes into the crypto stream so that they are encrypted bytes
cryptoStream.Write(bytes, 0, bytes.Length);
cryptoStream.FlushFinalBlock();
return Convert.ToBase64String(memoryStream.ToArray());
}
}
public string Decrypt(string cipherText)
{
byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
byte[] cipherTextBytes = Convert.FromBase64String(cipherText);
//PasswordDeriveBytes password = new PasswordDeriveBytes(passPhrase, null);
Rfc2898DeriveBytes password = new Rfc2898DeriveBytes(passPhrase, System.Text.Encoding.UTF8.GetBytes(salt));
byte[] keyBytes = password.GetBytes(keysize / 8);
RijndaelManaged symmetricKey = new RijndaelManaged();
symmetricKey.Mode = CipherMode.CBC;
ICryptoTransform decryptor = symmetricKey.CreateDecryptor(keyBytes, initVectorBytes);
MemoryStream memoryStream = new MemoryStream(cipherTextBytes);
CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read);
byte[] plainTextBytes = new byte[cipherTextBytes.Length];
int decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
memoryStream.Close();
cryptoStream.Close();
return Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);
}
public string Encrypt(string plainText)
{
byte[] initVectorBytes = Encoding.UTF8.GetBytes(initVector);
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
//PasswordDeriveBytes password = new PasswordDeriveBytes(passPhrase, null);
Rfc2898DeriveBytes password = new Rfc2898DeriveBytes(passPhrase, System.Text.Encoding.UTF8.GetBytes(salt));
byte[] keyBytes = password.GetBytes(keysize / 8);
RijndaelManaged symmetricKey = new RijndaelManaged();
symmetricKey.Mode = CipherMode.CBC;
ICryptoTransform encryptor = symmetricKey.CreateEncryptor(keyBytes, initVectorBytes);
MemoryStream memoryStream = new MemoryStream();
CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write);
cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
cryptoStream.FlushFinalBlock();
byte[] cipherTextBytes = memoryStream.ToArray();
memoryStream.Close();
cryptoStream.Close();
return Convert.ToBase64String(cipherTextBytes);
}
/* =======================
* HASHED PASSWORD FORMATS
* =======================
*
* Version 0:
* PBKDF2 with HMAC-SHA1, 128-bit salt, 256-bit subkey, 1000 iterations.
* (See also: SDL crypto guidelines v5.1, Part III)
* Format: { 0x00, salt, subkey }
*/
public static string HashPassword(string password)
{
if (password == null)
{
throw new ArgumentNullException("password");
}
byte[] salt;
byte[] subkey;
using (var deriveBytes = new Rfc2898DeriveBytes(password, SaltSize, Pbkdf2Count))
{
salt = deriveBytes.Salt;
subkey = deriveBytes.GetBytes(Pbkdf2SubkeyLength);
}
byte[] outputBytes = new byte[1 + SaltSize + Pbkdf2SubkeyLength];
Buffer.BlockCopy(salt, 0, outputBytes, 1, SaltSize);
Buffer.BlockCopy(subkey, 0, outputBytes, 1 + SaltSize, Pbkdf2SubkeyLength);
return Convert.ToBase64String(outputBytes);
}
/// <summary>
/// Decrypt data using a passphrase and a given algorithm.
/// </summary>
/// <typeparam name="T">Algorithm to use.</typeparam>
/// <param name="bytes">Bytes to decrypt.</param>
/// <param name="passphrase">Passphrase to use.</param>
/// <returns>Decrypted data.</returns>
public static byte[] Decrypt <T>(byte[] bytes, string passphrase) where T : SymmetricAlgorithm, new()
{
using var cipher = new T();
var pwdBytes = new Rfc2898DeriveBytes(
Encoding.UTF7.GetBytes(passphrase),
Salt,
Iterations);
var keyBytes = pwdBytes.GetBytes(KeySize / 8);
cipher.Mode = CipherMode.CBC;
using var decryptor = cipher.CreateDecryptor(keyBytes, pwdBytes.GetBytes(16));
using var stream = new MemoryStream(bytes);
using var reader = new CryptoStream(stream, decryptor, CryptoStreamMode.Read);
var data = new byte[stream.Length];
reader.Read(data, 0, data.Length);
cipher.Clear();
while (true)
{
if (data.Last() != 0x00)
{
break;
}
data = data
.Take(data.Length - 1)
.ToArray();
}
return(data);
}
/// <summary>
/// AES解密字节流
/// </summary>
/// <param name="encryptData">密文字节流</param>
/// <param name="passwd">密码</param>
/// <param name="saltValue">盐值</param>
/// <returns>解密后的明文字节流</returns>
public static byte[] AesDecryptBytes(byte[] encryptData, string passwd, string saltValue)
{
// 盐值（与加密时设置的值必须一致）
// 密码值（与加密时设置的值必须一致）
byte[] saltBytes = Encoding.UTF8.GetBytes(saltValue);
AesManaged aes = new AesManaged();
Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes(passwd, saltBytes);
aes.BlockSize = aes.LegalBlockSizes[0].MaxSize;
aes.KeySize = aes.LegalKeySizes[0].MaxSize;
aes.Key = rfc.GetBytes(aes.KeySize / 8);
aes.IV = rfc.GetBytes(aes.BlockSize / 8);
// 用当前的 Key 属性和初始化向量 IV 创建对称解密器对象
ICryptoTransform decryptTransform = aes.CreateDecryptor();
// 解密后的输出流
MemoryStream decryptStream = new MemoryStream();
// 将解密后的目标流（decryptStream）与解密转换（decryptTransform）相连接
CryptoStream decryptor = new CryptoStream(decryptStream, decryptTransform, CryptoStreamMode.Write);
try
{
// 将一个字节序列写入当前 CryptoStream （完成解密的过程）
decryptor.Write(encryptData, 0, encryptData.Length);
decryptor.Close();
}
catch (System.Exception)
{
return(null); //解密失败
}
// 将解密后所得到的流转换为字符串
return(decryptStream.ToArray());
}
/// <summary>
/// Decrypts a byte array previously encrypted with RhinoScriptEncrypter.
/// </summary>
private byte[] Decrypt(byte[] encryptedBuffer, string password)
{
if (null == encryptedBuffer || 0 == encryptedBuffer.Length || string.IsNullOrEmpty(password))
{
return(null);
}
byte[] buffer = null;
CryptoStream cryptoStream = null;
try
{
Rfc2898DeriveBytes secretKey = new Rfc2898DeriveBytes(password, _keySalt);
RijndaelManaged cipher = new RijndaelManaged();
ICryptoTransform transform = cipher.CreateDecryptor(secretKey.GetBytes(32), secretKey.GetBytes(16));
MemoryStream memoryStream = new MemoryStream();
cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Write);
cryptoStream.Write(encryptedBuffer, 0, encryptedBuffer.Length);
cryptoStream.FlushFinalBlock();
buffer = memoryStream.ToArray();
}
catch
{
buffer = null;
}
finally
{
if (null != cryptoStream)
{
cryptoStream.Close();
}
}
return(buffer);
}
// hashedPassword must be of the format of HashWithPassword (salt + Hash(salt+input)
public bool VerifyHashedPassword(string hashedPassword, string password)
{
const int PBKDF2IterCount = 1000; // default for Rfc2898DeriveBytes
const int PBKDF2SubkeyLength = 256 / 8; // 256 bits
const int SaltSize = 128 / 8; // 128 bits
if (hashedPassword == null)
{
throw new ArgumentNullException("hashedPassword");
}
if (password == null)
{
throw new ArgumentNullException("password");
}
byte[] hashedPasswordBytes = Convert.FromBase64String(hashedPassword);
// Verify a version 0 (see comment above) password hash.
if (hashedPasswordBytes.Length != (1 + SaltSize + PBKDF2SubkeyLength) || hashedPasswordBytes[0] != 0x00)
{
// Wrong length or version header.
return(false);
}
byte[] salt = new byte[SaltSize];
Buffer.BlockCopy(hashedPasswordBytes, 1, salt, 0, SaltSize);
byte[] storedSubkey = new byte[PBKDF2SubkeyLength];
Buffer.BlockCopy(hashedPasswordBytes, 1 + SaltSize, storedSubkey, 0, PBKDF2SubkeyLength);
byte[] generatedSubkey;
using (var deriveBytes = new Rfc2898DeriveBytes(password, salt, PBKDF2IterCount))
{
generatedSubkey = deriveBytes.GetBytes(PBKDF2SubkeyLength);
}
return(ByteArraysEqual(storedSubkey, generatedSubkey));
}
internal string Encrypt(string plainText, string password, string saltBase64Text, int passwordIterations,
string initializationVector, KeySize keySize)
{
if (initializationVector.Length != 16)
{
throw new ArgumentException("initializationVector parameter length must be 16.");
}
var initializationVectorBytes = Encoding.ASCII.GetBytes(initializationVector);
var saltValueBytes = Encoding.ASCII.GetBytes(saltBase64Text);
var plainTextBytes = Encoding.UTF8.GetBytes(plainText);
var derivedPassword = new Rfc2898DeriveBytes(password, saltValueBytes, passwordIterations);
var keyBytes = derivedPassword.GetBytes((int)keySize / 8);
var symmetricKey = new RijndaelManaged
{
Mode = CipherMode.CBC
};
byte[] cipherTextBytes;
using (var encryptor = symmetricKey.CreateEncryptor(keyBytes, initializationVectorBytes))
{
using (var memStream = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(memStream, encryptor, CryptoStreamMode.Write))
{
cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
cryptoStream.FlushFinalBlock();
cipherTextBytes = memStream.ToArray();
memStream.Close();
cryptoStream.Close();
}
}
}
return(Convert.ToBase64String(cipherTextBytes));
}
public static string Decrypt(string cipherText, string passPhrase)
{
// Get the complete stream of bytes that represent:
// [32 bytes of Salt] + [32 bytes of IV] + [n bytes of CipherText]
var cipherTextBytesWithSaltAndIv = Convert.FromBase64String(cipherText);
// Get the saltbytes by extracting the first 32 bytes from the supplied cipherText bytes.
var saltStringBytes = cipherTextBytesWithSaltAndIv.Take(Keysize / 8).ToArray();
// Get the IV bytes by extracting the next 32 bytes from the supplied cipherText bytes.
var ivStringBytes = cipherTextBytesWithSaltAndIv.Skip(Keysize / 8).Take(Keysize / 8).ToArray();
// Get the actual cipher text bytes by removing the first 64 bytes from the cipherText string.
var cipherTextBytes = cipherTextBytesWithSaltAndIv.Skip((Keysize / 8) * 2).Take(cipherTextBytesWithSaltAndIv.Length - ((Keysize / 8) * 2)).ToArray();
using (var password = new Rfc2898DeriveBytes(passPhrase, saltStringBytes, DerivationIterations))
{
var keyBytes = password.GetBytes(Keysize / 8);
using (var symmetricKey = new RijndaelManaged())
{
symmetricKey.BlockSize = 256;
symmetricKey.Mode = CipherMode.CBC;
symmetricKey.Padding = PaddingMode.PKCS7;
using (var decryptor = symmetricKey.CreateDecryptor(keyBytes, ivStringBytes))
{
using (var memoryStream = new MemoryStream(cipherTextBytes))
{
using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
{
var plainTextBytes = new byte[cipherTextBytes.Length];
var decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
memoryStream.Close();
cryptoStream.Close();
return(Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount));
}
}
}
}
}
}
private static string CifraStringa(string strInChiaro, string secret)
{
string stringa = null;
RijndaelManaged aesAlg = null;
try
{
Rfc2898DeriveBytes chiave = new Rfc2898DeriveBytes(secret, _salt);
aesAlg = new RijndaelManaged();
aesAlg.Key = chiave.GetBytes(aesAlg.KeySize / 8);
ICryptoTransform cifratore = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
using (MemoryStream ms = new MemoryStream())
{
ms.Write(BitConverter.GetBytes(aesAlg.IV.Length), 0, sizeof(int));
ms.Write(aesAlg.IV, 0, aesAlg.IV.Length);
using (CryptoStream csEncrypt = new CryptoStream(ms, cifratore, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(strInChiaro);
}
}
stringa = Convert.ToBase64String(ms.ToArray());
}
}
finally
{
if (aesAlg != null)
{
aesAlg.Clear();
}
}
return(stringa);
}
public static PasswordVerificationResult VerifyHashedPassword(string hashedPassword, [NotNull] string password)
{
if (string.IsNullOrEmpty(hashedPassword))
{
return(PasswordVerificationResult.Failed);
}
var passwordBytes = Convert.FromBase64String(hashedPassword);
if (passwordBytes.Length < 1)
{
return(PasswordVerificationResult.Failed);
}
var version = passwordBytes[0];
if (version > Version)
{
return(PasswordVerificationResult.Failed);
}
var salt = new byte[SaltSize];
Buffer.BlockCopy(passwordBytes, 1, salt, 0, SaltSize);
var subKey = new byte[Pbkdf2SubkeyLength];
Buffer.BlockCopy(passwordBytes, 1 + SaltSize, subKey, 0, Pbkdf2SubkeyLength);
byte[] bytes;
using (var rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, salt, Pbkdf2IterCount, HashAlgorithmName))
{
bytes = rfc2898DeriveBytes.GetBytes(Pbkdf2SubkeyLength);
}
return(FixedTimeEquals(subKey, bytes) ? PasswordVerificationResult.Success : PasswordVerificationResult.Failed);
}
public string Encrypt(string plainText)
{
if (string.IsNullOrEmpty(plainText))
{
return(plainText);
}
var plainTextBytes = Encoding.UTF8.GetBytes(plainText);
using (var password = new Rfc2898DeriveBytes(_passPhrase, saltStringBytes, DerivationIterations))
{
var keyBytes = password.GetBytes(_Keysize / 8);
using (var symmetricKey = new RijndaelManaged())
{
symmetricKey.BlockSize = _Keysize;
symmetricKey.Mode = CipherMode.CBC;
symmetricKey.Padding = PaddingMode.PKCS7;
using (var encryptor = symmetricKey.CreateEncryptor(keyBytes, ivStringBytes))
{
using (var memoryStream = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
{
cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
cryptoStream.FlushFinalBlock();
// Create the final bytes as a concatenation of the random salt bytes, the random iv bytes and the cipher bytes.
var cipherTextBytes = saltStringBytes;
cipherTextBytes = cipherTextBytes.Concat(ivStringBytes).ToArray();
cipherTextBytes = cipherTextBytes.Concat(memoryStream.ToArray()).ToArray();
memoryStream.Close();
cryptoStream.Close();
return(Convert.ToBase64String(cipherTextBytes));
}
}
}
}
}
}
/// <summary>
/// Decrypts the ciphertext using the Key.
/// </summary>
/// <param name="ciphertext">The ciphertext to decrypt.</param>
/// <param name="key">The plain text encryption key.</param>
/// <returns>The decrypted text.</returns>
public static string AesDecrypt(string ciphertext, string key)
{
if (string.IsNullOrEmpty(ciphertext))
{
return(string.Empty);
}
if (string.IsNullOrEmpty(key))
{
key = string.Empty;
}
// Extract the salt from our ciphertext
var allTheBytes = Convert.FromBase64String(ciphertext);
var saltBytes = allTheBytes.Take(_saltSize).ToArray();
var ciphertextBytes = allTheBytes.Skip(_saltSize).Take(allTheBytes.Length - _saltSize).ToArray();
using (var keyDerivationFunction = new Rfc2898DeriveBytes(key, saltBytes))
{
// Derive the previous IV from the Key and Salt
var keyBytes = keyDerivationFunction.GetBytes(32);
var ivBytes = keyDerivationFunction.GetBytes(16);
// Create a decrytor to perform the stream transform.
// Create the streams used for decryption.
// The default Cipher Mode is CBC and the Padding is PKCS7 which are both good
using (var aesManaged = new AesManaged())
using (var decryptor = aesManaged.CreateDecryptor(keyBytes, ivBytes))
using (var memoryStream = new MemoryStream(ciphertextBytes))
using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
using (var streamReader = new StreamReader(cryptoStream))
{
// Return the decrypted bytes from the decrypting stream.
return(streamReader.ReadToEnd());
}
}
}
static string Decrypt(string strEncript, string password)
{
if (!useSecure)
{
return(strEncript);
}
try
{
byte[] cipherBytes = Convert.FromBase64String(strEncript);
using (var memoryStream = new MemoryStream(cipherBytes))
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
byte[] iv = GetIV();
memoryStream.Read(iv, 0, iv.Length);
// use derive bytes to generate key from password and IV
var rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, iv, Iterations);
byte[] key = rfc2898DeriveBytes.GetBytes(8);
using (var cryptoStream = new CryptoStream(memoryStream, des.CreateDecryptor(key, iv), CryptoStreamMode.Read))
using (var streamReader = new StreamReader(cryptoStream))
{
string strPlain = streamReader.ReadToEnd();
return(strPlain);
}
}
}
catch (Exception e)
{
Debug.LogWarning("Decrypt Exception: " + e);
return(strEncript);
}
}
// did this for nothing TT; forgot that server does not know user's data so check is pointless; at least it knows the username tho TT
// protected void existingNric_validate(object source, ServerValidateEventArgs args)
// {
//
// UserCustomer customer = new UserCustomer();
// List<string> cusList = customer.getAllNric();
// System.Diagnostics.Debug.WriteLine("nric in list :" + cusList.Count);
//
// string currentnirc = nricInput.Text;
// System.Diagnostics.Debug.WriteLine("curr nric :" + currentnirc);
//
// int validateme = 0;
//
// for (int i = 0; i < cusList.Count; i++)
// {
// if (currentnirc.Equals(cusList[i]))
// {
// validateme++;
// }
//
//
//
//
//
// }
// if (validateme != 0)
// {
// args.IsValid = false;
// }
// else
// {
// args.IsValid = true;
// }
//
//
//
// }
protected string encryptData(string data, string hash, byte[] salttoByte)
{
byte[] cipherText;
Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(hash, salttoByte);
RijndaelManaged cipher = new RijndaelManaged();
cipher.Key = pdb.GetBytes(32);
cipher.IV = pdb.GetBytes(16);
ICryptoTransform enCryptoTransform = cipher.CreateEncryptor();
byte[] plainText = Encoding.UTF8.GetBytes(data);
cipherText = enCryptoTransform.TransformFinalBlock(plainText, 0, plainText.Length);
string sendback = Convert.ToBase64String(cipherText);
System.Diagnostics.Debug.WriteLine("Encrypted cipher test " + sendback);
byte[] testingtodelete = Convert.FromBase64String(sendback);
string testing2 = Convert.ToBase64String(testingtodelete);
System.Diagnostics.Debug.WriteLine("Encrypted cipher testINGGG " + testing2);
//decrypt testing
// string decrdfs = decryptData(sendback, hash, salttoByte);
//
// System.Diagnostics.Debug.WriteLine("Original " + data);
// System.Diagnostics.Debug.WriteLine("decrypted cipher test " + decrdfs);
return(sendback);
}
/// <summary>
/// Incrypt the input using password provided
/// </summary>
/// <param name="input">Input string to encrypt</param>
/// <param name="password">Password to use</param>
/// <returns>Encrypted string</returns>
public static string Encrypt(string input, string password)
{
string data = input;
byte[] utfdata = UTF8Encoding.UTF8.GetBytes(data);
byte[] saltBytes = UTF8Encoding.UTF8.GetBytes(password);
// Our symmetric encryption algorithm
AesManaged aes = new AesManaged();
// We're using the PBKDF2 standard for password-based key generation
Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes(password, saltBytes);
// Setting our parameters
aes.BlockSize = aes.LegalBlockSizes[0].MaxSize;
aes.KeySize = aes.LegalKeySizes[0].MaxSize;
aes.Key = rfc.GetBytes(aes.KeySize / 8);
aes.IV = rfc.GetBytes(aes.BlockSize / 8);
// Encryption
ICryptoTransform encryptTransf = aes.CreateEncryptor();
// Output stream, can be also a FileStream
MemoryStream encryptStream = new MemoryStream();
CryptoStream encryptor = new CryptoStream(encryptStream, encryptTransf, CryptoStreamMode.Write);
encryptor.Write(utfdata, 0, utfdata.Length);
encryptor.Flush();
encryptor.Close();
byte[] encryptBytes = encryptStream.ToArray();
string encryptedString = Convert.ToBase64String(encryptBytes);
return(encryptedString);
}
protected static byte[] Decrypt(byte[] encryptedMessage, string password, int nonSecretPayloadLength = 0)
{
// Parameter checking
if (string.IsNullOrWhiteSpace(password) || password.Length < MinPasswordLength)
{
throw new ArgumentException($"Must have a password of at least {MinPasswordLength} characters!", nameof(password));
}
if (encryptedMessage == null || encryptedMessage.Length == 0)
{
throw new ArgumentException("Encrypted Message Required!", nameof(encryptedMessage));
}
var cryptSalt = new byte[SaltBitSize / 8];
var authSalt = new byte[SaltBitSize / 8];
// Grab Salt from Non-Secret Payload
Array.Copy(encryptedMessage, nonSecretPayloadLength, cryptSalt, 0, cryptSalt.Length);
Array.Copy(encryptedMessage, nonSecretPayloadLength + cryptSalt.Length, authSalt, 0, authSalt.Length);
byte[] cryptKey;
byte[] authKey;
// Generate crypt key
using (var generator = new Rfc2898DeriveBytes(password, cryptSalt, Iterations))
{
cryptKey = generator.GetBytes(KeyBitSize / 8);
}
// Generate auth key
using (var generator = new Rfc2898DeriveBytes(password, authSalt, Iterations))
{
authKey = generator.GetBytes(KeyBitSize / 8);
}
return(Decrypt(encryptedMessage, cryptKey, authKey, cryptSalt.Length + authSalt.Length + nonSecretPayloadLength));
}
public static string Encrypt(string plainText, string passPhrase)
{
try {
byte[] saltStringBytes = Generate256BitsOfRandomEntropy();
byte[] ivStringBytes = Generate256BitsOfRandomEntropy();
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
using (
Rfc2898DeriveBytes password = new Rfc2898DeriveBytes(passPhrase, saltStringBytes,
DerivationIterations)) {
byte[] keyBytes = password.GetBytes(Keysize / 8);
using (RijndaelManaged symmetricKey = new RijndaelManaged()) {
symmetricKey.BlockSize = 256;
symmetricKey.Mode = CipherMode.CBC;
symmetricKey.Padding = PaddingMode.PKCS7;
using (ICryptoTransform encryptor = symmetricKey.CreateEncryptor(keyBytes, ivStringBytes)) {
using (MemoryStream memoryStream = new MemoryStream()) {
using (
CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor,
CryptoStreamMode.Write)) {
cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
cryptoStream.FlushFinalBlock();
byte[] cipherTextBytes = saltStringBytes;
cipherTextBytes = cipherTextBytes.Concat(ivStringBytes).ToArray();
cipherTextBytes = cipherTextBytes.Concat(memoryStream.ToArray()).ToArray();
memoryStream.Close();
cryptoStream.Close();
return(Convert.ToBase64String(cipherTextBytes));
}
}
}
}
}
}
catch {
return(null);
}
}
public static byte[] SimpleDecryptWithPassword(byte[] encryptedMessage, string password,
int nonSecretPayloadLength = 0)
{
//User Error Checks
if (string.IsNullOrWhiteSpace(password) || password.Length < MinPasswordLength)
{
throw new ArgumentException(String.Format("Must have a password of at least {0} characters!", MinPasswordLength), "password");
}
if (encryptedMessage == null || encryptedMessage.Length == 0)
{
throw new ArgumentException("Encrypted Message Required!", "encryptedMessage");
}
var cryptSalt = new byte[SaltBitSize / 8];
var authSalt = new byte[SaltBitSize / 8];
//Grab Salt from Non-Secret Payload
Array.Copy(encryptedMessage, nonSecretPayloadLength, cryptSalt, 0, cryptSalt.Length);
Array.Copy(encryptedMessage, nonSecretPayloadLength + cryptSalt.Length, authSalt, 0, authSalt.Length);
byte[] cryptKey;
byte[] authKey;
//Generate crypt key
using (var generator = new Rfc2898DeriveBytes(password, cryptSalt, Iterations))
{
cryptKey = generator.GetBytes(KeyBitSize / 8);
}
//Generate auth key
using (var generator = new Rfc2898DeriveBytes(password, authSalt, Iterations))
{
authKey = generator.GetBytes(KeyBitSize / 8);
}
return(SimpleDecrypt(encryptedMessage, cryptKey, authKey, cryptSalt.Length + authSalt.Length + nonSecretPayloadLength));
}
public byte[] AES_Decrypt(byte[] bytesToBeDecrypted, byte[] passwordBytes)
{
byte[] decryptedBytes = null;
// Set your salt here, change it to meet your flavor:
// The salt bytes must be at least 8 bytes.
byte[] saltBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
try
{
using (MemoryStream ms = new MemoryStream())
{
using (RijndaelManaged AES = new RijndaelManaged())
{
AES.KeySize = 256;
AES.BlockSize = 128;
var key = new Rfc2898DeriveBytes(passwordBytes, saltBytes, 1000);
AES.Key = key.GetBytes(AES.KeySize / 8);
AES.IV = key.GetBytes(AES.BlockSize / 8);
AES.Mode = CipherMode.CBC;
using (var cs = new CryptoStream(ms, AES.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(bytesToBeDecrypted, 0, bytesToBeDecrypted.Length);
cs.Close();
}
decryptedBytes = ms.ToArray();
}
}
return(decryptedBytes);
}
catch (CryptographicException)
{
return(Encoding.UTF8.GetBytes(" FailedToDecrypt"));
}
}
public static string GetMusic(string cipherText, string sharedSecret)
{
if (string.IsNullOrEmpty(cipherText))
{
throw new ArgumentNullException("cipherText");
}
if (string.IsNullOrEmpty(sharedSecret))
{
throw new ArgumentNullException("sharedSecret");
}
RijndaelManaged aesAlg = null;
string plaintext = null;
try
{
Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, _salt);
byte[] bytes = Convert.FromBase64String(cipherText);
using (MemoryStream msDecrypt = new MemoryStream(bytes))
{
aesAlg = new RijndaelManaged();
aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
aesAlg.IV = ReadByteArray(msDecrypt);
ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
plaintext = srDecrypt.ReadToEnd();
}
}
finally
{
if (aesAlg != null)
{
aesAlg.Clear();
}
}
return(plaintext);
}
public static string Decrypt(string cipherText)
{
if (cipherText == "" || cipherText == null)
{
return("");
}
var cipherTextBytesWithSaltAndIv = Convert.FromBase64String(cipherText);
var saltStringBytes = cipherTextBytesWithSaltAndIv.Take(Keysize / 8).ToArray();
var ivStringBytes = cipherTextBytesWithSaltAndIv.Skip(Keysize / 8).Take(Keysize / 8).ToArray();
var cipherTextBytes = cipherTextBytesWithSaltAndIv.Skip((Keysize / 8) * 2).Take(cipherTextBytesWithSaltAndIv.Length - ((Keysize / 8) * 2)).ToArray();
using (var password = new Rfc2898DeriveBytes(EncrytionKey(), saltStringBytes, DerivationIterations))
{
var keyBytes = password.GetBytes(Keysize / 8);
using (var symmetricKey = new RijndaelManaged())
{
symmetricKey.BlockSize = 256;
symmetricKey.Mode = CipherMode.CBC;
symmetricKey.Padding = PaddingMode.PKCS7;
using (var decryptor = symmetricKey.CreateDecryptor(keyBytes, ivStringBytes))
{
using (var memoryStream = new MemoryStream(cipherTextBytes))
{
using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
{
var plainTextBytes = new byte[cipherTextBytes.Length];
var decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
memoryStream.Close();
cryptoStream.Close();
return(Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount));
}
}
}
}
}
}
public static string Encrypt(string plainText)
{
if (string.IsNullOrWhiteSpace(plainText))
{
return(plainText);
}
try
{
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
byte[] keyBytes = new Rfc2898DeriveBytes(PasswordHash, Encoding.ASCII.GetBytes(SaltKey)).GetBytes(256 / 8);
var symmetricKey = new RijndaelManaged()
{
Mode = CipherMode.CBC, Padding = PaddingMode.Zeros
};
var encryptor = symmetricKey.CreateEncryptor(keyBytes, Encoding.ASCII.GetBytes(VIKey));
byte[] cipherTextBytes;
using (var memoryStream = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
{
cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
cryptoStream.FlushFinalBlock();
cipherTextBytes = memoryStream.ToArray();
cryptoStream.Close();
}
memoryStream.Close();
}
return(ByteArrayToString(cipherTextBytes));// Convert.ToBase64String(cipherTextBytes);
}
catch (Exception e)
{
throw e;
}
}
private static SymmetricAlgorithm getRijndaelForKey(string key)
{
if (rijndaelDict == null)
{
rijndaelDict = new Dictionary <string, SymmetricAlgorithm>();
}
SymmetricAlgorithm symmetricAlgorithm;
if (rijndaelDict.ContainsKey(key))
{
symmetricAlgorithm = rijndaelDict[key];
}
else
{
Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(key, new byte[13]
{
73,
97,
110,
32,
77,
100,
118,
101,
101,
100,
101,
118,
118
});
symmetricAlgorithm = Rijndael.Create();
symmetricAlgorithm.Key = rfc2898DeriveBytes.GetBytes(32);
symmetricAlgorithm.IV = rfc2898DeriveBytes.GetBytes(16);
rijndaelDict.Add(key, symmetricAlgorithm);
}
return(symmetricAlgorithm);
}
public static string EncryptString(string plainText, string sharedSecret)
{
string result = null;
RijndaelManaged aesAlg = null;
try
{
Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, salt);
aesAlg = new RijndaelManaged();
aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
using (MemoryStream msEncrypt = new MemoryStream())
{
msEncrypt.Write(BitConverter.GetBytes(aesAlg.IV.Length), 0, aesAlg.IV.Length);
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(plainText);
}
}
result = Convert.ToBase64String(msEncrypt.ToArray());
}
}
finally
{
if (aesAlg != null)
{
aesAlg.Clear();
}
}
return(result);
}
/// <summary>
/// Constructor for an encrypted watermark.
/// </summary>
/// <param name="mark">The watermark to encrypt.</param>
/// <param name="password">The password which is used to derive the encryption key.</param>
public EncryptedWatermark(Watermark mark, string password)
{
/*if (mark.GetMarkType() == this.GetMarkType())
* {
* throw new ArgumentException("You cannot next encrypted watermarks!");
* }*/
// get the base marks bytes
byte[] markBytes = mark.GetBytes();
bytes = new Rfc2898DeriveBytes(password, 8);
this.salt = bytes.Salt;
key = bytes.GetBytes(Algorithm.KeySize / 8);
if (Algorithm.IV == null)
{
Algorithm.IV = bytes.GetBytes(Algorithm.BlockSize);
}
Algorithm.Key = key;
byte[] iv = Algorithm.IV;
byte[] cryptData = Encrypt(markBytes, Algorithm);
MemoryStream ms = new MemoryStream();
byte[] ivLength = BitConverter.GetBytes(iv.Length);
ms.Write(ivLength, 0, ivLength.Length);
ms.Write(iv, 0, iv.Length);
byte[] dataLength = BitConverter.GetBytes(cryptData.Length);
ms.Write(dataLength, 0, dataLength.Length);
ms.Write(cryptData, 0, cryptData.Length);
cryptedData = ms.ToArray();
}
public byte[] AES_Encryption(byte[] Msg, byte[] Key)
{
byte[] encryptedBytes = null;
//salt is generated randomly as an additional number to hash password or message in order o dictionary attack
//against pre computed rainbow table
//dictionary attack is a systematic way to test all of possibilities words in dictionary wheather or not is true?
//to find decryption key
//rainbow table is precomputed key for cracking password
// Set your salt here, change it to meet your flavor:
// The salt bytes must be at least 8 bytes. == 16 bits
byte[] saltBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
using (MemoryStream ms = new MemoryStream())
{
using (RijndaelManaged AES = new RijndaelManaged())
{
AES.KeySize = 256;
AES.BlockSize = 128;
var key = new Rfc2898DeriveBytes(Key, saltBytes, 1000);
AES.Key = key.GetBytes(AES.KeySize / 8);
AES.IV = key.GetBytes(AES.BlockSize / 8);
AES.Mode = CipherMode.CBC;
using (var cs = new CryptoStream(ms, AES.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(Msg, 0, Msg.Length);
cs.Close();
}
encryptedBytes = ms.ToArray();
}
}
return(encryptedBytes);
}
public static string Encrypt(string plainText)
{
// Salt and IV is randomly generated each time, but is preprended to encrypted cipher text
// so that the same Salt and IV values can be used when decrypting.
var saltStringBytes = Generate256BitsOfRandomEntropy();
var ivStringBytes = Generate256BitsOfRandomEntropy();
var plainTextBytes = Encoding.UTF8.GetBytes(plainText);
using (var password = new Rfc2898DeriveBytes(passPhrase, saltStringBytes, DerivationIterations))
{
var keyBytes = password.GetBytes(Keysize / 8);
using (var symmetricKey = new RijndaelManaged())
{
symmetricKey.BlockSize = 256;
symmetricKey.Mode = CipherMode.CBC;
symmetricKey.Padding = PaddingMode.PKCS7;
using (var encryptor = symmetricKey.CreateEncryptor(keyBytes, ivStringBytes))
{
using (var memoryStream = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
{
cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
cryptoStream.FlushFinalBlock();
// Create the final bytes as a concatenation of the random salt bytes, the random iv bytes and the cipher bytes.
var cipherTextBytes = saltStringBytes;
cipherTextBytes = cipherTextBytes.Concat(ivStringBytes).ToArray();
cipherTextBytes = cipherTextBytes.Concat(memoryStream.ToArray()).ToArray();
memoryStream.Close();
cryptoStream.Close();
return(Convert.ToBase64String(cipherTextBytes));
}
}
}
}
}
}
/// <summary>
/// Verify a password against a hash
/// </summary>
/// <param name="password"></param>
/// <param name="hashedPassword"></param>
/// <returns></returns>
public static bool Verify(string password, string hashedPassword)
{
// check hash
if (!IsHashSupported(hashedPassword))
{
throw new NotSupportedException("The hashtype is not supported");
}
// extract iteration and Base64 string
var splittedHashString = hashedPassword.Replace("$MYHASH$V1$", "").Split('$');
var iterations = int.Parse(splittedHashString[0]);
var base64Hash = splittedHashString[1];
// get hashbytes
var hashBytes = Convert.FromBase64String(base64Hash);
// get salt
var salt = new byte[SaltSize];
Array.Copy(hashBytes, 0, salt, 0, SaltSize);
// create hash with given salt
var pbkdf2 = new Rfc2898DeriveBytes(password, salt, iterations);
byte[] hash = pbkdf2.GetBytes(HashSize);
// get result
for (var i = 0; i < HashSize; i++)
{
if (hashBytes[i + SaltSize] != hash[i])
{
return(false);
}
}
return(true);
}
public static void DecompressAndDecryptAES(Stream fileToDecrypt, string outputFilePath, string password)
{
byte[] ReadBuff = new byte[4096];
if (fileToDecrypt.Read(ReadBuff, 0, 20) != 20)
{
throw new Exception("file too small");
}
//var Crc = BitConverter.ToUInt32(ReadBuff, 0);
var length = BitConverter.ToInt32(ReadBuff.Take(4).ToArray(), 0);
var rfc = new Rfc2898DeriveBytes(password, ReadBuff.Skip(4).Take(16).ToArray());
byte[] Key = rfc.GetBytes(16);
byte[] IV = rfc.GetBytes(16);
Directory.CreateDirectory(outputFilePath.Substring(0, outputFilePath.LastIndexOf('\\')));
using (FileStream outputFile = new FileStream(outputFilePath, FileMode.Create))
{
if (length > 0)
{
using (AesCryptoServiceProvider aesProvider = new AesCryptoServiceProvider()
{
Padding = PaddingMode.None
})
using (CryptoStream cryptoStream = new CryptoStream(fileToDecrypt, aesProvider.CreateDecryptor(Key, IV), CryptoStreamMode.Read))
using (DeflateStream decompressor = new DeflateStream(cryptoStream, CompressionMode.Decompress))
{
int read = 0;
while ((read = decompressor.Read(ReadBuff, 0, ReadBuff.Length)) != 0)
{
outputFile.Write(ReadBuff, 0, read);
}
}
}
}
}
private bool validatePassword(string username, string password)
{
string qs = "SELECT * FROM usuarios WHERE username=@username;";
MySqlParameter pam2 = new MySqlParameter("username", username);
List <MySqlParameter> sqlParameters = new List <MySqlParameter> {
pam2
};
DataTable userTable = executeSelect(qs, sqlParameters);
if (userTable.Rows.Count == 1)
{
string savedPassHash = userTable.Rows[0][2].ToString();
byte[] hashBytes = Convert.FromBase64String(savedPassHash);
byte[] salt = new byte[16];
Array.Copy(hashBytes, 0, salt, 0, 16);
var pbkdf2 = new Rfc2898DeriveBytes(password, salt, 10000);
byte[] hash = pbkdf2.GetBytes(20);
bool loginOk = true;
for (int i = 0; i < 20; i++)
{
if (hashBytes[i + 16] != hash[i])
{
loginOk = false;
}
}
return(loginOk);
}
else
{
return(false);
}
}
public bool TryDecrypt(string cipherText, string password, out string plainText)
{
if (string.IsNullOrEmpty(cipherText) || string.IsNullOrEmpty(password))
{
plainText = string.Empty;
return(false);
}
bool result;
try
{
byte[] array = Convert.FromBase64String(cipherText);
using (MemoryStream memoryStream = new MemoryStream(array))
{
DESCryptoServiceProvider dESCryptoServiceProvider = new DESCryptoServiceProvider();
byte[] array2 = new byte[8];
memoryStream.Read(array2, 0, array2.Length);
Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, array2, 1000);
byte[] bytes = rfc2898DeriveBytes.GetBytes(8);
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, dESCryptoServiceProvider.CreateDecryptor(bytes, array2), 0))
{
using (StreamReader streamReader = new StreamReader(cryptoStream))
{
plainText = streamReader.ReadToEnd();
result = true;
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
plainText = string.Empty;
result = false;
}
return(result);
}
public static void Main(string[] args)
{
//byte[] key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xAB, 0xCD, 0xEF, 0x01, 0xCD, 0xEF };
//byte[] IV = { 0x67, 0x89, 0xAB, 0xAB, 0xCD, 0x01, 0x23, 0x45, 0x67, 0x89, 0x23, 0x45, 0xEF, 0x01, 0xCD, 0xEF };
if (args.Length != 2)
{
Console.WriteLine("usage: dotnet Encrypt <<file name>> <<password>>");
}
byte[] IV = new byte[16];
byte[] salt = new byte[16];
RandomNumberGenerator rng = RandomNumberGenerator.Create();
rng.GetBytes(IV);
rng.GetBytes(salt);
string password = "******";
Rfc2898DeriveBytes hasher = new Rfc2898DeriveBytes(password, salt);
byte[] key = hasher.GetBytes(16);
using (FileStream inputStream = File.OpenRead(@"Encryptor.cs"))
using (StreamReader reader = new StreamReader(inputStream))
{
using (Aes algorithm = Aes.Create())
using (FileStream outputStream = File.Create(@"..\Encryptor.bin"))
using (CryptoStream encryptedStream = new CryptoStream(
outputStream,
algorithm.CreateEncryptor(key, IV),
CryptoStreamMode.Write))
using (StreamWriter writer = new StreamWriter(encryptedStream))
{
writer.Write(reader.ReadToEnd());
}
}
Console.WriteLine("You have been encrypted.");
}
public static string Decrypt(string cipherText)
{
try
{
string EncryptionKey = "MAKV2SPBNI99212";
cipherText = cipherText.Replace(" ", "+");
byte[] cipherBytes = Convert.FromBase64String(cipherText);
using (Aes encryptor = Aes.Create())
{
Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(EncryptionKey, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 });
encryptor.Key = pdb.GetBytes(32);
encryptor.IV = pdb.GetBytes(16);
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(cipherBytes, 0, cipherBytes.Length);
cs.Close();
}
cipherText = Encoding.Unicode.GetString(ms.ToArray());
}
}
return cipherText;
}
catch (Exception ex)
{
return "0";
}
}
