# birthday_attack_demo.py
import hashlib
import random

def birthday_attack(hash_bytes=4):  # 4 bytes → 32-bit hash → 2^16 birthdays
    target_collisions = 2**(hash_bytes*4)   # 2^16 for 4 bytes
    seen = {}
    count = 0
    while True:
        count += 1
        data = str(random.randint(0, 2**32)).encode()
        h = hashlib.sha256(data).digest()[:hash_bytes]   # truncate to weak hash
        if h in seen:
            print(f"Collision found after {count} tries!")
            print(f"Message 1: {seen[h]} → {h.hex()}")
            print(f"Message 2: {data.decode()} → {h.hex()}")
            break
        seen[h] = data.decode()

# Run it – you will see collision in < 100,000 tries (expected ~2^16 ≈ 65k)
# birthday_attack(4)

# hmac_whatsapp_style.py  ← Real banking/API authentication
import hmac
import hashlib
import binascii

# Server and client share this secret key (like WhatsApp does)
secret_key = b"MySuperSecretKey123".encode()

# Message received from client
message = b"transfer 1000 USD to account 123456789"

# Generate MAC (Message Authentication Code)
mac = hmac.new(secret_key, message, hashlib.sha256).digest()

print("MAC (hex):", binascii.hexlify(mac))

# Verification on server side
def verify_mac(received_message, received_mac):
    expected_mac = hmac.new(secret_key, received_message, hashlib.sha256).digest()
    return hmac.compare_digest(expected_mac, received_mac)  # Safe from timing attack

# Tamper test
print("Valid   :", verify_mac(message, mac))                          # True
print("Tampered:", verify_mac(b"transfer 9000 USD", mac))             # False

# rsa_digital_signature_real.py  ← Used by Google, Microsoft, Banks
from Crypto.PublicKey import RSA
from Crypto.Signature import pkcs1_15
from Crypto.Hash import SHA256
import base64

# Step 1: Generate real 2048-bit RSA key (like real certificates)
key = RSA.generate(2048)
private_key = key
public_key = key.publickey()

# Message (e.g., software update or bank transaction)
message = b"Software version 15.2.1 - Approved by Microsoft"

# Step 2: Sign with private key
hash_obj = SHA256.new(message)
signature = pkcs1_15.new(private_key).sign(hash_obj)

print("Signature (base64):")
print(base64.b64encode(signature).decode())

# Step 3: Anyone can verify with public key
def verify_signature(msg, sig_base64, pub_key):
    try:
        hash_obj = SHA256.new(msg)
        pkcs1_15.new(pub_key).verify(hash_obj, base64.b64decode(sig_base64))
        return "Signature VALID – Message from real sender"
    except:
        return "FORGED or TAMPERED!"

# Test
print(verify_signature(message, base64.b64encode(signature), public_key))
print(verify_signature(b"Trojan virus inside!", base64.b64encode(signature), public_key))

# ecdsa_bitcoin_style.py  ← Exact same as Bitcoin/Ethereum
from ecdsa import SigningKey, SECP256k1, VerifyingKey
import hashlib
import base64

# Generate Bitcoin-style wallet
sk = SigningKey.generate(curve=SECP256k1)
vk = sk.verifying_key

message = b"I am Satoshi Nakamoto, sending 1 BTC to Alice"

# Sign
signature = sk.sign(message, hashfunc=hashlib.sha256)

print("Bitcoin-style Signature:")
print(base64.b64encode(signature).decode())

# Verify
def verify_bitcoin_style(msg, sig_b64):
    try:
        vk.verify(base64.b64decode(sig_b64), msg, hashfunc=hashlib.sha256)
        return "GENUINE Bitcoin transaction"
    except:
        return "FAKE!"

print(verify_bitcoin_style(message, base64.b64encode(signature)))

# file_sign_verify.py  ← Microsoft, Adobe, Android APK use this
from Crypto.PublicKey import RSA
from Crypto.Signature import pkcs1_15
from Crypto.Hash import SHA256

# Generate keys once (company's root certificate)
key = RSA.generate(2048)
with open("company_private.pem", "wb") as f:
    f.write(key.export_key())
with open("company_public.pem", "wb") as f:
    f.write(key.publickey().export_key())

# Sign a file (e.g., update.exe)
def sign_file(filename):
    with open(filename, "rb") as f:
        data = f.read()
    h = SHA256.new(data)
    signature = pkcs1_15.new(key).sign(h)
    with open(filename + ".sig", "wb") as f:
        f.write(signature)
    print(f"Signed {filename}")

# Verify before installing
def verify_file(filename):
    with open(filename, "rb") as f:
        data = f.read()
    with open("company_public.pem", "rb") as f:
        pub_key = RSA.import_key(f.read())
    with open(filename + ".sig", "rb") as f:
        sig = f.read()
    try:
        pkcs1_15.new(pub_key).verify(SHA256.new(data), sig)
        return "TRUSTED – Safe to install"
    except:
        return "DANGEROUS – Virus or tampered!"

# Test
sign_file("update.exe")
print(verify_file("update.exe"))

Unit3_Authentication_Lab/
│
├── 01_sha256_file_hash.py
├── 02_hmac_api_authentication.py
├── 03_birthday_attack_demo.py
├── 04_rsa_digital_signature.py
├── 05_ecdsa_bitcoin_sign.py
├── 06_file_sign_verify_real.py
├── company_private.pem
├── company_public.pem
├── update.exe.sig
└── Report.pdf (with screenshots + theory)