What is the RSA algorithm (Rivest-Shamir-Adleman)

The RSA algorithm (Rivest-Shamir-Adleman) is the basis of a cryptosystem -- a suite of cryptographic algorithms that
are used for specific security services or purposes -- which enables public key encryption and is widely used to secure
sensitive data, particularly when it is being sent over an insecure network such as the internet.

RSA was first publicly described in 1977 by Ron Rivest, Adi Shamir and Leonard Adleman of the Massachusetts
Institute of Technology, though the 1973 creation of a public key algorithm by British mathematician Clifford Cocks
was kept classified by the U.K.'s GCHQ until 1997.

Public key cryptography, also known as asymmetric cryptography, uses two different but mathematically linked keys -
- one public and one private. The public key can be shared with everyone, whereas the private key must be kept secret.

RSA is a type of asymmetric encryption, which uses two different but linked keys.

In RSA cryptography, both the public and the private keys can encrypt a message. The opposite key from
the one used to encrypt a message is used to decrypt it. This attribute is one reason why RSA has become the
most widely used asymmetric algorithm: It provides a method to assure the confidentiality, integrity,
authenticity, and non-repudiation of electronic communications and data storage.

Many protocols, including Secure Shell (SSH), OpenPGP, S/MIME, and SSL/TLS, rely on RSA for
encryption and digital signature functions. It is also used in software programs -- browsers are an obvious
example, as they need to establish a secure connection over an insecure network, like the internet, or validate
a digital signature. RSA signature verification is one of the most commonly performed operations in
network-connected systems.

Why is the RSA algorithm used?

RSA derives its security from the difficulty of factoring large integers that are the product of two large prime
numbers. Multiplying these two numbers is easy, but determining the original prime numbers from the total
-- or factoring -- is considered infeasible due to the time it would take using even today's supercomputers.

The public and private key generation algorithm is the most complex part of RSA cryptography. Two large
prime numbers, p and q, are generated using the Rabin-Miller primality test algorithm. A modulus, n, is
calculated by multiplying p and q. This number is used by both the public and private keys and provides the
link between them. Its length, usually expressed in bits, is called the key length.

The public key consists of the modulus n and a public exponent, e, which is normally set at 65537, as it's a
prime number that is not too large. The e figure doesn't have to be a secretly selected prime number, as the
public key is shared with everyone.

The private key consists of the modulus n and the private exponent d, which is calculated using the
Extended Euclidean algorithm to find the multiplicative inverse with respect to the totient of n.

How does the RSA algorithm work?

Alice generates her RSA keys by selecting two primes: p=11 and q=13. The modulus is n=p×q=143. The
totient is n ϕ(n)=(p−1)x(q−1)=120. She chooses 7 for her RSA public key e and calculates her RSA private
key using the Extended Euclidean algorithm, which gives her 103.

Bob wants to send Alice an encrypted message, M, so he obtains her RSA public key (n, e) which, in this
example, is (143, 7). His plaintext message is just the number 9 and is encrypted into ciphertext, C, as
follows:

Me mod n = 97 mod 143 = 48 = C

When Alice receives Bob's message, she decrypts it by using her RSA private key (d, n) as follows:

Cd mod n = 48103 mod 143 = 9 = M

To use RSA keys to digitally sign a message, Alice would need to create a hash -- a message digest of her
message to Bob -- encrypt the hash value with her RSA private key, and add the key to the message. Bob
can then verify that the message has been sent by Alice and has not been altered by decrypting the hash
value with her public key. If this value matches the hash of the original message, then only Alice could have
sent it -- authentication and non-repudiation -- and the message is exactly as she wrote it -- integrity.

Alice could, of course, encrypt her message with Bob's RSA public key -- confidentiality -- before sending it
to Bob. A digital certificate contains information that identifies the certificate's owner and also contains the
owner's public key. Certificates are signed by the certificate authority that issues them, and they can simplify
the process of obtaining public keys and verifying the owner.

An RSA key exchange involves multiple steps.

How is RSA secure?

