public static MemoryStream GetDeCryptedMemoryStream(string outputFilePath, string password = "******")
{
var ms = new MemoryStream();
var inFile = new FileStream(outputFilePath, FileMode.Open, FileAccess.Read);
var algorithm = GetAlgorithm(password);
//There could be a case, where more data is appended than required, as a result Serialization fails
//var length = inFile.Length > 1024 ? 1024 : inFile.Length;
var length = 1;
var fileData = new byte[length];
var encryptedStream = new CryptoStream(inFile, algorithm.CreateDecryptor(), CryptoStreamMode.Read);
while (encryptedStream.Read(fileData, 0, fileData.Length) != 0)
{
ms.Write(fileData, 0, fileData.Length);
}
encryptedStream.Flush();
encryptedStream.Close();
inFile.Close();
ms.Position = 0;
return ms;
}
/// <summary>
/// Decrypt a string
/// </summary>
/// <param name="input">Input string in base 64 format</param>
/// <returns>Decrypted string</returns>
public static string Decrypt(string input, string password)
{
byte[] encryptedBytes = Convert.FromBase64String(input);
byte[] saltBytes = Encoding.UTF8.GetBytes(password);
string decryptedString = string.Empty;
using (var aes = new AesManaged())
{
Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes(password, 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);
using (ICryptoTransform decryptTransform = aes.CreateDecryptor())
{
using (MemoryStream decryptedStream = new MemoryStream())
{
CryptoStream decryptor =
new CryptoStream(decryptedStream, decryptTransform, CryptoStreamMode.Write);
decryptor.Write(encryptedBytes, 0, encryptedBytes.Length);
decryptor.Flush();
decryptor.Close();
byte[] decryptBytes = decryptedStream.ToArray();
decryptedString =
UTF8Encoding.UTF8.GetString(decryptBytes, 0, decryptBytes.Length);
}
}
}
return decryptedString;
}
public static string Encrypt(string key, string text)
{
// Our symmetric encryption algorithm
AesManaged aes = new AesManaged();
// We're using the PBKDF2 standard for password-based key generation
Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes("password", Encoding.UTF8.GetBytes(key));
// 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);
byte[] utfData = Encoding.Unicode.GetBytes(text);
encryptor.Write(utfData, 0, utfData.Length);
encryptor.Flush();
encryptor.Close();
// return encrypted content
return Convert.ToBase64String(encryptStream.ToArray());
}
/// <summary>
///
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static string Encrypt(string password)
{
byte[] utfData = UTF8Encoding.UTF8.GetBytes(password);
byte[] saltBytes = Encoding.UTF8.GetBytes("Element5");
string encryptedString = string.Empty;
using (AesManaged aes = new AesManaged())
{
Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes(password, 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);
using (ICryptoTransform encryptTransform = aes.CreateEncryptor())
{
using (MemoryStream encryptedStream = new MemoryStream())
{
using (CryptoStream encryptor =
new CryptoStream(encryptedStream, encryptTransform, CryptoStreamMode.Write))
{
encryptor.Write(utfData, 0, utfData.Length);
encryptor.Flush();
encryptor.Close();
byte[] encryptBytes = encryptedStream.ToArray();
encryptedString = Convert.ToBase64String(encryptBytes);
encryptedString = encryptedString.Substring(0, 20);
}
}
}
}
return encryptedString;
}
public string Decrypt(byte[] key, string encryptedString)
{
// Initialize
AesManaged decryptor = new AesManaged();
byte[] encryptedData = Convert.FromBase64String(encryptedString);
// Set the key
decryptor.Key = key;
decryptor.IV = key;
// create a memory stream
using (MemoryStream decryptionStream = new MemoryStream())
{
// Create the crypto stream
using (
CryptoStream decrypt = new CryptoStream(decryptionStream, decryptor.CreateDecryptor(),
CryptoStreamMode.Write))
{
// Encrypt
decrypt.Write(encryptedData, 0, encryptedData.Length);
decrypt.Flush();
decrypt.Close();
// Return the unencrypted data
byte[] decryptedData = decryptionStream.ToArray();
return UTF8Encoding.UTF8.GetString(decryptedData, 0, decryptedData.Length);
}
}
}
/// <summary>
/// Decrypt a Base64 string using Triple Data Encryption Standard(TDES) 256 bit symmetric encryption format
/// and returns the decrypted string. The decryption key is generated based on the FiWare
/// framework assembly public key.
/// </summary>
/// <param name="valueToDecrypt">Input String to decrypy in Base64 format.</param>
/// <returns>Decrypted output string.</returns>
public string DecryptString(string valueToDecrypt)
{
using (MemoryStream decryVal = new MemoryStream())
{
using (TripleDESCryptoServiceProvider cryptoProvider = new TripleDESCryptoServiceProvider())
{
symKey = new byte[24];
symIV = new byte[8];
byte[] publicKey = Assembly.GetExecutingAssembly().GetName().GetPublicKey();
Encoding encoding = Encoding.UTF8;
string keyValue = encoding.GetString(publicKey);
GenerateKeyVector(keyValue);
cryptoProvider.Key = symKey;
cryptoProvider.IV = symIV;
using (ICryptoTransform cryptoTrans = cryptoProvider.CreateDecryptor())
{
using (CryptoStream cryptoStreamDecr = new CryptoStream(decryVal, cryptoTrans, CryptoStreamMode.Write))
{
byte[] arrayInput = Convert.FromBase64String(valueToDecrypt);
cryptoStreamDecr.Write(arrayInput, 0, arrayInput.Length);
cryptoStreamDecr.Flush();
}
}
return encoding.GetString(decryVal.ToArray());
}
}
}
public static bool EncryptFile(string alg, string key, string srcFile, string dstFile)
{
try
{
SymmetricAlgorithm cipher = SymmetricAlgorithm.Create(alg);
cipher.Key = Encoding.Default.GetBytes(key);
cipher.IV = cipher.Key;
FileStream iStream = File.OpenRead(srcFile);
FileStream oStream = new FileStream(dstFile, FileMode.Create);
CryptoStream cStream = new CryptoStream(oStream, cipher.CreateEncryptor(), CryptoStreamMode.Write);
byte[] buffer = new byte[4096];
int len = iStream.Read(buffer, 0, buffer.Length);
while (len > 0)
{
cStream.Write(buffer, 0, len);
len = iStream.Read(buffer, 0, buffer.Length);
}
cStream.Flush();
cStream.Close();
oStream.Close();
iStream.Close();
return true;
}
catch
{
return false;
}
}
public string Encrypt(string data)
{
try
{
List<byte> hexString = new List<byte>(Encoding.Default.GetBytes(data));
while (hexString.Count % 16 != 0)
{
hexString.Add(0x00);
}
_rijndael.Key = _chatKey;
CryptoStream stream = new CryptoStream(new MemoryStream(hexString.ToArray()), _rijndael.CreateEncryptor(), CryptoStreamMode.Read);
MemoryStream textBytes = new MemoryStream();
#if NET20 || NET35
byte[] buffer = new byte[1024];
int read = stream.Read(buffer, 0, buffer.Length);
stream.Flush();
textBytes.Write(buffer, 0, read);
#else
stream.CopyTo(textBytes);
#endif
return Convert.ToBase64String(textBytes.ToArray());
}
catch (CryptographicException e)
{
Debug.WriteLine("A Cryptographic error occurred: {0}", e.Message);
return null;
}
}
/// <summary>
/// Encrypt a message using AES in CBC (cipher-block chaining) mode.
/// </summary>
/// <param name="plaintext">The message (plaintext) to encrypt</param>
/// <param name="key">An AES key</param>
/// <param name="iv">The IV to use or null to use a 0 IV</param>
/// <param name="addHmac">When set, a SHA256-based HMAC (HMAC256) of 32 bytes using the same key is added to the plaintext
/// before it is encrypted.</param>
/// <returns>The ciphertext derived by encrypting the orignal message using AES in CBC mode</returns>
public static byte[] EncryptAesCbc(byte[] plaintext, byte[] key, byte[] iv = null, bool addHmac = false)
{
using (Aes aes =Aes.Create())
// using (AesCryptoServiceProvider aes = new AesCryptoServiceProvider())
{
aes.Key = key;
if (iv == null)
iv = NullIv;
aes.Mode = CipherMode.CBC;
aes.IV = iv;
// Encrypt the message with the key using CBC and InitializationVector=0
byte[] cipherText;
using (System.IO.MemoryStream ciphertext = new System.IO.MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ciphertext, aes.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(plaintext, 0, plaintext.Length);
if (addHmac)
{
byte[] hmac = new HMACSHA256(key).ComputeHash(plaintext);
cs.Write(hmac, 0, hmac.Length);
}
cs.Flush();
}
cipherText = ciphertext.ToArray();
}
return cipherText;
}
}
/// <summary>
/// Metoda za simetrično kriptiranje
/// </summary>
/// <param name="file"></param>
public void SyncCrypt(string file)
{
string zapis;
zapis = file + ".ecb";
FileStream fstreamU = File.OpenRead(file),
fstreamO = File.OpenWrite(zapis);
long lSize = fstreamU.Length;
byte[] bytes = new byte[BufferSize];
int read = -1;
Rijndael rijndaelAlg = Rijndael.Create();
rijndaelAlg.Mode = CipherMode.ECB;
TextReader streamreader = new StreamReader("tajni_kljuc.txt");
string secretKey = streamreader.ReadLine();
rijndaelAlg.Key = Convert.FromBase64String(secretKey);
streamreader.Close();
CryptoStream cout = new CryptoStream(fstreamO, rijndaelAlg.CreateEncryptor(), CryptoStreamMode.Write);
BinaryWriter bw = new BinaryWriter(cout);
bw.Write(lSize);
while ((read = fstreamU.Read(bytes, 0, bytes.Length)) != 0)
{
cout.Write(bytes, 0, read);
}
cout.Flush();
cout.Close();
cout.Dispose();
fstreamU.Flush();
fstreamU.Close();
fstreamU.Dispose();
}
EncryptedValue IEncryptionService.Encrypt(string value)
{
if (Key == null)
throw new InvalidOperationException("Cannot encrypt because a Key was not configured. Please specify 'RijndaelEncryptionServiceConfig' in your application's configuration file.");
using (var rijndael = new RijndaelManaged())
{
rijndael.Key = Key;
rijndael.Mode = CipherMode.CBC;
rijndael.GenerateIV();
using (var encryptor = rijndael.CreateEncryptor())
using (var memoryStream = new MemoryStream())
using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
using (var writer = new StreamWriter(cryptoStream))
{
writer.Write(value);
writer.Flush();
cryptoStream.Flush();
cryptoStream.FlushFinalBlock();
return new EncryptedValue
{
EncryptedBase64Value = Convert.ToBase64String(memoryStream.ToArray()),
Base64Iv = Convert.ToBase64String(rijndael.IV)
};
}
}
}
/// <summary>
/// Decrypt encrypted string
/// </summary>
/// <param name="Str">Encrypted string</param>
/// <param name="Password">Password used for encryption</param>
/// <param name="Salt">Salt string used for encryption (at least 8 bytes)</param>
/// <returns>Decrypted string if success; otherwise - empty string</returns>
public static string DecryptString(string Str, string Password = "******", string Salt = "tdcm1234")
{
try
{
using (Aes aes = new AesManaged())
{
Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(Password, Encoding.UTF8.GetBytes(Salt));
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(Str);
decrypt.Write(encryptedData, 0, encryptedData.Length);
decrypt.Flush();
}
byte[] decryptedData = decryptionStream.ToArray();
return UTF8Encoding.UTF8.GetString(decryptedData, 0, decryptedData.Length);
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Error : AES ~ DecryptString ; " + ex.Message);
return "";
}
}
public EncryptedValue Encrypt(string value)
{
using (var rijndael = new RijndaelManaged())
{
rijndael.Key = Key;
rijndael.Mode = CipherMode.CBC;
rijndael.GenerateIV();
using (var encryptor = rijndael.CreateEncryptor())
using (var memoryStream = new MemoryStream())
using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
using (var writer = new StreamWriter(cryptoStream))
{
writer.Write(value);
writer.Flush();
cryptoStream.Flush();
cryptoStream.FlushFinalBlock();
return new EncryptedValue
{
EncryptedBase64Value = Convert.ToBase64String(memoryStream.ToArray()),
Base64Iv = Convert.ToBase64String(rijndael.IV)
};
}
}
}
public static void EncryptFile(string strInFile, string strOutFile)
{
// Create a file pointer to the text file to encrypt.
FileStream fileInText = new FileStream(strInFile,FileMode.Open, FileAccess.Read);
// Create a file pointer for the encrypted output file.
FileStream fileOutEncrypted = new FileStream(strOutFile, FileMode.Create, FileAccess.Write);
// Start encryption service and provided string parameter as key.
DESCryptoServiceProvider DES = new DESCryptoServiceProvider();
DES.Key = ASCIIEncoding.ASCII.GetBytes(KEY);
DES.IV = ASCIIEncoding.ASCII.GetBytes(KEY);
ICryptoTransform desencrypt = DES.CreateEncryptor();
// Links the key and the data in a stream.
CryptoStream cryptostream = new CryptoStream(fileOutEncrypted,desencrypt,CryptoStreamMode.Write);
byte[] bytearrayInput = new byte[fileInText.Length];
fileInText.Read(bytearrayInput, 0, bytearrayInput.Length);
cryptostream.Write(bytearrayInput, 0, bytearrayInput.Length);
cryptostream.Flush();
cryptostream.Close();
fileInText.Close();
}
public void FullByteRangeTest()
{
//writing
MemoryStream ms = new MemoryStream(); //this could be any stream we want to write to
YEncEncoder encoder = new YEncEncoder();
CryptoStream cs = new CryptoStream(ms, encoder, CryptoStreamMode.Write);
byte[] bytes = new byte[256];
for(int i=byte.MinValue; i<=byte.MaxValue; i++)
{
bytes[i] = (byte)i;
}
BinaryWriter w = new BinaryWriter(cs);
w.Write(bytes, 0, 256);
w.Flush();
cs.Flush();
//reading back from the memorystream
ms.Position = 0;
YEncDecoder decoder = new YEncDecoder();
CryptoStream cs2 = new CryptoStream(ms, decoder, CryptoStreamMode.Read);
BinaryReader r = new BinaryReader(cs2);
byte[] newBytes = r.ReadBytes(256);
Assert.AreEqual(BitConverter.ToString(bytes, 0, 256), BitConverter.ToString(newBytes, 0, 256));
}
/// <summary>
/// Serializes this <see cref="Token"/> instance as a string that can be
/// included as part of a return_to variable in a querystring.
/// This string is cryptographically signed to protect against tampering.
/// </summary>
public string Serialize(INonceStore store) {
using (MemoryStream dataStream = new MemoryStream()) {
if (!persistSignature(store)) {
Debug.Assert(!persistNonce(Endpoint, store), "Without a signature, a nonce is meaningless.");
dataStream.WriteByte(0); // there will be NO signature.
StreamWriter writer = new StreamWriter(dataStream);
Endpoint.Serialize(writer);
writer.Flush();
return Convert.ToBase64String(dataStream.ToArray());
} else {
using (HashAlgorithm shaHash = createHashAlgorithm(store))
using (CryptoStream shaStream = new CryptoStream(dataStream, shaHash, CryptoStreamMode.Write)) {
StreamWriter writer = new StreamWriter(shaStream);
Endpoint.Serialize(writer);
if (persistNonce(Endpoint, store))
writer.WriteLine(Nonce.Code);
writer.Flush();
shaStream.Flush();
shaStream.FlushFinalBlock();
byte[] hash = shaHash.Hash;
byte[] data = new byte[1 + hash.Length + dataStream.Length];
data[0] = 1; // there is a signature
Buffer.BlockCopy(hash, 0, data, 1, hash.Length);
Buffer.BlockCopy(dataStream.ToArray(), 0, data, 1 + hash.Length, (int)dataStream.Length);
return Convert.ToBase64String(data);
}
}
}
}
static void Decrypt(string[] args)
{
//Precheck if a tmp file already exists.
//If so delete it.
if (File.Exists(args[0] + ".tmp"))
{
Display("Destroying old .tmp files.");
DestroyFile(args[0] + ".tmp");
Display("Done.");
}
//SET UP STREAMS//
FileStream Output;
FileStream Input;
CryptoStream CryptStream;
//SET UP SERVICE PROVIDERS//
AesCryptoServiceProvider ACSP = new AesCryptoServiceProvider();
//AES PARAMETERS//
ACSP.Padding = PaddingMode.PKCS7;
Display("Creating keys.");
ACSP.IV = GenerateIV(args[2]); //initialization vector
ACSP.Key = GenerateKey(args[2]); //32 byte key
Display("Done.");
Input = new FileStream(args[0], FileMode.Open);
Output = new FileStream(args[0] + ".tmp", FileMode.CreateNew);
CryptStream = new CryptoStream(Input, ACSP.CreateDecryptor(), CryptoStreamMode.Read);
Display("Starting decryption.");
CryptStream.CopyTo(Output);
Display("Done.");
Input.Flush();
Input.Dispose();
CryptStream.Flush();
//CryptStream.Dispose(); <-- Is disposed with input.
Output.Flush();
Output.Dispose();
Display("Destroying old raw file.");
DestroyFile(args[0]);
Display("Done.");
//Rename .tmp to the original file.
Display("Renaming new file.");
File.Move(args[0] + ".tmp", args[0]);
Display("Done.");
ACSP.Dispose();
Display("Decryption process completed.");
Console.ReadKey();
return;
}
public string Decrypt(string data,int vi)
{
MemoryStream ms = new MemoryStream();
Byte[] tb = Convert.FromBase64String(data);
des.Key = Convert.FromBase64String(Keys[vi]);
des.IV = Convert.FromBase64String(IVs[vi]);
CryptoStream cs = new CryptoStream(ms,des.CreateDecryptor(),CryptoStreamMode.Write);
cs.Write(tb,0,tb.Length);
cs.Flush();
cs.Close();
return Encoding.Unicode.GetString(ms.ToArray());
}
internal string Decrypt(string cipherText)
{
var keyBytes = new Rfc2898DeriveBytes(Password, salt, Iterations);
var alg = new RijndaelManaged {Key = keyBytes.GetBytes(32), IV = keyBytes.GetBytes(16)};
var decryptStream = new MemoryStream();
var decrypt = new CryptoStream(decryptStream, alg.CreateDecryptor(), CryptoStreamMode.Write);
byte[] data = Convert.FromBase64String(cipherText);
decrypt.Write(data, 0, data.Length);
decrypt.Flush();
decrypt.Close();
return Encoding.UTF8.GetString(decryptStream.ToArray());
}
/// <summary>
/// Permet de crypter une chaine de caractères
/// </summary>
/// <param name="p_chaineACrypter">Chaine de caractères qui doit être cryptée</param>
/// <returns>
/// La chaine de caractères cryptée
/// </returns>
public string Crypter(string p_chaineACrypter)
{
byte[] cleEnByte = new byte[32];
MemoryStream memoryBuffer = new MemoryStream();
CryptoStream crypteur = new CryptoStream(memoryBuffer, _rijndael.CreateEncryptor(_cleHasher, _vecteurInitialisation), CryptoStreamMode.Write);
crypteur.Write(Encoding.ASCII.GetBytes(p_chaineACrypter), 0, p_chaineACrypter.Length);
crypteur.Flush();
crypteur.Close();
return Convert.ToBase64String(memoryBuffer.ToArray());
}
public static string Decrypt(string base64Input)
{
if (string.IsNullOrEmpty(base64Input))
{
return string.Empty;
}
if (string.IsNullOrWhiteSpace(base64Input))
{
return string.Empty;
}
// Get inputs as bytes
byte[] encryptBytes = Convert.FromBase64String(base64Input);
byte[] saltBytes = Encoding.UTF8.GetBytes(SALT);
// We're using the PBKDF2 standard for password-based key generation
Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes(
PASS, saltBytes);
// Our symmetric encryption algorithm
AesManaged aes = new AesManaged();
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);
// Now, decryption
ICryptoTransform decryptTrans = aes.CreateDecryptor();
// Output stream, can be also a FileStream
MemoryStream decryptStream = new MemoryStream();
CryptoStream decryptor = new CryptoStream(
decryptStream, decryptTrans, CryptoStreamMode.Write);
decryptor.Write(encryptBytes, 0, encryptBytes.Length);
decryptor.Flush();
decryptor.Close();
// Showing our decrypted content
byte[] decryptBytes = decryptStream.ToArray();
string decryptedString = Encoding.UTF8.GetString(
decryptBytes, 0, decryptBytes.Length);
// Close Stream
decryptStream.Close();
// Return decrypted text
return decryptedString;
}
public static string EncryptString(string input, string password)
{
using (MemoryStream memoryStream = new MemoryStream())
using (SymmetricAlgorithm algorithm = CreateRijndael(password, salt))
{
algorithm.IV = iv;
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, algorithm.CreateEncryptor(), CryptoStreamMode.Write))
{
byte[] bytes = UTF32Encoding.Default.GetBytes(input);
cryptoStream.Write(bytes, 0, bytes.Length);
cryptoStream.Flush();
}
return Convert.ToBase64String(memoryStream.ToArray());
}
}
public static string Encrypt(string input)
{
// Test data
var data = input;
var utfdata = Encoding.UTF8.GetBytes(data);
var saltBytes = Encoding.UTF8.GetBytes("saltIsGoodForYou");
// Our symmetric encryption algorithm
using (var aes = new AesManaged())
{
// We're using the PBKDF2 standard for password-based key generation
#if !SILVERLIGHT
using (var rfc = new Rfc2898DeriveBytes("thePassword", saltBytes))
{
#else
var rfc = new Rfc2898DeriveBytes("thePassword", saltBytes);
#endif
// 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
var encryptTransf = aes.CreateEncryptor();
// Output stream, can be also a FileStream
using (var encryptStream = new MemoryStream())
{
var encryptor = new CryptoStream(encryptStream, encryptTransf, CryptoStreamMode.Write);
encryptor.Write(utfdata, 0, utfdata.Length);
encryptor.Flush();
encryptor.Close();
// Showing our encrypted content
var encryptBytes = encryptStream.ToArray();
var encryptedString = Convert.ToBase64String(encryptBytes);
return encryptedString;
}
#if !SILVERLIGHT
}
#endif
}
}
// 加密
private void button3_Click(object sender, EventArgs e)
{
try
{
if (pictureBox1.ImageLocation == null)
{ MessageBox.Show("请选择一幅图片用于加密"); return; }
if (textBox1.Text == "")
{ MessageBox.Show("请选择加密文件路径"); return; }
//图片流
FileStream fsPic = new FileStream(pictureBox1.ImageLocation, FileMode.Open, FileAccess.Read);
//加密文件流
FileStream fsText = new FileStream(textBox1.Text, FileMode.Open, FileAccess.Read);
//初始化Key IV
byte[] bykey = new byte[16];
byte[] byIv = new byte[8];
fsPic.Read(bykey, 0, 16);
fsPic.Read(byIv, 0, 8);
//临时加密文件
string strPath = textBox1.Text;//加密文件的路径
int intLent = strPath.LastIndexOf("\\") + 1;
int intLong = strPath.Length;
string strName = strPath.Substring(intLent, intLong - intLent);//要加密的文件名称
string strLinPath = "C:\\" + strName;//临时加密文件路径，所以被加密的文件不可以放在C盘的根目录下
FileStream fsOut = File.Open(strLinPath, FileMode.Create, FileAccess.Write);
//开始加密
RC2CryptoServiceProvider desc = new RC2CryptoServiceProvider();//des进行加
BinaryReader br = new BinaryReader(fsText);//从要加密的文件中读出文件内容
CryptoStream cs = new CryptoStream(fsOut, desc.CreateEncryptor(bykey, byIv), CryptoStreamMode.Write);//写入临时加密文件
cs.Write(br.ReadBytes((int)fsText.Length), 0, (int)fsText.Length);//写入加密流
cs.FlushFinalBlock();
cs.Flush();
cs.Close();
fsPic.Close();
fsText.Close();
fsOut.Close();
File.Delete(textBox1.Text.TrimEnd());//册除原文件
File.Copy(strLinPath, textBox1.Text);//复制加密文件
File.Delete(strLinPath);//册除临时文件
MessageBox.Show("加密成功");
pictureBox1.ImageLocation = null;
textBox1.Text = "";
}
catch (Exception ee)
{
MessageBox.Show(ee.Message);
}
}
protected void BtnGenerate_Click(object sender, EventArgs e)
{
byte[] buf = GenerateRandom();
Response.ContentType = "application/octet-stream";
Response.AppendHeader("Content-Disposition", "inline; filename=\"random.txt\"");
using (var stm = new CryptoStream(
Response.OutputStream,
new ToBase64Transform(),
CryptoStreamMode.Write))
{
stm.Write(buf, 0, buf.Length);
stm.Flush();
}
Response.End();
}
private static void Crypto(Stream input, Stream output, ICryptoTransform transform)
{
var buffer = new byte[512];
var cs = new CryptoStream(output, transform, CryptoStreamMode.Write);
for (long i = 0; i < input.Length; i += buffer.Length)
{
int sz = (int)Math.Min(input.Length - input.Position, buffer.Length);
input.Read(buffer, 0, sz);
cs.Write(buffer, 0, sz);
}
int pad = buffer.Length - (int)(input.Length % buffer.Length);
if (pad > 0)
cs.Write(new byte[pad], 0, pad);
cs.Flush();
output.Flush();
output.Seek(0, SeekOrigin.Begin);
}
public static String Decrypt(String ciphertext, String salt)
{
Rfc2898DeriveBytes KeyBytes = new Rfc2898DeriveBytes(_privateKey, Encoding.UTF8.GetBytes(salt));
//The deafault iteration count is 1000
RijndaelManaged alg = new RijndaelManaged();
alg.Key = KeyBytes.GetBytes(32);
alg.IV = KeyBytes.GetBytes(16);
MemoryStream decryptStream = new MemoryStream();
//Stream to read
CryptoStream decrypt = new CryptoStream(decryptStream, alg.CreateDecryptor(), CryptoStreamMode.Write);
//convert ciphertext to byte array
byte[] data = Convert.FromBase64String(ciphertext); //IF using for WEB APPLICATION and getting ciphertext via Querystring change code to : Convert.FromBase64String(ciphertext.Replace(」 「,」+」));
decrypt.Write(data, 0, data.Length); //data to encrypt,start,stop
decrypt.Flush();
decrypt.Close();
return Encoding.UTF8.GetString(decryptStream.ToArray());//return PlainText
}
/// <summary>
/// Decrypt a Base64 string using Advanced Encryption Standard(AES) 256 bit symmetric encryption format
/// and returns the decrypted string. The decryption key is generated based on the
/// assembly public key.
/// </summary>
/// <param name="stringToDecrypt">Input String to decrypy in Base64 format.</param>
/// <returns>Decrypted output string.</returns>
public string DecryptString(string valueToDecrypt)
{
using (MemoryStream msDecrypted = new MemoryStream())
{
// Create a new instance of the RijndaelManaged
// class. This generates a new key and initialization
// vector (IV).
using (RijndaelManaged cryptoProvider = new RijndaelManaged())
{
//A (128/192/256) bit key and 128 bit IV is required for this provider.
symKey = new byte[16];
symIV = new byte[16];
//Get the public key from the executing assembly,
//this will be based on the strong name associated with the dll/with which
//the project was build
byte[] publicKey = Assembly.GetExecutingAssembly().GetName().GetPublicKey();
Encoding encoding = Encoding.UTF8;
string keyValue = encoding.GetString(publicKey);
GenerateKeyVector(keyValue);
cryptoProvider.KeySize = 128;
cryptoProvider.Key = symKey;
cryptoProvider.IV = symIV;
// Create a decryptor to perform the stream transform.
using (ICryptoTransform cryptoTrans = cryptoProvider.CreateDecryptor())
{
//AES decryption transform on incoming bytes.
using (CryptoStream cryptoStreamDecr = new CryptoStream(msDecrypted, cryptoTrans, CryptoStreamMode.Write))
{
byte[] arrayInput = Convert.FromBase64String(valueToDecrypt);
cryptoStreamDecr.Write(arrayInput, 0, arrayInput.Length);
cryptoStreamDecr.Flush();
}
}
//Return decrypted string
return encoding.GetString(msDecrypted.ToArray());
}
}
}
public static string DecryptFile(string sInputFilename, string sKey)
{
string result = "";
DESCryptoServiceProvider DES = new DESCryptoServiceProvider();
//A 64 bit key and IV is required for this provider.
//Set secret key For DES algorithm.
DES.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
//Set initialization vector.
DES.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
//Create a file stream to read the encrypted file back.
FileStream fsread = new FileStream(sInputFilename,
FileMode.Open,
FileAccess.Read);
//Create a DES decryptor from the DES instance.
ICryptoTransform desdecrypt = DES.CreateDecryptor();
//Create crypto stream set to read and do a
//DES decryption transform on incoming bytes.
//CryptoStream cryptostreamDecr = new CryptoStream(fsread, desdecrypt, CryptoStreamMode.Read);
//Print the contents of the decrypted file.
/*StreamWriter fsDecrypted = new StreamWriter(outputFile);
fsDecrypted.Write(new StreamReader(cryptostreamDecr).ReadToEnd());
fsDecrypted.Flush();
fsDecrypted.Close();*/
using (var output = new MemoryStream())
{
using (var cryptStream = new CryptoStream(fsread, desdecrypt, CryptoStreamMode.Read))
{
var buffer = new byte[1024];
var read = cryptStream.Read(buffer, 0, buffer.Length);
while (read > 0)
{
output.Write(buffer, 0, read);
read = cryptStream.Read(buffer, 0, buffer.Length);
}
cryptStream.Flush();
result = Encoding.Unicode.GetString(output.ToArray());
}
}
return result;
}
public static string Encrypt(string plaintext)
{
byte[] rgbIV;
byte[] key;
RijndaelManaged rijndael = BuildRigndaelCommon(out rgbIV, out key);
//convert plaintext into a byte array
byte[] plaintextBytes = Encoding.UTF8.GetBytes(plaintext);
byte[] cipherTextBytes = null;
//create uninitialized Rijndael encryption obj
using (RijndaelManaged symmetricKey = new RijndaelManaged())
{
//Call SymmetricAlgorithm.CreateEncryptor to create the Encryptor obj
var transform = rijndael.CreateEncryptor();
//Chaining mode
symmetricKey.Mode = CipherMode.CFB;
//create encryptor from the key and the IV value
ICryptoTransform encryptor = symmetricKey.CreateEncryptor(key, rgbIV);
//define memory stream to hold encrypted data
using (var ms = new MemoryStream())
using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
{
//encrypt contents of cryptostream
cs.Write(plaintextBytes, 0, plaintextBytes.Length);
cs.Flush();
cs.FlushFinalBlock();
//convert encrypted data from a memory stream into a byte array
ms.Position = 0;
cipherTextBytes = ms.ToArray();
ms.Close();
cs.Close();
}
}
//store result as a hex value
return BitConverter.ToString(cipherTextBytes).Replace("-", "");
}
