Symmetric Encryption Class

using System;
using System.Text;
using System.IO;
using System.Security.Cryptography;
using Encryption;

namespace Encryption {

public class TripleDESEncryption {

public static string EncryptData(string data, out byte[] desKey, out byte[] desIV) {
MemoryStream output = new MemoryStream();
byte[] byteData = new UnicodeEncoding().GetBytes(data);

//Use the TripleDES symmetric encryption algorithm to encrypt our data. Without an IV, the
//same input block of plaintext will encrypt to same output block of ciphertext. IV guarantees
//output of two identical plaintext blocks are different.
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
CryptoStream crypt = new CryptoStream(output, des.CreateEncryptor(), CryptoStreamMode.Write);

//Assign our crypto-generated key and iv values to our output arguments
desKey = des.Key; desIV = des.IV;
crypt.Write(byteData, 0, byteData.Length);

crypt.Close(); output.Close();
return new UnicodeEncoding().GetString(output.ToArray());
}

public static string EncryptData(byte[] desKey, byte[] desIV, string data) {
MemoryStream output = new MemoryStream();
byte[] byteData = new UnicodeEncoding().GetBytes(data);

//Use the TripleDES symmetric encryption algorithm to encrypt our data. Without an IV, the
//same input block of plaintext will encrypt to same output block of ciphertext. IV guarantees
//output of two identical plaintext blocks are different.
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
CryptoStream crypt = new CryptoStream(output, des.CreateEncryptor(desKey, desIV), CryptoStreamMode.Write);
crypt.Write(byteData, 0, byteData.Length);

crypt.Close(); output.Close();
return new UnicodeEncoding().GetString(output.ToArray());
}

public static string DecryptData(string data, byte[] desKey, byte[] desIV) {
MemoryStream output = new MemoryStream();
byte[] byteData = new UnicodeEncoding().GetBytes(data);

//Use the TripleDES symmetric encryption algorithm to decrypt our data. In order for the ciphertext to be
//successfully decrypted, the exact same key and iv must be used when initially encryted.
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
CryptoStream crypt = new CryptoStream(output, des.CreateDecryptor(desKey, desIV), CryptoStreamMode.Write);
crypt.Write(byteData, 0, byteData.Length);

crypt.Close(); output.Close();
return new UnicodeEncoding().GetString(output.ToArray());
}
}
}

class CipherText {

static void Main() {
byte[] key; byte[] iv;
string password = "secret";
string cif = TripleDESEncryption.EncryptData(password, out key, out iv);
Console.WriteLine(TripleDESEncryption.DecryptData(cif, key, iv));

//NOTE: Key and IVector must be 16 bytes each
//byte[] key = UnicodeEncoding.Unicode.GetBytes("cornhle");
//string cif = TripleDESEncryption.EncryptData(key, key, password);
//Console.WriteLine(TripleDESEncryption.DecryptData(cif, key, key));
}
}

Encrypting data from one stream to another and attaching hash of the password

using System.Security.Cryptography;
using System.IO;
using System.Data;
using System;
using System.Collections;
using System.ComponentModel;

public class PasswordEncryptor
{
private byte[] _keyBytes;
private byte[] _IVBytes;
private int _bufferSize=256;
private byte[] _hash;

public PasswordEncryptor(string password)
{
byte[] saltValueBytes = null;
PasswordDeriveBytes pdb = new PasswordDeriveBytes(password,saltValueBytes,"SHA1",50);
_keyBytes = pdb.GetBytes(32);
_IVBytes = pdb.GetBytes(16);

HashAlgorithm hasher = SHA256.Create();
_hash = hasher.ComputeHash(System.Text.ASCIIEncoding.ASCII.GetBytes("password"));
}

public void EncryptWithHash(Stream input, ref Stream output)
{
output.Write(_hash,0,_hash.Length);

RijndaelManaged rj = new System.Security.Cryptography.RijndaelManaged();
rj.Mode= CipherMode.CBC;

ICryptoTransform trans = rj.CreateEncryptor(_keyBytes, _IVBytes);

CryptoStream cs = new CryptoStream(output, trans, CryptoStreamMode.Write);

byte[] bytes = new byte[_bufferSize];

int byteCount;

while((byteCount = input.Read(bytes, 0, bytes.Length))!= 0)
{
cs.Write(bytes,0,byteCount);
}

cs.FlushFinalBlock();
//cs.Close();
}

public void DecryptWithHash(Stream input, ref Stream output)
{
byte[] inputHash = new byte[_hash.Length];
input.Read(inputHash,0,_hash.Length);

if (inputHash.Length!=_hash.Length) throw new Exception("Invalid Password");

for (int i=0;i<_hash.Length;i++)
{
if (_hash[i]!=inputHash[i]) throw new Exception("Invalid Password");
}

RijndaelManaged rj = new System.Security.Cryptography.RijndaelManaged();
rj.Mode= CipherMode.CBC;

ICryptoTransform trans = rj.CreateDecryptor(_keyBytes, _IVBytes);

CryptoStream cs = new CryptoStream(input, trans, CryptoStreamMode.Read);

byte[] bytes = new byte[_bufferSize];

int byteCount;

while((byteCount = cs.Read(bytes, 0, bytes.Length))!= 0)
{
output.Write(bytes,0,byteCount);
}

cs.Flush();
}

}

