Aşağıdakini çok uzun zaman önce yazmıştım. Bununla yapabilirsin ama bazı şifrelemeler geri döndürülemez. Bilgine.

public partial class Islemler
{
/// <summary>
/// Hash Şifreleme Yöntemleri
/// MD5
///SHA1
///SHA256
///SHA384
///SHA512
///Simetrik Şifreleme Yöntemleri
///DES
///Triple DES
///RC2
///Rijndael
///Asimetrik Şifreleme Yöntemleri
///DSA
///RSA
/// </summary>
/// <remarks>
/// Add more details here.
/// </remarks>
public Islemler()
{
}

#region Hash Şifreleme Yöntemleri

/// <summary>
/// MD5 Şifreleme
/// Çözümü Yok
/// </summary>
/// <param name="strGiris"></param>
/// <returns>string döndürür</returns>
public string SifreMD5(string strGiris)
{
if (strGiris == "" || strGiris == null)
{
throw new ArgumentNullException("Şifrelenecek veri yok");
}
else
{
MD5CryptoServiceProvider sifre = new MD5CryptoServiceProvider();
byte[] arySifre = ByteDonustur(strGiris);
byte[] aryHash = sifre.ComputeHash(arySifre);
return BitConverter.ToString(aryHash);
}
}

public string SifreSHA1(string strGiris)
{
if (strGiris == "" || strGiris == null)
{
throw new ArgumentNullException("Şifrelenecek veri yok.");
}
else
{
SHA1CryptoServiceProvider sifre = new SHA1CryptoServiceProvider();
byte[] arySifre = ByteDonustur(strGiris);
byte[] aryHash = sifre.ComputeHash(arySifre);
return BitConverter.ToString(aryHash);
}
}

public string SifreSHA256(string strGiris)
{
if (strGiris == "" || strGiris == null)
{
throw new ArgumentNullException("Şifrelenecek Veri Yok");
}
else
{
SHA256Managed sifre = new SHA256Managed();
byte[] arySifre = ByteDonustur(strGiris);
byte[] aryHash = sifre.ComputeHash(arySifre);
return BitConverter.ToString(aryHash);
}
}

public string SifreSHA384(string strGiris)
{
if (strGiris == "" || strGiris == null)
{
throw new ArgumentNullException("Şifrelenecek veri bulunamadı.");
}
else
{
SHA384Managed sifre = new SHA384Managed();
byte[] arySifre = ByteDonustur(strGiris);
byte[] aryHash = sifre.ComputeHash(arySifre);
return BitConverter.ToString(aryHash);
}
}

public string SifreSHA512(string strGiris)
{
if (strGiris == "" || strGiris == null)
{
throw new ArgumentNullException("Şifrelenecek veri yok.");
}
else
{
SHA512Managed sifre = new SHA512Managed();
byte[] arySifre = ByteDonustur(strGiris);
byte[] aryHash = sifre.ComputeHash(arySifre);
return BitConverter.ToString(aryHash);
}
}

#endregion Hash Şifreleme Yöntemleri

#region Simetrik Şifreleme Yöntemleri

/// <summary>
/// DES Şifreleme Yöntemi
/// Simetrik şifreleme yöntemlerinde şifrelenen veriye ulaşmak için şifreyi çözen tarafın veriyi şifreleyen tarafla aynı anahtara ihtiyacı vardır.
/// </summary>
/// <param name="strGiris">Şifrelenecek Veri</param>
/// <param name="key1">String Bir Şifre</param>
/// <param name="key2">String Bir Şifre</param>
/// <returns></returns>
public string SifreDESSifrele(string strGiris, string key1 = "123456", string key2 = "654321")
{
string sonuc = "";
if (strGiris == "" || strGiris == null)
{
throw new ArgumentNullException("Şifrelenecek veri yok");
}
else
{
byte[] aryKey = Byte8(key1); // BURAYA 8 bit string DEĞER GİRİN
byte[] aryIV = Byte8(key2); // BURAYA 8 bit string DEĞER GİRİN
DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, cryptoProvider.CreateEncryptor(aryKey, aryIV), CryptoStreamMode.Write);
StreamWriter writer = new StreamWriter(cs);
writer.Write(strGiris);
writer.Flush();
cs.FlushFinalBlock();
writer.Flush();
sonuc = Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);
writer.Dispose();
cs.Dispose();
ms.Dispose();
}
return sonuc;
}

