Chapter 6: Digital Signatures

The digital signature of a document is essentially the document's hash value encrypted with the signer's private key.

As mentioned in Chapter 4, public-key cryptography is based on two keys, public and private. The two are mathematically related but one cannot be deduced from the other. A message encrypted with one key can only be decrypted with the other.

To generate the digital signature of a document, the signer computes the one-way hash function of this document and then encrypts this value with her private key. To validate the signature, the document's recipient decrypts the signature using the signer's public key, computes the hash value of the document and compares the two values: if they match the signature is validated. Therefore, the signature serves two purposes: it provides proof of the signer's identity and verifies that the document has not been modified since the signing.

To simplify signature validation, the signature is sometimes bundled with the signer's certificate containing her public key.

Throughout the previous chapters, we have been calling the ubiquitous OpenContext method with an empty string as the first argument. As mentioned briefly in Section 2.1.2 of Chapter 2, the first argument to OpenContext is the name of a public/private key container within the current Cryptographic Service Provider. The container contains two key pairs, one for signatures and the other for key exchange (for consistency purposes we will always use the former, although there is no practical difference between the two.) If the name specified in OpenContext does not yet exist, a new container is created and populated with two brand-new key pairs.

By default, the lengths of the public keys in the container are 1024 bits. As of Version 2.5, OpenContext allows you to specify a different key length by appending it to the container name via the delimiter string "##", as follows:

To connect to one of the two key pairs of the current context, the CryptoContext method GetUserKey should be used. This method's only argument specifies whether the key pair is the signature pair (if set to False) or key-exchange pair (if set to True). For example:

The public key of a key pair can be exported to a file via the CryptoKey method ExportToFile. It can later be used for signature validation.

The first argument to ExportToFile should normally be another key to encrypt the key being exported. However, since we are exporting a public key, no encryption is necessary. Therefore, Nothing (null) is specified instead of a CryptoKey object.

A public key file can be imported back to the CryptoKey object via the CryptoContext method ImportKeyFromFile, as follows:

6.3.1 Signature Creation

As mentioned earlier, a digital signature is the result of encrypting a hash value with the signer's private key. Hash values are calculated using the CryptoHash object described in Chapter 3.

The CryptoHash object provides the Sign method that signs the underlying hash value with one of the two private keys associated with the context from which this CryptoHash object was created. Just like the GetUserKey method described earlier, the Sign method accepts a Boolean argument which specifies which of the two keys to use for the signing: the signature key if set to False or key-exchange key if set to True. The Sign method returns the signature as a CryptoBlob object.

For example, the following code snippet signs a text string with the signature key of the "mycontainer" context and outputs the signature value in Base64 encoding:

If we were to create the signature of a file, the call to CryptoHash.AddText would be replaced with a call to CryptoHash.AddFile:

The output of the script above would look similar to the following:

The compact format of the signatures produced by the CryptoHash.Sign method is referred to as PKCS#1. It only contains the encrypted hash value and nothing else. There is another format called PKCS#7 which contains the signature as well as the signer certificate. AspEncrypt supports it also. PKCS#7 signatures and envelopes will be covered in Chapter 9.

6.3.2 Signature Verification

The signature verification process goes as follows:

1. Compute your own hash value of the file or text string.
2. Decrypt the signature using the signer's public key.
3. Compare the values obtained in Steps 1 and 2. If they match the signature is verified.

With AspEncrypt, steps 2 and 3 are performed with the CryptoHash method VerifySignature which accepts two arguments: a CryptoBlob object containing the signature being verified and a CryptoKey object containing the public key corresponding to the private key used to create the signature. This method returns True if the signature is verified, and False otherwise. To verify the Base64 value created by the code snippet above, you may use the following code:

The following code sample combines the code snippets above. It performs both the signing and signature verification of a text string. To avoid creating temporary files, it uses the methods CryptoKey.ExportToBlob and CryptoContext.ImportKeyFromBlob instead of ExportToFile and ImportKeyFromFile.

Click the links below to run this code sample:

http://localhost/aspencrypt/manual_06/06_sign_verify.asp http://localhost/aspencrypt/manual_06/06_sign_verify.aspx

All the code samples above use private keys from arbitrary key containers opened via the OpenContext method. To verify the signature, the public key has to be exported into a file and transferred to a location where the verification takes place.

A signature can also be generated based on the private key associated with a specific certificate as opposed to an abstract key container. The certificate itself (its public-key portion) can be used for signature verification.

Once the certificate is obtained and moved to the HKEY_LOCAL_MACHINE section of the registry (see Section 4.6), its private key context can be obtained via the CryptoCert property PrivateKeyContext. This property returns an instance of the CryptoContext object that can be used to create a CryptoHash object to perform the signing.

The following code sample obtains a certificate from the local-machine MY store and signs a text string with its private key:

Note that we always pass True to the Sign method when the private key context is associated with a certificate.

The following code sample verifies the signature using the public key imported from the signer certificate's .cer file via the CryptoContext method ImportKeyFromCert:

The code samples above compute and verify the signature of data. As of Version 2.9, the Value property of the CryptoHash object is made read/write (as opposed to read-only.) This way, a CryptoHash object can directly be populated with a hash value so that the signature can be computed based on the hash of data rather than data itself. This is useful when the data being signed resides on the server while the private key used for signing resides on the user workstation. Only the hash of the data needs to be transferred to the workstation for signing, not the entire data. The code sample below demonstrates how a hash object can be assigned a value: