Solved

Symmetric Algorithm

Posted on 2008-10-11
2
300 Views
Last Modified: 2013-11-07
Hello All,

My sample code is listed below:
Please look into this.
using System;

using System.Data;

using System.Configuration;

using System.Web;

using System.Web.Security;

using System.Web.UI;

using System.Web.UI.WebControls;

using System.Web.UI.HtmlControls;

using System.IO;

using System.Security.Cryptography;

using System.Text;
 

/// <summary>

/// Summary description for SymmetricAlgorithm

/// </summary>

public abstract class SymmetricAlgorithm : IDisposable

{

	// State that is accessible to subclasses.

	protected int BlockSizeValue;

	protected int FeedbackSizeValue;

	protected byte[] IVValue;

	protected int KeySizeValue;

	protected byte[] KeyValue;

	protected KeySizes[] LegalBlockSizesValue;

	protected KeySizes[] LegalKeySizesValue;

	protected CipherMode ModeValue;

	protected PaddingMode PaddingValue;
 

	// Create a symmetric algorithm object.

	public static SymmetricAlgorithm Create()

	{

		return (SymmetricAlgorithm)

			(CryptoConfig.CreateFromName

			(CryptoConfig.SymmetricDefault, null));

	}

	public static SymmetricAlgorithm Create(String algName)

	{

		return (SymmetricAlgorithm)

			(CryptoConfig.CreateFromName(algName, null));

	}
 

	// Constructor.

	public SymmetricAlgorithm()

	{

		ModeValue = CipherMode.CBC;

		PaddingValue = PaddingMode.PKCS7;
 

		// Note: some implementations check that the subclass is

		// one of the builtin classes.  This is to ensure that

		// the user hasn't made their own cryptographic algorithm.

		//

		// Supposedly this is to obey US export rules that say

		// that plugging a new algorithm into an existing system

		// should not be allowed.

		//

		// However, releasing source code makes such rules meaningless

		// as the user could always modify the source and recompile.

		//

		// Even if this library was binary-only, it wouldn't stop

		// the user implementing their own encryption class that

		// didn't inherit from this class and then use that.

	}
 

	// Destructor.

	~SymmetricAlgorithm()

	{

		Dispose(false);

	}
 

	// Get or set the block size.

	public virtual int BlockSize

	{

		get

		{

			return BlockSizeValue;

		}

		set

		{

			KeySizes.Validate(LegalBlockSizesValue, value,

				"Crypto_InvalidBlockSize");

			BlockSizeValue = value;

		}

	}
 

	// Get or set the feedback size.

	public virtual int FeedbackSize

	{

		get

		{

			return FeedbackSizeValue;

		}

		set

		{

			if(value > BlockSizeValue)

			{

				throw new CryptographicException

					//(_("Crypto_InvalidFeedbackSize"),value.ToString());

					(("Crypto_InvalidFeedbackSize"),value.ToString());

			}

			FeedbackSizeValue = value;

		}

	}
 

	// Get or set the IV.

	public virtual byte[] IV

	{

		get

		{

			if(IVValue == null)

			{

				GenerateIV();

			}

			return IVValue;

		}

		set

		{

			if(value == null)

			{

				throw new ArgumentNullException("value");

			}

			else if(value.Length != BlockSizeValue)

			{

				throw new CryptographicException

					//(_("Crypto_InvalidIVSize"), value.ToString());

					(("Crypto_InvalidIVSize"), value.ToString());

			}

			IVValue = value;

		}

	}
 

	// Get or set the key value.

	public virtual byte[] Key

	{

		get

		{

			if(KeyValue == null)

			{

				GenerateKey();

			}

			return KeyValue;

		}

		set

		{

			if(value == null)

			{

				throw new ArgumentNullException("value");

			}

			KeySizes.Validate(LegalKeySizesValue, value.Length * 8,

				"Crypto_InvalidKeySize");

			KeyValue = value;

			KeySizeValue = value.Length * 8;

		}

	}
 

	// Get or set the key size value.

	public virtual int KeySize

	{

		get

		{

			return KeySizeValue;

		}

		set

		{

			KeySizes.Validate(LegalKeySizesValue, value,

				"Crypto_InvalidKeySize");

			KeySizeValue = value;

		}

	}
 

	// Get the list of legal block sizes.

	public virtual KeySizes[] LegalBlockSizes

	{

		get

		{

			return LegalBlockSizesValue;

		}

	}
 

	// Get the list of legal key sizes.

	public virtual KeySizes[] LegalKeySizes

	{

		get

		{

			return LegalKeySizesValue;

		}

	}
 

	// Get or set the cipher mode.

	public virtual CipherMode Mode

