DIFFIE-HELLMAN ALGORITMASININ UYGULANMASI

Diffie-Hellman algoritması:

Diffie-Hellman algoritması, noktalar oluşturmak ve parametreleri kullanarak gizli anahtarı almak için eliptik eğriyi kullanarak genel bir ağ üzerinden veri alışverişi yaparken gizli iletişimler için kullanılabilecek paylaşılan bir sır oluşturmak için kullanılıyor.

Algoritmanın basitliği ve pratik uygulaması açısından yalnızca 4 değişkeni ele alacağız: biri asal P ve G (P'nin ilkel kökü) ve iki özel değer a ve b.
P ve G'nin her ikisi de kamuya açık numaralardır. Kullanıcılar (örneğin Alice ve Bob) a ve b özel değerlerini seçerler ve bir anahtar oluştururlar ve bunu herkese açık olarak değiştirirler. Karşı kişi anahtarı alır ve bu, gizli bir anahtar oluşturur ve ardından şifrelemek için aynı gizli anahtara sahip olur.

Adım Adım açıklama aşağıdaki gibidir:

Alice	Bob
Mevcut Genel Anahtarlar = P G	Mevcut Genel Anahtarlar = P G
Seçilen Özel Anahtar = a	Seçilen Özel Anahtar = b
Anahtar oluşturuldu = x = G^a mod P	Anahtar oluşturuldu = y = G^b mod P
Oluşturulan anahtarların değişimi gerçekleşir
Alınan anahtar = y	alınan anahtar = x
Oluşturulan Gizli Anahtar = k_a = y^a mod P	Oluşturulan Gizli Anahtar = k_b = x^b mod P
Cebirsel olarak gösterilebilir k_a = k_b
Kullanıcıların artık şifrelemek için simetrik bir gizli anahtarı var

Örnek:

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.

Uygulama:

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>

Çıkış

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

Diffie-Hellman Algoritmasının Uygulanması

Diffie-Hellman algoritması: