TLS and Encrypted Communication

package main

import (
	"fmt"
	"strings"
)

// TOY numbers so you can follow the maths by hand. Real TLS uses the same ideas with
// numbers hundreds of digits long (or elliptic curves) and real hash functions.

// modpow computes base^exp mod m without ever building a huge number.
func modpow(base, exp, m int) int {
	result := 1
	base %= m
	for ; exp > 0; exp /= 2 {
		if exp%2 == 1 {
			result = result * base % m
		}
		base = base * base % m
	}
	return result
}

func main() {
	// 1. Key exchange (Diffie-Hellman): agree on a secret over a public network.
	p, g := 23, 5 // public: everyone, including an eavesdropper, knows these
	a, b := 6, 15 // private: each side picks one and never sends it
	A, B := modpow(g, a, p), modpow(g, b, p)
	fmt.Printf("public: p=%d, g=%d\n", p, g)
	fmt.Printf("client picks secret a=%d, sends A = g^a mod p = %d\n", a, A)
	fmt.Printf("server picks secret b=%d, sends B = g^b mod p = %d\n", b, B)
	clientKey, serverKey := modpow(B, a, p), modpow(A, b, p)
	fmt.Printf("client computes B^a mod p = %d\n", clientKey)
	fmt.Printf("server computes A^b mod p = %d\n", serverKey)
	fmt.Printf("eavesdropper saw p, g, %d and %d, but not a, b or %d\n", A, B, clientKey)

	// 2. Certificate: a trusted authority (CA) signs the server's public value,
	// so an attacker in the middle can't swap in their own.
	n, e, d := 3233, 17, 2753 // the CA's key pair: (n, e) is public and built into the client; d is secret
	sig := modpow(B, d, n)    // only the CA can make this
	fmt.Printf("CA signs server key %d: signature = %d\n", B, sig)
	check := func(key int) string {
		recovered := modpow(sig, e, n) // anyone can do this with the CA's public (n, e)
		if recovered == key {
			return fmt.Sprintf("signature gives %d, matches the key: trusted", recovered)
		}
		return fmt.Sprintf("signature gives %d, but the key is %d: rejected", recovered, key)
	}
	fmt.Printf("client checks the signature: %s\n", check(B))
	fmt.Printf("attacker swaps in key 7 with the same signature: %s\n", check(7))

	// 3. Encryption: scramble the request with the shared key (a toy XOR; real TLS uses AES or ChaCha20).
	msg := "GET /"
	enc := make([]byte, len(msg))
	hexes := make([]string, len(msg))
	for i := range msg {
		enc[i] = msg[i] ^ byte(clientKey)
		hexes[i] = fmt.Sprintf("%02x", enc[i])
	}
	dec := make([]byte, len(enc))
	for i := range enc {
		dec[i] = enc[i] ^ byte(serverKey)
	}
	fmt.Printf("%q on the wire: %s, server decrypts it to %q\n", msg, strings.Join(hexes, " "), string(dec))
}

// TOY numbers so you can follow the maths by hand. Real TLS uses the same ideas with
// numbers hundreds of digits long (or elliptic curves) and real hash functions.

// modpow computes base^exp mod m without ever building a huge number.
function modpow(base, exp, m) {
  let result = 1;
  base %= m;
  for (; exp > 0; exp = Math.floor(exp / 2)) {
    if (exp % 2 === 1) result = (result * base) % m;
    base = (base * base) % m;
  }
  return result;
}

// 1. Key exchange (Diffie-Hellman): agree on a secret over a public network.
const [p, g] = [23, 5]; // public: everyone, including an eavesdropper, knows these
const [a, b] = [6, 15]; // private: each side picks one and never sends it
const [A, B] = [modpow(g, a, p), modpow(g, b, p)];
console.log(`public: p=${p}, g=${g}`);
console.log(`client picks secret a=${a}, sends A = g^a mod p = ${A}`);
console.log(`server picks secret b=${b}, sends B = g^b mod p = ${B}`);
const [clientKey, serverKey] = [modpow(B, a, p), modpow(A, b, p)];
console.log(`client computes B^a mod p = ${clientKey}`);
console.log(`server computes A^b mod p = ${serverKey}`);
console.log(`eavesdropper saw p, g, ${A} and ${B}, but not a, b or ${clientKey}`);

