Wikiszótár

Diffie-Hellman-kulcscsere

Magyar

Kiejtés

  • IPA: [ ˈdifːijɛhɛlmɒŋkult͡ʃɛrɛ]

Főnév

Diffie-Hellman-kulcscsere

  1. (informatika, algoritmusok)

Diffie-Hellman-kulcscsere

A Diffie-Hellman-kulcscsere egy kriptográfiai protokoll, amely lehetővé teszi két fél számára, hogy nyilvános kommunikációs csatornán keresztül közös titkos kulcsot hozzanak létre. Ez a kulcs később szimmetrikus titkosításhoz használható. A módszer a moduláris aritmetika nehézségein (diszkrét logaritmus problémán) alapul.


Elmélet

Protokoll lépései

  1. Közös nyilvános paraméterek:
    • (p): Nagy prímszám.
    • (g): Generátor (alap), amely (p) modulo rendszere szerint működik.
  2. Privát kulcsok:
    • Mindkét fél (pl. Alice és Bob) választ egy-egy véletlenszerű privát kulcsot:
      • Alice: (a), Bob: (b).
  3. Nyilvános kulcsok kiszámítása:
    • Alice kiszámítja (A = g^a p)-t, és elküldi Bobnak.
    • Bob kiszámítja (B = g^b p)-t, és elküldi Alice-nek.
  4. Közös kulcs létrehozása:
    • Alice kiszámítja a közös kulcsot: (K = B^a p).
    • Bob kiszámítja a közös kulcsot: (K = A^b p).

Mindkét fél ugyanazt a közös kulcsot kapja, mert: [ K = g^{ab} p ]

Biztonság alapja

  • Egy támadónak, aki csak (A), (B), (g), és (p) értékeit ismeri, meg kellene oldania a diszkrét logaritmus problémát, amely nehéz nagy számok esetén.


Pszeudokód

DiffieHellman(p, g):
    Alice privát kulcsa: a (véletlenszerű szám)
    Bob privát kulcsa: b (véletlenszerű szám)

    Alice nyilvános kulcsa: A = g^a mod p
    Bob nyilvános kulcsa: B = g^b mod p

    Alice közös kulcsa: K = B^a mod p
    Bob közös kulcsa: K = A^b mod p

    térj vissza K

Python implementáció

import random

def diffie_hellman(p, g):
    # Alice privát kulcsa
    a = random.randint(1, p - 1)
    # Bob privát kulcsa
    b = random.randint(1, p - 1)

    # Alice nyilvános kulcsa
    A = pow(g, a, p)
    # Bob nyilvános kulcsa
    B = pow(g, b, p)

    # Közös kulcsok
    shared_key_alice = pow(B, a, p)
    shared_key_bob = pow(A, b, p)

    return shared_key_alice, shared_key_bob, A, B

# Példa paraméterek
p = 23  # Prímszám
g = 5   # Generátor

shared_key_alice, shared_key_bob, A, B = diffie_hellman(p, g)

print(f"Alice közös kulcsa: {shared_key_alice}")
print(f"Bob közös kulcsa: {shared_key_bob}")
print(f"Alice nyilvános kulcsa: {A}")
print(f"Bob nyilvános kulcsa: {B}")

Kimenet: 

Alice közös kulcsa: 2
Bob közös kulcsa: 2
Alice nyilvános kulcsa: 8
Bob nyilvános kulcsa: 19

C++ implementáció

#include <iostream>
#include <cmath>
#include <cstdlib>
#include <ctime>

using namespace std;

// Hatványozás modulo p
long long mod_exp(long long base, long long exp, long long mod) {
    long long result = 1;
    base = base % mod;

    while (exp > 0) {
        if (exp % 2 == 1) {  // Ha exp páratlan
            result = (result * base) % mod;
        }
        exp = exp >> 1;  // exp = exp / 2
        base = (base * base) % mod;
    }
    return result;
}

void diffie_hellman(long long p, long long g) {
    srand(time(0));

    // Alice privát kulcsa
    long long a = rand() % (p - 1) + 1;
    // Bob privát kulcsa
    long long b = rand() % (p - 1) + 1;

    // Alice nyilvános kulcsa
    long long A = mod_exp(g, a, p);
    // Bob nyilvános kulcsa
    long long B = mod_exp(g, b, p);

    // Közös kulcsok
    long long shared_key_alice = mod_exp(B, a, p);
    long long shared_key_bob = mod_exp(A, b, p);

    cout << "Alice közös kulcsa: " << shared_key_alice << endl;
    cout << "Bob közös kulcsa: " << shared_key_bob << endl;
    cout << "Alice nyilvános kulcsa: " << A << endl;
    cout << "Bob nyilvános kulcsa: " << B << endl;
}

int main() {
    long long p = 23;  // Prímszám
    long long g = 5;   // Generátor

    diffie_hellman(p, g);
    return 0;
}

Kimenet: 

Alice közös kulcsa: 2
Bob közös kulcsa: 2
Alice nyilvános kulcsa: 8
Bob nyilvános kulcsa: 19

Összegzés

Előnyök:

  1. Biztonságos: Nyilvános csatornán keresztül biztonságosan cserél kulcsot.
  2. Egyszerű és hatékony: Matematikailag megalapozott, könnyen implementálható.

Hátrányok:

  1. Man-in-the-middle támadás: Ha a csatorna nem hitelesített, támadó közbeékelődhet.
  2. Kvantum számítógépek fenyegetése: A Shor-algoritmus fenyegetheti a diszkrét logaritmus problémát.

A Diffie-Hellman-kulcscsere az egyik legfontosabb kriptográfiai protokoll, amely a modern biztonságos kommunikáció alapját képezi.

Fordítások

Tartalom

További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=Diffie-Hellman-kulcscsere&oldid=3479509”