Scribd
Upload
194 views

RSA Algorithm in Cryptography

The RSA algorithm is an asymmetric cryptographic algorithm that uses a public key and private key. The public key is distributed to others and is used to encrypt messages, while the private key is kept secret and is used to decrypt messages. RSA works by generating the public key from two large prime numbers and deriving the private key from the same numbers. The security of RSA lies in the difficulty of factoring the product of the two prime numbers. A C implementation example demonstrates encrypting and decrypting a small message using RSA with sample prime numbers and keys.

Uploaded by

Kanwal Preet
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
194 views

RSA Algorithm in Cryptography

The RSA algorithm is an asymmetric cryptographic algorithm that uses a public key and private key. The public key is distributed to others and is used to encrypt messages, while the private key is kept secret and is used to decrypt messages. RSA works by generating the public key from two large prime numbers and deriving the private key from the same numbers. The security of RSA lies in the difficulty of factoring the product of the two prime numbers. A C implementation example demonstrates encrypting and decrypting a small message using RSA with sample prime numbers and keys.

Uploaded by

Kanwal Preet
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 3

RSA Algorithm in Cryptography

RSA algorithm is asymmetric cryptography algorithm. Asymmetric actually means that it works on two
different keys i.e. Public Key and Private Key. As the name describes that the Public Key is given to
everyone and Private key is kept private.
An example of asymmetric cryptography :
1. A client (for example browser) sends its public key to the server and requests for some data.
2. The server encrypts the data using client’s public key and sends the encrypted data.
3. Client receives this data and decrypts it.
Since this is asymmetric, nobody else except browser can decrypt the data even if a third party has public
key of browser.

The idea! The idea of RSA is based on the fact that it is difficult to factorize a large integer. The public
key consists of two numbers where one number is multiplication of two large prime numbers. And private
key is also derived from the same two prime numbers. So if somebody can factorize the large number,
the private key is compromised. Therefore encryption strength totally lies on the key size and if we double
or triple the key size, the strength of encryption increases exponentially. RSA keys can be typically 1024
or 2048 bits long, but experts believe that 1024 bit keys could be broken in the near future. But till now it
seems to be an infeasible task.
Let us learn the mechanism behind RSA algorithm :

>> Generating Public Key :


 Select two prime no's. Suppose P = 53 and Q = 59.
 Now First part of the Public key : n = P*Q = 3127.

 We also need a small exponent say e :


 But e Must be

 An integer.

 Not be a factor of n.

 1 < e < Φ(n) [Φ(n) is discussed below],
 Let us now consider it to be equal to 3.

 Our Public Key is made of n and e


>> Generating Private Key :
 We need to calculate Φ(n) :
 Such that Φ(n) = (P-1)(Q-1)
 so, Φ(n) = 3016

 Now calculate Private Key, d :


 d = (k*Φ(n) + 1) / e for some integer k
 For k = 2, value of d is 2011.
Now we are ready with our – Public Key ( n = 3127 and e = 3) and Private Key(d = 2011)

Now we will encrypt “HI” :


 Convert letters to numbers : H = 8 and I = 9

 Thus Encrypted Data c = 89e mod n.


 Thus our Encrypted Data comes out to be 1394

Now we will decrypt 1394 :

 Decrypted Data = cd mod n.


 Thus our Encrypted Data comes out to be 89

8 = H and I = 9 i.e. "HI".

Below is C implementation of RSA algorithm for small values:


// C program for RSA asymmetric cryptographic
// algorithm. For demonstration values are
// relatively small compared to practical
// application
#include<stdio.h>
#include<math.h>

// Returns gcd of a and b


int gcd(int a, int h)
{
int temp;
while (1)
{
temp = a%h;
if (temp == 0)
return h;
a = h;
h = temp;
}
}

// Code to demonstrate RSA algorithm


int main()
{
// Two random prime numbers
double p = 3;
double q = 7;

// First part of public key:


double n = p*q;

// Finding other part of public key.


// e stands for encrypt
double e = 2;
double phi = (p-1)*(q-1);
while (e < phi)
{
// e must be co-prime to phi and
// smaller than phi.
if (gcd(e, phi)==1)
break;
else
e++;
}

// Private key (d stands for decrypt)


// choosing d such that it satisfies
// d*e = 1 + k * totient
int k = 2; // A constant value
double d = (1 + (k*phi))/e;

// Message to be encrypted
double msg = 20;

printf("Message data = %lf", msg);

// Encryption c = (msg ^ e) % n
double c = pow(msg, e);
c = fmod(c, n);
printf("\nEncrypted data = %lf", c);

// Decryption m = (c ^ d) % n
double m = pow(c, d);
m = fmod(m, n);
printf("\nOriginal Message Sent = %lf", m);

return 0;
}
// This code is contributed by Akash Sharan.
Run on IDE
Output :

Message data = 12.000000

Encrypted data = 3.000000

Original Message Sent = 12.000000

You might also like