IMPLEMENTACIÓN DEL ALGORITMO DIFFIE-HELLMAN

Algoritmo de Diffie-Hellman:

El algoritmo Diffie-Hellman se utiliza para establecer un secreto compartido que se puede utilizar para comunicaciones secretas mientras se intercambian datos a través de una red pública utilizando la curva elíptica para generar puntos y obtener la clave secreta utilizando los parámetros.

En aras de la simplicidad y la implementación práctica del algoritmo, consideraremos solo 4 variables, una prima P y G (una raíz primitiva de P) y dos valores privados a y b.
P y G son números disponibles públicamente. Los usuarios (por ejemplo, Alice y Bob) eligen valores privados a y b, generan una clave y la intercambian públicamente. La persona opuesta recibe la clave y genera una clave secreta, después de lo cual tiene la misma clave secreta para cifrar.

La explicación paso a paso es la siguiente:

Alicia	Chelín
Claves públicas disponibles = P G	Claves públicas disponibles = P G
Clave privada seleccionada = a	Clave privada seleccionada = b
Clave generada = emitir cadena como int x = G^a mod P	Clave generada = y = G^b mod P
Se realiza el intercambio de claves generadas.
Clave recibida = y	clave recibida = x
Clave secreta generada = k_a = y^a mod P	Clave secreta generada = clasificación de lista de matrices java k_b = x^b mod P
Algebraicamente se puede demostrar que k_a = k_b eliminar el archivo en java
Los usuarios ahora tienen una clave secreta simétrica para cifrar

Ejemplo:

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.

Implementación:

C++

/* This program calculates the Key for two persons using the Diffie-Hellman Key exchange algorithm using C++ */ #include  #include    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  #include  // 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 : %lldn' P);  G = 9; // A primitive root for P G is taken  printf('The value of G : %lldnn' G);  // Alice will choose the private key a  a = 4; // a is the chosen private key  printf('The private key a for Alice : %lldn' 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 : %lldnn' 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 : %lldn' ka);  printf('Secret Key for the Bob is : %lldn' 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 + '  
'); // A primitive root for P G is taken G = 9; document.write('The value of G:' + G + '  
'); // Alice will choose the private key a // a is the chosen private key a = 4;  document.write('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;  document.write('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 document.write('Secret key for the Alice is:' +   ka + '  
'); document.write('Secret key for the Bob is:' +   kb + '  
'); // This code is contributed by Ankita saini </script>

Producción

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

TechCodeview

Implementación del algoritmo Diffie-Hellman

Algoritmo de Diffie-Hellman: