Information Security and Cryptography

A set of protocols and mechanisms has been created in order to deal with the issues raised by information security when the information is send by physical documents. The objectives of the information security can be achieved as well through mathematical algorithms and protocols, requiring at the same time procedural techniques and following the laws by achieving the result that is desired. As an example, let’s consider the privacy of letters, which is provided by sealed envelopes that are delivered by a legitimate mail service. The physical security of the envelope has its own limitations and laws are established in such way that if mail is open by someone who is not authorized to do so, they can be charged with a criminal offense. There are cases when that security is achieved not only through the information itself but also through the paper document that records the originality of the information. As an example, consider paper currency, which requires special ink and material in order to avoid and prevent the forgery of it.

Conceptually speaking, the way information is stored, registered, interpreted, and recorded hasn’t changed too much. The ability to copy and modify information represents one of the most important characteristics of manipulating information that has been changed significantly.

One of the most important tools used in information security is represented by the signature . It represents a building block for multiple services such as non-repudiation, data origin authentication, identification, and witnessing.

In a society based on electronic communication, achieving information security implies fulfilling requirements based on legal and technical skills. At the same time, there is no guarantee that the objectives of information security can be met accordingly. The technical part of information security is assured by cryptography .

Cryptography represents the discipline that studies mathematical techniques that are related to information security such as confidentiality, integrity (data), authentication (entity), and the origin of the authentication. Cryptography doesn’t consist only of providing information security, but also in a specific set of techniques.

Background of Mathematical Functions

This book does not represent a monograph on abstract mathematics. Getting familiar with some basic and fundamental mathematical concepts is necessary and will prove to be very useful in practical implementations. A very important concept that is fundamental to cryptography is based on a function in the mathematical sense. A function is also known as a transformation or mapping .

Functions – 1-1, One-Way, Trapdoor One-Way

We will consider as concept, a set that is based on distinct objects which are known as elements of that specific set. Let’s consider as an example set A, which has the elements a, b, c, this being denoted as A = {a, b, c}.

Definition 1.1. Cryptography represents the study of mathematical techniques that are related to the aspects of information security such as confidentiality, integrity (data), authentication (entity), and authentication of the data origin.

Definition 1.2. Two sets, A and B, and a rule, f, define a function. The rule f will assign to each element in A an element in B. The set A is known as the domain that characterizes the function and B represents the codomain. If a represents an element from A, written as a ∈ A, the image of a is represented by the element in B with the help of rule f; the image b of a is noted by b = f(a). The standard notation for function f from set A to set B is represented as f : A → B. If b ∈ B, and then we have a preimage of b, which is an element a ∈ A for which f(a) = b. The entire set of elements in B, which has at least one preimage, is known as the image of f, noted as Im(f).

Example 1.3. (function) Consider the sets A = {a, b, c} and B = {1, 2, 3, 4}, and the rule f from A to B as being defined as f(a) = 2, f(b) = 4, f(c) = 1. Figure 1-2 shows a depiction of the sets A, B and the function f. The preimage of the element 2 is a. The image of f is {1, 2, 4}.

Example 1.4. (function) Let’s consider the following set of A = {1, 2, 3, ……, 10} and consider f to be the rule that for each a ∈ A, f(a) = r_a, where r_a represents the remainder when a² is being divided by 11.

The image of f is represented by the set Y = {1, 3, 4, 5, 9}.

Think of the function in terms of the scheme (in the literature, it’s known as the functional diagram ) as depicted in Figure 1-2, where each element from domain A has precisely one arrow originating from it. For each element from codomain B we can have any number of arrows as being incidental to it (including also zero lines).

Example 1.5. (function) Let’s consider the following set defined as A = {1, 2, 3, …, 10⁵⁰} and consider f to be the rule f(a) = r_a, where r_a represents the remainder in the case when a² is divided by 10⁵⁰ + 1 for all a ∈ A. In this situation, it is not feasible to write down f explicitly as we did in Example 1.4. This being said, the function is completely defined by the domain and the mathematical description that characterize the rule f.

1-1 (One-to-One) Functions

