Comment mettre en œuvre Triple DES en C# (exemple complet)

Source complet ici: http://www.codeproject.com/Articles/14150/Encrypt-and-Decrypt-Data-with-C

Chiffrer:

public static string Encrypt(string toEncrypt, bool useHashing)
{
    byte[] keyArray;
    byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);

    System.Configuration.AppSettingsReader settingsReader = 
                                        new AppSettingsReader();
    //Get the key from config file

    string key = (string)settingsReader.GetValue("SecurityKey", 
                                                     typeof(String));
    //System.Windows.Forms.MessageBox.Show(key);
    //If hashing use get hashcode regards to your key
    if (useHashing)
    {
        MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
        keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
        //Always release the resources and flush data
        //of the Cryptographic service provide. Best Practice

        hashmd5.Clear();
    }
    else
        keyArray = UTF8Encoding.UTF8.GetBytes(key);

    TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
    //set the secret key for the tripleDES algorithm
    tdes.Key = keyArray;
    //mode of operation. there are other 4 modes.
    //We choose ECB(Electronic code Book)
    tdes.Mode = CipherMode.ECB;
    //padding mode(if any extra byte added)

    tdes.Padding = PaddingMode.PKCS7;

    ICryptoTransform cTransform = tdes.CreateEncryptor();
    //transform the specified region of bytes array to resultArray
    byte[] resultArray = 
      cTransform.TransformFinalBlock(toEncryptArray, 0, 
      toEncryptArray.Length);
    //Release resources held by TripleDes Encryptor
    tdes.Clear();
    //Return the encrypted data into unreadable string format
    return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}

Déchiffrer:

public static string Decrypt(string cipherString, bool useHashing)
{
    byte[] keyArray;
    //get the byte code of the string

    byte[] toEncryptArray = Convert.FromBase64String(cipherString);

    System.Configuration.AppSettingsReader settingsReader = 
                                        new AppSettingsReader();
    //Get your key from config file to open the lock!
    string key = (string)settingsReader.GetValue("SecurityKey", 
                                                 typeof(String));

    if (useHashing)
    {
        //if hashing was used get the hash code with regards to your key
        MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
        keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
        //release any resource held by the MD5CryptoServiceProvider

        hashmd5.Clear();
    }
    else
    {
        //if hashing was not implemented get the byte code of the key
        keyArray = UTF8Encoding.UTF8.GetBytes(key);
    }

    TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
    //set the secret key for the tripleDES algorithm
    tdes.Key = keyArray;
    //mode of operation. there are other 4 modes. 
    //We choose ECB(Electronic code Book)

    tdes.Mode = CipherMode.ECB;
    //padding mode(if any extra byte added)
    tdes.Padding = PaddingMode.PKCS7;

    ICryptoTransform cTransform = tdes.CreateDecryptor();
    byte[] resultArray = cTransform.TransformFinalBlock(
                         toEncryptArray, 0, toEncryptArray.Length);
    //Release resources held by TripleDes Encryptor                
    tdes.Clear();
    //return the Clear decrypted TEXT
    return UTF8Encoding.UTF8.GetString(resultArray);
}

OriginalL'auteur Chris Gessler

Ici est un exemple complet de copier coller prêt..

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Web;
namespace MVC3JavaScript_3_2012.Utilities
{
public class MyTripleDES
{
private readonly TripleDESCryptoServiceProvider _des = new TripleDESCryptoServiceProvider();
private readonly UTF8Encoding _utf8 = new UTF8Encoding();
///<summary>
///Key to use during encryption and decryption
///</summary>
private byte[] _keyValue;
public byte[] Key
{
get { return _keyValue; }
private set { _keyValue = value; }
}
///<summary>
///Initialization vector to use during encryption and decryption
///</summary>
private byte[] _ivValue;
public byte[] IV
{
get { return _ivValue; }
private set { _ivValue = value; }
}
///<summary>
///Constructor, allows the key and initialization vector to be provided as strings
///</summary>
///<param name="key"></param>
///<param name="iv"></param>
public MyTripleDES(string key, string iv)
{
_keyValue = Convert.FromBase64String(key);
_ivValue = Convert.FromBase64String(iv);
}
///<summary>
///Decrypt Bytes
///</summary>
///<param name="bytes"></param>
///<returns></returns>
public byte[] Decrypt(byte[] bytes)
{
return Transform(bytes, _des.CreateDecryptor(_keyValue, _ivValue));
}
///<summary>
///Encrypt Bytes
///</summary>
///<param name="bytes"></param>
///<returns></returns>
public byte[] Encrypt(byte[] bytes)
{
return Transform(bytes, _des.CreateEncryptor(_keyValue, _ivValue));
}
///<summary>
///Decrypt a string
///</summary>
///<param name="text"></param>
///<returns></returns>
public string Decrypt(string text)
{
byte[] input = HttpServerUtility.UrlTokenDecode(text);
byte[] output = Transform(input, _des.CreateDecryptor(_keyValue, _ivValue));
return _utf8.GetString(output);
}
///<summary>
///Encrypt a string and return Base64String
///</summary>
///<param name="text"></param>
///<returns></returns>
public string Encrypt(string text)
{
byte[] input = _utf8.GetBytes(text);
byte[] output = Transform(input, _des.CreateEncryptor(_keyValue, _ivValue));
return HttpServerUtility.UrlTokenEncode(output);
}
///<summary>
///Encrypt or Decrypt bytes.
///</summary>
private byte[] Transform(byte[] input, ICryptoTransform cryptoTransform)
{
//Create the necessary streams
using (var memory = new MemoryStream())
{
using (var stream = new CryptoStream(memory, cryptoTransform, CryptoStreamMode.Write))
{
//Transform the bytes as requested
stream.Write(input, 0, input.Length);
stream.FlushFinalBlock();
//Read the memory stream and convert it back into byte array
memory.Position = 0;
var result = new byte[memory.Length];
memory.Read(result, 0, result.Length);
//Return result
return result;
}
}
}
public static string CreateNewVector()
{
using (var des = new System.Security.Cryptography.TripleDESCryptoServiceProvider())
{
des.GenerateIV();
return Convert.ToBase64String(des.IV);
}
}
public static string CreateNewKey()
{
using (var des = new System.Security.Cryptography.TripleDESCryptoServiceProvider())
{
des.GenerateKey();
return Convert.ToBase64String(des.Key);
}
}
}
}

OriginalL'auteur TheDev6