16.5.5. Operational Steps of RSA Cryptosystem

The race for coming up with the first instantiation of public key cryptosystem was won by another Turing Award winner triplet, namely RSA, Rivest, Shamir, and Adleman. Now, let me give you briefly a description of the RSA public key cryptosystem, again which is based on several interesting results from number theory that we have discussed.

RSA is a public key cryptosystem developed by Rivest, Shamir, and Adleman, which provides a secure method for encrypting messages based on mathematical principles from number theory. It involves generating two keys: a public key for encryption and a private key for decryption. The underlying security of RSA relies on the practical difficulty of factoring large prime numbers.

Imagine sending a locked box with a combination lock to a friend. Anyone can see the locked box (the public key), but only your friend has the combination (the private key) to open it. This ensures that no one else can read the contents of the box while it's being sent.

So, recall the definition of the group Z_N* which is the collection of all the values in the range 1 to N - 1 which are co-prime to your modulus N. For instance, the set Z_10* will have the elements 1, 3, 7, 9. It would not have the element 2 because 2 is not co-prime to 10.

The group Z_N* consists of numbers that can be divided by N without leaving a remainder and are co-prime to N. The Euler's totient function, denoted as φ(N), counts these elements. Understanding this group is crucial because it forms the foundation on which the RSA algorithm operates, particularly in terms of defining how many valid keys can be created.

Think of Z_N* like a group of friends invited to a party. Some friends can attend (co-prime), while others (not co-prime) are not invited due to conflicts. The total invited friends represent the elements in the group which can interact freely.

The RSA function in the forward direction is the following. If I want to compute the output of the RSA function for x then that is same as computing x^e mod N. ... If I have a value y and if I want to invert it, I compute y^d mod N.

RSA makes use of two primary operations: encryption and decryption. Encryption involves raising the plaintext message x to the power of e (public exponent) modulo N. The decryption process then involves raising the encrypted value back to the power of d (private exponent). This two-step process ensures that only someone with the private key can decrypt the message.

Imagine using a special locked mailbox. To send a message, you drop your letter inside and secure it with a unique key (e) that only the mailbox understands. Later, the owner of the mailbox uses their own key (d) to unlock and read the message, ensuring only they can view it.

So, now let us introduce a computational problem which we believe is really difficult to solve. It is like your discrete log problem. ... The RSA problem is the following. If I give you the modulus, but not its prime factors and if I give you the public exponent, what would not be known to you are the prime factors of N.

The RSA parameter generation involves selecting two large prime numbers (p and q) and calculating their product to form N. The challenge lies in factorizing N to retrieve p and q, which is currently a computationally intensive problem. This difficulty in factorization is what secures the RSA cryptosystem.

Think of N like a combination lock built from two large gears (the prime numbers). Knowing the lock only provides the outer appearance, but the security is in figuring out the combination to take it apart—a task that is extremely hard unless you know the gear sizes.

The way RSA cryptosystem works is as follows. Receiver will run the parameter generation algorithm. ... If there is a sender, who has a plain text m and which it wants to encrypt then, encryption of m is nothing but computing the forward direction function as per the RSA function, namely, just output m^e mod N.

In practice, RSA involves several steps. The receiver generates their keys, making the public key known while keeping the private key secret. The sender encrypts the message using the receiver's public key with the RSA function to produce a ciphertext. The receiver then uses their private key to decrypt the ciphertext back into the original plaintext message.

Consider a library. You can borrow books (messages) but can only do so with the librarian's permission (public key). When you want to borrow a book, you fill out a form (the encryption process) which only the librarian can understand and process due to their unique access rights (private key).

--