	{

		get

		{

			return ModeValue;

		}

		set

		{

			if(value < CipherMode.CBC || value > CipherMode.CTS)

			{

				throw new CryptographicException

					//(_("Crypto_InvalidCipherMode"));

					(("Crypto_InvalidCipherMode"));
 

			}

			ModeValue = value;

		}

	}
 

	// Get or set the padding mode.

	public virtual PaddingMode Padding

	{

		get

		{

			return PaddingValue;

		}

		set

		{

			if(value < PaddingMode.None || value > PaddingMode.Zeros)

			{

				throw new CryptographicException

					//(_("Crypto_InvalidPaddingMode"));

					(("Crypto_InvalidPaddingMode"));

			}

			PaddingValue = value;

		}

	}
 

	// Clear the state of this object.

	public void Clear()

	{

		((IDisposable)this).Dispose();

	}
 

	// Dispose the state of this object.

	void IDisposable.Dispose()

	{

		Dispose(true);

		GC.SuppressFinalize(this);

	}

	protected virtual void Dispose(bool disposing)

	{

		if(KeyValue != null)

		{

			Array.Clear(KeyValue, 0, KeyValue.Length);

		}

		if(IVValue != null)

		{

			Array.Clear(IVValue, 0, IVValue.Length);

		}

	}
 

	// Create a decryptor object with the current key and IV.

	public virtual ICryptoTransform CreateDecryptor()

	{

		return CreateDecryptor(Key, IV);

	}
 

	// Create a decryptor object with a specific key and IV.

	public abstract ICryptoTransform CreateDecryptor

		(byte[] rgbKey, byte[] rgbIV);
 

	// Create an encryptor object with the current key and IV.

	public virtual ICryptoTransform CreateEncryptor()

	{

		return CreateEncryptor(Key, IV);

	}

	public abstract ICryptoTransform CreateEncryptor

		(byte[] rgbKey, byte[] rgbIV);
 

	// Generate a random IV.

	public abstract void GenerateIV();
 

	// Generate a random key.

	public abstract void GenerateKey();
 

	// Determine if a key size is valid.

	public bool ValidKeySize(int bitLength)

	{

		return KeySizes.Validate(LegalKeySizesValue, bitLength);

	}
 

	// Validate "rgbKey" and "rgbIV" values for a call on

	// "CreateDecryptor" or "CreateEncryptor".

	internal void ValidateCreate(byte[] rgbKey, byte[] rgbIV)

	{

		if(rgbKey == null)

		{

			throw new ArgumentNullException("rgbKey");

		}

		KeySizes.Validate(LegalKeySizesValue, rgbKey.Length * 8,

			"Crypto_InvalidKeySize");

		if(rgbIV != null)

		{

			// Verify the size of the IV against the block size.

			if((rgbIV.Length * 8) != BlockSizeValue)

			{

				throw new CryptographicException

					//(_("Crypto_InvalidIVSize"), rgbIV.Length.ToString());

					(("Crypto_InvalidIVSize"), rgbIV.Length.ToString());

			}

		}

		else if(ModeValue != CipherMode.ECB)

		{

			// We must have an IV in every mode except ECB.

			throw new ArgumentNullException("rgbIV");

		}

	}
 

}; // class SymmetricAlgorithm

Open in new window

0
Comment
Question by:DevIndian
2 Comments
 
LVL 26

Accepted Solution

by:
Anurag Thakur earned 500 total points
ID: 22694719
The error says it all
Please go through the follwoing link and there is no method named Validate for KeySize
0
 

Author Comment

by:DevIndian
ID: 22694975
I can see the keySize class, how can I add the method Validate in it.Please suggest me.
0

Featured Post

Maximize Your Threat Intelligence Reporting

Reporting is one of the most important and least talked about aspects of a world-class threat intelligence program. Here’s how to do it right.

Join & Write a Comment

Suggested Solutions

Calculating holidays and working days is a function that is often needed yet it is not one found within the Framework. This article presents one approach to building a working-day calculator for use in .NET.
Real-time is more about the business, not the technology. In day-to-day life, to make real-time decisions like buying or investing, business needs the latest information(e.g. Gold Rate/Stock Rate). Unlike traditional days, you need not wait for a fe…
Internet Business Fax to Email Made Easy - With eFax Corporate (http://www.enterprise.efax.com), you'll receive a dedicated online fax number, which is used the same way as a typical analog fax number. You'll receive secure faxes in your email, fr…
Here's a very brief overview of the methods PRTG Network Monitor (https://www.paessler.com/prtg) offers for monitoring bandwidth, to help you decide which methods you´d like to investigate in more detail.  The methods are covered in more detail in o…

706 members asked questions and received personalized solutions in the past 7 days.

Join the community of 500,000 technology professionals and ask your questions.

Join & Ask a Question

Need Help in Real-Time?

Connect with top rated Experts

15 Experts available now in Live!

Get 1:1 Help Now