Diffie-Hellman Key Exchange 2D (Live Discrete-Log Attack)

Q: Why does the benchmark matter?

Instead of quoting a textbook number, it measures how fast your browser actually performs the same operation the brute-force search uses, then multiplies that real rate out to the size of the search space for larger keys, so the infeasibility claim for 2048-bit primes is backed by a real measured speed.

Q: Why can't Eve just combine A and B directly?

A and B are both public, but there is no known efficient way to combine them into the shared secret without first recovering a private exponent — that problem is the Diffie-Hellman Problem, and every known method for solving it reduces to solving discrete logarithms.

Public Parameters

Preset (p, g) 7-bit

Alice's secret a 6

Bob's secret b 15

Live Keys (real BigInt math)

…

Shared secret match

✓ Alice = Bob

Eve — Passive Eavesdropper

Eve sees p, g, A and B on the wire — never a, b, or the secret itself. To recover it she must solve the discrete logarithm problem: find x with g^x ≡ A (mod p). The only known way is to search.

Attempts tried

Elapsed

0 ms

Status

idle

Cost Scaling (real benchmark)

Brute force is embarrassingly parallel-free per guess — its cost is exactly the number of guesses. This benchmarks how many modular multiplications your device actually does per second, then extrapolates that real number to real key sizes.

Measured rate

— run benchmark —

Key size	Avg. guesses	Projected time

How it works

Public: prime p, generator g
Alice:  a secret        A = g^a mod p  (sent openly)
Bob:    b secret        B = g^b mod p  (sent openly)
Alice:  s = B^a mod p
Bob:    s = A^b mod p   (same s, since (g^b)^a = (g^a)^b)

Eve has p, g, A, B only. Computing s directly from those
without first solving x from g^x ≡ A (mod p) is the
Diffie-Hellman Problem — believed as hard as discrete log.

The interactive brute force above is real: it computes g¹, g², g³… mod p one at a time and compares each to A, exactly like an attacker with no shortcuts. The benchmark measures how many of those modular multiplications your browser actually completes per second, then uses that real number — not a made-up one — to project how long the same naive search would take against realistic key sizes, via log10(time) = (bits−1)·log10(2) − log10(rate). The 2048-bit row is why Diffie-Hellman is still trusted in TLS today.

🔑 Diffie-Hellman Key Exchange 2D

A flat 2D companion to the 3D Diffie-Hellman colour-mixing simulator, built around the same real BigInt modular exponentiation but focused on the attacker's side: Eve genuinely brute-forces the discrete logarithm, and a live benchmark shows exactly why that attack cannot scale to real key sizes.

🔬 What It Demonstrates

Alice and Bob each raise a shared base g to their own secret exponent modulo a prime p, exchange only the results (A and B), and each raises the value they received to their own secret to land on the identical shared value g^(ab) mod p — without either ever transmitting a or b.

🎮 How to Use

Pick a preset prime/generator pair and Alice's and Bob's secret exponents to watch the shared secret update live. Then switch to Eve: run the real brute-force search on the small demo prime, and run the benchmark to see your own device's guesses-per-second projected out to 2048-bit keys.

💡 Did You Know?

Brute force and the smarter baby-step giant-step algorithm both scale with the square root of the key space at best for classical computers — doubling the bit-length roughly squares the work, which is why key sizes grow in whole multiples rather than small increments.

Frequently Asked Questions

Is the brute-force attack in this simulation real?

Yes — it performs actual modular multiplications one guess at a time, exactly like a real naive attacker, and stops the instant it finds an exponent that reproduces A. There is no shortcut or lookup table.

Why does the benchmark matter?

Instead of quoting a textbook number, it measures how fast your browser actually performs the same operation the brute-force search uses, then multiplies that real rate out to the size of the search space for larger keys — so the "computationally infeasible" claim for 2048-bit primes is backed by your own device's measured speed, not an assumption.

Why can't Eve just combine A and B directly?

A = g^a mod p and B = g^b mod p are both public, but there is no known efficient way to combine them into g^(ab) mod p without first recovering a or b — that combination problem is the Diffie-Hellman Problem, and every known method for solving it reduces to solving discrete logarithms.