Symmetric-encryption

Symmetric encryption in C#
Symmetric (two way/key based) encryption wrapper class.

Home
›
Code snippets
›
C#
›
Symmetric encryption in C#

The original class can be found at codeproject.com. This class is a tidied up version of it. You may get issues with the GetLegalIV portion of the code, particularly with triple DES. This is because it pads the IV with spaces, and is not compatible with other implementations of the algorithm, such as the Perl one.

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

namespace Sloppycode
{

/// <summary>
	/// Provides the standard 4 types of symmetric encryption
	/// methods supported by the .net framework.
	/// </summary>
	public enum EncryptionType
	{
		/// <summary>
		/// Data Encryption Standard algorithm, created in 1977.
		/// The standard encryption strength of DES is 56bit. The
		/// algorithm has been cracked using 100,00 PCs (combined power via the
		/// internet) in 22 hours 15 minutes!
		/// A detailed explanation can be found at:
		/// http://www.tropsoft.com/strongenc/des.htm
		/// </summary>
		DES,
		/// <summary>
		/// RC2 was created by RSA as a proposed replacement for
		/// the DES encryption standard. Its strength is 64bit
		/// (64bit block sizes). The RFC for the standard can 
		/// be found at: 
		/// http://www.networksorcery.com/enp/rfc/rfc2268.txt
		/// </summary>
		RC2,
		/// <summary>
		/// Rijndael is the encryption algorithm used for 
		/// the Advanced Encryption Standard (AES), the standard
		/// symmetric encryption method used by US Government organisations.
		/// The block size can be 128, 192, or 256 bits.
		/// Further information can be found at:
		/// http://csrc.nist.gov/CryptoToolkit/aes/rijndael/
		/// </summary>
		Rijndael,
		/// <summary>
		/// Triple DES is a more powerful form of the original DES standard,
		/// encrypting data using 364bit keys, giving Triple DES a strength
		/// of 192bits. The data is encrypted with the first key, 
		/// decrypted with the second key, and finally encrypted again with 
		/// the third key.
		/// A detailed explaination of the algorithm can be found at:
		/// http://www.tropsoft.com/strongenc/des3.htm
		/// </summary>
		TripleDES

//RC4
	}

/// <summary>
	/// SymmetricEncryption is a wrapper of System.Security.Cryptography.SymmetricAlgorithm 
	/// classes and simplifies the interface. Symmetric encryption involves a private
	/// key to encrypt the data, which enables the data to be de-crypted by other
	/// clients, providing they have the private key.
	/// 
	/// This class is based on Frank Fang's 'SymmCrypto' class, found at: 
	/// http://www.codeproject.com/dotnet/encryption_decryption.asp
	/// </summary>
	public class SymmetricEncryption
	{
		public string InitialIV
		{
			get
			{
				return this.initialIV;
			}
			set
			{
				this.initialIV = value;
			}
		}
		private string initialIV = "12345678";
		private SymmetricAlgorithm symmetricAlgorithm;

/// <summary>
		/// Creates a new SymmetricEncryption class with the EncryptionType provided.
		/// </summary>
		/// <param name="Type">The type of symmetric encryption to use.</param>
		public SymmetricEncryption(EncryptionType Type)
		{
			switch (Type)
			{
				case EncryptionType.DES:
					this.symmetricAlgorithm = new DESCryptoServiceProvider();
					break;
				case EncryptionType.RC2:
					this.symmetricAlgorithm = new RC2CryptoServiceProvider();
					break;
				case EncryptionType.Rijndael:
					this.symmetricAlgorithm = new RijndaelManaged();
					break;
				case EncryptionType.TripleDES:
					this.symmetricAlgorithm = new TripleDESCryptoServiceProvider();
					break;
				/*case EncryptionType.RC4:
					this.symmetricAlgorithm = new Org.Mentalis.Security.Cryptography.RC4CryptoServiceProvider();
					break;*/
			}
		}

/// <summary>
		/// Creates a new SymmetricEncryption class with the SymmetricAlgorithm
		/// provided (which could include an implementation of an algorithm
		/// not provided in the standard .net fcl).
		/// </summary>
		/// <param name="ServiceProvider">A</param>
		public SymmetricEncryption(SymmetricAlgorithm ServiceProvider)
		{
			this.symmetricAlgorithm = ServiceProvider;
		}

/// <summary>
		/// Encrypts data using the key provided, and the algorithm
		/// specified in the constructor of the class.
		/// </summary>
		/// <param name="Contents">The data to encrypt.</param>
		/// <param name="Key">The key to encrypt the data with. The longer
		/// and more random the key, the stronger the encryption is.</param>
		/// <returns>A string containing the contents, encrypted using the
		/// key and the algorithm specified in the constructor of the class.</returns>
		public string Encrypt(string Contents, string Key)
		{
			// use UTF8 unicode conversion for two byte characters
			byte[] bytIn = UTF8Encoding.UTF8.GetBytes(Contents);

// create a MemoryStream so that the process can be done without I/O files
			System.IO.MemoryStream ms = new System.IO.MemoryStream();

// set the private key
			this.symmetricAlgorithm.Key = GetLegalKey(Key);
			this.symmetricAlgorithm.IV = GetLegalIV();

// create an Encryptor from the Provider Service instance
			ICryptoTransform encrypto = this.symmetricAlgorithm.CreateEncryptor();

// create Crypto Stream that transforms a stream using the encryption
			CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);

// write out encrypted content into MemoryStream
			cs.Write(bytIn, 0, bytIn.Length);
			cs.FlushFinalBlock();

ms.Close();
			byte[] bytOut = ms.ToArray();

// convert into Base64 so that the result can be used in xml
			return System.Convert.ToBase64String(bytOut);
		}

/// <summary>
		/// Decrypts data using the key provided, and the algorithm
		/// specified in the constructor of the class.
		/// </summary>
		/// <param name="Contents">The data to decrypt.</param>
		/// <param name="Key">The key to decrypt the data with.</param>
		/// <returns>A string containing the contents, decrypted using the
		/// key and the algorithm specified in the constructor of the class.</returns>
		public string Decrypt(string Contents, string Key)
		{
			// convert from Base64 to binary
			byte[] bytIn = System.Convert.FromBase64String(Contents);
			// create a MemoryStream with the input
			System.IO.MemoryStream ms = new System.IO.MemoryStream(bytIn, 0, bytIn.Length);

// set the private key
			this.symmetricAlgorithm.Key = GetLegalKey(Key);
			this.symmetricAlgorithm.IV = GetLegalIV();

// create a Decryptor from the Provider Service instance
			ICryptoTransform encrypto = this.symmetricAlgorithm.CreateDecryptor();

// create Crypto Stream that transforms a stream using the decryption
			CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);

// read out the result from the Crypto Stream
			System.IO.StreamReader sr = new System.IO.StreamReader( cs );
			return sr.ReadToEnd();
		}