// 2. Certificate: a trusted authority (CA) signs the server's public value,
// so an attacker in the middle can't swap in their own.
const [n, e, d] = [3233, 17, 2753]; // the CA's key pair: (n, e) is public and built into the client; d is secret
const sig = modpow(B, d, n); // only the CA can make this
console.log(`CA signs server key ${B}: signature = ${sig}`);
function check(key) {
  const recovered = modpow(sig, e, n); // anyone can do this with the CA's public (n, e)
  return recovered === key
    ? `signature gives ${recovered}, matches the key: trusted`
    : `signature gives ${recovered}, but the key is ${key}: rejected`;
}
console.log(`client checks the signature: ${check(B)}`);
console.log(`attacker swaps in key 7 with the same signature: ${check(7)}`);

// 3. Encryption: scramble the request with the shared key (a toy XOR; real TLS uses AES or ChaCha20).
const msg = "GET /";
const enc = [...Buffer.from(msg)].map((c) => c ^ clientKey);
const dec = Buffer.from(enc.map((c) => c ^ serverKey)).toString();
const hex = enc.map((c) => c.toString(16).padStart(2, "0")).join(" ");
console.log(`"${msg}" on the wire: ${hex}, server decrypts it to "${dec}"`);

// TOY numbers so you can follow the maths by hand. Real TLS uses the same ideas with
// numbers hundreds of digits long (or elliptic curves) and real hash functions.

// modpow computes base^exp mod m without ever building a huge number.
fn modpow(mut base: u64, mut exp: u64, m: u64) -> u64 {
    let mut result = 1;
    base %= m;
    while exp > 0 {
        if exp % 2 == 1 {
            result = result * base % m;
        }
        base = base * base % m;
        exp /= 2;
    }
    result
}

fn main() {
    // 1. Key exchange (Diffie-Hellman): agree on a secret over a public network.
    let (p, g) = (23, 5); // public: everyone, including an eavesdropper, knows these
    let (a, b) = (6, 15); // private: each side picks one and never sends it
    let (big_a, big_b) = (modpow(g, a, p), modpow(g, b, p));
    println!("public: p={p}, g={g}");
    println!("client picks secret a={a}, sends A = g^a mod p = {big_a}");
    println!("server picks secret b={b}, sends B = g^b mod p = {big_b}");
    let (client_key, server_key) = (modpow(big_b, a, p), modpow(big_a, b, p));
    println!("client computes B^a mod p = {client_key}");
    println!("server computes A^b mod p = {server_key}");
    println!("eavesdropper saw p, g, {big_a} and {big_b}, but not a, b or {client_key}");

    // 2. Certificate: a trusted authority (CA) signs the server's public value,
    // so an attacker in the middle can't swap in their own.
    let (n, e, d) = (3233, 17, 2753); // the CA's key pair: (n, e) is public and built into the client; d is secret
    let sig = modpow(big_b, d, n); // only the CA can make this
    println!("CA signs server key {big_b}: signature = {sig}");
    let check = |key: u64| {
        let recovered = modpow(sig, e, n); // anyone can do this with the CA's public (n, e)
        if recovered == key {
            format!("signature gives {recovered}, matches the key: trusted")
        } else {
            format!("signature gives {recovered}, but the key is {key}: rejected")
        }
    };
    println!("client checks the signature: {}", check(big_b));
    println!("attacker swaps in key 7 with the same signature: {}", check(7));

    // 3. Encryption: scramble the request with the shared key (a toy XOR; real TLS uses AES or ChaCha20).
    let msg = "GET /";
    let enc: Vec<u8> = msg.bytes().map(|c| c ^ client_key as u8).collect();
    let dec: String = enc.iter().map(|c| (c ^ server_key as u8) as char).collect();
    let hex: Vec<String> = enc.iter().map(|c| format!("{c:02x}")).collect();
    println!("\"{msg}\" on the wire: {}, server decrypts it to \"{dec}\"", hex.join(" "));
}

# TOY numbers so you can follow the maths by hand. Real TLS uses the same ideas with
# numbers hundreds of digits long (or elliptic curves) and real hash functions.

# Python's built-in pow(base, exp, m) computes base^exp mod m without building a huge number.

# 1. Key exchange (Diffie-Hellman): agree on a secret over a public network.
p, g = 23, 5  # public: everyone, including an eavesdropper, knows these
a, b = 6, 15  # private: each side picks one and never sends it
A, B = pow(g, a, p), pow(g, b, p)
print(f"public: p={p}, g={g}")
print(f"client picks secret a={a}, sends A = g^a mod p = {A}")
print(f"server picks secret b={b}, sends B = g^b mod p = {B}")
client_key, server_key = pow(B, a, p), pow(A, b, p)
print(f"client computes B^a mod p = {client_key}")
print(f"server computes A^b mod p = {server_key}")
print(f"eavesdropper saw p, g, {A} and {B}, but not a, b or {client_key}")