RSA security relies on the computational difficulty of factoring large integers. As computing power
increases and more efficient factoring algorithms are discovered, the ability to factor larger and larger
numbers also increases.

Encryption strength is directly tied to key size. Doubling key length can deliver an exponential increase in
strength, although it does impair performance. RSA keys are typically 1024- or 2048-bits long, but experts
believe that 1024-bit keys are no longer fully secure against all attacks. This is why the government and
some industries are moving to a minimum key length of 2048-bits.

Barring an unforeseen breakthrough in quantum computing, it will be many years before longer keys are
required, but elliptic curve cryptography (ECC) is gaining favor with many security experts as an alternative
to RSA to implement public key cryptography. It can create faster, smaller and more efficient cryptographic
keys.

Modern hardware and software are ECC-ready, and its popularity is likely to grow. It can deliver equivalent
security with lower computing power and battery resource usage, making it more suitable for mobile apps
than RSA.

A team of researchers, which included Adi Shamir, a co-inventor of RSA, successfully created a 4096-bit
RSA key using acoustic cryptanalysis. However, note that any encryption algorithm is vulnerable to attack.

Implement the RSA Algorithm

RSA is one of the first practicable public-key cryptosystems and is widely used for
secure data transmission. In such a cryptosystem, the encryption key is public and
differs from the decryption key which is kept secret. In RSA, this asymmetry is based
on the practical difficulty of factoring the product of two large prime numbers, the
factoring problem. RSA stands for Ron Rivest, Adi Shamir and Leonard Adleman.
Here is the source code of the Java Program to Implement the RSA Algorithm. The Java
program is successfully compiled and run on a Windows system. The program output is
also shown below.

package com.sanfoundry.setandstring;

import java.io.DataInputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.util.Random;

public class RSA

{
private BigInteger p;
private BigInteger q;
private BigInteger N;
private BigInteger phi;
private BigInteger e;
private BigInteger d;
private int bitlength = 1024;
private Random r;
public RSA()
{
r = new Random();
p = BigInteger.probablePrime(bitlength, r);
q = BigInteger.probablePrime(bitlength, r);
N = p.multiply(q);
phi = p.subtract(BigInteger.ONE).multiply(q.subtract(BigInteger.ONE));
e = BigInteger.probablePrime(bitlength / 2, r);
while (phi.gcd(e).compareTo(BigInteger.ONE) > 0 && e.compareTo(phi) < 0)
{
e.add(BigInteger.ONE);
}
d = e.modInverse(phi);
}

public RSA(BigInteger e, BigInteger d, BigInteger N)

{
this.e = e;
this.d = d;
this.N = N;
}

@SuppressWarnings("deprecation")
public static void main(String[] args) throws IOException
{
RSA rsa = new RSA();
DataInputStream in = new DataInputStream(System.in);
String teststring;
System.out.println("Enter the plain text:");
teststring = in.readLine();
System.out.println("Encrypting String: " + teststring);
System.out.println("String in Bytes: "
+ bytesToString(teststring.getBytes()));
// encrypt
byte[] encrypted = rsa.encrypt(teststring.getBytes());
// decrypt
byte[] decrypted = rsa.decrypt(encrypted);
System.out.println("Decrypting Bytes: " + bytesToString(decrypted));
System.out.println("Decrypted String: " + new String(decrypted));
}

private static String bytesToString(byte[] encrypted)

{
String test = "";
for (byte b : encrypted)
{
test += Byte.toString(b);
}
 return test;
}

// Encrypt message
public byte[] encrypt(byte[] message)
{
return (new BigInteger(message)).modPow(e, N).toByteArray();
}

// Decrypt message
public byte[] decrypt(byte[] message)
{
return (new BigInteger(message)).modPow(d, N).toByteArray();
}
}

Output:

$ javac RSA.java
$ java RSA

Enter the plain text:

Sanfoundry
Encrypting String: Sanfoundry
String in Bytes: 8397110102111117110100114121
Decrypting Bytes: 8397110102111117110100114121
Decrypted String: Sanfoundry