Two strangers. No shared secret.
Communicate privately anyway.

// Add to Cargo.toml:
//   sha2   = "0.10"
//   ripemd = "0.1"
use sha2::{Sha256, Digest};
use ripemd::Ripemd160;

// Bitcoin address derivation from a public key.
// Real Bitcoin uses secp256k1 ECDSA to make the key.
// This shows the hashing steps only.
fn hash160(public_key: &[u8]) -> [u8; 20] {
    // Step 1: SHA-256 of the public key
    let sha256_hash = Sha256::digest(public_key);

    // Step 2: RIPEMD-160 of the SHA-256 hash
    let ripemd_hash = Ripemd160::digest(sha256_hash);

    ripemd_hash.into()
    // 20 bytes: the core of a Bitcoin address.
    // This is what gets Base58Check encoded.
}

// Commitment scheme: prove you knew a value
// before revealing it.
fn commit(secret: &[u8]) -> [u8; 32] {
    Sha256::digest(secret).into()
    // publish this. reveal the secret later.
    // anyone verifies: SHA256(secret) == commitment.
    // this is how pay-to-public-key-hash works:
    // publish the hash of the public key,
    // reveal the public key when spending.
}

fn verify_commitment(secret: &[u8],
                     commitment: &[u8; 32]) -> bool {
    let hash: [u8; 32] = Sha256::digest(secret).into();
    hash == *commitment
}

// XOR as the building block of stream ciphers.
// Rust: explicit types, bounds-checked iteration.
fn xor_stream(data: &[u8], keystream: &[u8]) -> Vec<u8> {
    assert_eq!(data.len(), keystream.len(),
        "keystream must be as long as data");
    data.iter().zip(keystream).map(|(d, k)| d ^ k).collect()
    // AES-CTR generates the keystream from key + nonce,
    // then XORs with plaintext. This is the final step.
}

#include <stdint.h>
#include <string.h>
#include <openssl/sha.h>
#include <openssl/ripemd.h>
/* compile: cc dh.c -lcrypto */

/* Bitcoin HASH160: SHA256 then RIPEMD160.
 * The core of every P2PKH address. */
void hash160(const uint8_t *pubkey, size_t len,
             uint8_t out[20]) {
    uint8_t sha_out[32];
    SHA256(pubkey, len, sha_out);
    RIPEMD160(sha_out, 32, out);
    /* 20-byte output. Base58Check encode it
     * to produce a Bitcoin address like
     * 1A1zP1eP5QGefi2DMPTfTL5SLmv7Divf. */
}

/* Commitment: publish the hash, reveal later.
 * Used in P2PKH, sealed-bid auctions, and
 * zero-knowledge protocols. */
int verify_commitment(const uint8_t *secret, size_t len,
                      const uint8_t commitment[32]) {
    uint8_t h[32];
    SHA256(secret, len, h);
    return memcmp(h, commitment, 32) == 0;
    /* returns 1 when the secret matches the commitment */
}

/* Simplified Diffie-Hellman with small numbers.
 * NOT cryptographically secure. Concept only.
 * Real DH uses 2048-bit or larger primes. */
uint64_t mod_pow(uint64_t base, uint64_t exp,
                 uint64_t mod) {
    uint64_t result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp & 1) result = result * base % mod;
        exp >>= 1;
        base = base * base % mod;
    }
    return result;
}

void diffie_hellman_demo(void) {
    uint64_t g = 5, p = 23; /* public parameters */
    uint64_t a = 6;         /* Alice private */
    uint64_t b = 15;        /* Bob private   */

    uint64_t A = mod_pow(g, a, p); /* Alice sends 8  */
    uint64_t B = mod_pow(g, b, p); /* Bob sends   19 */

    uint64_t alice_secret = mod_pow(B, a, p); /* = 2 */
    uint64_t bob_secret   = mod_pow(A, b, p); /* = 2 */
    (void)alice_secret; (void)bob_secret;
    /* both equal 2: shared secret established.
     * eavesdropper saw g=5, p=23, A=8, B=19,
     * and cannot compute 2 without a or b. */
}