Basic Rijndael (AES) encryption

// Basic Rijndael (AES) encryption

using System.IO;
using System.Security.Cryptography;

private static readonly byte[] SALT = new byte[] { 0x26, 0xdc, 0xff, 0x00, 0xad, 0xed, 0x7a, 0xee, 0xc5, 0xfe, 0x07, 0xaf, 0x4d, 0x08, 0x22, 0x3c };

public static byte[] Encrypt(byte[] plain, string password)
{
MemoryStream memoryStream;
CryptoStream cryptoStream;
Rijndael rijndael = Rijndael.Create();
Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(password, SALT);
rijndael.Key = pdb.GetBytes(32);
rijndael.IV = pdb.GetBytes(16);
memoryStream = new MemoryStream();
cryptoStream = new CryptoStream(memoryStream, rijndael.CreateEncryptor(), CryptoStreamMode.Write);
cryptoStream.Write(plain, 0, plain.Length);
cryptoStream.Close();

return memoryStream.ToArray();
}
public static byte[] Decrypt(byte[] cipher, string password)
{
MemoryStream memoryStream;
CryptoStream cryptoStream;
Rijndael rijndael = Rijndael.Create();
Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(password, SALT);
rijndael.Key = pdb.GetBytes(32);
rijndael.IV = pdb.GetBytes(16);
memoryStream = new MemoryStream();
cryptoStream = new CryptoStream(memoryStream, rijndael.CreateDecryptor(), CryptoStreamMode.Write);
cryptoStream.Write(cipher, 0, cipher.Length);
cryptoStream.Close();

return memoryStream.ToArray();
}

RC4 Encryption

// RC4 Encryption

/*
From RSA Security's website:
"RC4 is a stream cipher designed by Rivest for RSA Data
Security (now RSA Security). It is a variable key-size stream
cipher with byte-oriented operations. The algorithm is based on
the use of a random permutation. Analysis shows that the period
of the cipher is overwhelmingly likely to be greater than 10^100.
Eight to sixteen machine operations are required per output byte,
and the cipher can be expected to run very quickly in software.
Independent analysts have scrutinized the algorithm and it is
considered secure."

This implementation encodes the byte stream to be encrypted
"in-place".

------------
// Examples:
------------

Byte[] Key = new Byte[5] { 12, 34, 22, 12, 32 };
Byte[] B = new Byte[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

// Examine B array before and after this next call.
RC4(ref B, Key);

// Examine B array before and after this next call.
RC4(ref B, Key);
*/


public void RC4(ref Byte[] bytes, Byte[] key )
{
Byte[] s = new Byte[256];
Byte[] k = new Byte[256];
Byte temp;
int i, j, t;
int byteLen = bytes.GetLength(0);
int keyLen = key.GetLength(0);

// Generate "8x8 S-Box" and initialize key index
for (i = 0; i < 256; i++)
{
s[i] = (Byte) i;
k[i] = key[i % keyLen];
}

j = 0;
for (i = 0; i<256; i++)
{
j = (j + s[i] + k[i]) % 256;
// swap
temp = s[i];
s[i] = s[j];
s[j] = temp;
}

i = j = 0;
for (int x = 0; x < byteLen; x++)
{
// The following is used to generate a random byte
i = (i + 1) % 256;
j = (j + s[i]) % 256;
temp = s[i];
s[i] = s[j];
s[j] = temp;
t = ((int)s[i] + s[j]) % 256;
// which is xor'd to the source
bytes[x] ^= s[t];
}
}