Export (0) Print
Expand All

DSACryptoServiceProvider Class

Members

Defines a wrapper object to access the cryptographic service provider (CSP) implementation of the DSA algorithm. This class cannot be inherited.

Namespace: System.Security.Cryptography
Assembly: mscorlib (in mscorlib.dll)

Syntax

Visual Basic (Declaration)

<ComVisibleAttribute(True)> _
Public NotInheritable Class DSACryptoServiceProvider
	Inherits DSA
	Implements ICspAsymmetricAlgorithm

Visual Basic (Usage)

Dim instance As DSACryptoServiceProvider

C#

[ComVisibleAttribute(true)] 
public sealed class DSACryptoServiceProvider : DSA, ICspAsymmetricAlgorithm

C++

[ComVisibleAttribute(true)] 
public ref class DSACryptoServiceProvider sealed : public DSA, ICspAsymmetricAlgorithm

J#

/** @attribute ComVisibleAttribute(true) */ 
public final class DSACryptoServiceProvider extends DSA implements ICspAsymmetricAlgorithm

JScript

ComVisibleAttribute(true) 
public final class DSACryptoServiceProvider extends DSA implements ICspAsymmetricAlgorithm

Remarks

You can use the DSACryptoServiceProvider class to create digital signatures and protect the integrity of your data.

To use a public-key system to digitally sign a message, the sender first applies a hash function to the message to create a message digest. The sender then encrypts the message digest with the sender's private key to create the sender's personal signature. Upon receiving the message and signature, the receiver decrypts the signature using the sender's public key to recover the message digest and hashes the message using the same hash algorithm that the sender used. If the message digest that the receiver computes exactly matches the message digest received from the sender, the receiver can be sure that the message was not altered while in transit. Note that a signature can be verified by anyone, because the sender's public key is common knowledge.

This algorithm supports key lengths from 512 bits to 1024 bits in increments of 64 bits.

Example

The following code example creates a digital signature of a hash value using the DSACryptoServiceProvider class and then verifies the signature.

Visual Basic

Imports System
Imports System.Security.Cryptography

 _

Class DSACSPSample


    Shared Sub Main()
        Try
            'Create a new instance of DSACryptoServiceProvider to generate
            'a new key pair.
            Dim DSA As New DSACryptoServiceProvider()

            'The hash value to sign.
            Dim HashValue As Byte() = {59, 4, 248, 102, 77, 97, 142, 201, 210, 12, 224, 93, 25, 41, 100, 197, 213, 134, 130, 135}

            'The value to hold the signed value.
            Dim SignedHashValue As Byte() = DSASignHash(HashValue, DSA.ExportParameters(True), "SHA1")

            'Verify the hash and display the results.
            If DSAVerifyHash(HashValue, SignedHashValue, DSA.ExportParameters(False), "SHA1") Then
                Console.WriteLine("The hash value was verified.")
            Else
                Console.WriteLine("The hash value was not verified.")
            End If


        Catch e As ArgumentNullException
            Console.WriteLine(e.Message)
        End Try
    End Sub


    Public Shared Function DSASignHash(ByVal HashToSign() As Byte, ByVal DSAKeyInfo As DSAParameters, ByVal HashAlg As String) As Byte()
        Try
            'Create a new instance of DSACryptoServiceProvider.
            Dim DSA As New DSACryptoServiceProvider()

            'Import the key information.   
            DSA.ImportParameters(DSAKeyInfo)

            'Create an DSASignatureFormatter object and pass it the 
            'DSACryptoServiceProvider to transfer the private key.
            Dim DSAFormatter As New DSASignatureFormatter(DSA)

            'Set the hash algorithm to the passed value.
            DSAFormatter.SetHashAlgorithm(HashAlg)

            'Create a signature for HashValue and return it.
            Return DSAFormatter.CreateSignature(HashToSign)
        Catch e As CryptographicException
            Console.WriteLine(e.Message)

            Return Nothing
        End Try
    End Function


    Public Shared Function DSAVerifyHash(ByVal HashValue() As Byte, ByVal SignedHashValue() As Byte, ByVal DSAKeyInfo As DSAParameters, ByVal HashAlg As String) As Boolean
        Try
            'Create a new instance of DSACryptoServiceProvider.
            Dim DSA As New DSACryptoServiceProvider()

            'Import the key information. 
            DSA.ImportParameters(DSAKeyInfo)

            'Create an DSASignatureDeformatter object and pass it the 
            'DSACryptoServiceProvider to transfer the private key.
            Dim DSADeformatter As New DSASignatureDeformatter(DSA)

            'Set the hash algorithm to the passed value.
            DSADeformatter.SetHashAlgorithm(HashAlg)

            'Verify signature and return the result. 
            Return DSADeformatter.VerifySignature(HashValue, SignedHashValue)
        Catch e As CryptographicException
            Console.WriteLine(e.Message)

            Return False
        End Try
    End Function
