Sie sind auf Seite 1von 8

Title : RSA ALGORITHM for encryption and decryption.

Aim : Write a program to implement RSA using c language

Theory :
Working :

1. Generate two large random primes, p and q, of approximately equal size such that their product n
= pq is of the required bit length, e.g. 1024 bits.
2. Compute n = pq and (φ) phi = (p-1)(q-1).
3. Choose an integer e, 1 < e < phi, such that gcd(e, phi) = 1.
4. Compute the secret exponent d, 1 < d < phi, such that ed ≡ 1 (mod phi).
5. The public key is (n, e) and the private key is (n, d). Keep all the values d, p, q and phi secret.

• n is known as the modulus.

• e is known as the public exponent or encryption exponent or just the exponent.
• d is known as the secret exponent or decryption exponent.

Encryption :

Sender A does the following:-

1. Obtains the recipient B's public key (n, e).

2. Represents the plaintext message as a positive integer m
3. Computes the ciphertext c = me mod n.
4. Sends the ciphertext c to B.

Decryption :

Recipient B does the following:-

1. Uses his private key (n, d) to compute m = cd mod n.

2. Extracts the plaintext from the message representative m.

Digital signing :

Sender A does the following:-

1. Creates a message digest of the information to be sent.
2. Represents this digest as an integer m between 0 and n-1.
3. Uses her private key (n, d) to compute the signature s = md mod n.
4. Sends this signature s to the recipient, B.

Signature verification :

Recipient B does the following:-

1. Uses sender A's public key (n, e) to compute integer v = se mod n.

2. Extracts the message digest from this integer.
3. Independently computes the message digest of the information that has been signed.
4. If both message digests are identical, the signature is valid.

Notes on practical applications :

1. To generate the primes p and q, generate a random number of bit length b/2 where b is the
required bit length of n; set the low bit (this ensures the number is odd) and set the two highest
bits (this ensures that the high bit of n is also set); check if prime (use the Rabin-Miller test); if not,
increment the number by two and check again until you find a prime. This is p. Repeat for q
starting with a random integer of length b-b/2. If p<q, swop p and q (this only matters if you intend
using the CRT form of the private key). In the extremely unlikely event that p = q, check your
random number generator. Alternatively, instead of incrementing by 2, just generate another
random number each time.
2. In practice, common choices for e are 3, 17 and 65537 (216+1). These are Fermat primes,
sometimes referred to as F0, F2 and F4 respectively (Fx=2^(2^x)+1). They are chosen because
they make the modular exponentiation operation faster. Also, having chosen e, it is simpler to test
whether gcd(e, p-1)=1 and gcd(e, q-1)=1 while generating and testing the primes in step 1.
Values of p or q that fail this test can be rejected there and then. (Even better: if e is prime and
greater than 2 then you can do the less-expensive test (p mod e)!=1 instead of gcd(p-1,e)==1.)
3. To compute the value for d, use the Extended Euclidean Algorithm to calculate d = e-1 mod phi
(this is known as modular inversion).
4. When representing the plaintext octets as the representative integer m, it is usual to add random
padding characters to make the size of the integer m large and less susceptible to certain types
of attack. If m = 0 or 1 or n-1 there is no security as the ciphertext has the same value. For more
details on how to represent the plaintext octets as a suitable representative integer m, see
PKCS#1 Schemes below or the reference itself [PKCS1]. It is important to make sure that m < n
otherwise the algorithm will fail. This is usually done by making sure the first octet of m is equal to
5. Decryption and signing are identical as far as the mathematics is concerned as both use the
private key. Similarly, encryption and verification both use the same mathematical operation with
the public key. That is, mathematically, for m < n,

m = (me mod n)d mod n = (md mod n)e mod n

However, note these important differences in implementation:-

o The signature is derived from a message digest of the original information. The recipient
will need to follow exactly the same process to derive the message digest, using an
identical set of data.
o The recommended methods for deriving the representative integers are different for
encryption and signing (encryption involves random padding, but signing uses the same
padding each time).

Summary of RSA :

• n = pq, where p and q are distinct primes.

• phi, φ = (p-1)(q-1)
• e < n such that gcd(e, phi)=1
• d = e-1 mod phi.
• c = me mod n, 1<m<n.
• m = cd mod n.

Conclusion :

After studying the above program , we observe that initially the given data is encrypted by
the program, and we obtain a code for the given data, and afterwards when we enter the corresponding
code , the original data is recovered by decryption .Hence the above program can be used for encryption
and decryption purpose.
Algorithm :

Step 1: Initialize the variables

Step 2: Taking the value of two prime numbers from the user

Step 3 :Calculate the value of n by the formula n = p*q

Step 4:Calculate the value of phi by ,phi = (p-1)(q-1).

Step 5:Taking the value of e from the user

Step 6:Taking the value from the user to be encrypted

Step 7: Display the encrypted code of the given data

Step 8:Taking the code from the user to be decrypted

Step 9: Display the decrypted value for the corresponding code.

Step 10 : Stop
Program :



int phi,M,n,e,d,C,FLAG;

int check()

int i;

for(i=3;e%i==0 && phi%i==0;i+2)

FLAG = 1;


FLAG = 0;


void encrypt()

int i;

C = 1;

for(i=0;i< e;i++)


C = C%n;

printf("\n\tEncrypted keyword : %d",C);


void decrypt()

int i;

M = 1;

for(i=0;i< d;i++)


M = M%n;

printf("\n\tDecrypted keyword : %d",M);

void main()

int p,q,s;


printf("Enter Two Relatively Prime Numbers\t: ");


n = p*q;


printf("\n\tF(n)\t= %d",phi);


printf("\n\nEnter e\t: ");



d = 1;


s = (d*e)%phi;



d = d-1;

printf("\n\tPublic Key\t: {%d,%d}",e,n);

printf("\n\tPrivate Key\t: {%d,%d}",d,n);

printf("\n\nEnter The data to be encrypted\t: ");



printf("\n\nEnter the code to be decrypted\t: ");




o/p :