This type of encryption is commonly referred to as asymmetric encryption and uses a public and private key pair to perform encryption or decryption of data. The public key is available to everyone and is used to encrypt data that will be decrypted by the owner of the private key. The private key is kept secure by the owner and is used to decrypt data that has been encrypted with the public key.

Asymmetric encryption is generally only efficient on relatively small sets of data. The .NET Class Framework contains two asymmetric encryption algorithms: Digital Signature Algorithm (DSA) and RSA.

This type of encryption is commonly referred to as symmetric encryption and uses a single key to perform encryption or decryption of data. The private key must be kept safe from anyone other than the owner of the data.

Symmetric encryption is generally fast and can operate on large sets of data. The .NET Class Framework contains four symmetric encryption algorithms: DES, Triple DES, RC2, and Rijndael.

Ciphers are cryptographic algorithms that use a private key to transform plain text input into an encrypted output, also known as cipher text. There are two forms of ciphers: block-based and stream-based.

A block-based cipher takes a fixed size input block and transforms the data into a fixed size cipher text block.

A stream-based cipher does not encrypt data but instead generates a key stream that produces the cipher text by XORing the stream bytes with the input bytes.

The .NET Class Framework only provides block-based ciphers, but it is possible to make a block-based cipher behave in a streaming fashion.

Block ciphers were designed to operate on complete blocks of data. Padding is used when processing a partial block of data to append extra data to the incomplete block, making it an even multiple of the block size.

The .NET 2.0 Class Framework supports three types of block padding, as described in Table 16.1.

It is advisable to use PaddingMode.PKCS7 when developing with .NET 1.1 and PaddingMode.ISO10126 when developing with .NET 2.0. Both versions of the .NET framework default to PaddingMode.PKCS7, so you will have to explicitly set the padding mode to ISO10126.

Keep in mind that your software does not exist in a vacuum, so it is important that you make sure that using a different padding mode will not break any existing code.

The key strength, also known as key size, of an encryption algorithm refers to the length of the underlying key, and the higher the number the better. Consider the case of an 8-bit key. It would take an attacker roughly 256 guesses to land on the key, whereas a 40-bit key would take an attacker roughly over a trillion guesses to land on the key. The key length is very important, as is the data comprising the key.

Pseudo-random number generators (PRNG) are sometimes used by developers to generate private keys. Computers are fairly predictable, so achieving randomness is difficult to do. Do not try to create your own PRNG classes; use the built-in functionality provided by the RNGCryptoServiceProvider class in the .NET Class Framework.

Lastly, some developers also derive the key from a password, which may result in a key of substantial length, but the key is only as random as its source. If a 256-bit key is derived from a 12-character password, the key is not as secure as one might think. If a malicious attacker understands how the key is derived, he only has to attack the 12-character password to reveal the key itself.

One of the most important security issues to correctly configure is the cipher mode. This mode determines how the individual blocks of a transform are assembled to form the final data.

Messages are usually more than one block in length, so how does the data get encrypted? The obvious solution would be to encrypt each block individually and slap them all together in the end. In actuality, this is one of the most insecure cipher modes (ECB—Electronic Code Book), which can lead to security compromises of the encrypted data.

Cipher modes are used to modify the encryption process based on data carried over from previous block encryptions. The resulting encryption provides a much higher level of security than performing a simple block-level encryption.

The .NET class framework has a variety of other cipher modes available at your disposal, each with its own pros and cons. These cipher modes are listed in Table 16.2. We will be using the CBC mode for this chapter as it offers the best security.

Symmetric algorithms will encrypt the same input block into the same output block based on the key. This is a weakness that can be potentially exploited by malicious attackers if they determine the structure of the data. Attackers could locate patterns and eventually reverse-engineer the private key.

In order to protect against this, the algorithms in the .NET Class Framework perform data chaining, where information from the previously encrypted block is used to encrypt the current block. This technique requires what is known as an initialization vector (IV) to perform the encryption with increased cryptographic variance.

There are a couple of ways to generate an initialization vector, but one approach is to run a hashing algorithm on a secret phrase and use a segment of the result as the encryption IV.

The following code shows how to do this:

using System.Security.Cryptography;

static public byte[] GenerateIV(byte[] key, int size)
{
    byte[] result = new byte[size];

    SHA384Managed sha384 = new SHA384Managed();
    sha384.ComputeHash(key);

    for (int byteIndex = 0; byteIndex < result.Length; byteIndex++)
    {
        result[byteIndex] = sha384.Hash[byteIndex];
    }

    return result;
}

The following generates a correctly sized key using a variation of the code for the initialization vector generation.

static public byte[] GenerateKey(byte[] key, int size)
{
    byte[] result = new byte[size];

    SHA384Managed sha384 = new SHA384Managed();
    sha384.ComputeHash(key);

    int counter = 0;

    for (int byteIndex = sha384.Hash.Length - 1;
           byteIndex > = (sha384.Hash.Length - size);
           byteIndex—)
    {
        result[counter++] = sha384.Hash[byteIndex];
    }

    return result;
}