End Class

C#

using System;
using System.Security.Cryptography;

class DSACSPSample
{
		
	static void Main()
	{
		try
		{
			//Create a new instance of DSACryptoServiceProvider to generate
			//a new key pair.
			DSACryptoServiceProvider DSA = new DSACryptoServiceProvider();

			//The hash value to sign.
			byte[] HashValue = {59,4,248,102,77,97,142,201,210,12,224,93,25,41,100,197,213,134,130,135};
				
			//The value to hold the signed value.
			byte[] SignedHashValue = DSASignHash(HashValue, DSA.ExportParameters(true), "SHA1");

			//Verify the hash and display the results.
			if(DSAVerifyHash(HashValue, SignedHashValue, DSA.ExportParameters(false), "SHA1"))
			{
				Console.WriteLine("The hash value was verified.");
			}
			else
			{
				Console.WriteLine("The hash value was not verified.");
			}


		}
		catch(ArgumentNullException e)
		{
			Console.WriteLine(e.Message);
		}
	}

	public static byte[] DSASignHash(byte[] HashToSign, DSAParameters DSAKeyInfo, string HashAlg)
	{
		try
		{
			//Create a new instance of DSACryptoServiceProvider.
			DSACryptoServiceProvider DSA = new DSACryptoServiceProvider();

			//Import the key information.   
			DSA.ImportParameters(DSAKeyInfo);

			//Create an DSASignatureFormatter object and pass it the 
			//DSACryptoServiceProvider to transfer the private key.
			DSASignatureFormatter DSAFormatter = new DSASignatureFormatter(DSA);

			//Set the hash algorithm to the passed value.
			DSAFormatter.SetHashAlgorithm(HashAlg);

			//Create a signature for HashValue and return it.
			return DSAFormatter.CreateSignature(HashToSign);
		}
		catch(CryptographicException e)
		{
			Console.WriteLine(e.Message);

			return null;
		}

	}

	public static bool DSAVerifyHash(byte[] HashValue, byte[] SignedHashValue, DSAParameters DSAKeyInfo, string HashAlg)
	{
		try
		{
			//Create a new instance of DSACryptoServiceProvider.
			DSACryptoServiceProvider DSA = new DSACryptoServiceProvider();

			//Import the key information. 
			DSA.ImportParameters(DSAKeyInfo);

			//Create an DSASignatureDeformatter object and pass it the 
			//DSACryptoServiceProvider to transfer the private key.
			DSASignatureDeformatter DSADeformatter = new DSASignatureDeformatter(DSA);
				
			//Set the hash algorithm to the passed value.
			DSADeformatter.SetHashAlgorithm(HashAlg);

			//Verify signature and return the result. 
			return DSADeformatter.VerifySignature(HashValue, SignedHashValue);
		}
		catch(CryptographicException e)
		{
			Console.WriteLine(e.Message);

			return false;
		}
			
	}

}

C++

#using <System.dll>

using namespace System;
using namespace System::Security::Cryptography;
array<Byte>^ DSASignHash( array<Byte>^HashToSign, DSAParameters DSAKeyInfo, String^ HashAlg )
{
   try
   {
      
      //Create a new instance of DSACryptoServiceProvider.
      DSACryptoServiceProvider^ DSA = gcnew DSACryptoServiceProvider;
      
      //Import the key information.   
      DSA->ImportParameters( DSAKeyInfo );
      
      //Create an DSASignatureFormatter object and pass it the 
      //DSACryptoServiceProvider to transfer the private key.
      DSASignatureFormatter^ DSAFormatter = gcnew DSASignatureFormatter( DSA );
      
      //Set the hash algorithm to the passed value.
      DSAFormatter->SetHashAlgorithm( HashAlg );
      
      //Create a signature for HashValue and return it.
      return DSAFormatter->CreateSignature( HashToSign );
   }
   catch ( CryptographicException^ e ) 
   {
      Console::WriteLine( e->Message );
      return nullptr;
   }

}

bool DSAVerifyHash( array<Byte>^HashValue, array<Byte>^SignedHashValue, DSAParameters DSAKeyInfo, String^ HashAlg )
{
   try
   {
      
      //Create a new instance of DSACryptoServiceProvider.
      DSACryptoServiceProvider^ DSA = gcnew DSACryptoServiceProvider;
      
      //Import the key information. 
      DSA->ImportParameters( DSAKeyInfo );
      
      //Create an DSASignatureDeformatter Object* and pass it the 
      //DSACryptoServiceProvider to transfer the private key.
      DSASignatureDeformatter^ DSADeformatter = gcnew DSASignatureDeformatter( DSA );
      
      //Set the hash algorithm to the passed value.
      DSADeformatter->SetHashAlgorithm( HashAlg );
      
      //Verify signature and return the result. 
      return DSADeformatter->VerifySignature( HashValue, SignedHashValue );
   }
   catch ( CryptographicException^ e ) 
   {
      Console::WriteLine( e->Message );
      return false;
   }

}

int main()
{
   try
   {
      
      //Create a new instance of DSACryptoServiceProvider to generate
      //a new key pair.
      DSACryptoServiceProvider^ DSA = gcnew DSACryptoServiceProvider;
      
      //The hash value to sign.
      array<Byte>^HashValue = {59,4,248,102,77,97,142,201,210,12,224,93,25,41,100,197,213,134,130,135};
      
      //The value to hold the signed value.
      array<Byte>^SignedHashValue = DSASignHash( HashValue, DSA->ExportParameters( true ), "SHA1" );
      
      //Verify the hash and display the results.
      if ( DSAVerifyHash( HashValue, SignedHashValue, DSA->ExportParameters( false ), "SHA1" ) )
      {
         Console::WriteLine( "The hash value was verified." );
      }
      else
      {
         Console::WriteLine( "The hash value was not verified." );
      }
   }
   catch ( ArgumentNullException^ e ) 
   {
      Console::WriteLine( e->Message );
   }

}

J#

import System.*;
import System.Security.Cryptography.*;

class DSACSPSample
{
    public static void main(String[] args)
    {
        try {
            // Create a new instance of DSACryptoServiceProvider to generate
            // a new key pair.
            DSACryptoServiceProvider dsa =  new DSACryptoServiceProvider();
            
            // The hash value to sign.
            ubyte hashValue[] =  {59, 4, 248, 102, 77, 97, 142, 201,
                210, 12, 224, 93, 25, 41, 100, 197, 213, 134, 130, 135};
            
            // The value to hold the signed value.
            ubyte signedHashValue[] = DSASignHash(hashValue,
                dsa.ExportParameters(true), "SHA1");
            
            // Verify the hash and display the results.
            if (DSAVerifyHash(hashValue, signedHashValue, 
                dsa.ExportParameters(false), "SHA1")) {
                Console.WriteLine("The hash value was verified.");
            }
            else {
                Console.WriteLine("The hash value was not verified.");
            }
        } 
        catch (ArgumentNullException e) {
            Console.WriteLine(e.get_Message());
        }
    } //main

    public static ubyte[] DSASignHash(ubyte hashToSign[], 
        DSAParameters dsaKeyInfo, String hashAlg) 
    {
        try {
            // Create a new instance of DSACryptoServiceProvider.
            DSACryptoServiceProvider dsa =  new DSACryptoServiceProvider();
            
            // Import the key information.   
            dsa.ImportParameters(dsaKeyInfo);
            
            // Create an DSASignatureFormatter object and pass it the 
            // DSACryptoServiceProvider to transfer the private key.
            DSASignatureFormatter dsaFormatter =  new
                DSASignatureFormatter(dsa);
            
            // Set the hash algorithm to the passed value.
            dsaFormatter.SetHashAlgorithm(hashAlg);
            
            // Create a signature for HashValue and return it.
            return dsaFormatter.CreateSignature(hashToSign) ;
        }
        catch (CryptographicException e) {
            Console.WriteLine(e.get_Message());
            return null ;
        }
    } //DSASignHash

    public static boolean DSAVerifyHash(ubyte hashValue[], 
        ubyte signedHashValue[], DSAParameters dsaKeyInfo, String hashAlg) 
    {
        try {
            // Create a new instance of DSACryptoServiceProvider.
            DSACryptoServiceProvider dsa =  new DSACryptoServiceProvider();
            
            // Import the key information. 
            dsa.ImportParameters(dsaKeyInfo);
            
            // Create an DSASignatureDeformatter object and pass it the 
            // DSACryptoServiceProvider to transfer the private key.
            DSASignatureDeformatter dsaDeformatter =  new 
                DSASignatureDeformatter(dsa);
            
            // Set the hash algorithm to the passed value.
            dsaDeformatter.SetHashAlgorithm(hashAlg);
            
            // Verify signature and return the result. 
            return dsaDeformatter.VerifySignature(hashValue, signedHashValue);
        }
        catch (CryptographicException e) {
            Console.WriteLine(e.get_Message());
            return false ;
        }
    } //DSAVerifyHash
} //DSACSPSample

Inheritance Hierarchy

System.Object
   System.Security.Cryptography.AsymmetricAlgorithm
     System.Security.Cryptography.DSA
      System.Security.Cryptography.DSACryptoServiceProvider

Thread Safety

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Platforms

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see System Requirements.

Version Information

.NET Framework

Supported in: 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 2.0

See Also

Community Additions

ADD
Show:
© 2014 Microsoft