Hi I Have following program.

When I run this program and try to encrypt the file using the "Encrypt"
button, the file gets encrypted. But every time i do encrypt, I get a
different output.

As per my knowledge of the cryptography, every time I encrypt same data
using the same key, I should get the same output. I want to use the key
imported into my local store (in this case the store name is "").

Any help is appreciated.

Thanks

//-------------------------------------------------------------------------------------------
using System;
using System.IO;
using System.Reflection;
using System.Text;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using System.Drawing;
using System.Security.Cryptography.X509Certificates;
using System.Runtime.InteropServices;
using System.Security.Cryptography;

namespace EncryptDecrypt
{
    }
public sealed class CERTPROPS_INFO
{
    public CERTPROPS_INFO(byte[] hash, string certsubjname)
    {
        this.sha1hash = hash;
        this.SubjectNameCN = certsubjname;
    }
    public byte[] Hash
    {
        get
        {
            return sha1hash;
        }
    }
    public String Name
    {
        get
        {
            return SubjectNameCN;
        }
    }

    private byte[] sha1hash;
    private String SubjectNameCN;
}

public class Form1 : System.Windows.Forms.Form
{
    private System.Windows.Forms.Button button1;
    private System.Windows.Forms.Button button2;
       
    private System.ComponentModel.Container components = null;

    public Form1()
    {
        InitializeComponent();
    }

    protected override void Dispose( bool disposing )
    {
        if( disposing )
        {
            if (components != null)
            {
                components.Dispose();
            }
        }
        base.Dispose( disposing );
    }

    #region Windows Form Designer generated code
    private void InitializeComponent()
    {
        this.button1 = new System.Windows.Forms.Button();
        this.button2 = new System.Windows.Forms.Button();
        this.SuspendLayout();
        // button1
        this.button1.Location = new System.Drawing.Point(72, 40);
        this.button1.Name = "button1";
        this.button1.Size = new System.Drawing.Size(128, 48);
        this.button1.TabIndex = 0;
        this.button1.Text = "Encrypt";
        this.button1.Click += new System.EventHandler(this.button1_Click);
        // button2
        this.button2.Location = new System.Drawing.Point(72, 120);
        this.button2.Name = "button2";
        this.button2.Size = new System.Drawing.Size(128, 40);
        this.button2.TabIndex = 1;
        this.button2.Text = "Decrypt";
        this.button2.Click += new System.EventHandler(this.button2_Click);
        // Form1
        this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
        this.ClientSize = new System.Drawing.Size(292, 266);
        this.Controls.AddRange(new System.Windows.Forms.Control[] {
             this.button2,
             this.button1});
        this.Name = "Form1";
        this.Text = "Form1";
        this.ResumeLayout(false);
    }
        #endregion

    /// The main entry point for the application.
    [STAThread]
    static void Main()
    {
           
        Application.Run(new Form1());
    }

