Implementation of Diffie-Hellman Algorithm

09 Jun, 2022
Background
Elliptic Curve Cryptography (ECC) is an approach to public-key cryptography, based on the algebraic structure of elliptic curves over finite fields. ECC requires a smaller key as compared to non-ECC cryptography to provide equivalent security (a 256-bit ECC security has equivalent security attained by 3072-bit RSA cryptography).
For a better understanding of Elliptic Curve Cryptography, it is very important to understand the basics of the Elliptic Curve. An elliptic curve is a planar algebraic curve defined by an equation of the form
 
Where ‘a’ is the co-efficient of x and ‘b’ is the constant of the equation  
The curve is non-singular; that is, its graph has no cusps or self-intersections (when the characteristic of the Co-efficient field is equal to 2 or 3). 
In general, an elliptic curve looks like as shown below. Elliptic curves can intersect almost 3 points when a straight line is drawn intersecting the curve. As we can see, the elliptic curve is symmetric about the x-axis. This property plays a key role in the algorithm.
Diffie-Hellman algorithm
The Diffie-Hellman algorithm is being used to establish a shared secret that can be used for secret communications while exchanging data over a public network using the elliptic curve to generate points and get the secret key using the parameters.  
For the sake of simplicity and practical implementation of the algorithm, we will consider only 4 variables, one prime P and G (a primitive root of P) and two private values a and b.
P and G are both publicly available numbers. Users (say Alice and Bob) pick private values a and b and they generate a key and exchange it publicly. The opposite person receives the key and that generates a secret key, after which they have the same secret key to encrypt.
Step by Step Explanation 
Key generated = 
Key generated = 
Generated Secret Key = 
Generated Secret Key = 
Algebraically, it can be shown that 
Example: 
Step 1: Alice and Bob get public numbers P = 23, G = 9

Step 2: Alice selected a private key a = 4 and
        Bob selected a private key b = 3

Step 3: Alice and Bob compute public values
Alice:    x =(9^4 mod 23) = (6561 mod 23) = 6
        Bob:    y = (9^3 mod 23) = (729 mod 23)  = 16

Step 4: Alice and Bob exchange public numbers

Step 5: Alice receives public key y =16 and
        Bob receives public key x = 6

Step 6: Alice and Bob compute symmetric keys
        Alice:  ka = y^a mod p = 65536 mod 23 = 9
        Bob:    kb = x^b mod p = 216 mod 23 = 9