Definition 1.6. We can say that a function or transformation is 1 − 1 (one-to-one) if each of the elements found within the codomain B are represented as the image of at most one element in the domain A.

Definition 1.7. We can say that a function or transformation is onto if each of the elements found within the codomain B represents the image of at least one element that can be found in the domain. At the same time, a function f : A → B is known as being onto if Im(f) = B.

Definition 1.8. If function f : A → B is to be considered 1 − 1 and Im(f) = B, and then the function f is called bijection.

Conclusion 1.9. If f : A → B is considered 1 − 1, then f : A →  Im (f) represents the bijection. In special cases, if f : A → B is represented as 1 − 1, and A and B are represented as finite sets with the same size, then f represents a bijection.

Based on the scheme and its representation, if f represents a bijection, then each element from B has exactly one line that is incidental with it. The function shown and described in Examples 1.3 and 1.4 does not represent bijections. As you can see in Example 1.3, element 3 doesn’t have the image of any other element that can be found within the domain. In Example 1.4, each element from the codomain is identified with two preimages.

Definition 1.10. If f is a bijection from A to B, then it is a quite simple matter to define a bijection g from B to A as follows: for each b ∈ B we will define g(b) = a where a ∈ A and f(a) = b. The function g is obtained from f and it is called an inverse function of f and is denoted as g = f⁻¹.

Example 1.11. (inverse function) Let’s consider the following sets of A = {a, b, c, d, e} and Y = {1, 2, 3, 4, 5}, and consider the rule f which is given and represented by the lines in Figure 1-3. f represents a bijection and its inverse, g, is formed by reversing the sense of the arrows. The domain of g is represented by B and the codomain is A.

Keep in mind that if f represents a bijection, f⁻¹ is also a bijection. The bijections in cryptography are used as tools for message encryption and inverse transformations are used for decryption. The fundamental condition for decryption is for transformation to be bijections.

One-Way Functions

In cryptography, there are a certain types of functions that play an important role. Due to the rigor, a definition for one-way function is given as follows.

Definition 1.12. Let’s consider function f from set A to set B that is called a one-way function if f(a) proves to be simple and easy to be computed for all a ∈ A but for “essentially all” elements b ∈  Im (f) it is computationally infeasible to manage to find any a ∈ A in such way that f(a) = b.

Note 1.13. This note represents some additional notes and clarifications of the terms used in Definition1.12.

1. 1.

   For the terms easy and computationally infeasible a rigorous definition is necessary but it will distract the attention from the general idea that is being agreed. For the goal of this chapter, the simple and intuitive meaning is sufficient.

    
2. 2.

   The phrase “essentially all” refers to the idea that there are a couple of values b ∈ B for which it is easy to find an a ∈ A in such way that b = f(a). As an example, one may compute b = f(a) for a small number of a values and then for these, the inverse is known by a table look-up. A different way to describe this property of a one-way function is as follows: for any random b ∈  Im (f), it is computationally feasible to have and find any a ∈ A in such way that f(a) = b.

    

The following examples show the concept behind a one-way function.

Example 1.14. (one-way function) Consider A = {1, 2, 3, …, 16} and let’s define f(a) = r_a for all the elements a ∈ A where r_a represents the remainder when 3^x will be divided with 17.

a	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
f(a)	3	9	10	13	5	15	11	16	14	8	7	4	12	2	6	1

Having a number between 1 and 16, it is quite easy to look and find the image of it under f. Without having the table in front of you, for example, for 7 it is hard to find a given that f(a) = 7. If the number that you are given is 3, then is quite easy to see that a = 1 is what you actually need.

Keep in mind that this represents an example that is based on very small numbers. The important aspect here is that there is a difference in the volume of work to compute f(a) and the amount of work to find a given f(a). Also, for large numbers, f(a) can be efficiently computed using the square-and-multiply algorithm [20], where the process of finding a from f(a) is harder to find.

