Implementation of Diffie-Hellman Algorithm

Last Updated : 03 Jul, 2024

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 is as follows:

Alice	Bob
Public Keys available = P, G	Public Keys available = P, G
Private Key Selected = a	Private Key Selected = b
Key generated = x = G^a mod P	Key generated = y = G^b mod P
Exchange of generated keys takes place
Key received = y	key received = x
Generated Secret Key = k_a = y^a mod P	Generated Secret Key = k_b = x^b mod P
Algebraically, it can be shown that k_a = k_b
Users now have a symmetric secret key to encrypt

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++

/* This program calculates the Key for two persons using the Diffie-Hellman Key exchange algorithm using C++ */ #include <cmath> #include <iostream>  using namespace std;  // Power function to return value of a ^ b mod P long 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 program int 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 Bob is : " << kb << endl;      return 0; } // This code is contributed by Pranay Arora

/* This program calculates the Key for two persons using the Diffie-Hellman Key exchange algorithm */ #include <math.h> #include <stdio.h>  // Power function to return value of a ^ b mod P long 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 program int 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; }

Java

// This program calculates the Key for two persons // using the Diffie-Hellman Key exchange algorithm class GFG {      // Power function to return value of a ^ b mod P     private static long power(long a, long b, long p)     {         if (b == 1)             return a;         else             return (((long)Math.pow(a, b)) % p);     }      // Driver code     public 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

Python

# Diffie-Hellman Code  # Power function to return value of a^b mod P def power(a, b, p):     if b == 1:         return a     else:         return pow(a, b) % p  # Main function def main():     # Both persons agree upon the public keys G and P     # A prime number P is taken     P = 23     print("The value of P:", P)      # A primitive root for P, G is taken     G = 9     print("The value of G:", G)      # Alice chooses the private key a     # a is the chosen private key     a = 4     print("The private key a for Alice:", a)      # Gets the generated key     x = power(G, a, P)      # Bob chooses the private key b     # b is the chosen private key     b = 3     print("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      print("Secret key for Alice is:", ka)     print("Secret key for Bob is:", kb)  if __name__ == "__main__":     main()

// C# implementation to calculate the Key for two persons // using the Diffie-Hellman Key exchange algorithm using System; class GFG {      // Power function to return value of a ^ b mod P     private static long power(long a, long b, long P)     {         if (b == 1)             return a;          else             return (((long)Math.Pow(a, b)) % P);     }     public static void Main()     {         long 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         Console.WriteLine("The value of P:" + P);          G = 9; // A primitive root for P, G is taken         Console.WriteLine("The value of G:" + G);          // Alice will choose the private key a         a = 4; // a is the chosen private key         Console.WriteLine("\nThe private key a for Alice:"                           + 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         Console.WriteLine("The private key b for Bob:" + 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          Console.WriteLine("\nSecret key for the Alice is:"                           + ka);         Console.WriteLine("Secret key for the Alice is:"                           + kb);     } }  // This code is contributed by Pranay Arora

JavaScript

<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 P function power(a, b, p)  {     if (b == 1)         return a;     else         return((Math.pow(a, b)) % p); }  // Driver code var 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; document.write("The value of P:" + P + "<br>");  // A primitive root for P, G is taken G = 9; document.write("The value of G:" + G + "<br>");  // Alice will choose the private key a // a is the chosen private key a = 4;  document.write("The private key a for Alice:" +                 a + "<br>");  // Gets the generated key x = 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 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  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>

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

ElGamal Encryption Algorithm

Souvik Nandi

Improve

Article Tags :

Practice Tags :

Misc

Implementation of Diffie-Hellman Algorithm

Diffie-Hellman algorithm:

Similar Reads

Cryptography Basic

Cryptography Algorithm

What is data encryption?

Classical Encryption Techniques

Block Cipher , DES and AES

Public Key Cryptography and RSA

What is Cryptanalysis?

Comman Cryptography

Data Integrity in Cryptography