private void ContinueStartup(string token, byte[] akey, byte[] aiv, string pth)
{
var utf8 = new UTF8Encoding(false);
using (var aes = RijndaelManaged.Create())
using (var aes_enc = aes.CreateEncryptor(akey, aiv))
using (var fs = File.Create(pth))
using (var bw = new BinaryWriter(fs))
using (var cs = new CryptoStream(fs, aes_enc, CryptoStreamMode.Write))
{
var tkb = utf8.GetBytes(token);
bw.Write(aiv);
cs.Write(tkb, 0, tkb.Length);
cs.FlushFinalBlock();
}
this.Bot = new DspXamarinBot(token);
this.Bot.LogMessage += this.Bot_LogMessage;
this.LogItems.Clear();
this.RunOnUiThread(() => this.LogItemsAdapter.NotifyDataSetChanged());
this.BotTaskCancellationTokenSource = new CancellationTokenSource();
this.BotTask = Task.Run(this.RunBot, this.BotTaskCancellationToken);
}
public string Decrypt(string data)
{
var buffer = Convert.FromBase64String(data);
var aes = RijndaelManaged.Create();
aes.BlockSize = 256;
aes.KeySize = 256;
aes.Padding = PaddingMode.Zeros;
aes.Mode = CipherMode.CBC;
using (var ms = new MemoryStream(buffer))
{
using (var encoder = new CryptoStream(ms, aes.CreateDecryptor(Key.Clone() as byte[], InitialVector.Clone() as byte[]), CryptoStreamMode.Read))
{
using (var raw = new MemoryStream())
{
var readLen = 0;
var readBuf = new byte[102400];
while ((readLen = encoder.Read(readBuf, 0, 102400)) != 0)
{
raw.Write(readBuf, 0, readLen);
}
var decBuffer = raw.ToArray();
return(Encoding.UTF8.GetString(decBuffer).Trim('\0'));
}
}
}
}
public static string Decrypt(byte[] data)
{
if (data == null || data.Length < 1)
{
return(null);
}
var secretIV = HttpContext.Current.Application[SECRET_IV] as byte[];
var secretKey = HttpContext.Current.Application[SECRET_KEY] as byte[];
if (secretIV == null || secretKey == null)
{
return(null);
}
using (var cryptography = RijndaelManaged.Create())
{
cryptography.IV = secretIV;
cryptography.Key = secretKey;
using (var decryptor = cryptography.CreateDecryptor())
{
using (var ms = new System.IO.MemoryStream(data))
{
using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
{
using (var reader = new System.IO.StreamReader(cs, System.Text.Encoding.UTF8))
{
return(reader.ReadToEnd());
}
}
}
}
}
}
public void DecryptStream(Stream sourcestream, Stream deststream, string key)
{
byte[] _key = new byte[32];
byte[] _IV = new byte[16];
byte[] myKey = Encoding.ASCII.GetBytes(key);
for (int i = 0; i < _key.Length; i++)
{
_key[i] = 0;
}
for (int i = 0; (i < _key.Length) && (i < myKey.Length); i++)
{
_key[i] = myKey[i];
}
for (int i = 0; (i < _key.Length) && (i < _IV.Length); i++)
{
_IV[i] = _key[i];
}
_IV.Reverse();
Rijndael rijndael = RijndaelManaged.Create();
rijndael.IV = _IV;
rijndael.Key = _key;
var decStream = new CryptoStream(sourcestream, rijndael.CreateDecryptor(), CryptoStreamMode.Read);
deststream.SetLength(0);
decStream.CopyTo(deststream);
}
/// <summary>
/// Decrypts a byte array that has been encrypted by ProtectBuffer
/// </summary>
/// <param name="encrpyted">Value that has been encrypted with ProtectBuffer</param>
/// <returns>A decrypted string value</returns>
/// 1. Decrypt the 256 byte prefix to get Key and IV
/// 2. Decrypt remainder using Key and IV
public string UnprotectBuffer(byte[] encrpyted)
{
if (encrpyted == null)
{
return(null);
}
else if (encrpyted.Length < 256)
{
throw new ArgumentException("encrypted");
}
// extract the first 256 bytes and decrypt
var clearpw = DecryptAsymmetrical(encrpyted.Take(256).ToArray());
var key = clearpw.Take(32); // Rijndael key is 32 bytes
var iv = clearpw.Skip(32).Take(16); // Rijndael iv is 16 bytes
// now extract the remainder
using (Rijndael rj = RijndaelManaged.Create())
using (MemoryStream ms = new MemoryStream(encrpyted.Skip(256).ToArray()))
// decrypt using symmeterical (key and initial vector from encrypted value)
using (CryptoStream cs = new CryptoStream(ms, rj.CreateDecryptor(key.ToArray(), iv.ToArray()), CryptoStreamMode.Read))
{
byte[] decrypted = new byte[encrpyted.Length - 256];
cs.Read(decrypted, 0, decrypted.Length);
return(Encoding.UTF8.GetString(decrypted).TrimEnd('\0'));
}
}
public AES()
{
CNG c = new CNG();
c.Key = Key = RijndaelManaged.Create().Key;
Cng = c;
}
static void Main(string[] args)
{
TcpListener listener = new TcpListener(IPAddress.Parse("127.0.0.1"), 1892);
listener.Start();
TcpClient client = listener.AcceptTcpClient();
NetworkStream ns = client.GetStream();
Rijndael aes = RijndaelManaged.Create();
byte[] key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
byte[] iv = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
aes.Key = key;
aes.IV = iv;
byte[] message = Program.ReadMessage(ns, aes);
String output = System.Text.Encoding.UTF8.GetString(message);
Console.WriteLine(output);
Console.Read();
ns.Close();
client.Close();
listener.Stop();
}
private static string DecryptString(string decString, string password)
{
MemoryStream ms = new MemoryStream();
byte[] clearBytes = Convert.FromBase64String(decString);
PasswordDeriveBytes pdb = new PasswordDeriveBytes(password,
new byte[] { 0x49, 0x76, 0x61, 0x6e,
0x20, 0x4d, 0x65, 0x64, 0x76,
0x65, 0x64, 0x65, 0x76 });
byte[] Key = pdb.GetBytes(32);
byte[] IV = pdb.GetBytes(16);
Rijndael encryptor = RijndaelManaged.Create();
encryptor.Key = Key;
encryptor.IV = IV;
encryptor.Padding = PaddingMode.PKCS7;
CryptoStream cs = new CryptoStream(ms, encryptor.CreateDecryptor(), CryptoStreamMode.Write);
cs.Write(clearBytes, 0, clearBytes.Length);
cs.Close();
byte[] decryptedData = ms.ToArray();
decString = System.Text.Encoding.Unicode.GetString(decryptedData);
return(decString);
}
private byte[] DecryptKey(byte[] contentBytes, string passphrase)
{
byte[] importKey = null;
if (passwordProtected)
{
byte[] passHash = CheckPassword(contentBytes, passphrase);
byte[] encryptedKey = new byte[contentBytes.Length - FlagLength - PassHashLength];
Buffer.BlockCopy(contentBytes, FlagLength + PassHashLength, encryptedKey, 0, encryptedKey.Length);
using (SymmetricAlgorithm algorithm = RijndaelManaged.Create())
{
SymmetricCryptographer crypto = new SymmetricCryptographer(algorithm, passHash);
importKey = crypto.Decrypt(encryptedKey);
}
}
else
{
importKey = new byte[contentBytes.Length - 1];
Buffer.BlockCopy(contentBytes, 1, importKey, 0, contentBytes.Length - FlagLength);
}
return(importKey);
}
public void testAES()
{
var aes = RijndaelManaged.Create();
aes.BlockSize = 256;
aes.KeySize = 256;
aes.Padding = PaddingMode.Zeros;
aes.Mode = CipherMode.CBC;
aes.GenerateIV();
aes.GenerateKey();
var iv = Convert.ToBase64String(aes.IV);
var key = Convert.ToBase64String(aes.Key);
var init = $"{key}:{iv}";
var myaes = new AES();
myaes.Init(init);
var rnd = StrHelper.RndString(1100);
Assert.AreEqual(
rnd,
myaes.Decrypt(myaes.Encrypt(rnd))
);
}
} //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
public void uploadPicture()
{
//insert sql query to get users password for string passPhrase from Encrypt method
SqlConnection con = new SqlConnection(connectionstring);
con.Open();
SqlCommand getPassCmd = new SqlCommand("Select Password FROM Users Where UserID = " + Session["UserID"], con);
string password = getPassCmd.Parameters.ToString();
con.Close();
string fileName;
if (picFile.HasFile)
{
fileName = picFile.PostedFile.FileName;
using (Rijndael encryption = RijndaelManaged.Create())
{
byte[] image = ImageToBytes(fileName);
byte[] encyptedImage = Encrypt(image, password);
con.Open();
SqlCommand cmd = new SqlCommand("Insert Into Images values (@Images, @UserID)", con);
cmd.Parameters.AddWithValue("@Images", encyptedImage);
cmd.Parameters.AddWithValue("@UserID", Session["UserID"]);
cmd.ExecuteNonQuery();
con.Close();
}
}
else
{
result.Visible = true;
result.Text = "Please upload an image!";
}
}
/// <summary>
/// Generates a random 256 bit key to be used for encrypting
/// Customer data.
/// </summary>
/// <returns>The base64 encoded key</returns>
private static string GenerateKey()
{
using (var alg = RijndaelManaged.Create())
{
return(Convert.ToBase64String(alg.Key));
}
}
private byte[] GenerateKeyToBeArchived()
{
RijndaelManaged symmetricAlgorithm = (RijndaelManaged)RijndaelManaged.Create();
symmetricAlgorithm.GenerateKey();
return(symmetricAlgorithm.Key);
}
private static byte[] GenerateKey()
{
using (var e = RijndaelManaged.Create())
{
e.GenerateKey();
return(e.Key);
}
}
protected static Rijndael Create()
{
var instance = RijndaelManaged.Create();
instance.Key = _key;
instance.IV = _iv;
return(instance);
}
public void CreateSymmetricKey()
{
symmetricAlgo = (RijndaelManaged)RijndaelManaged.Create();
symmetricAlgo.GenerateKey();
encryptedKey = ProtectedData.Protect(symmetricAlgo.Key, null, DataProtectionScope.CurrentUser);
stream = new MemoryStream();
}
public void decrypt_file(object pcp /*string pwd_file_enc, int key_size, string src_enc_file, string dst_dec_file, ProgressBar pr_b*/)
{
PackDeCryptParam _vpcp = (PackDeCryptParam)pcp;
string pwd_file_enc = _vpcp.pwd_file_enc;
int key_size = _vpcp.key_size;
string src_enc_file = _vpcp.src_enc_file;
string dst_dec_file = _vpcp.dst_dec_file;
ProgressBar pr_b = _vpcp.pr_b;
if (string.IsNullOrEmpty(pwd_file_enc))
{
pwd_file_enc = Crypt.default_key;
}
SymmetricAlgorithm alg;
alg = (SymmetricAlgorithm)RijndaelManaged.Create(); //пример создания класса RijndaelManaged
PasswordDeriveBytes pdb = new PasswordDeriveBytes(pwd_file_enc, null); //класс, позволяющий генерировать ключи на базе паролей
pdb.HashName = "SHA512"; //будем использовать SHA512
int keylen = key_size; //получаем размер ключа из ComboBox’а
alg.KeySize = keylen; //устанавливаем размер ключа
alg.Key = pdb.GetBytes(keylen >> 3); //получаем ключ из пароля
alg.Mode = CipherMode.CBC; //используем режим CBC
alg.IV = new Byte[alg.BlockSize >> 3]; //и пустой инициализационный вектор
ICryptoTransform tr = alg.CreateDecryptor(); //создаем decryptor
FileStream instream = new FileStream(src_enc_file, FileMode.Open, FileAccess.Read, FileShare.Read);
FileStream outstream = new FileStream(dst_dec_file, FileMode.Create, FileAccess.Write, FileShare.None);
int buflen = ((2 << 16) / alg.BlockSize) * alg.BlockSize;
byte[] inbuf = new byte[buflen];
byte[] outbuf = new byte[buflen];
int len;
long input_size = instream.Length;
long cur_byte = 0;
while ((len = instream.Read(inbuf, 0, buflen)) == buflen)
{
int enclen = tr.TransformBlock(inbuf, 0, buflen, outbuf, 0); //собственно расшифровываем
outstream.Write(outbuf, 0, enclen);
cur_byte += enclen;
NewMethod2(pr_b, input_size, cur_byte);
EncryptingFile(cur_byte, input_size);
}
instream.Close();
outbuf = tr.TransformFinalBlock(inbuf, 0, len); //расшифровываем финальный блок
outstream.Write(outbuf, 0, outbuf.Length);
pr_b.Value = (int)input_size;
outstream.Close();
alg.Clear(); //осуществляем зачистку
SetDecryptedFile d = new SetDecryptedFile(Action.FormAction.RecievedFile);
pr_b.Invoke(d, new object[] { src_enc_file });
DecryptedFile(src_enc_file);
}
public static string Encrypt(string plainText, string password = "******")
{
if (plainText == null)
{
throw new ArgumentNullException("plainText");
}
if (password == null)
{
throw new ArgumentNullException("password");
}
// Will return this
var CryptoJSFormat = new CryptoJSFormat();
// Generate random 8 byte salt
Random rnd = new Random();
byte[] salt = new byte[8];
rnd.NextBytes(salt);
CryptoJSFormat.s = Parsers.ByteArrayToHexViaLookup32Unsafe(salt);
// Convert plain text to bytes
byte[] plainBytes = Encoding.UTF8.GetBytes(plainText);
// create new password derived bytes using password/salt
using (OpenSslCompatDeriveBytes pdb = new OpenSslCompatDeriveBytes(password, salt))
{
using (Rijndael aes = RijndaelManaged.Create())
{
// Generate key and iv from password/salt and pass to aes
aes.Key = pdb.GetBytes(aes.KeySize / 8);
aes.IV = pdb.GetBytes(aes.BlockSize / 8);
aes.Mode = CipherMode.CBC;
aes.BlockSize = 128;
CryptoJSFormat.iv = Parsers.ByteArrayToHexViaLookup32Unsafe(aes.IV);
// Open a new memory stream to write the encrypted data to
using (MemoryStream ms = new MemoryStream())
{
// Create a crypto stream to perform encryption
using (CryptoStream cs = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write))
{
// write encrypted bytes to memory
cs.Write(plainBytes, 0, plainBytes.Length);
}
// get the cipher bytes from memory
byte[] cipherBytes = ms.ToArray();
// convert cipher array to base 64 string
CryptoJSFormat.ct = Convert.ToBase64String(cipherBytes);
}
aes.Clear();
}
}
return(JsonConvert.SerializeObject(CryptoJSFormat));
}
public void crypt_file(bool isEncrypting, string key_word, int key_size, string src_file, string dst_file, ProgressBar pr_b)
{
if (string.IsNullOrEmpty(key_word))
{
key_word = FileCrypt.default_key;
}
SymmetricAlgorithm alg;
alg = (SymmetricAlgorithm)RijndaelManaged.Create(); //пример создания класса RijndaelManaged
PasswordDeriveBytes pdb = new PasswordDeriveBytes(key_word, null); //класс, позволяющий генерировать ключи на базе паролей
pdb.HashName = "SHA512"; //будем использовать SHA512
int keylen = key_size; //получаем размер ключа из ComboBox’а
alg.KeySize = keylen; //устанавливаем размер ключа
alg.Key = pdb.GetBytes(keylen >> 3); //получаем ключ из пароля
alg.Mode = CipherMode.CBC; //используем режим CBC
alg.IV = new Byte[alg.BlockSize >> 3]; //и пустой инициализационный вектор
ICryptoTransform tr;
if (isEncrypting)
{
tr = alg.CreateEncryptor(); //создаем encryptor
}
else
{
tr = alg.CreateDecryptor(); //создаем decryptor
}
FileStream instream = new FileStream(src_file, FileMode.Open, FileAccess.Read, FileShare.Read);
FileStream outstream = new FileStream(dst_file, FileMode.Create, FileAccess.Write, FileShare.None);
int buflen = ((2 << 16) / alg.BlockSize) * alg.BlockSize;
byte[] inbuf = new byte[buflen];
byte[] outbuf = new byte[buflen];
int len;
long input_size = instream.Length;
long c_position = 0;
pr_b.Maximum = int.MaxValue;
while ((len = instream.Read(inbuf, 0, buflen)) == buflen)
{
int enclen = tr.TransformBlock(inbuf, 0, buflen, outbuf, 0); //собственно шифруем
outstream.Write(outbuf, 0, enclen);
c_position += enclen;
pr_b.Value = (int)Math.Ceiling((double)int.MaxValue * ((double)c_position / (double)input_size));
Application.DoEvents();
}
instream.Close();
outbuf = tr.TransformFinalBlock(inbuf, 0, len); //шифруем финальный блок
outstream.Write(outbuf, 0, outbuf.Length);
pr_b.Value = int.MaxValue;
outstream.Close();
alg.Clear(); //осуществляем зачистку
}
public static CryptoStream GetEncryptStreamAES(byte[] key, byte[] salt, Stream output)
{
var r = RijndaelManaged.Create();
Rfc2898DeriveBytes pw = new Rfc2898DeriveBytes(key, salt, 5);
CryptoStream cs = new CryptoStream(output, r.CreateEncryptor(pw.GetBytes(32), pw.GetBytes(16)), CryptoStreamMode.Write);
return(cs);
}
public static CryptoStream GetDecryptStreamAES(string key, byte[] salt, Stream input)
{
var r = RijndaelManaged.Create();
Rfc2898DeriveBytes pw = new Rfc2898DeriveBytes(key, salt);
CryptoStream cs = new CryptoStream(input, r.CreateDecryptor(pw.GetBytes(32), pw.GetBytes(16)), CryptoStreamMode.Read);
return(cs);
}
private void ContinueStartup(string token, byte[] akey, byte[] aiv, string pth)
{
var utf8 = new UTF8Encoding(false);
using (var aes = RijndaelManaged.Create())
using (var aes_enc = aes.CreateEncryptor(akey, aiv))
using (var fs = File.Create(pth))
using (var bw = new BinaryWriter(fs))
using (var cs = new CryptoStream(fs, aes_enc, CryptoStreamMode.Write))
{
var tkb = utf8.GetBytes(token);
bw.Write(aiv);
cs.Write(tkb, 0, tkb.Length);
cs.FlushFinalBlock();
}
this.Discord = new DiscordClient(new DiscordConfiguration
{
AutoReconnect = true,
LargeThreshold = 250,
LogLevel = LogLevel.Info,
ShardCount = 1,
ShardId = 0,
Token = token,
TokenType = TokenType.Bot,
UseInternalLogHandler = true
});
this.DiscordCommands = this.Discord.UseCommandsNext(new CommandsNextConfiguration
{
CaseSensitive = true,
EnableDefaultHelp = true,
EnableDms = true,
EnableMentionPrefix = true,
StringPrefix = "daddy:",
SelfBot = false
});
this.Discord.DebugLogger.LogMessageReceived += this.DebugLogger_LogMessageReceived;
this.Discord.ClientErrored += this.Discord_ClientError;
this.Discord.GuildAvailable += this.Discord_GuildAvailable;
this.Discord.Ready += this.Discord_Ready;
this.DiscordCommands.CommandExecuted += this.DiscordCommands_CommandExecuted;
this.DiscordCommands.CommandErrored += this.DiscordCommands_CommandErrored;
this.Discord.SetWebSocketClient <WebSocket4NetClient>();
this.DiscordCommands.RegisterCommands <PortableCommands>();
this.LogItems.Clear();
this.RunOnUiThread(() => this.LogItemsAdapter.NotifyDataSetChanged());
this.BotTaskCancellationTokenSource = new CancellationTokenSource();
this.BotTask = Task.Run(this.RunBot, this.BotTaskCancellationToken);
}
private static MemoryStream CreateSymmetricKey()
{
MemoryStream stream = new MemoryStream();
RijndaelManaged algo = (RijndaelManaged)RijndaelManaged.Create();
algo.GenerateKey();
KeyManager.Write(stream, ProtectedKey.CreateFromPlaintextKey(algo.Key, DataProtectionScope.CurrentUser));
stream.Seek(0, SeekOrigin.Begin);
return(stream);
}
static void Main(string[] args)
{
//perform symmetric encryption using RijndaelManaged algorithm
SymmetricAlgorithm algoProvider = RijndaelManaged.Create();
Console.WriteLine("Crypto Provider Information");
Console.WriteLine("--------------------");
Console.WriteLine("Cipher Mode : " + algoProvider.Mode);
Console.WriteLine("Padding Mode : " + algoProvider.Padding);
Console.WriteLine("Block Size : " + algoProvider.BlockSize);
Console.WriteLine("Key Size : " + algoProvider.KeySize);
Console.WriteLine("Contract Note Encryption Stage - Broker end");
Console.WriteLine("-------------------------------------------");
//Generate Symmetric Key
algoProvider.GenerateKey();
//Generate IV
algoProvider.GenerateIV();
//create file which stores encrypted content of contract note
FileStream fileStream = new FileStream(@"C:\ContractNote.enc", FileMode.Create);
//create symmetric encryptor object
ICryptoTransform cryptoTransform = algoProvider.CreateEncryptor();
//create crypto stream
CryptoStream cryptoStream = new CryptoStream(fileStream, cryptoTransform, CryptoStreamMode.Write);
string contractNote = "<CONTRACTNOTE>"
+ "<SYMBOL>MSFT</SYMBOL>"
+ "<QUANTITY>100</QUANTITY>"
+ "<PRICE>24</PRICE>"
+ "</CONTRACTNOTE>";
byte[] contentBuffer = Encoding.ASCII.GetBytes(contractNote);
//write encrypted data
cryptoStream.Write(contentBuffer, 0, contentBuffer.Length);
cryptoStream.Close();
fileStream.Close();
Console.WriteLine("Contract Note Decryption Stage - Fund Manager end");
Console.WriteLine("-------------------------------------------------");
//open encrypted content of contract note
fileStream = new FileStream(@"C:\ContractNote.enc", FileMode.Open);
//create symmetric decryptor object
cryptoTransform = algoProvider.CreateDecryptor();
cryptoStream = new CryptoStream(fileStream, cryptoTransform, CryptoStreamMode.Read);
byte[] readBuffer = new byte[fileStream.Length];
//decrypt data
cryptoStream.Read(readBuffer, 0, readBuffer.Length);
string decryptedText = Encoding.ASCII.GetString(readBuffer, 0, readBuffer.Length);
Console.WriteLine(decryptedText);
}
public byte[] Encrypt(byte[] data)
{
using (var crypto = RijndaelManaged.Create())
{
crypto.Mode = CipherMode.CBC;
crypto.BlockSize = 256;
crypto.KeySize = 256;
crypto.Padding = PaddingMode.ISO10126;
using (var encryptor = crypto.CreateEncryptor(_key, _iv))
{
return(encryptor.TransformFinalBlock(data, 0, data.Length));
}
}
}
private string EncryptKey(byte[] key, string passphrase)
{
byte[] output = null;
byte[] passphraseBytes = GetPassphraseBytes(passphrase);
using (SymmetricAlgorithm algorithm = RijndaelManaged.Create())
{
SymmetricCryptographer crypto = new SymmetricCryptographer(algorithm, passphraseBytes);
byte[] encryptedKey = crypto.Encrypt(key);
output = AppendPasswordHash(encryptedKey, passphraseBytes, PasswordProtectedFlag);
}
return(Convert.ToBase64String(output));
}
public void AddChannel(byte[] cryptoKey, SymmetricAlgorithm algorithm = null, string channelName = null)
{
algorithm = algorithm ?? RijndaelManaged.Create();
var channel = new EncryptionChannel(channelName, cryptoKey, algorithm);
if (channelName == null)
{
_defaultChannel = channel;
}
else
{
_channels[channelName] = channel;
}
}
public byte[] Decrypt(byte[] encrypted)
{
using (var crypto = RijndaelManaged.Create())
{
crypto.Mode = CipherMode.CBC;
crypto.BlockSize = 128;
crypto.KeySize = 256;
crypto.Padding = PaddingMode.ISO10126;
using (var dencryptor = crypto.CreateDecryptor(_key, _iv))
{
return(dencryptor.TransformFinalBlock(encrypted, 0, encrypted.Length));
}
}
}
public static string GenerateKey()
{
var aes = RijndaelManaged.Create();
aes.BlockSize = 256;
aes.KeySize = 256;
aes.Padding = PaddingMode.Zeros;
aes.Mode = CipherMode.CBC;
aes.GenerateKey();
aes.GenerateIV();
var key = Convert.ToBase64String(aes.Key);
var iv = Convert.ToBase64String(aes.IV);
return(key + ":" + iv);
}
