Feature	Symmetric	Asymmetric
Keys	One shared key	Public + Private key pair
Speed	Fast (bulk data)	Slow (key exchange/signing only)
Key sharing	Problem — must share secretly	Public key freely shareable
Algorithms	AES, 3DES, ChaCha20	RSA, ECC, DH
Use case	File/disk/DB encryption	Key exchange, digital signatures, certificates

RSA (Rivest–Shamir–Adleman) is based on the mathematical difficulty of factoring the product of two large prime numbers.

Key generation:

• Choose two large primes p and q
• Compute n = p × q (public modulus)
• Choose public exponent e (commonly 65537)
• Compute private exponent d such that e×d ≡ 1 mod λ(n)

Encryption: C = M^e mod n (using public key)
Decryption: M = C^d mod n (using private key)
Security: Without knowing p and q, computing d from e and n is computationally infeasible for large keys (2048+ bits).

A hash function takes arbitrary-length input and produces a fixed-length output (digest). Five essential properties:

• Deterministic: Same input always produces the same hash.
• One-way (Pre-image resistant): Cannot reverse a hash to find the input.
• Collision resistant: Computationally infeasible to find two inputs with the same hash.
• Avalanche effect: A tiny change in input produces a completely different hash.
• Fixed output size: SHA-256 always produces 256 bits regardless of input size.

Uses: Password storage, file integrity verification, digital signatures, blockchain, MACs.

Feature	Encryption	Hashing
Reversible?	Yes (with key)	No (one-way)
Key required?	Yes	No
Output size	Variable (≈ input)	Fixed
Use case	Data confidentiality	Integrity, passwords, signing
Examples	AES-256, RSA	SHA-256, bcrypt

A digital signature provides three guarantees: authenticity (proves who sent it), integrity (proves it wasn't changed), and non-repudiation (sender can't deny sending it).

How it works:

1. Sender hashes the document (e.g., SHA-256)
2. Sender encrypts the hash with their private key → this is the signature
3. Receiver decrypts the signature with sender's public key → gets hash
4. Receiver independently hashes the document → compares with decrypted hash
5. If they match → authentic, unaltered, and from the claimed sender

PKI is the complete framework — policies, procedures, hardware, software, and people — that creates, manages, distributes, uses, stores, and revokes digital certificates and manages public-key encryption.

Components:

• CA (Certificate Authority): Trusted entity that issues and signs certificates
• Root CA: Top of the trust chain; self-signed; kept offline
• Intermediate CA: Issues end-entity certs; acts as buffer protecting Root CA
• X.509 Certificate: Binds a public key to an identity
• CRL / OCSP: Revocation mechanisms for compromised certificates
• Registration Authority (RA): Verifies identity before CA issues certificate

A CA is a trusted third party that:

• Verifies the identity of certificate applicants
• Issues X.509 digital certificates binding identity to a public key
• Digitally signs certificates with its own private key so others can verify them
• Maintains revocation lists (CRL) and responds to OCSP queries
• Manages certificate lifecycle (issue, renew, revoke)

Types of certificates: DV (Domain Validated), OV (Organization Validated), EV (Extended Validation — green bar). Well-known public CAs: DigiCert, Let's Encrypt, Comodo, GlobalSign.

Feature	MD5	SHA-256
Output size	128-bit (32 hex chars)	256-bit (64 hex chars)
Speed	Fast	Slower
Collision resistance	Broken — collisions found	Secure — no known collisions
Status	Do NOT use for security	Current standard
Use today	Non-security checksums only	Signatures, TLS, integrity

A rainbow table is a precomputed lookup table mapping common passwords to their hash values. Instead of brute-forcing in real-time, an attacker simply looks up the hash in the table to find the password instantly.

Example: MD5("password") = "5f4dcc3b..." is in every rainbow table.

Mitigation — Salting: Add a unique random value (salt) to each password before hashing: hash = SHA256(salt + password). The salt is stored alongside the hash. Since every user's salt is unique, precomputed rainbow tables are useless.

A salt is a random value added to a password (or data) before hashing. It is unique per user and stored in plaintext alongside the hash. Purpose:

• Defeats rainbow table attacks (unique salt → unique hash even for identical passwords)
• Prevents attackers from seeing that two users have the same password
• Forces per-hash brute-force attempts even if the database is stolen

Example: User A and User B both use "password123".
Without salt: both have identical hashes → attacker cracks once, gets both.
With salt: A's hash = SHA256("xk92" + "password123"), B's hash = SHA256("m3p1" + "password123") → completely different hashes.

TLS (Transport Layer Security) is a hybrid cryptographic protocol:

1. Handshake — Asymmetric phase: Client and server exchange certificates, agree on cipher suite, and use Diffie-Hellman (ECDHE) to derive a shared session key without transmitting it.
2. Key derivation: Both sides independently compute the same symmetric session key from DH parameters.
3. Data transfer — Symmetric phase: AES-GCM (or ChaCha20) encrypts all data using the session key. Much faster than asymmetric.
4. MAC / AEAD: Each record is authenticated, preventing tampering.

