Diffie Hellman Key Exchange: Difference between revisions

From charlesreid1

(Create Diffie Hellman Key Exchange page with DH + RSA practical implementations (via create-page on MediaWiki MCP Server))
 
(Rewrite as clean DH-only page following AES page format (via update-page on MediaWiki MCP Server))
 
Line 1: Line 1:
<![CDATA[from Crypto.PublicKey import RSA, DSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA256
from Crypto import Random
from Crypto import Random
from Crypto.Util import number


# --- RSA Key Generation ---
def rsa_generate_keys(key_size=2048):
    key = RSA.generate(key_size)
    private_key = key.export_key()
    public_key = key.publickey().export_key()
    return private_key, public_key
# --- RSA Encryption / Decryption ---
def rsa_encrypt(plaintext, public_key_pem):
    key = RSA.import_key(public_key_pem)
    cipher = PKCS1_OAEP.new(key)
    return cipher.encrypt(plaintext.encode('utf-8'))
def rsa_decrypt(ciphertext, private_key_pem):
    key = RSA.import_key(private_key_pem)
    cipher = PKCS1_OAEP.new(key)
    return cipher.decrypt(ciphertext).decode('utf-8')
# --- RSA Signing / Verification ---
def rsa_sign(message, private_key_pem):
    key = RSA.import_key(private_key_pem)
    h = SHA256.new(message.encode('utf-8'))
    signer = PKCS1_v1_5.new(key)
    return signer.sign(h)
def rsa_verify(message, signature, public_key_pem):
    key = RSA.import_key(public_key_pem)
    h = SHA256.new(message.encode('utf-8'))
    verifier = PKCS1_v1_5.new(key)
    return verifier.verify(h, signature)
# --- Diffie-Hellman Key Exchange ---


def dh_generate_parameters(key_size=2048):
def dh_generate_parameters(key_size=2048):
     """Generate DH group parameters (p, g)."""
     """Generate DH group parameters (p, g)."""
     from Crypto.PublicKey import DSA
     p = number.getPrime(key_size)
    # Use DSA to obtain safe DH parameters — p prime, g generator
     g = 2
    dsa_key = DSA.generate(key_size, randfunc=Random.new().read)
    return p, g
     params = dsa_key.p, dsa_key.g
    return params




def dh_generate_keypair(p, g):
def dh_generate_keypair(p, g):
     """Generate a DH private key (a) and public key (A = g^a mod p)."""
     """Generate private key a and public key A = g^a mod p."""
     a = int.from_bytes(Random.new().read(p.bit_length() // 8 + 8), 'big') % (p - 1)
     a = int.from_bytes(Random.new().read(p.bit_length() // 8 + 8), 'big') % (p - 1)
     A = pow(g, a, p)
     A = pow(g, a, p)
Line 64: Line 18:


def dh_compute_shared(their_public, my_private, p):
def dh_compute_shared(their_public, my_private, p):
     """Compute shared secret s = (their_public)^my_private mod p."""
     """Compute shared secret = (their_public)^my_private mod p."""
     return pow(their_public, my_private, p)
     return pow(their_public, my_private, p)




if __name__ == '__main__':
if __name__ == '__main__':
    # --- RSA demo ---
     print("=== Diffie-Hellman Key Exchange ===")
     print("=== RSA Key Generation ===")
    priv, pub = rsa_generate_keys(2048)
    print("Private key (first 120 chars): %s..." % priv[:120])
    print("Public  key (first 120 chars): %s..." % pub[:120])


     message = "Hello from RSA"
     # Step 1: Agree on public parameters
     ct = rsa_encrypt(message, pub)
     p, g = dh_generate_parameters(2048)
    print("\n=== RSA Encryption ===")
     print("Prime p (first 80 hex): %s..." % hex(p)[:80])
     print("Ciphertext (hex): %s" % ct.hex()[:80])
     print("Generator g: %s" % g)
 
    pt = rsa_decrypt(ct, priv)
    print("\n=== RSA Decryption ===")
     print("Decrypted: '%s'" % pt)
 
    sig = rsa_sign(message, priv)
    print("\n=== RSA Signing ===")
    print("Signature (hex): %s" % sig.hex()[:80])


     ok = rsa_verify(message, sig, pub)
     # Step 2: Alice generates keypair
     print("\n=== RSA Verification ===")
    alice_priv, alice_pub = dh_generate_keypair(p, g)
    print("Signature valid: %s" % ok)
     print("Alice public key (first 80 hex): %s..." % hex(alice_pub)[:80])


     # --- Diffie-Hellman demo ---
     # Step 3: Bob generates keypair
     print("\n=== Diffie-Hellman Key Exchange ===")
     bob_priv, bob_pub = dh_generate_keypair(p, g)
    p, g = dh_generate_parameters(2048)
     print("Bob  public key (first 80 hex): %s..." % hex(bob_pub)[:80])
     print("DH  p  (first 80 hex chars): %s..." % hex(p)[:80])
    print("DH  g  (first 80 hex chars): %s..." % hex(g)[:80])


     a_priv, a_pub = dh_generate_keypair(p, g)
     # Step 4: Each computes the shared secret
    b_priv, b_pub = dh_generate_keypair(p, g)
    s_alice = dh_compute_shared(bob_pub, alice_priv, p)
     print("Alice public (first 80 hex): %s..." % hex(a_pub)[:80])
     s_bob   = dh_compute_shared(alice_pub, bob_priv, p)
    print("Bob   public (first 80 hex): %s..." % hex(b_pub)[:80])


    s_alice = dh_compute_shared(b_pub, a_priv, p)
     print("Shared secrets match: %s" % (s_alice == s_bob))
    s_bob  = dh_compute_shared(a_pub, b_priv, p)
     print("Alice shared secret matches Bob: %s" % (s_alice == s_bob))
     print("Shared secret (first 80 hex): %s..." % hex(s_alice)[:80])
     print("Shared secret (first 80 hex): %s..." % hex(s_alice)[:80])


https://www.pycryptodome.org/src/protocol/dh


{{CryptoFlag}}
{{CryptoFlag}}
Line 114: Line 52:


[[Category:Security]]
[[Category:Security]]
[[Category:Encryption]]]]>
[[Category:Encryption]]

Latest revision as of 03:50, 20 June 2026

from Crypto import Random from Crypto.Util import number


def dh_generate_parameters(key_size=2048): 

   """Generate DH group parameters (p, g)."""
   p = number.getPrime(key_size)
   g = 2
   return p, g


def dh_generate_keypair(p, g): 

   """Generate private key a and public key A = g^a mod p."""
   a = int.from_bytes(Random.new().read(p.bit_length() // 8 + 8), 'big') % (p - 1)
   A = pow(g, a, p)
   return a, A


def dh_compute_shared(their_public, my_private, p): 

   """Compute shared secret = (their_public)^my_private mod p."""
   return pow(their_public, my_private, p)


if __name__ == '__main__': 

   print("=== Diffie-Hellman Key Exchange ===")

   # Step 1: Agree on public parameters
   p, g = dh_generate_parameters(2048)
   print("Prime p (first 80 hex): %s..." % hex(p)[:80])
   print("Generator g: %s" % g)

   # Step 2: Alice generates keypair
   alice_priv, alice_pub = dh_generate_keypair(p, g)
   print("Alice public key (first 80 hex): %s..." % hex(alice_pub)[:80])

   # Step 3: Bob generates keypair
   bob_priv, bob_pub = dh_generate_keypair(p, g)
   print("Bob   public key (first 80 hex): %s..." % hex(bob_pub)[:80])

   # Step 4: Each computes the shared secret
   s_alice = dh_compute_shared(bob_pub, alice_priv, p)
   s_bob   = dh_compute_shared(alice_pub, bob_priv, p)

   print("Shared secrets match: %s" % (s_alice == s_bob))
   print("Shared secret (first 80 hex): %s..." % hex(s_alice)[:80])

https://www.pycryptodome.org/src/protocol/dh


Defcon.png
Crypto
cryptography-related resources on the wiki


Crypto - overview of crypto materials on the wiki

Implementing AES Cipher in Python: AES


Category:Crypto  · Category:Security  · Category:Encryption


Flags  · Template:CryptoFlag  · e


Red Links





Python.png
Python
a powerful programming language


Python  · Category:Python


Scientific Python:

Data analysis libraries: Scipy  · Numpy  · Pandas  · Statsmodel

Machine learning libraries: Sklearn

Neural network libraries: Tensorflow  · Keras

Plotting/viz: Matplotlib  · Seaborn  · Jupyter

Solving partial differential equations and bessel functions: Fipy  · Bessel Functions


Web and Networking Python:

Web programming: Flask  · Webapps  · Mechanize  · Scrapy  · Gunicorn

Wifi: Wireless/Python  · Scapy

IPython and Jupyter: Jupyter


Drawing, Geometry, and Shapes:

Shapely (for drawing shapes): Shapely

Geography library: Geos


General Useful Python Utilities:

Python Remote Objects: Pyro

Logging (create multi-channel log messages): Logging

Keyboard (control keyboard from Python): Keyboard


Black Hat Python:

Network scanning: Python/Scanner


Flags  · Template:PythonFlag  · e



Retrieved from "https://charlesreid1.com/w/index.php?title=Diffie_Hellman_Key_Exchange&oldid=30706"