# 2. Certificate: a trusted authority (CA) signs the server's public value,
# so an attacker in the middle can't swap in their own.
n, e, d = 3233, 17, 2753  # the CA's key pair: (n, e) is public and built into the client; d is secret
sig = pow(B, d, n)  # only the CA can make this
print(f"CA signs server key {B}: signature = {sig}")


def check(key):
    recovered = pow(sig, e, n)  # anyone can do this with the CA's public (n, e)
    if recovered == key:
        return f"signature gives {recovered}, matches the key: trusted"
    return f"signature gives {recovered}, but the key is {key}: rejected"


print(f"client checks the signature: {check(B)}")
print(f"attacker swaps in key 7 with the same signature: {check(7)}")

# 3. Encryption: scramble the request with the shared key (a toy XOR; real TLS uses AES or ChaCha20).
msg = "GET /"
enc = bytes(c ^ client_key for c in msg.encode())
dec = bytes(c ^ server_key for c in enc).decode()
print(f'"{msg}" on the wire: {" ".join(f"{c:02x}" for c in enc)}, server decrypts it to "{dec}"')

import java.nio.charset.StandardCharsets;
import java.util.StringJoiner;

public class Main {
    // TOY numbers so you can follow the maths by hand. Real TLS uses the same ideas with
    // numbers hundreds of digits long (or elliptic curves) and real hash functions.

    // modpow computes base^exp mod m without ever building a huge number.
    static long modpow(long base, long exp, long m) {
        long result = 1;
        base %= m;
        for (; exp > 0; exp /= 2) {
            if (exp % 2 == 1) result = result * base % m;
            base = base * base % m;
        }
        return result;
    }

    public static void main(String[] args) {
        // 1. Key exchange (Diffie-Hellman): agree on a secret over a public network.
        long p = 23, g = 5; // public: everyone, including an eavesdropper, knows these
        long a = 6, b = 15; // private: each side picks one and never sends it
        long bigA = modpow(g, a, p), bigB = modpow(g, b, p);
        System.out.printf("public: p=%d, g=%d%n", p, g);
        System.out.printf("client picks secret a=%d, sends A = g^a mod p = %d%n", a, bigA);
        System.out.printf("server picks secret b=%d, sends B = g^b mod p = %d%n", b, bigB);
        long clientKey = modpow(bigB, a, p), serverKey = modpow(bigA, b, p);
        System.out.printf("client computes B^a mod p = %d%n", clientKey);
        System.out.printf("server computes A^b mod p = %d%n", serverKey);
        System.out.printf("eavesdropper saw p, g, %d and %d, but not a, b or %d%n", bigA, bigB, clientKey);

        // 2. Certificate: a trusted authority (CA) signs the server's public value,
        // so an attacker in the middle can't swap in their own.
        long n = 3233, e = 17, d = 2753; // the CA's key pair: (n, e) is public and built into the client; d is secret
        long sig = modpow(bigB, d, n); // only the CA can make this
        System.out.printf("CA signs server key %d: signature = %d%n", bigB, sig);
        for (long key : new long[] {bigB, 7}) {
            long recovered = modpow(sig, e, n); // anyone can do this with the CA's public (n, e)
            String verdict = recovered == key
                ? "signature gives " + recovered + ", matches the key: trusted"
                : "signature gives " + recovered + ", but the key is " + key + ": rejected";
            String who = key == bigB ? "client checks the signature" : "attacker swaps in key 7 with the same signature";
            System.out.println(who + ": " + verdict);
        }

        // 3. Encryption: scramble the request with the shared key (a toy XOR; real TLS uses AES or ChaCha20).
        String msg = "GET /";
        byte[] enc = msg.getBytes(StandardCharsets.UTF_8);
        StringJoiner hex = new StringJoiner(" ");
        for (int i = 0; i < enc.length; i++) {
            enc[i] = (byte) (enc[i] ^ clientKey);
            hex.add(String.format("%02x", enc[i]));
        }
        byte[] dec = new byte[enc.length];
        for (int i = 0; i < enc.length; i++) dec[i] = (byte) (enc[i] ^ serverKey);
        System.out.printf("\"%s\" on the wire: %s, server decrypts it to \"%s\"%n", msg, hex, new String(dec, StandardCharsets.UTF_8));
    }
}