/// <summary>
/// DES Çözme Yöntemi
/// Simetrik şifreleme yöntemlerinde şifrelenen veriye ulaşmak için şifreyi çözen tarafın veriyi şifreleyen tarafla aynı anahtara ihtiyacı vardır.
/// </summary>
/// <param name="strGiris">Çözülecek Veri</param>
/// <param name="key1">String Bir Şifre (8 Bit)</param>
/// <param name="key2">String Bir Şifre (8 Bit)</param>
/// <returns></returns>
public string SifreDESCoz(string strGiris, string key1 = "123456", string key2 = "654321")
{
string strSonuc = "";
if (strGiris == "" || strGiris == null)
{
throw new ArgumentNullException("Şifrelenecek veri yok.");
}
else
{
byte[] aryKey = Byte8(key1);
byte[] aryIV = Byte8(key2);
DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
MemoryStream ms = new MemoryStream(Convert.FromBase64String(strGiris));
CryptoStream cs = new CryptoStream(ms, cryptoProvider.CreateDecryptor(aryKey, aryIV), CryptoStreamMode.Read);
StreamReader reader = new StreamReader(cs);
strSonuc = reader.ReadToEnd();
reader.Dispose();
cs.Dispose();
ms.Dispose();
}
return strSonuc;
}

/// <summary>
/// Triple Şifreleme Yöntemi
/// Simetrik şifreleme yöntemlerinde şifrelenen veriye ulaşmak için şifreyi çözen tarafın veriyi şifreleyen tarafla aynı anahtara ihtiyacı vardır.
/// </summary>
/// <param name="strGiris">Şifrelenecek Veri</param>
/// <param name="key1">String Bir Şifre (24 Bit)</param>
/// <param name="key2">String Bir Şifre (8 Bit)</param>
/// <returns></returns>
public string SifreTripleDESSifrele(string strGiris, string key1 = "123456781234567812345678", string key2 = "12345678")
{
string sonuc = "";
if (strGiris == "" || strGiris == null)
{
throw new ArgumentNullException("Şifrelenecek veri yok.");
}
else
{
byte[] aryKey = Byte8(key1);
byte[] aryIV = Byte8(key2);
TripleDESCryptoServiceProvider dec = new TripleDESCryptoServiceProvider();
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, dec.CreateEncryptor(aryKey, aryIV), CryptoStreamMode.Write);
StreamWriter writer = new StreamWriter(cs);
writer.Write(strGiris);
writer.Flush();
cs.FlushFinalBlock();
writer.Flush();
sonuc = Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);
writer.Dispose();
cs.Dispose();
ms.Dispose();
}
return sonuc;
}

/// <summary>
/// DES Çözme Yöntemi
/// Simetrik şifreleme yöntemlerinde şifrelenen veriye ulaşmak için şifreyi çözen tarafın veriyi şifreleyen tarafla aynı anahtara ihtiyacı vardır.
/// </summary>
/// <param name="strGiris">Çözülecek Veri</param>
/// <param name="key1">String Bir Şifre (24 Bit)</param>
/// <param name="key2">String Bir Şifre (8 Bit)</param>
/// <returns></returns>
public string SifreTripleDESCoz(string strGiris, string key1 = "123456781234567812345678", string key2 = "12345678")
{
string strSonuc = "";
if (strGiris == "" || strGiris == null)
{
throw new ArgumentNullException("Şifrelenecek veri yok.");
}
else
{
byte[] aryKey = Byte8(key1);
byte[] aryIV = Byte8(key2);
TripleDESCryptoServiceProvider cryptoProvider = new TripleDESCryptoServiceProvider();
MemoryStream ms = new MemoryStream(Convert.FromBase64String(strGiris));
CryptoStream cs = new CryptoStream(ms, cryptoProvider.CreateDecryptor(aryKey, aryIV), CryptoStreamMode.Read);
StreamReader reader = new StreamReader(cs);
strSonuc = reader.ReadToEnd();
reader.Dispose();
cs.Dispose();
ms.Dispose();
}
return strSonuc;
}