    public byte[] Encrypt(byte[] data)
    {
        byte[] rawBuffer=data;
        byte[] encBuffer=null;
           
        // Length of the string to be encrypted
        uint bufLength= (uint)rawBuffer.Length;   

        //    Initialize the handle to Public key BLOB.
        IntPtr pPublicKeyBlob = IntPtr.Zero;
               
        // Handle to the certificate store (MyStore)
        IntPtr hSysStore;
           
        // Open the system store
        hSysStore = EncryptDecrypt.Wincrypt.CertOpenSystemStore(IntPtr.Zero,
EncryptDecrypt.Wincrypt.MyStore) ; // MyStore
           
        // Handle to the certificate
        IntPtr pDesiredCert=IntPtr.Zero;
           
        // Finding the certificate in store for the using subject string
"administrator"
        // This function returns handle to the certificate
        pDesiredCert =
EncryptDecrypt.Wincrypt.CertFindCertificateInStore(hSysStore,
EncryptDecrypt.Wincrypt.X509_ASN_ENCODING, 0,
EncryptDecrypt.Wincrypt.CERT_FIND_SUBJECT_STR, "administrator",
pDesiredCert);   //administrator
   
        if(pDesiredCert!=IntPtr.Zero)                      
        {
            Console.WriteLine("The desired certificate was found. \n");
        }
        else
        {
            Console.WriteLine("Could not find the desired certificate.\n");
        }
           
        //    Handle to particular key container within CSP
        IntPtr hProv = IntPtr.Zero;
        // The CryptAcquireContext function is used to acquire a handle to
        //    a particular key container within a particular cryptographic
        //    service provider (CSP).
        //  'slcchander512' is the name of the container which contains the key
        // pairs for the requested certificate.[Specified while requesting for
        // administrator]

        if (!EncryptDecrypt.Wincrypt.CryptAcquireContext(
            ref hProv,          // Handle to be acquired
            "slcchander512",   // Key Container's name
            null,            //  Name of the CSP -----default is null
----EncryptDecrypt.Wincrypt.MS_ENHANCED_PROV,
            EncryptDecrypt.Wincrypt.PROV_RSA_FULL,  //Specifies the type of provider
to acquire. The PROV_RSA_FULL provider type supports both digital signatures
and data encryption
            0  
            ))         //EncryptDecrypt.Wincrypt.CRYPT_VERIFYCONTEXT
        {
            Console.Write("CryptAcquireContext failed :" +
Marshal.GetLastWin32Error().ToString());
            goto Cleanup;
        }
        // The CryptSetProvParam function customizes the operations of a
cryptographic
        // service provider (CSP). This function is commonly used to set a security
        // descriptor on the key container associated with a CSP to control access
to
        // the private keys in that key container.

        if(!EncryptDecrypt.Wincrypt.CryptSetProvParam(
            hProv,
            EncryptDecrypt.Wincrypt.PP_CLIENT_HWND,
            EncryptDecrypt.Wincrypt.MS_ENHANCED_PROV,
            0))
        {
            Console.WriteLine(Marshal.GetLastWin32Error().ToString());
            goto Cleanup;
        }

        //    To acquire context again with Provider's name
        if (EncryptDecrypt.Wincrypt.CryptAcquireContext(
            ref hProv,
            "slcchander512",
            EncryptDecrypt.Wincrypt.MS_ENHANCED_PROV,
            EncryptDecrypt.Wincrypt.PROV_RSA_FULL,
            0  
            )) //EncryptDecrypt.Wincrypt.CRYPT_VERIFYCONTEXT
        {
            Console.Write("CryptAcquireContext failed :" +
Marshal.GetLastWin32Error().ToString());
            goto Cleanup;
        }

        // Import the public key information from the certificate context
        // into a key container by passing the pointer to the
        // SubjectPublicKeyInfo member of the CERT_INFO structure
        // into CryptImportPublicKeyInfoEx.

        //    An Additional byte offset, Adding to the pointer before read
        IntPtr pCertInfo = (IntPtr)Marshal.ReadInt32(pDesiredCert, 12);
       
        //    For public key subject pointer, adding the integer number to the
        //    certificate handle
        IntPtr pSubjectPublicKeyInfo = (IntPtr)(pDesiredCert.ToInt32() + 56);
       
        //    Handle to the public key            
        IntPtr hKey=IntPtr.Zero;

        //    Getting the  handle of one of a user's two public/private key pairs.
        if(!EncryptDecrypt.Wincrypt.CryptGetUserKey(
            hProv,
            EncryptDecrypt.Wincrypt.AT_KEYEXCHANGE,
            ref hKey))
        {
            Console.Write("CryptGetUserKey failed :" +
Marshal.GetLastWin32Error().ToString());
            goto Cleanup;
        }
            //    Now that the key is imported into a key container.
            //    CryptExportKey is used to export the public key to the PUBLICKEYBLOB
            //    format.

            //    Gets the size of the buffer needed to hold the PUBLICKEYBLOB structure.
            //    Length for public key
            uint dwDataLen = 0;

            //Handle to the Exported key (public key)
            IntPtr hExpkey= IntPtr.Zero;
            if (!EncryptDecrypt.Wincrypt.CryptExportKey(
                hKey,
                hExpkey,
                EncryptDecrypt.Wincrypt.PUBLICKEYBLOB,
                0,
                pPublicKeyBlob,
                ref dwDataLen))
            {
                Console.WriteLine("CryptExportKey failed: "
                    + Marshal.GetLastWin32Error().ToString());
                goto Cleanup;
            }

            pPublicKeyBlob = Marshal.AllocHGlobal((int)dwDataLen);

            //    Then export the public key into the PUBLICKEYBLOB format by passing
length.
            if (!EncryptDecrypt.Wincrypt.CryptExportKey(
                hKey,
                hExpkey,
                EncryptDecrypt.Wincrypt.PUBLICKEYBLOB,
                0,
                pPublicKeyBlob,
                ref dwDataLen))
            {
                Console.WriteLine("CryptExportKey failed: "
                    + Marshal.GetLastWin32Error().ToString());
                goto Cleanup;
            }

   
            //    Get the public exponent.
            //    The public exponent is located in bytes 17 through 20 of the
            //    PUBLICKEYBLOB structure.
            byte[] Exponent = new byte[4];

            //    A 32-bit signed integer equal to the value of this instance
            Marshal.Copy((IntPtr)(pPublicKeyBlob.ToInt32() + 16), Exponent, 0, 4);
   
            //    Reverse the byte order.
            Array.Reverse(Exponent);

            //    Get the length of the modulus.
            //    To do this extract the bit length of the modulus from the
PUBLICKEYBLOB.
            //    The bit length of the modulus is at bytes 13 through 17 of the
PUBLICKEYBLOB.
                int BitLength = Marshal.ReadInt32(pPublicKeyBlob, 12);
           
            //    Get the modulus. The modulus starts at the 21st byte of the
            //    PUBLICKEYBLOB structure and is BitLengh/8 bytes in length.
            //    byte[] Modulus = new byte[BitLength / 8];

            byte[] Modulus = new byte[BitLength / 8];
           
                        Marshal.Copy((IntPtr)(pPublicKeyBlob.ToInt32() + 20), Modulus,
0,BitLength / 8);
            //stop now Marshal.Copy((IntPtr)(pPublicKeyBlob.ToInt32() + 4), Modulus,
0,BitLength / 8);