private byte[] GetLegalKey(string Key)
		{
			string sTemp = Key;
			this.symmetricAlgorithm.GenerateKey();
			byte[] bytTemp = this.symmetricAlgorithm.Key;
			int KeyLength = bytTemp.Length;
			if (sTemp.Length > KeyLength)
				sTemp = sTemp.Substring(0, KeyLength);
			else if (sTemp.Length < KeyLength)
				sTemp = sTemp.PadRight(KeyLength, ' ');

return ASCIIEncoding.ASCII.GetBytes(sTemp);
		}

private byte[] GetLegalIV()
		{
			// The initial string of IV may be modified with any data you like
			string sTemp = this.initialIV;
			this.symmetricAlgorithm.GenerateIV();
			byte[] bytTemp = this.symmetricAlgorithm.IV;
			int IVLength = bytTemp.Length;
			if (sTemp.Length > IVLength)
				sTemp = sTemp.Substring(0, IVLength);
			else if (sTemp.Length < IVLength)
				sTemp = sTemp.PadRight(IVLength, ' ');

return ASCIIEncoding.ASCII.GetBytes(sTemp);
		}
	}

}

› Home
› C#
› Snippets
› Articles
› Tools
› Taglines
› ASP
› Dictionary Object
› FSO
› Unix cheat sheet
› Gaming
› CSS
› Yak
› Umbraco
› About
› Contact
› Privacy
› Projects
› Search