This action might not be possible to undo. Are you sure you want to continue?

**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 0x00.

**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 :

#include<stdio.h> #include<conio.h> 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; return; } FLAG = 0; return; } void encrypt() { int i; C = 1; for(i=0;i< e;i++) C=C*M%n; C = C%n; printf("\n\tEncrypted keyword : %d",C);

} void decrypt() { int i; M = 1; for(i=0;i< d;i++) M=M*C%n; M = M%n; printf("\n\tDecrypted keyword : %d",M); } void main() { int p,q,s; clrscr(); printf("Enter Two Relatively Prime Numbers\t: "); scanf("%d%d",&p,&q); n = p*q; phi=(p-1)*(q-1); printf("\n\tF(n)\t= %d",phi); do { printf("\n\nEnter e\t: "); scanf("%d",&e); check();

}while(FLAG==1); d = 1; do { s = (d*e)%phi; d++; }while(s!=1); 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: "); scanf("%d",&M); encrypt(); printf("\n\nEnter the code to be decrypted\t: "); scanf("%d",&C); decrypt(); getch(); }

o/p :

Sign up to vote on this title

UsefulNot usefulTHIS IS A DOCUMENT SPECIALLY FOR THE ENGINEERING STUDENTS , IT CONSISTS THEORY ON ENCRYPTION AND DECRYPTION , AND A C PROGRAM RELATED TO IT ALONG WITH THE OUTPUT

THIS IS A DOCUMENT SPECIALLY FOR THE ENGINEERING STUDENTS , IT CONSISTS THEORY ON ENCRYPTION AND DECRYPTION , AND A C PROGRAM RELATED TO IT ALONG WITH THE OUTPUT

- week_5.pdf
- crytography_New1
- 01621007
- CCCC.docx
- Is One Time Pad History
- Computer Security and Cryptography A simple Presentation
- CYCLIC Group Appn
- Cryptography Basics
- Cryptography for Dummies (ISBN - 0764541889)
- pkivsidpkc.doc
- A Calculus for Secure Channel Establishment in Open Networks
- Chapter 6 Data Security (Dr.Atef)
- ecomsecurity bs
- Ben an Tar
- Chapter 9 Information Systems Controls for Systems ReliabilityPart 2 Confidentiality and Privacy
- Security Review1
- All Unit 2 Mark and 16 mark.pdf
- Cryptography
- IPortable Security Transaction Protocol
- nandu
- Class 18
- DDEEE11
- Quantum Cryptography
- Encryption Decryption
- CDAMA
- Message Oriented Web Services
- Implementation of Aes and Blowfish Algorithm
- fawkes.pdf
- Lightweight PKI Form WSN and uPKI
- 16 Security 2 Study on Operating Systems অপারেটিং সিস্টেম
- RSA ALGORITHM