            Array.Reverse(Modulus); // Reverse the byte order.
       
            // Performs asymmetric encryption and decryption using the implementation
of the
            // RSA algorithm provided by the cryptographic service provider (CSP)
           

            // Put the modulus and exponent into an RSAParameters object.
            RSAParameters rsaparms = new RSAParameters();
            rsaparms.Exponent = Exponent;
            rsaparms.Modulus = Modulus;

            // Import the modulus and exponent into an RSACryptoServiceProvider
            // object via the RSAParameters object.
            RSACryptoServiceProvider rsacsp = null;
            rsacsp = new RSACryptoServiceProvider(512,GetCSPParams());
            rsacsp.ImportParameters(rsaparms);
            encBuffer=rsacsp.Encrypt(rawBuffer,false);
           
        Cleanup:
       
            if (pDesiredCert != IntPtr.Zero)
                EncryptDecrypt.Wincrypt.CertFreeCertificateContext(pDesiredCert);
       
            if (hProv != IntPtr.Zero)
                EncryptDecrypt.Wincrypt.CryptReleaseContext(hProv, 0);
       
            if (pPublicKeyBlob != IntPtr.Zero)
                Marshal.FreeHGlobal(pPublicKeyBlob);
            return encBuffer;
    }

    enum CheckTrue
    {
        first,
        second
    }
    public byte[] Encrypt(byte[] data,bool bchk)
    {
        // byte array of plain text to be encrypted   
        byte[] rawBuffer=data;
        // byte array of encrypted text will be generated in this array
        byte[] encBuffer=null;
           
        // Length of the string to be encrypted
        uint bufLength= (uint)rawBuffer.Length;   

        //    Initialize the handle to Public key BLOB.
        IntPtr pPublicKeyBlob = IntPtr.Zero;
               
        // Handle to the certificate store (MyStore)
        IntPtr hSysStore;
           
        // Open the system store
        hSysStore = EncryptDecrypt.Wincrypt.CertOpenSystemStore(IntPtr.Zero,
EncryptDecrypt.Wincrypt.MyStore) ; // MyStore
           
        // Handle to the certificate
        IntPtr pDesiredCert=IntPtr.Zero;
           
        // Finding the certificate in store for the using subject string
"administrator"
        // This function returns handle to the certificate
        pDesiredCert =
EncryptDecrypt.Wincrypt.CertFindCertificateInStore(hSysStore,
EncryptDecrypt.Wincrypt.X509_ASN_ENCODING, 0,
EncryptDecrypt.Wincrypt.CERT_FIND_SUBJECT_STR, "administrator",
pDesiredCert);   //administrator
   
        if(pDesiredCert!=IntPtr.Zero)                      
        {
            Console.WriteLine("The desired certificate was found. \n");
        }
        else
        {
            Console.WriteLine("Could not find the desired certificate.\n");
        }
           
        //    Handle to particular key container within CSP
        IntPtr hProv = IntPtr.Zero;

        // The CryptAcquireContext function is used to acquire a handle to
        //    a particular key container within a particular cryptographic
        //    service provider (CSP).
        //  'slcchander512' is the name of the container which contains the key
        // pairs for the requested certificate.[Specified while requesting for
        // administrator]

        if (!EncryptDecrypt.Wincrypt.CryptAcquireContext(
            ref hProv,          // Handle to be acquired
            "slcchander512",   // Key Container's name
            null,            //  Name of the CSP -----default is null
----EncryptDecrypt.Wincrypt.MS_ENHANCED_PROV,
            EncryptDecrypt.Wincrypt.PROV_RSA_FULL,  //Specifies the type of provider
to acquire. The PROV_RSA_FULL provider type supports both digital signatures
and data encryption
            0  
            ))         //EncryptDecrypt.Wincrypt.CRYPT_VERIFYCONTEXT
        {
            Console.Write("CryptAcquireContext failed :" +
Marshal.GetLastWin32Error().ToString());
            goto Cleanup;
        }
               
                   
        // The CryptSetProvParam function customizes the operations of a
cryptographic
        // service provider (CSP). This function is commonly used to set a security
        // descriptor on the key container associated with a CSP to control access
to
        // the private keys in that key container.

        if(!EncryptDecrypt.Wincrypt.CryptSetProvParam(
            hProv,
            EncryptDecrypt.Wincrypt.PP_CLIENT_HWND,
            EncryptDecrypt.Wincrypt.MS_ENHANCED_PROV,
            0))
        {
            Console.WriteLine(Marshal.GetLastWin32Error().ToString());
            goto Cleanup;
        }

        //    To acquire context again with Provider's name
        if (EncryptDecrypt.Wincrypt.CryptAcquireContext(
            ref hProv,
            "slcchander512",
            EncryptDecrypt.Wincrypt.MS_ENHANCED_PROV,
            EncryptDecrypt.Wincrypt.PROV_RSA_FULL,
            0  
            )) //EncryptDecrypt.Wincrypt.CRYPT_VERIFYCONTEXT
        {
            Console.Write("CryptAcquireContext failed :" +
Marshal.GetLastWin32Error().ToString());
            goto Cleanup;
        }

        // Import the public key information from the certificate context
        // into a key container by passing the pointer to the
        // SubjectPublicKeyInfo member of the CERT_INFO structure
        // into CryptImportPublicKeyInfoEx.

        //    An Additional byte offset, Adding to the pointer before read
        IntPtr pCertInfo = (IntPtr)Marshal.ReadInt32(pDesiredCert, 12);
       
        //    For public key subject pointer, adding the integer number to the
        //    certificate handle
        IntPtr pSubjectPublicKeyInfo = (IntPtr)(pDesiredCert.ToInt32() + 56);
       
        //    Handle to the public key            
        IntPtr hKey=IntPtr.Zero;

        //    Getting the  handle of one of a user's two public/private key pairs.
        if(!EncryptDecrypt.Wincrypt.CryptGetUserKey(
            hProv,
            EncryptDecrypt.Wincrypt.AT_KEYEXCHANGE,
            ref hKey))
        {
            Console.Write("CryptGetUserKey failed :" +
Marshal.GetLastWin32Error().ToString());
            goto Cleanup;
        }

   
        //    The CryptImportPublicKeyInfoEx function imports public key
        //    information into the CSP and returns a handle of the public key.
        //    Now that the key is imported into a key container.
        //    CryptExportKey is used to export the public key to the PUBLICKEYBLOB
        //    format.

        //    Gets the size of the buffer needed to hold the PUBLICKEYBLOB structure.
        //    Length for public key
        uint dwDataLen = 0;

        //Handle to the Exported key (public key)
        IntPtr hExpkey= IntPtr.Zero;
        if (!EncryptDecrypt.Wincrypt.CryptExportKey(
            hKey,
            hExpkey,
            EncryptDecrypt.Wincrypt.PUBLICKEYBLOB,
            0,
            pPublicKeyBlob,
            ref dwDataLen))
        {
            Console.WriteLine("CryptExportKey failed: "
                + Marshal.GetLastWin32Error().ToString());
            goto Cleanup;
        }

        pPublicKeyBlob = Marshal.AllocHGlobal((int)dwDataLen);

        //    Then export the public key into the PUBLICKEYBLOB format by passing
length.
        if (!EncryptDecrypt.Wincrypt.CryptExportKey(
            hKey,
            hExpkey,
            EncryptDecrypt.Wincrypt.PUBLICKEYBLOB,
            0,
            pPublicKeyBlob,
            ref dwDataLen))
        {
            Console.WriteLine("CryptExportKey failed: "
                + Marshal.GetLastWin32Error().ToString());
            goto Cleanup;
        }

        //    Get the public exponent.
        //    The public exponent is located in bytes 17 through 20 of the
        //    PUBLICKEYBLOB structure.
        byte[] Exponent = new byte[4];

        //    A 32-bit signed integer equal to the value of this instance
        //stop now Marshal.Copy((IntPtr)(pPublicKeyBlob.ToInt32() + 164),
Exponent, 0, 4);
        Marshal.Copy((IntPtr)(pPublicKeyBlob.ToInt32() + 16), Exponent, 0, 4);
   
        //    Reverse the byte order.
        Array.Reverse(Exponent);

        //    Get the length of the modulus.
        //    To do this extract the bit length of the modulus from the PUBLICKEYBLOB.
        //    The bit length of the modulus is at bytes 13 through 17 of the
