public IEnumerable <RawSimpleEntity> EncryptAll(
IEnumerable <RawSimpleEntity> entities, string password, byte[] salt)
{
if (String.IsNullOrEmpty(password))
{
foreach (var entity in entities)
{
yield return(entity);
}
}
var key = Hash(password, GetDataSalt(salt));
foreach (var entity in entities)
{
RawSimpleEntity e = new RawSimpleEntity();
e.Guid = entity.Guid;
using (var ms = new MemoryStream())
{
Rijndael rijndael = Rijndael.Create();
rijndael.Key = key;
rijndael.GenerateIV();
using (var cs = new CryptoStream(ms, rijndael.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(entity.Data, 0, entity.Data.Length);
}
var data = ms.ToArray();
e.Data = new byte[data.Length + 16];
Array.Copy(rijndael.IV, e.Data, 16);
Array.Copy(data, 0, e.Data, 16, data.Length);
}
yield return(e);
}
}
private static string EncriptarTexto(string mensaje, byte[] clave)
{
Rijndael cifradoRijn = Rijndael.Create();
byte[] byteEncriptado = null;
byte[] byteSalida = null;
try
{
cifradoRijn.Key = clave;
cifradoRijn.GenerateIV();
byte[] byteEntrada = System.Text.Encoding.UTF8.GetBytes(mensaje);
byteEncriptado = cifradoRijn.CreateEncryptor().TransformFinalBlock(byteEntrada, 0, byteEntrada.Length);
byteSalida = new byte[cifradoRijn.IV.Length + byteEncriptado.Length];
cifradoRijn.IV.CopyTo(byteSalida, 0);
byteEncriptado.CopyTo(byteSalida, cifradoRijn.IV.Length);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
cifradoRijn.Clear();
}
string textoSalida = Encoding.Default.GetString(byteSalida);
return(textoSalida);
}
public string Encriptar(string strEncriptar)
{
Rijndael miRijndael = Rijndael.Create();
byte[] encrypted = null;
byte[] returnValue = null;
try
{
miRijndael.Key = bytPK;
miRijndael.GenerateIV();
byte[] toEncrypt = System.Text.Encoding.UTF8.GetBytes(strEncriptar);
encrypted = (miRijndael.CreateEncryptor()).TransformFinalBlock(toEncrypt, 0, toEncrypt.Length);
returnValue = new byte[miRijndael.IV.Length + encrypted.Length];
miRijndael.IV.CopyTo(returnValue, 0);
encrypted.CopyTo(returnValue, miRijndael.IV.Length);
}
finally
{
miRijndael.Clear();
}
return(Convert.ToBase64String(returnValue));
}
public byte[] EncryptString(string message)
{
byte[] encrypted;
using (Rijndael rijAlg = Rijndael.Create())
{
rijAlg.Key = key;
rijAlg.GenerateIV();
rijAlg.Mode = CipherMode.CBC;
rijAlg.Padding = PaddingMode.PKCS7;
byte[] iv = rijAlg.IV;
ICryptoTransform encryptor = rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.IV);
using (MemoryStream msEncrypt = new MemoryStream())
{
msEncrypt.Write(iv, 0, iv.Length);
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(message);
swEncrypt.Flush();
}
encrypted = msEncrypt.ToArray();
}
}
}
return(encrypted);
}
/// <summary>
/// Encriptar cadena
/// </summary>
/// <param name="strEncriptar">Cadena a encriptar</param>
/// <param name="bytPK">llave</param>
/// <returns>Encriptacion</returns>
private static byte[] Encriptar(string strEncriptar, byte[] bytPK)
{
Rijndael miRijndael = Rijndael.Create();
miRijndael.Mode = CipherMode.CBC;
byte[] encrypted = null;
byte[] returnValue = null;
try
{
miRijndael.Key = bytPK;
miRijndael.GenerateIV();
byte[] toEncrypt = System.Text.Encoding.UTF8.GetBytes(strEncriptar);
encrypted = (miRijndael.CreateEncryptor()).TransformFinalBlock(toEncrypt, 0, toEncrypt.Length);
returnValue = new byte[miRijndael.IV.Length + encrypted.Length];
miRijndael.IV.CopyTo(returnValue, 0);
encrypted.CopyTo(returnValue, miRijndael.IV.Length);
}
catch { }
finally { miRijndael.Clear(); }
return(returnValue);
}
public RAOPClient( string Host )
{
host = Host;
volume = VOLUME_DEF;
ajstatus = JACK_STATUS_DISCONNECTED;
ajtype = JACK_TYPE_ANALOG;
nfi = new CultureInfo( "en-US" ).NumberFormat;
alg = Rijndael.Create();
alg.Mode = CipherMode.CBC;
alg.Padding = PaddingMode.None;
alg.KeySize = 128;
alg.GenerateKey();
alg.GenerateIV();
int i = host.LastIndexOf( '.' );
string hostnet = host.Substring( 0, i );
IPHostEntry iphe = Dns.GetHostEntry(Dns.GetHostName());//Dns.GetHostByName( Dns.GetHostName() );
foreach( IPAddress ipaddr in iphe.AddressList )
{
string s = ipaddr.ToString();
if( s.StartsWith( hostnet ) )
{
local = s;
break;
}
}
if( local == null )
local = Host;
}
public byte[] EncryptBytes(byte[] bytes)
{
if (bytes.Length == 0)
{
return(bytes);
}
byte[] encrypted;
using (Rijndael rijAlg = Rijndael.Create()) {
rijAlg.Key = key;
rijAlg.GenerateIV();
rijAlg.Mode = CipherMode.CBC;
rijAlg.Padding = PaddingMode.PKCS7;
byte[] iv = rijAlg.IV;
ICryptoTransform encryptor = rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.IV);
using (MemoryStream msEncrypt = new MemoryStream())
{
msEncrypt.Write(iv, 0, iv.Length);
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
csEncrypt.Write(bytes, 0, bytes.Length);
csEncrypt.FlushFinalBlock();
encrypted = msEncrypt.ToArray();
}
}
}
return(encrypted);
}
string TextEncryption(string message, byte[] key)
{
Rijndael rijndael = Rijndael.Create();
byte[] encryptByte = null;
byte[] outputByte = null;
try
{
rijndael.Key = key;
rijndael.GenerateIV();
byte[] inputByte = Encoding.UTF8.GetBytes(message);
encryptByte = rijndael.CreateEncryptor().TransformFinalBlock(inputByte, 0, inputByte.Length);
outputByte = new byte[rijndael.IV.Length + encryptByte.Length];
rijndael.IV.CopyTo(outputByte, 0);
encryptByte.CopyTo(outputByte, rijndael.IV.Length);
;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message.ToString());
}
finally
{
rijndael.Clear();
}
string output = Encoding.Default.GetString(outputByte);
return(output);
}
public static byte[] Encriptar(string strEncriptar, byte[] bytPK)
{
Rijndael rijndael = Rijndael.Create();
byte[] buffer = null;
byte[] array = null;
try
{
rijndael.Key = bytPK;
rijndael.GenerateIV();
byte[] bytes = Encoding.UTF8.GetBytes(strEncriptar);
buffer = rijndael.CreateEncryptor().TransformFinalBlock(bytes, 0, bytes.Length);
array = new byte[rijndael.IV.Length + buffer.Length];
rijndael.IV.CopyTo(array, 0);
buffer.CopyTo(array, rijndael.IV.Length);
}
catch
{
}
finally
{
rijndael.Clear();
}
return(array);
}
public static byte[] AESEncrypt(string plainText)
{
byte[] bKey = Encoding.UTF8.GetBytes(ConfigurationController.Instance._AesKey);
byte[] byteArray = Encoding.UTF8.GetBytes(plainText);
byte[] encrypt = null;
Rijndael aes = Rijndael.Create();
aes.GenerateIV();
aes.Mode = CipherMode.CFB;
try {
using (MemoryStream mStream = new MemoryStream()) {
using (CryptoStream cStream = new CryptoStream(mStream, aes.CreateEncryptor(bKey, aes.IV), CryptoStreamMode.Write)) {
cStream.Write(aes.IV, 0, aes.IV.Length);
cStream.Write(byteArray, 0, byteArray.Length);
cStream.FlushFinalBlock();
encrypt = mStream.ToArray();
}
}
} catch (Exception e) {
LogManager.Log(e);
return(null);
} finally {
aes.Clear();
}
return(encrypt);
}
private byte[] DiffieHellmanClient(Rijndael newRijndael)
{
ECDiffieHellmanCng ECDF = new ECDiffieHellmanCng();
ECDF.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
ECDF.HashAlgorithm = CngAlgorithm.Sha256;
byte[] pubkey = ECDF.PublicKey.ToByteArray();
string base64pubkey = Convert.ToBase64String(pubkey);
Send(dataStream, base64pubkey); //pošlje javni ključ kot base64
string serverPublicKey = Recieve(dataStream); //prejme njegov javni ključ
//byte[] iv = Encoding.UTF32.GetBytes("sestnajst1234567");
//Send(dataStream, Convert.ToBase64String(iv));
newRijndael.GenerateIV();
iv = Convert.ToBase64String(newRijndael.IV);
MessageBox.Show("iv je: " + iv);
Send(dataStream, iv);
byte[] byteServerKey = Convert.FromBase64String(serverPublicKey);
byte[] sharedKey = ECDF.DeriveKeyMaterial(ECDiffieHellmanCngPublicKey.FromByteArray(byteServerKey, CngKeyBlobFormat.EccPublicBlob));
return sharedKey;
}
public static string Encriptar(string cadenaEncriptar, byte[] bytPK)
{
Rijndael rijndael = Rijndael.Create();
byte[] array = null;
byte[] array2 = null;
try
{
rijndael.Key = bytPK;
rijndael.GenerateIV();
byte[] bytes = Encoding.UTF8.GetBytes(cadenaEncriptar);
array = rijndael.CreateEncryptor().TransformFinalBlock(bytes, 0, bytes.Length);
array2 = new byte[rijndael.IV.Length + array.Length];
rijndael.IV.CopyTo(array2, 0);
array.CopyTo(array2, rijndael.IV.Length);
return(Convert.ToBase64String(array2));
}
catch (Exception)
{
throw;
}
finally
{
rijndael.Clear();
}
}
//With the AsymmetricEncrypt we are going to encrypt the symmetric keys
public static MemoryStream HybridEnryption(MemoryStream clearFile, string publicKey)
{
Rijndael myAlg = Rijndael.Create();
myAlg.GenerateKey(); //secretkey
myAlg.GenerateIV(); //iv
var key = myAlg.Key;
var iv = myAlg.IV;
byte[] fileInBytes = clearFile.ToArray();
var encryptedFile = SymmetricEncrypt(fileInBytes, iv, key);
byte[] encryptedKey = AsymmetricEncrypt(key, publicKey);
byte[] encryptedIv = AsymmetricEncrypt(iv, publicKey);
MemoryStream msOut = new MemoryStream();
msOut.Write(encryptedKey, 0, encryptedKey.Length);
msOut.Write(encryptedIv, 0, encryptedIv.Length);
MemoryStream encryptedFileContent = new MemoryStream(encryptedFile);
encryptedFileContent.Position = 0;
encryptedFileContent.CopyTo(msOut);
return(msOut);
}
static byte[] Encrypt(byte[] buff, byte[] dat, out byte[] iv, byte key)
{
dat = (byte[])dat.Clone();
SHA512 sha = SHA512.Create();
byte[] c = sha.ComputeHash(buff);
for (int i = 0; i < dat.Length; i += 64)
{
byte[] o = new byte[64];
int len = dat.Length <= i + 64 ? dat.Length : i + 64;
Buffer.BlockCopy(dat, i, o, 0, len - i);
for (int j = i; j < len; j++)
{
dat[j] ^= (byte)(c[j - i] ^ key);
}
c = sha.ComputeHash(o);
}
Rijndael ri = Rijndael.Create();
ri.GenerateIV(); iv = ri.IV;
MemoryStream ret = new MemoryStream();
using (CryptoStream cStr = new CryptoStream(ret, ri.CreateEncryptor(SHA256.Create().ComputeHash(buff), iv), CryptoStreamMode.Write))
cStr.Write(dat, 0, dat.Length);
return(ret.ToArray());
}
} //compute hash from arguments and return hash value as string
private static string GetRijndaelHash(string text)
{
//create variables for computing hash and making it a string
UnicodeEncoding UniCode = new UnicodeEncoding();
byte[] HashResult;
byte[] msg = UniCode.GetBytes(text);
Rijndael hashString = RijndaelManaged.Create();
//generate a weak KEY and Initialization Vector for the hash algorithm
hashString.GenerateKey();
hashString.GenerateIV();
ICryptoTransform encryptor = hashString.CreateEncryptor(hashString.Key, hashString.IV);
string Str = "";
//compute hash with Rijndael module and format output as string
//convert bytes in HashResult to string values
HashResult = encryptor.TransformFinalBlock(msg, 0, msg.Length);
foreach (byte x in HashResult)
{
Str += String.Format("{0:x2}", x);
}
//clear excess resource usage
hashString.Clear();
return(Str);
} //compute hash from arguments and return hash value as string
private static void TestShims(Rijndael alg)
{
alg.BlockSize = 128;
Assert.Equal(128, alg.BlockSize);
var emptyIV = new byte[alg.BlockSize / 8];
alg.IV = emptyIV;
Assert.Equal(emptyIV, alg.IV);
alg.GenerateIV();
Assert.NotEqual(emptyIV, alg.IV);
var emptyKey = new byte[alg.KeySize / 8];
alg.Key = emptyKey;
Assert.Equal(emptyKey, alg.Key);
alg.GenerateKey();
Assert.NotEqual(emptyKey, alg.Key);
alg.KeySize = 128;
Assert.Equal(128, alg.KeySize);
alg.Mode = CipherMode.ECB;
Assert.Equal(CipherMode.ECB, alg.Mode);
alg.Padding = PaddingMode.PKCS7;
Assert.Equal(PaddingMode.PKCS7, alg.Padding);
}
public static string Encrypt(string plain, string password)
{
if (password == null)
{
return(plain);
}
//convert password to key
Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(password, SALT);
byte[] encrypted;
byte[] iv;
//Create instance of the rijndael encryption algorithm
using (Rijndael rijndael = Rijndael.Create())
{
rijndael.Key = pdb.GetBytes(32);
rijndael.GenerateIV();
iv = rijndael.IV;
using (MemoryStream memoryStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, rijndael.CreateEncryptor(), CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(cryptoStream))
{
swEncrypt.Write(plain);
}
encrypted = memoryStream.ToArray();
}
}
}
return(Convert.ToBase64String(iv.Concat(encrypted).ToArray()));
}
/// <summary>
/// Función para encriptar usuario y password e introducirlo en un Token de RECO para autenticarse en los servicios Web
/// </summary>
/// <param name="strEncriptar">Cadena que será encriptada</param>
/// <param name="bytPK">Llave del servicio Web en Bytes</param>
/// <returns></returns>
private byte[] Encriptar(string strEncriptar, byte[] bytPK)
{
Rijndael rijndael = Rijndael.Create();
byte[] numArray = (byte[])null /* TODO Change to default(_) if this is not a reference type */;
try
{
rijndael.Key = bytPK;
rijndael.GenerateIV();
byte[] bytes1 = Encoding.UTF8.GetBytes(strEncriptar);
byte[] bytes2 = rijndael.CreateEncryptor().TransformFinalBlock(bytes1, 0, bytes1.Length);
numArray = new byte[rijndael.IV.Length + bytes2.Length - 1 + 1];
rijndael.IV.CopyTo((Array)numArray, 0);
string str1 = Encoding.Default.GetString(rijndael.IV);
string str2 = Encoding.Default.GetString(bytes2);
string str3;
if (str1 == str2)
{
str3 = str1 + "¯‡«í\0x25Ö›O\0x18\0x129öIǤqž";
}
bytes2.CopyTo((Array)numArray, rijndael.IV.Length);
}
catch
{
}
finally
{
rijndael.Clear();
}
return(numArray);
}
static Rijndael CreateRijndael(byte[] userID, string password, string pepper)
{
if (userID == null)
{
throw new ArgumentNullException("userID");
}
if (password == null)
{
throw new ArgumentNullException("password");
}
if (pepper == null)
{
throw new ArgumentNullException("pepper");
}
string passpepper = password + pepper;
Rijndael Rij = Rijndael.Create();
Rij.KeySize = 256;
Rij.Padding = PaddingMode.ISO10126;
Rij.Mode = CipherMode.CBC;
Rfc2898DeriveBytes aesKey = new Rfc2898DeriveBytes(passpepper, userID, 65536);
Rij.Key = aesKey.GetBytes(Rij.KeySize / 8);
Rij.GenerateIV();
return(Rij);
}
public User(string name, string keyApi)
{
Name = name;
KeyApi = keyApi;
//Encryption initialization
encryptorParams = Rijndael.Create();
encryptorParams.GenerateIV();
encryptorParams.KeySize = 256;
encryptorParams.Padding = PaddingMode.Zeros;
}
void EncryptWithNewKey(ref Packet input)
{
using (var output = new MemoryStream()) {
Rij.GenerateIV();
Rij.Key = NewKey;
DataUtility.WriteOnlyBytesToStream(Rij.IV, output);
DataUtility.WriteOnlyBytesToStream(Rij.CreateEncryptor().TransformFinalBlock
(input.RawContent, 0, input.RawContent.Length), output);
Rij.Key = CurrentKey;
input.RawContent = output.ToArray();
}
}
public void GenerateKeys(int keySize)
{
rijndael = Rijndael.Create();
rijndael.BlockSize = 128;
rijndael.KeySize = keySize;
rijndael.GenerateIV();
rijndael.GenerateKey();
this.blockSize = rijndael.BlockSize;
this.keySize = rijndael.KeySize;
this.key = rijndael.Key;
this.iv = rijndael.IV;
}
static void Main()
{
try
{
// Create a new Rijndael object to generate a key
// and initialization vector (IV).
Rijndael RijndaelAlg = Rijndael.Create();
System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
string privateKey = "qwertyuiopasdfghjklzxcvbnmqwerty";
RijndaelAlg.Key = encoding.GetBytes(privateKey);
bool cryptFileExists = File.Exists(CryptFile);
bool ivFileExists = File.Exists(IVFile);
if (cryptFileExists && ivFileExists)
{
Console.WriteLine("Enter Text to Encrypt, or a Blank Line to Decrypt Previous:");
}
else
{
Console.WriteLine("Enter Text to Encrypt:");
}
// Create a string to encrypt.
string sData = Console.ReadLine();
if (!String.IsNullOrEmpty(sData))
{
// Initialize the IV explicitly to something random
RijndaelAlg.GenerateIV();
// Encrypt text to a file using the file name, key, and IV.
EncryptTextToFile(sData, CryptFile, RijndaelAlg);
// Save the IV for use when decrypting
File.WriteAllBytes(IVFile, RijndaelAlg.IV);
}
else if (!cryptFileExists || !ivFileExists)
{
throw new InvalidOperationException("Previous Encrypted Data Not Found");
}
else
{
// Read the IV that was used for encrypting the file
RijndaelAlg.IV = File.ReadAllBytes(IVFile);
}
// Decrypt the text from a file using the file name, key, and IV.
string Final = DecryptTextFromFile(CryptFile, RijndaelAlg);
// Display the decrypted string to the console.
Console.WriteLine(Final);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.ReadLine();
}
private byte[] EncryptBytes(byte[] message)
{
if ((message == null) || (message.Length == 0))
{
return(message);
}
Rij.GenerateIV();
using (MemoryStream outStream = new MemoryStream()) {
DataUtility.WriteBytesToStream(Rij.IV, outStream);
DataUtility.WriteBytesToStream(Rij.CreateEncryptor().TransformFinalBlock(message, 0, message.Length), outStream);
return(outStream.ToArray());
}
}
//drawback of this method is that you have to save the key and iv somwhere because you 'll need them for the decrypt
public static SymmetricKeys GenerateSymmetricKeys()
{
Rijndael myAlg = Rijndael.Create();
myAlg.GenerateKey(); myAlg.GenerateIV();
SymmetricKeys keys = new SymmetricKeys()
{
Key = myAlg.Key,
Iv = myAlg.IV
};
return(keys);
}
// Generate random AES key and IV
public static string[] GenerateAESKeyAndIV(int length)
{
using (Rijndael myAes = Rijndael.Create())
{
myAes.KeySize = length;
myAes.GenerateKey();
myAes.GenerateIV();
string[] keyAndIV = new string[2];
keyAndIV[0] = Convert.ToBase64String(myAes.Key);
keyAndIV[1] = Convert.ToBase64String(myAes.IV);
return(keyAndIV);
}
}
/// <summary>
/// 获得初始向量IV数组
/// </summary>
/// <returns>初试向量IV数组</returns>
private byte[] GetLegalIV()
{
string result = iv;
mCrypto.GenerateIV();
byte[] ivBytes = mCrypto.IV;
int ivLength = ivBytes.Length;
if (result.Length > ivLength)
{
result = result.Substring(0, ivLength);
}
else if (result.Length < ivLength)
{
result = result.PadRight(ivLength, ' ');
}
return(ASCIIEncoding.ASCII.GetBytes(result));
}
public string encrypt(string content)
{
// Encrypt token content
Rijndael myRijndael = Rijndael.Create();
myRijndael.GenerateIV();
byte[] key = Convert.FromBase64String(this.appKey);
string iv = Convert.ToBase64String(myRijndael.IV);
string value = Convert.ToBase64String(EncryptStringToBytes(content, key, myRijndael.IV));
// Caculate mac with SHA256 Hash
Byte[] hashBytes = new HMACSHA256(key).ComputeHash(Encoding.UTF8.GetBytes(iv + value));
string mac = BitConverter.ToString(hashBytes).Replace("-", "").ToLower();
Credential credential = new Credential(iv, value, mac);
// Build token with Json
return(Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(credential))));
}
// This encrypts the passed data
internal void SetData(string data)
{
if (data != null)
{
if (rijndael == null)
{
rijndael = Rijndael.Create();
rijndael.GenerateKey(); // Not sure if this is necessary. Is
rijndael.GenerateIV(); // this done by default in the ctor?
}
ICryptoTransform encryptor = rijndael.CreateEncryptor();
encryptedData = encryptor.TransformFinalBlock(ToBytes(data), 0, (data.Length) * 2);
}
else
{
encryptedData = null;
}
}
/// <summary>
/// Método de la clase SecurityProtocol. Utilizado para la encryptación de datos.
/// </summary>
/// <param name="toEncrypt">Array de bytes a ser encryptado.</param>
/// <param name="key">Llave para la emcriptación.</param>
/// <returns>Retorna un byte[] con los datos encryptados.</returns>
public static byte[] Encrypt(byte[] toEncrypt, byte[] key)
{
Rijndael miRijndael = Rijndael.Create();
byte[] encrypted = null;
byte[] returnValue = null;
try
{
miRijndael.Key = key;
miRijndael.GenerateIV();
encrypted = (miRijndael.CreateEncryptor()).TransformFinalBlock(toEncrypt, 0, toEncrypt.Length);
returnValue = new byte[miRijndael.IV.Length + encrypted.Length];
miRijndael.IV.CopyTo(returnValue, 0);
encrypted.CopyTo(returnValue, miRijndael.IV.Length);
}
catch (Exception ex) { throw ex; }
finally { miRijndael.Clear(); }
return returnValue;
}
static string Encrypt(string stringToEncrypt = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce aliquam magna ligula. Lorem ipsum dolor sit amet, consectetur adipiscing elit.")
{
string retValue = "";
Rijndael rij = Rijndael.Create();
rij.GenerateKey();
rij.GenerateIV();
ICryptoTransform transformer = rij.CreateEncryptor();
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, transformer, CryptoStreamMode.Write);
StreamWriter sw = new StreamWriter(cs);
sw.Write(stringToEncrypt);
retValue = Encoding.UTF8.GetString(ms.ToArray());
return(retValue);
}