TLS 1.3 (current standard) removed weak cipher suites (RC4, MD5, SHA-1, RSA key exchange), making it significantly more secure than TLS 1.2.

Diffie-Hellman (DH) allows two parties to establish a shared secret over an insecure channel without ever transmitting the secret. Analogy: mixing paint colours — each party adds a private colour to a shared public colour; the result is the same on both sides, but an eavesdropper can't determine the private colours from the mixture.

Math basis: Discrete logarithm problem. Given g^a mod p, it's computationally infeasible to find a.

ECDHE: Elliptic Curve DH with Ephemeral keys — provides Perfect Forward Secrecy (new key each session).

AES (Advanced Encryption Standard) was selected by NIST in 2001 after an international competition. It replaced DES. Key reasons it became the standard:

• No known practical attacks against AES-128 or AES-256
• Fast in both software and hardware
• Hardware acceleration built into modern CPUs (AES-NI instructions)
• Three key sizes: 128, 192, 256-bit — flexible security levels
• Block cipher: operates on 128-bit blocks
• Used everywhere: TLS, WPA2/3, BitLocker, 7-Zip, SSH, S/MIME

Modes of operation: ECB (insecure — identical plaintext blocks produce identical ciphertext), CBC, CTR, GCM (authenticated encryption — adds integrity check).

An X.509 digital certificate is a standardised document that binds a public key to an identity. Contents:

• Version: Certificate format version (typically v3)
• Serial Number: Unique identifier assigned by the CA
• Subject: Identity the certificate is issued to (domain, organisation)
• Subject Public Key: The public key itself
• Issuer: The CA that signed this certificate
• Validity period: Not Before / Not After dates
• Signature algorithm: e.g., SHA256WithRSAEncryption
• CA's digital signature: Proves the CA vouches for this certificate
• Extensions: SANs, key usage, CDP (CRL Distribution Points)

Feature	Signing	Encrypting
Key used	Sender's private key	Recipient's public key
Verified with	Sender's public key (by anyone)	Recipient's private key (only recipient)
Purpose	Authenticity + integrity + non-repudiation	Confidentiality
Readable?	Yes (message is not hidden)	No (message is hidden)

An attacker intercepts a TLS connection and presents their own certificate to the client while impersonating the server. If the client trusts the attacker's CA (e.g., a rogue corporate CA installed on company devices), the attack succeeds — the client decrypts to the attacker, who re-encrypts to the real server.

Preventions:

• Certificate Pinning: App hardcodes expected certificate or public key — rejects anything else
• HSTS (HTTP Strict Transport Security): Browser remembers that site uses HTTPS only
• CAA DNS records: Specify which CAs are authorised to issue certificates for your domain
• Certificate Transparency (CT): All certificates logged publicly — abnormal certs are detectable
• OCSP Stapling: Server proves its certificate is valid in real-time

Certificate pinning is a security technique where an application explicitly trusts only a specific certificate or public key, rather than any certificate signed by a trusted CA. This protects against rogue CA scenarios.

Types:

• Certificate pinning: Pin the exact certificate (must update app on renewal)
• Public key pinning: Pin the public key hash (survives certificate renewals)
• HPKP: HTTP Public Key Pinning header (deprecated — too risky if misconfigured)

Downside: If the pinned certificate/key changes and the app isn't updated, it will break — this has caused major production outages.

An HSM is a dedicated, tamper-resistant hardware device that safeguards and manages cryptographic keys and performs cryptographic operations (signing, encryption, decryption) without exposing the private key to the host system.

Key properties:

• Physical tamper detection and response (zeroizes keys if tampered)
• Keys never leave the HSM in plaintext
• FIPS 140-2 / 140-3 certified (Level 2 or 3)
• High-performance crypto operations (10,000+ RSA ops/sec)

Use cases: Root CA key storage, payment card processing (PCI-HSM), code signing, TLS offloading, blockchain key management.

E2EE ensures that only the communicating parties (sender and recipient) can read the messages. Even the service provider cannot decrypt the data in transit or at rest on their servers.

How it works: Each user has a key pair. Messages are encrypted with the recipient's public key. Only the recipient's private key (stored on their device) can decrypt it.

Examples: WhatsApp/Signal (Signal Protocol), iMessage, ProtonMail, PGP email.

Limitations: Does not protect against endpoint compromise (if the device is hacked, messages are readable). Does not protect metadata (who communicates with whom).

Homomorphic encryption (HE) allows computations to be performed on encrypted data without decrypting it. The result, when decrypted, matches what you would have gotten by operating on the plaintext.

Example: A hospital encrypts patient data, sends to a cloud analytics provider. Provider runs analysis on the ciphertext. Hospital decrypts the result — and gets the correct statistics — without the cloud provider ever seeing the data.

Types: Partially HE (supports one operation: add OR multiply), Somewhat HE (limited operations), Fully HE (any operations — still very slow).

Status: FHE is currently 1,000–10,000× slower than plaintext computation. Active research area — Microsoft SEAL, IBM HElib, Google's open-source libraries.