Example 1.15. (one-way function) A prime number represents a positive integer bigger than 1 whose positive integer divisors are 1 and itself. Choose the following primes of p = 50633, q = 58411, compute n = pq = 50633 · 58411 = 2957524163, and let’s consider A = {1, 2, 3, …, n − 1}. We define a function f on A by f(a) = r_a for each a ∈ A, where r_a represents the remainder when x³ is divided by n. For example, let’s consider f(2489991 = 1981394214 since 2489991³ = 5881949859 · n + 1981394214. Computing f(a) represents a simple thing to be done, but reversing the procedure is quite difficult .

Trapdoor One-Way Functions

Definition 1.16. A trapdoor one-way function is defined as a one-way function f : A → B with the additional property that by having extra information (known as trapdoor information) it will become feasible to find and identify any given b ∈  Im (f), with an a ∈ A in such way that f(a) = b.

In Example 1.15, we show the concept of a trapdoor one-way function. With extra information about the factors of n = 2957524163 it will become much easier to invert the function. The factors of 2957524163 are large enough that finding them by hand computation would be difficult. With the help of any computer software we can find the factors quite quickly. If, for example, we have very large distinct prime numbers (each number having around 200 decimal digits), p and q, with today’s technologies, it’s quite difficult even with the most powerful computers to find p and q from n. This is the well-known problem entitled as integer factorization problem, which for quantum computers will not represent an issue.

One-way and trapdoor one-way functions represent the basic foundation for public-key cryptography. These concepts are very important and they will become much clearer later when their application to cryptographic techniques are implemented and discussed. It is quite important to keep these abstract concepts from this section in mind as the concrete methods and the main foundation for the cryptography algorithms that will be implemented later within this book.

Permutations

Permutations represent functions that are in cryptographic constructs.

Definition 1.17. Consider S to be a finite set formed of elements. A permutation p on S represents a bijection as defined in Definition 1.8. The bijection is represented from S to itself as p : S → S.

Example 1.18. This example represents a permutation example. Let’s consider the following permutation: S = {1, 2, 3, 4, 5}. The permutation p : S → S is defined as follows:

A permutation can be described in different ways. It can be written as above or as an array as

in which the top row of the array is represented by the domain and the bottom row is represented by the image under p as mapping.

As the permutations are bijections, they have inverses. If the permutation is written as an away (second form), its inverse will be very easily to find by interchanging the rows in the array and reordering the elements from the new top row and the bottom row. In this case, the inverse of p is defined as follows:

Example 1.19. This example represents a permutation example. Let’s consider A to be the set of integers {0, 1, 2, …, p · q − 1} where p and q represent two distinct large primes. We need to suppose also that neither p − 1 nor q − 1 can be divisible by 3. The function p(a) = r_a, in which r_a represents the remainder when a³ is divided by pq can be demonstrated and shown as being the inverse perumutation. The inverse permutation is computationally infeasible by computers nowadays, unless p and q are known.

Involutions

Involutions are known as functions having their own inverses.

Definition 1.20. Let’s consider a finite set of S and f defined as a bijection S to S, noted as f : S → S. In this case, function f will be noted as the involution if f = f⁻¹. Another way of defining this is f(f(a)) = a for any a ∈ S.

Example 1.21. This example represents an involution case. In Figure 1-4, we depict an example of involution. In Figure 1-4, note that if j represents the image of i, then i represents the image of j.

Concepts and Basic Terminology

When we deal with the scientific study of the cryptography discipline, we see that it was built on hard and abstract definitions born from fundamental concepts. In this section, we will list the most important terms and key concepts that are used in this book.

The Participants in the Communication Process

Starting with Figure 1-5 the following terminology is defined:

• An entity or party represents someone or something who sends, receives, or manipulates the information. In Figure 1-5, Alice and Bob are represented as entities or parties, as computers, etc.

• A sender represents an entity in a two-party communication. It represents the rightful transmitter of the information. In Figure 1-5, the sender is represented by Alice.

• A receiver represents an entity in a two-party communication. It represents the intended recipient of information. In Figure 1-5, the receiver is represented by Bob.

• An adversary (attacker, or sometimes for simplifying the examples it is referred as Oscar or Eve¹) represents an entity in a two-party communication. It is neither the sender nor the receiver. The adversary tries to break the information security service that serves as a service provided between the sender and receiver. Other names for the adversary found in the literature are enemy, attacker, opponent, eavesdropper, intruder, and interloper. Often, the adversary will play the role of either the rightful sender or the rightful receiver.

Digital Signatures

In this book, we will deal with digital signatures as well. A digital signature represents a cryptographic primitive that is fundamental in the process of authentication, authorization, and non-repudiation. The goal of a digital signature is to offer a way for an entity to map its identity with a piece of information. The process of signing implies the transforming of the message and a part known as secret information that is held by the entity into a tag known as the signature.

Signing Procedure

We will use an entity A, which we will name as the signer. We will create a signature for a specific message by applying the following messages:

• Calculate s = S_A(m).

• Send the pair (m, s), where s represents the signature for the message m.

Verification Procedure

Public-Key Cryptography

Public-key cryptography plays an important role in .NET and when we need to implement related algorithms. There are several important commercial libraries that implement public-key cryptography solutions for developers, such as [21-30].

To understand better how public-key cryptography works, let’s consider a of encryption transformations defined as and a set of matching decryption transformations defined as , where represents the key space. Take into consideration the following pair association of encryption/decryption transformations (E_e, D_d) and let’s suppose that each pair has the property of knowing E_e that is computationally unrealizable, having a random ciphertext to manage to identify the message in such way that E_e(m) = c. The property defined involves that for any given e it is unrealizable to determine the corresponding decryption key d.

Having the assumptions made above, let’s consider a two-party communication between Alice and Bob as illustrated in Figure 1-6.

• Bob will select a key pair (e, d).

• Bob will send the encryption key e, known as the public key, to Alice over any channel and will keep the decryption key, d, known as the private key, secure and secret.

• Alice, afterwards, will send a message m to Bob by applying the encryption transformation that is computed and determined by Bob’s public key in order to get c = E_e(m). Bob will decrypt the ciphertext c by using the inverse transformation D_d which is determined uniquely by d.

The encryption key e does not need to be kept secret. It may be made public. Any entity can send encrypted messages to Bob, and only Bob has the ability to decrypt them. Figure 1-7 illustrates the idea where A₁, A₂, and A₃ represent different entities. Remember if A₁ destroys message m₁ after encrypting it to c₁, then even A₁ is found in the position of not being able to recover m₁ from c₁.

To make it clear, let’s consider as an example a box with the cover secured by a lock with a specific combination. Bob is the only one who knows the combination. If the lock remains unlocked for any reason and is thus publicly available, anyone can get inside the box and leave a message inside and lock the lock.

Hash Functions

.NET offers the HashAlgorithm class , which is part of the namespace System.Security.Cryptography [19]. The class represents the base class that needs to be used when all implementations of cryptographic hash algorithms must derive.

As an example (see Figure 1-8 and Listing 1-1), the following C# code example will compute the SHA1CryptoServiceProvider hash for a specific array. This example is based on the assumption that we have already a predefined byte array dataArray[]. SHA1CryptoServiceProvider represents a class that is derived from HashAlgorithm:

HashAlgorithm sha = new SHA1CryptoServiceProvider();

byte[] result = sha.ComputeHash(dataArray);

Hash functions represent one of the most important primitives in modern cryptography. A hash function is also known as a one-way hash function. A hash function represents a computationally efficient function mapping the binary string with an arbitrary length to binary strings with a fixed length known as a hash value.

Hash functions are widely used with digital signatures and also within the data integrity. When we are dealing with digital signatures, a long message is usually hashed and only the hash value is signed. The party that will receive the message then will hash the received message, and they will verify that the received signature is correct for this hash value. This will save time and space by signing the message directly, which consists of splitting the message into appropriate-sized blocks and individually signing each block.

Case Studies

Caesar Cipher Implementation in C#

In this section, we will give an implementation in C# of a Caesar cipher. The purpose of this section is to illustrate how the mathematical foundations listed above can be useful during the implementation process and the advantages of understanding the basic math mechanisms behind the algorithms. We will NOT focus on the mathematical background of the algorithms in this book. If you want to go deeply into the mathematical background, it is recommended to follow the following references [6-18].

The encryption process used by a Caesar cipher can be represented as modular arithmetic by first transforming the letters into numbers. For this, we will use the following alphabet in such way that A = 0, B = 1, …, Z = 25. The encryption of a letter x is done by a shift n and mathematically can be described as

The decryption is done in a similar way:

Let’s start the implementation of the algorithm. In Solution Explorer we have only one single file, StartCaesar.cs (see Figure 1-9).

The application (see Figure 1-10 and Listing 1-2) is very simple and easy to interact with.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace ConsoleCaesarCipher

{

    class Program

    {

        static void Main(string[] args)

        {

            Console.WriteLine("Enter the plaintext/ciphertext: ");

            string text = Convert.ToString(Console.ReadLine());

            Console.WriteLine(" Choose a cryptographic method:");

            Console.WriteLine(" 1 -> Encrypt");

            Console.WriteLine(" 2 -> Decrypt ");

            int option = Convert.ToInt32(Console.ReadLine());

            if (option == 1)

            {

                Console.WriteLine(" Enter the key: ");

                int key = Convert.ToInt32(Console.ReadLine());

                Console.WriteLine("The encryption of text is {0}. ", Encode(text, key));

            }

            if (option == 2)

            {

                Console.WriteLine(" Enter the key: ");

                int key = Convert.ToInt32(Console.ReadLine());

                Console.WriteLine("The decryption of the ciphertext is {0}. ", Decode(text, key));

            }

            Console.ReadKey();

        }

        private static string Encode(string plaintext, int key)

        {

            string alphabets = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

            string final = "";

            int indexOfChar = 0;

            char encryptedChar;

            //Convert/encrypt each and every character of the text

            foreach (char c in plaintext)

            {

                //Get the index of the character from alphabets variable

                indexOfChar = alphabets.IndexOf(c);

                //if encounters an white space

                if (c == ' ')

                {

                    final = final + c;

                }

                //if encounters a new line

                else if (c == ' ')

                {

                    final += c;

                }

                //if the character is at the end of the string "alphabets"

                else if ((indexOfChar + key) > 25)

                {

                    //encrypt the character

                    encryptedChar = alphabets[(indexOfChar + key) - 26];

                    //add the encrypted character to a string every time to get an encrypted string

                    final += encryptedChar;

                }

                else

                {

                    //encrypt the character

                    //add the encrypted character to a string every time to get an encrypted string

                    encryptedChar = alphabets[indexOfChar + key];

                    final += encryptedChar;

                }

            }

            return final;

        }

        private static string Decode(string ciphertext, int key)

        {

            string alphabets = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

            string final = "";

            int indexOfChar = 0;

            char decryptedChar;

            //Convert/decrypt each and every character of the text

            foreach (char c in ciphertext)

            {

                //Get the index of the character from alphabets variable

                indexOfChar = alphabets.IndexOf(c);

                //if encounters a white space

                if (c == ' ')

                {

                    final = final + c;

                }

                //if encounters a new line

                else if (c == ' ')

                {

                    final = final + c;

                }

                //if the character is at the start of the string "alphabets"

                else if ((indexOfChar - key) < 0)

                {

                    //decrypt the character

                    //add the decrypted character to a string every time to get a decrypted string

                    decryptedChar = alphabets[(indexOfChar - key) + 26];

                    final = final + decryptedChar;

                }

                else

                {

                    //decrypt the character

                    //add the decrypted character to a string every time to get a decrypted string

                    decryptedChar = alphabets[indexOfChar - key];

                    final = final + decryptedChar;

                }

            }

            //Display decrypted text

            return final;

        }

    }

}

Listing 1-2

Caesar Cipher Implementation

Vigenére Cipher Implementation in C#

The Vigenére cipher (see Figure 1-11 and Listing 1-3) represents one of the classic methods of encrypting the alphabetical text by using a series of different Caesar ciphers that are based on the letters of a keyword. Some documentation shows it as a form of polyalphabetic substitution.

A short algebraic description of the cipher is as follows. The numbers will be taken as numbers (A = 0, B = 1, etc) and an addition operation is performed as modulo 26. The Vigenére encryption E using K as the key can be written as

and decryption D using the key K as

in which M = M₁…M_n is the message, C = C₁…C_n represents the ciphertext, and K = K₁…K_n represents the key obtained by repeating the keyword [n/m] times in which m represents the keyword length.

Our implementation has two important files. The file Program.cs contains the functions for encryption and decryption operations. See Figure 1-12.

The source code for Program.cs is shown in Listing 1-3.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace ConsoleVigenereCipher

{

    class Program

    {

        static void Main(string[] args)

        {

            VigenereCipher vigenere_engine = new VigenereCipher();

            //the key used for encryption or decryption

            string key = "apress";

            //the text that will encrypted

            //encrypted value is "WTCGGEEIFEHJEHJ"

            string text_for_encryption = "WELCOMETOAPRESS";

            string ciphertext = "WTCGGEEIFEHJEHJ";

            //You can use also Decrypt

            Console.WriteLine("The text that will be encrypted is: {0}", text_for_encryption);

            Console.WriteLine("The key used is: {0}", key);

            Console.WriteLine("The encryption is {0}. ", vigenere_engine.Encrypt(key, text_for_encryption));

            Console.WriteLine("The decryption is {0}. ", vigenere_engine.Decrypt(key, ciphertext));

            Console.ReadKey();

        }

    }

    class VigenereCipher

    {

        Dictionary<sbyte, char> TheAlphabet = new Dictionary<sbyte, char>();

        public VigenereCipher()

        {

            //Me from the future: wtf lol

            TheAlphabet.Add(0, 'A');

            TheAlphabet.Add(1, 'B');

            TheAlphabet.Add(2, 'C');

            TheAlphabet.Add(3, 'D');

            TheAlphabet.Add(4, 'E');

            TheAlphabet.Add(5, 'F');

            TheAlphabet.Add(6, 'G');

            TheAlphabet.Add(7, 'H');

            TheAlphabet.Add(8, 'I');

            TheAlphabet.Add(9, 'J');

            TheAlphabet.Add(10, 'K');

            TheAlphabet.Add(11, 'L');

            TheAlphabet.Add(12, 'M');

            TheAlphabet.Add(13, 'N');

            TheAlphabet.Add(14, 'O');

            TheAlphabet.Add(15, 'P');

            TheAlphabet.Add(16, 'Q');

            TheAlphabet.Add(17, 'R');

            TheAlphabet.Add(18, 'S');

            TheAlphabet.Add(19, 'T');

            TheAlphabet.Add(20, 'U');

            TheAlphabet.Add(21, 'V');

            TheAlphabet.Add(22, 'W');

            TheAlphabet.Add(23, 'X');

            TheAlphabet.Add(24, 'Y');

            TheAlphabet.Add(25, 'Z');

        }

        private bool CheckIfEmptyString(string Key, string Text)

        {

            if (string.IsNullOrEmpty(Key)

                || string.IsNullOrWhiteSpace(Key))

            {

                return true;

            }

            if (string.IsNullOrEmpty(Text)

                || string.IsNullOrWhiteSpace(Text))

            {

                return true;

            }

            return false;

        }

        public string Encrypt(string Key, string Text)

        {

            try

            {

                Key = Key.ToUpper();

                Text = Text.ToUpper();

                if (CheckIfEmptyString(Key, Text))

                    { return "Enter a valid string"; }

                string ciphertext = "";

                int i = 0;

                foreach (char element in Text)

                {

                    //** if we are having a character

                    //** that is not in the alphabet

                    if (!Char.IsLetter(element))

                        { ciphertext += element; }

                    else

                    {

                        //Obtain from the dictionary TKey by the TValue

                        sbyte T_Order = TheAlphabet.FirstOrDefault

                            (x => x.Value == element).Key;

                        sbyte K_Order = TheAlphabet.FirstOrDefault

                            (x => x.Value == Key[i]).Key;

                        sbyte Final = (sbyte)(T_Order + K_Order);

                        if (Final > 25) { Final -= 26; }

                        ciphertext += TheAlphabet[Final];

                        i++;

                    }

                    if (i == Key.Length) { i = 0; }

                }

                return ciphertext;

            }

            catch (Exception E)

            {

                return "Error: " + E.Message;

            }

        }

        public string Decrypt(string Key, string Text)

        {

            try

            {

                Key = Key.ToUpper();

                Text = Text.ToUpper();

                if (CheckIfEmptyString(Key, Text)) { return "Enter a valid string value!"; }

                string plaintext = "";

                int i = 0;

                foreach (char element in Text)

                {

                    //if the character is not an alphabetical value

                    if (!Char.IsLetter(element)) { plaintext += element; }

                    else

                    {

                        sbyte TOrder = TheAlphabet.FirstOrDefault

                            (x => x.Value == element).Key;

                        sbyte KOrder = TheAlphabet.FirstOrDefault

                            (x => x.Value == Key[i]).Key;

                        sbyte Final = (sbyte)(TOrder - KOrder);

                        if (Final < 0) { Final += 26; }

                        plaintext += TheAlphabet[Final];

                        i++;

                    }

                    if (i == Key.Length) { i = 0; }

                }

                return plaintext;

            }

            catch (Exception E)

            {

                return "Error: " + E.Message;

            }

        }

    }

}

Listing 1-3

Vigenére Implementation

We will continue with the source code analysis as follows. Let’s examine the source code from Program.cs, more precisely the source code behind the two operations that represents the main operations, Encrypt and Decrypt.

The source code for the Encrypt method is show in Listing 1-4.

public string Encrypt(string Key, string Text)

    {

        try

        {

            Key = Key.ToUpper();

            Text = Text.ToUpper();

            if (CheckIfEmptyString(Key, Text))

                { return "Enter a valid string"; }

            string ciphertext = "";

            int i = 0;

            foreach (char element in Text)

            {

                //** if we are having a character

                //** that is not in the alphabet

                if (!Char.IsLetter(element))

                    { ciphertext += element; }

                else

                {

                    //Obtain from the dictionary TKey by the TValue

                    sbyte T_Order = TheAlphabet.FirstOrDefault

                        (x => x.Value == element).Key;

                    sbyte K_Order = TheAlphabet.FirstOrDefault

                        (x => x.Value == Key[i]).Key;

                    sbyte Final = (sbyte)(T_Order + K_Order);

                    if (Final > 25) { Final -= 26; }

                    ciphertext += TheAlphabet[Final];

                    i++;

                }

                if (i == Key.Length) { i = 0; }

            }

            return ciphertext;

        }

        catch (Exception E)

        {

            return "Error: " + E.Message;

        }

    }

Listing 1-4

Source Code for the Encryption Method

The source code for the Decrypt method is shown in Listing 1-5.

public string Decrypt(string Key, string Text)

        {

            try

            {

                Key = Key.ToUpper();

                Text = Text.ToUpper();

                if (CheckIfEmptyString(Key, Text)) { return "Enter a valid string value!"; }

                string plaintext = "";

                int i = 0;

                foreach (char element in Text)

                {

                    //if the character is not an alphabetical value

                    if (!Char.IsLetter(element)) { plaintext += element; }

                    else

                    {

                        sbyte TOrder = TheAlphabet.FirstOrDefault

                            (x => x.Value == element).Key;

                        sbyte KOrder = TheAlphabet.FirstOrDefault

                            (x => x.Value == Key[i]).Key;

                        sbyte Final = (sbyte)(TOrder - KOrder);

                        if (Final < 0) { Final += 26; }

                        plaintext += TheAlphabet[Final];

                        i++;

                    }

                    if (i == Key.Length) { i = 0; }

                }

                return plaintext;

            }

            catch (Exception E)

            {

                return "Error: " + E.Message;

            }

        }

Listing 1-5

Souce Code for the Decryption Method

Conclusion

In the next chapter, we will go through the basics of probability theory, information theory, number theory, and finite fields. We will discuss their importance and how they are related during the implementation already existing in .NET and how they are useful for developers.

Bibliography