/// <summary>
/// RC2 Şifreleme Yöntemi
/// Simetrik şifreleme yöntemlerinde şifrelenen veriye ulaşmak için şifreyi çözen tarafın veriyi şifreleyen tarafla aynı anahtara ihtiyacı vardır.
/// </summary>
/// <param name="strGiris">Şifrelenecek Veri</param>
/// <param name="key1">String Bir Şifre (24 Bit)</param>
/// <param name="key2">String Bir Şifre (8 Bit)</param>
/// <returns></returns>
public string SifreRC2Sifrele(string strGiris, string key1 = "123456", string key2 = "654321")
{
string sonuc = "";
if (strGiris == "" || strGiris == null)
{
throw new ArgumentNullException("Şifrelenecek veri yok.");
}
else
{
byte[] aryKey = Byte8(key1);
byte[] aryIV = Byte8(key2);
RC2CryptoServiceProvider dec = new RC2CryptoServiceProvider();
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, dec.CreateEncryptor(aryKey, aryIV), CryptoStreamMode.Write);
StreamWriter writer = new StreamWriter(cs);
writer.Write(strGiris);
writer.Flush();
cs.FlushFinalBlock();
writer.Flush();
sonuc = Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);
writer.Dispose();
cs.Dispose();
ms.Dispose();
}
return sonuc;
}

/// <summary>
/// RC2 Çözme Yöntemi
/// Simetrik şifreleme yöntemlerinde şifrelenen veriye ulaşmak için şifreyi çözen tarafın veriyi şifreleyen tarafla aynı anahtara ihtiyacı vardır.
/// </summary>
/// <param name="strGiris">Çözülecek Veri</param>
/// <param name="key1">String Bir Şifre (24 Bit)</param>
/// <param name="key2">String Bir Şifre (8 Bit)</param>
/// <returns></returns>
public string SifreRC2Coz(string strGiris, string key1 = "123456", string key2 = "654321")
{
string strSonuc = "";
if (strGiris == "" || strGiris == null)
{
throw new ArgumentNullException("Şifresi çözülecek veri yok.");
}
else
{
byte[] aryKey = Byte8(key1);
byte[] aryIV = Byte8(key2);
RC2CryptoServiceProvider cp = new RC2CryptoServiceProvider();
MemoryStream ms = new MemoryStream(Convert.FromBase64String(strGiris));
CryptoStream cs = new CryptoStream(ms, cp.CreateDecryptor(aryKey, aryIV), CryptoStreamMode.Read);
StreamReader reader = new StreamReader(cs);
strSonuc = reader.ReadToEnd();
reader.Dispose();
cs.Dispose();
ms.Dispose();
}
return strSonuc;
}

/// <summary>
/// Rijndael Şifreleme Yöntemi
/// Simetrik şifreleme yöntemlerinde şifrelenen veriye ulaşmak için şifreyi çözen tarafın veriyi şifreleyen tarafla aynı anahtara ihtiyacı vardır.
/// </summary>
/// <param name="strGiris">Şifrelenecek Veri</param>
/// <param name="key1">String Bir Şifre (8 Bit)</param>
/// <param name="key2">String Bir Şifre (16 Bit)</param>
/// <returns></returns>
public string SifreRijndaelSifrele(string strGiris, string key1 = "12345678", string key2 = "1234567812345678")
{
string sonuc = "";
if (strGiris == "" || strGiris == null)
{
throw new ArgumentNullException("Şifrelenecek veri yok.");
}
else
{
byte[] aryKey = Byte8(key1);
byte[] aryIV = Byte8(key2);
RijndaelManaged dec = new RijndaelManaged();
dec.Mode = CipherMode.CBC;
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, dec.CreateEncryptor(aryKey, aryIV), CryptoStreamMode.Write);
StreamWriter writer = new StreamWriter(cs);
writer.Write(strGiris);
writer.Flush();
cs.FlushFinalBlock();
writer.Flush();
sonuc = Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);
writer.Dispose();
cs.Dispose();
ms.Dispose();
}
return sonuc;
}