PUBLICKEYBLOB.
        int BitLength = Marshal.ReadInt32(pPublicKeyBlob, 12);
        //stop now int BitLength = 64 * 8;
           
        //    Get the modulus. The modulus starts at the 21st byte of the
        //    PUBLICKEYBLOB structure and is BitLengh/8 bytes in length.
        //    byte[] Modulus = new byte[BitLength / 8];

        byte[] Modulus = new byte[BitLength / 8];
           
        Marshal.Copy((IntPtr)(pPublicKeyBlob.ToInt32() + 20), Modulus, 0,BitLength
/ 8);

        Array.Reverse(Modulus); // Reverse the byte order.

        // Performs asymmetric encryption and decryption using the implementation
of the
        // RSA algorithm provided by the cryptographic service provider (CSP)
           

        // Put the modulus and exponent into an RSAParameters object.
       
        RSAParameters rsaparms = new RSAParameters();
        rsaparms.Exponent = Exponent;
        rsaparms.Modulus = Modulus;

        // Import the modulus and exponent into an RSACryptoServiceProvider
        // object via the RSAParameters object.
        RSACryptoServiceProvider rsacsp = null;
        rsacsp = new RSACryptoServiceProvider(512,GetCSPParams());
        rsacsp.ImportParameters(rsaparms);
        encBuffer=rsacsp.Encrypt(rawBuffer,false);
           
        Cleanup:
       
            if (pDesiredCert != IntPtr.Zero)
                EncryptDecrypt.Wincrypt.CertFreeCertificateContext(pDesiredCert);
       
        if (hProv != IntPtr.Zero)
            EncryptDecrypt.Wincrypt.CryptReleaseContext(hProv, 0);
       
        if (pPublicKeyBlob != IntPtr.Zero)
            Marshal.FreeHGlobal(pPublicKeyBlob);
        return encBuffer;
    }

    // This function takes a encrypted byte array and returns decrypted data   
    public byte[] Decrypt(byte[] data)  
        {                                     
        //Byte array containing encrypted data   
        byte[] rawBuffer=data;
        //Byte array for containing decrypted data   
        byte[] decBuffer=null;

        //handle to the key container within CSP provider
        IntPtr hProv = IntPtr.Zero;
         
        IntPtr hExpkey = IntPtr.Zero;       
       
        //Length of the data to be encrypted   
        uint dataLength = (uint)data.Length;  
       
        //Handle to the private key blob
        IntPtr pPrivateKeyBlob = IntPtr.Zero;

   
        //Handle to the private key
        IntPtr hPrivateKey=IntPtr.Zero;       
   
        //Handle to the Certificate key
        IntPtr hSysStore;
       
        //Opening certificate store
        hSysStore = EncryptDecrypt.Wincrypt.CertOpenSystemStore(IntPtr.Zero,
EncryptDecrypt.Wincrypt.MyStore) ; // MyStore
           
        //Handle to the certificate thru which private key is to be retrieved
        IntPtr pDesiredCert=IntPtr.Zero;      

        //Retrieves the certificate handle
        pDesiredCert =
EncryptDecrypt.Wincrypt.CertFindCertificateInStore(hSysStore,
EncryptDecrypt.Wincrypt.X509_ASN_ENCODING, 0,
EncryptDecrypt.Wincrypt.CERT_FIND_SUBJECT_STR, "administrator",
pDesiredCert);   //administrator
   
        if(pDesiredCert!=IntPtr.Zero)                      
        {
            Console.WriteLine("The desired certificate was found. \n");
        }
        else
        {
            Console.WriteLine("Could not find the desired certificate.\n");
        }
        // The CryptAcquireContext function is used to acquire a handle to
        //    a particular key container within a particular cryptographic
        //    service provider (CSP).
        //  'slcchander512' is the name of the container which contains the key
        // pairs for the requested certificate.[Specified while requesting for
        // administrator]

        if (!EncryptDecrypt.Wincrypt.CryptAcquireContext(
            ref hProv,
            "slcchander512",
            null,
            EncryptDecrypt.Wincrypt.PROV_RSA_FULL,
            0  
            ))
        {
            Console.Write("CryptAcquireContext failed :" +
Marshal.GetLastWin32Error().ToString());
            goto Cleanup;
        }
           
           
        //Retrieves a handle of one of a user's two public/private key pairs.
            if (!EncryptDecrypt.Wincrypt.CryptGetUserKey(
                                            hProv,
                                            EncryptDecrypt.Wincrypt.AT_KEYEXCHANGE,
                                            ref hPrivateKey))
            {
                Console.Write("CryptGetUserKey failed :" +
Marshal.GetLastWin32Error().ToString());
                goto Cleanup;
            }

        //Holds length of the private key blob
        uint dwDataLen = 0;
       
        //The CryptExportKey function exports a cryptographic key or a key pair
        // from a cryptographic service provider (CSP) in a secure manner.
        //Get the length of BLOB first time
        if (!EncryptDecrypt.Wincrypt.CryptExportKey(
                hPrivateKey,
                hExpkey,
                EncryptDecrypt.Wincrypt.PRIVATEKEYBLOB,
                0,
                IntPtr.Zero ,
                ref dwDataLen))
            {
                Console.WriteLine("CryptExportKey failed: " +
Marshal.GetLastWin32Error().ToString());
                goto Cleanup;
            }

        // Then export the private key into the PRIVATEKEYBLOB format.
            pPrivateKeyBlob = Marshal.AllocHGlobal((int)dwDataLen);
           
        if (!EncryptDecrypt.Wincrypt.CryptExportKey(
                hPrivateKey,
                hExpkey,
                EncryptDecrypt.Wincrypt.PRIVATEKEYBLOB,
                0,
                pPrivateKeyBlob,
                ref dwDataLen))
            {
                Console.WriteLine("CryptExportKey failed: " +
Marshal.GetLastWin32Error().ToString());
                goto Cleanup;
            }
        // Get the public exponent.
        // The private exponent is located in bytes 17 through 20 of the
        // PRIVATEKEYBLOB structure.
        //-------------------------------------
        byte[] test=new byte[1024];

        Marshal.Copy((IntPtr)(pPrivateKeyBlob.ToInt32()),test,0,1024);
        this.PutFileBytes(@"c:\testkeyPrivate.txt",test,test.Length );

        byte[] Exponent = new byte[64];
        Marshal.Copy((IntPtr)(pPrivateKeyBlob.ToInt32()), Exponent, 4, 64);
        Array.Reverse(Exponent); // Reverse the byte order.

        // Get the length of the modulus.
        // To do this extract the bit length of the modulus
        // from the PRIVATEBLOB. The bit length of the modulus is at bytes
        // 13 through 17 of the PRIVATEBLOB.
        int BitLength = Marshal.ReadInt32(pPrivateKeyBlob, 16);
           
        // Get the modulus. The modulus starts at the 21st byte of the
        // PRIVATEBLOB structure and is BitLengh/8 bytes in length.
        byte[] Modulus = new byte[BitLength / 8];
       
        //byte[] Modulus = new byte[BitLength / 16];
       
        Marshal.Copy((IntPtr)(pPrivateKeyBlob.ToInt32() + 20), Modulus, 0,
                BitLength / 8);
        Array.Reverse(Modulus); // Reverse the byte order.

        // Performs asymmetric encryption and decryption using the implementation
of the
        // RSA algorithm provided by the cryptographic service provider (CSP)
        RSACryptoServiceProvider rsacsp = null;

        // Put the modulus and exponent into an RSAParameters object.
        RSAParameters rsaparms = new RSAParameters();
        rsaparms.Exponent = Exponent;
        rsaparms.Modulus = Modulus;

        // Import the modulus and exponent into an RSACryptoServiceProvider
        // object via the RSAParameters object.
        rsacsp = new RSACryptoServiceProvider(512,GetCSPParams());
        rsacsp.ImportParameters(rsaparms);
        decBuffer=rsacsp.Decrypt(rawBuffer,false);

        Cleanup:
       
            if (pDesiredCert != IntPtr.Zero)
                EncryptDecrypt.Wincrypt.CertFreeCertificateContext(pDesiredCert);
           
            if (hProv != IntPtr.Zero)
                EncryptDecrypt.Wincrypt.CryptReleaseContext(hProv, 0);
       
            if (pPrivateKeyBlob != IntPtr.Zero)
                Marshal.FreeHGlobal(pPrivateKeyBlob);
   
        return decBuffer;
        }

        public byte[] GetFileBytes(String filename)
        {
            if(!File.Exists(filename))
                return null;
            Stream stream=new FileStream(filename,FileMode.Open);
            int datalen = (int)stream.Length;
            byte[] filebytes =new byte[datalen];
            stream.Seek(0,SeekOrigin.Begin);
            stream.Read(filebytes,0,datalen);
            stream.Close();
            return filebytes;
        }

        public void PutFileBytes(String outfile, byte[] data, int bytes)
        {
            FileStream fs = null;
            if(bytes > data.Length)
            {
                Console.WriteLine("Too many bytes");
                return;
            }
            try
            {
                fs = new FileStream(outfile, FileMode.Create);
                fs.Write(data, 0, bytes);
                Console.WriteLine("Wrote file '{0}'", outfile) ;
            }
            catch(Exception e)
            {
                Console.WriteLine(e.Message) ;
            }
            finally
            {
                fs.Close();
            }
        }

        private void button1_Click(object sender, System.EventArgs e)
        {
            byte[] rawBuffer=GetFileBytes(@"c:\rajesh.txt");
            byte[] encBuffer= Encrypt(rawBuffer,true);
            PutFileBytes(@"c:\rajeshout.txt",encBuffer,encBuffer.Length);
        }

        private void button2_Click(object sender, System.EventArgs e)
        {
            byte[] rawBuffer=GetFileBytes(@"c:\rajeshout.txt");
            byte[] decBuffer= Decrypt(rawBuffer);
            PutFileBytes(@"c:\rajeshdec.txt",decBuffer,decBuffer.Length);
   
        }

        public static CspParameters GetCSPParams()
        {
            CspParameters cspParams = new CspParameters(1);

            cspParams.KeyContainerName = "slcchander512";
            cspParams.KeyNumber=2;
            cspParams.ProviderType = 1;

            cspParams.ProviderName = "Microsoft Enhanced Cryptographic Provider v1.0";
            //cspParams.Flags=CspProviderFlags.UseMachineKeyStore;

            return cspParams;
        }

}