Step 7: 9 is the shared secret.
Implementation:  
C
Java
Python3
Javascript
C++
/* This program calculates the Key for two personsusing the Diffie-Hellman Key exchange algorithm */#include<stdio.h>#include<math.h> // Power function to return value of a ^ b mod Plong long int power(long long int a, long long int b,                                     long long int P){    if (b == 1)        return a;     else        return (((long long int)pow(a, b)) % P);} //Driver programint main(){    long long int P, G, x, a, y, b, ka, kb;         // Both the persons will be agreed upon the        // public keys G and P    P = 23; // A prime number P is taken    printf("The value of P : %lld\n", P);     G = 9; // A primitive root for P, G is taken    printf("The value of G : %lld\n\n", G);     // Alice will choose the private key a    a = 4; // a is the chosen private key    printf("The private key a for Alice : %lld\n", a);    x = power(G, a, P); // gets the generated key         // Bob will choose the private key b    b = 3; // b is the chosen private key    printf("The private key b for Bob : %lld\n\n", b);    y = power(G, b, P); // gets the generated key     // Generating the secret key after the exchange        // of keys    ka = power(y, a, P); // Secret key for Alice    kb = power(x, b, P); // Secret key for Bob         printf("Secret key for the Alice is : %lld\n", ka);    printf("Secret Key for the Bob is : %lld\n", kb);         return 0;}
// This program calculates the Key for two persons// using the Diffie-Hellman Key exchange algorithmclass GFG{     // Power function to return value of a ^ b mod Pprivate static long power(long a, long b, long p){    if (b == 1)        return a;    else        return (((long)Math.pow(a, b)) % p);} // Driver codepublic static void main(String[] args){    long P, G, x, a, y, b, ka, kb;         // Both the persons will be agreed upon the    // public keys G and P         // A prime number P is taken    P = 23;    System.out.println("The value of P:" + P);         // A primitive root for P, G is taken    G = 9;    System.out.println("The value of G:" + G);         // Alice will choose the private key a    // a is the chosen private key    a = 4;    System.out.println("The private key a for Alice:" + a);         // Gets the generated key    x = power(G, a, P);         // Bob will choose the private key b    // b is the chosen private key       b = 3;    System.out.println("The private key b for Bob:" + b);         // Gets the generated key    y = power(G, b, P);         // Generating the secret key after the exchange    // of keys    ka = power(y, a, P); // Secret key for Alice    kb = power(x, b, P); // Secret key for Bob         System.out.println("Secret key for the Alice is:" + ka);    System.out.println("Secret key for the Bob is:" + kb);}} // This code is contributed by raghav14
from random import randint if __name__ == '__main__':     # Both the persons will be agreed upon the    # public keys G and P    # A prime number P is taken    P = 23         # A primitive root for P, G is taken    G = 9               print('The Value of P is :%d'%(P))    print('The Value of G is :%d'%(G))         # Alice will choose the private key a    a = 4    print('The Private Key a for Alice is :%d'%(a))         # gets the generated key    x = int(pow(G,a,P))          # Bob will choose the private key b    b = 3    print('The Private Key b for Bob is :%d'%(b))        # gets the generated key    y = int(pow(G,b,P))               # Secret key for Alice    ka = int(pow(y,a,P))         # Secret key for Bob    kb = int(pow(x,b,P))         print('Secret key for the Alice is : %d'%(ka))    print('Secret Key for the Bob is : %d'%(kb))
<script> // This program calculates the Key for two persons// using the Diffie-Hellman Key exchange algorithm // Power function to return value of a ^ b mod Pfunction power(a, b, p){    if (b == 1)        return a;    else        return((Math.pow(a, b)) % p);} // Driver codevar P, G, x, a, y, b, ka, kb; // Both the persons will be agreed upon the// public keys G and P // A prime number P is takenP = 23;document.write("The value of P:" + P + "<br>"); // A primitive root for P, G is takenG = 9;document.write("The value of G:" + G + "<br>"); // Alice will choose the private key a// a is the chosen private keya = 4;document.write("The private key a for Alice:" +               a + "<br>"); // Gets the generated keyx = power(G, a, P); // Bob will choose the private key b// b is the chosen private key   b = 3;document.write("The private key b for Bob:" +               b + "<br>"); // Gets the generated keyy = power(G, b, P); // Generating the secret key after the exchange// of keyska = power(y, a, P); // Secret key for Alicekb = power(x, b, P); // Secret key for Bob document.write("Secret key for the Alice is:" +               ka + "<br>");document.write("Secret key for the Bob is:" +               kb + "<br>"); // This code is contributed by Ankita saini </script>
/* This program calculates the Key for two personsusing the Diffie-Hellman Key exchange algorithm using C++ */#include <cmath>#include <iostream>using namespace std; // Power function to return value of a ^ b mod Plong long int power(long long int a, long long int b,                    long long int P){    if (b == 1)        return a;     else        return (((long long int)pow(a, b)) % P);} // Driver programint main(){    long long int P, G, x, a, y, b, ka, kb;     // Both the persons will be agreed upon the    // public keys G and P    P = 23; // A prime number P is taken    cout << "The value of P : " << P << endl;     G = 9; // A primitive root for P, G is taken    cout << "The value of G : " << G << endl;     // Alice will choose the private key a    a = 4; // a is the chosen private key    cout << "The private key a for Alice : " << a << endl;     x = power(G, a, P); // gets the generated key     // Bob will choose the private key b    b = 3; // b is the chosen private key    cout << "The private key b for Bob : " << b << endl;     y = power(G, b, P); // gets the generated key     // Generating the secret key after the exchange    // of keys    ka = power(y, a, P); // Secret key for Alice    kb = power(x, b, P); // Secret key for Bob    cout << "Secret key for the Alice is : " << ka << endl;     cout << "Secret key for the Alice is : " << kb << endl;     return 0;}// This code is contributed by Pranay Arora
Output:
The value of P : 23
The value of G : 9

The private key a for Alice : 4
The private key b for Bob : 3

Secret key for the Alice is : 9
Secret Key for the Bob is : 9
This article is contributed by Souvik Nandi. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.GeeksforGeeks.org or mail your article to contribute@GeeksforGeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
nalasivam
ShJos
raghav14
ankita_saini
sooda367
arorapranay
Computer Networks
Computer Networks
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.