/// <summary>
/// Rijndael Çözme Yöntemi
/// Simetrik şifreleme yöntemlerinde şifrelenen veriye ulaşmak için şifreyi çözen tarafın veriyi şifreleyen tarafla aynı anahtara ihtiyacı vardır.
/// </summary>
/// <param name="strGiris">Çözülecek Veri</param>
/// <param name="key1">String Bir Şifre (8 Bit)</param>
/// <param name="key2">String Bir Şifre (16 Bit)</param>
/// <returns></returns>
public string SifreRijndaelCoz(string strGiris, string key1 = "12345678", string key2 = "1234567812345678")
{
string strSonuc = "";
if (strGiris == "" || strGiris == null)
{
throw new ArgumentNullException("Şifrezi çözülecek veri yok.");
}
else
{
byte[] aryKey = Byte8(key1);
byte[] aryIV = Byte8(key2);
RijndaelManaged cp = new RijndaelManaged();
MemoryStream ms = new MemoryStream(Convert.FromBase64String(strGiris));
CryptoStream cs = new CryptoStream(ms, cp.CreateDecryptor(aryKey, aryIV), CryptoStreamMode.Read);
StreamReader reader = new StreamReader(cs);
strSonuc = reader.ReadToEnd();
reader.Dispose();
cs.Dispose();
ms.Dispose();
}
return strSonuc;
}

#endregion Simetrik Şifreleme Yöntemleri

#region Asimetrik Şifreleme

/// <summary>
/// Asimetrik şifreleme yöntemleri ileri düzey şifreleme yöntemleridir. Bu algoritma türünde veriyi şifreleyen taraf ile veriyi çözecek olan taraf birbirinden farklı anahtarlar kullanırlar.
/// </summary>
/// <param name="strGiris"></param>
/// <param name="prm"></param>
/// <returns></returns>
public string AsimetrikSifrele(string strGiris, out RSAParameters prm)
{
string strSonuc = "";
if (strGiris == "")
{
throw new ArgumentNullException("Şifrelenecek veri yok.");
}
else
{
byte[] aryDizi = ByteDonustur(strGiris);
RSACryptoServiceProvider dec = new RSACryptoServiceProvider();
prm = dec.ExportParameters(true);
byte[] aryDonus = dec.Encrypt(aryDizi, false);
strSonuc = Convert.ToBase64String(aryDonus);
}
return strSonuc;
}

/// <summary>
/// Asimetrik şifreleme yöntemleri ileri düzey şifreleme yöntemleridir. Bu algoritma türünde veriyi şifreleyen taraf ile veriyi çözecek olan taraf birbirinden farklı anahtarlar kullanırlar.
/// </summary>
/// <param name="strGiris"></param>
/// <param name="prm"></param>
/// <returns></returns>
public string AsimetrikCoz(string strGiris, RSAParameters prm)
{
string strSonuc = "";
if (strGiris == "" || strGiris == null)
{
throw new ArgumentNullException("Çözülecek kayıt yok");
}
else
{
RSACryptoServiceProvider dec = new RSACryptoServiceProvider();
byte[] aryDizi = Convert.FromBase64String(strGiris);
UnicodeEncoding UE = new UnicodeEncoding();
dec.ImportParameters(prm);
byte[] aryDonus = dec.Decrypt(aryDizi, false);
strSonuc = UE.GetString(aryDonus);
}
return strSonuc;
}

#endregion Asimetrik Şifreleme

/// <summary>
/// Şifreleme İçin Gereken Yapılar
/// </summary>
/// <param name="deger"></param>
/// <returns>byte döndürür</returns>
public static byte[] ByteDonustur(string deger)
{
UnicodeEncoding ByteConverter = new UnicodeEncoding();
return ByteConverter.GetBytes(deger);
}

/// <summary>
/// Şifreleme İçin Gereken Yapılar
/// </summary>
/// <param name="deger"></param>
/// <returns></returns>
public static byte[] Byte8(string deger)
{
char[] arrayChar = deger.ToCharArray();
byte[] arrayByte = new byte[arrayChar.Length];
for (int i = 0; i < arrayByte.Length; i++)
{
arrayByte[i] = Convert.ToByte(arrayChar[i]);
}
return arrayByte;
}
    }