HTTP vs HTTPS Explained — How the Web Actually Talks to You

import socket

# We're going to manually craft an HTTP/1.1 request using just a raw TCP socket.
# This is exactly what your browser does under the hood, just automated.

HOST = "example.com"   # The server we want to talk to
PORT = 80              # Port 80 is the standard port for plain HTTP

# Step 1: Create a TCP socket — this is our 'phone line' to the server
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Step 2: Connect to the server on port 80
client_socket.connect((HOST, PORT))

# Step 3: Build the HTTP request as a plain text string.
# Every HTTP request has: a request line, headers, and a blank line at the end.
http_request = (
    "GET / HTTP/1.1\r\n"          # GET the root path (/), using HTTP version 1.1
    "Host: example.com\r\n"       # The Host header tells the server which site we want
    "Connection: close\r\n"       # Tell the server to close the connection after responding
    "\r\n"                        # Blank line signals the end of the headers
)

# Step 4: Send the request — notice it's just text, nothing encrypted
client_socket.sendall(http_request.encode("utf-8"))

# Step 5: Receive the response in chunks
response_parts = []
while True:
    chunk = client_socket.recv(4096)  # Receive up to 4096 bytes at a time
    if not chunk:
        break                         # Empty chunk means the server closed the connection
    response_parts.append(chunk)

client_socket.close()

# Decode the full response from bytes back to a readable string
full_response = b"".join(response_parts).decode("utf-8", errors="replace")

# Split the response into headers and body — they're separated by a blank line
header_section, _, body_section = full_response.partition("\r\n\r\n")

print("=== HTTP RESPONSE HEADERS ===")
print(header_section)
print("\n=== FIRST 300 CHARS OF BODY ===")
print(body_section[:300])

# This script does NOT actually sniff packets (that requires root and special libraries).
# Instead it illustrates what an attacker SEES on the wire with plain HTTP
# versus what they see with HTTPS. This is conceptual but 100% accurate.

# === WHAT AN ATTACKER SEES WITH PLAIN HTTP ===
# Imagine this is the raw bytes flowing over the network during an HTTP login

http_login_request_visible_to_attacker = """
POST /login HTTP/1.1
Host: mycoolbank.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 39

username=alice&password=SuperSecret123
"""
# Every character above is readable by anyone on the network.
# The attacker now has Alice's password.

print("=== ATTACKER'S VIEW: Plain HTTP ===")
print("Intercepted request (fully readable):")
print(http_login_request_visible_to_attacker)

print("-" * 50)

# === WHAT AN ATTACKER SEES WITH HTTPS (TLS encrypted) ===
# After the TLS handshake, all data is encrypted with a session key
# that only the client and server know. The attacker sees gibberish.

# This simulates the encrypted bytes — real TLS ciphertext looks like random noise.
import os
random_encrypted_bytes = os.urandom(64)  # 64 random bytes, like real TLS ciphertext

print("=== ATTACKER'S VIEW: HTTPS (TLS encrypted) ===")
print("Intercepted bytes (encrypted, unreadable):")
print(random_encrypted_bytes)
print("\nAll the attacker knows: the destination IP and the approximate size of the request.")
print("They cannot read the username, password, or any content.")

import ssl
import socket
import json

# Let's make an HTTPS request manually — similar to what we did with HTTP,
# but this time we wrap our socket in TLS using Python's ssl module.

HOST = "httpbin.org"  # A public API that reflects back request info — great for testing
PORT = 443            # Port 443 is the standard port for HTTPS

# Step 1: Create a raw TCP socket (same as before)
raw_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Step 2: Create an SSL context — this is the TLS configuration.
# PROTOCOL_TLS_CLIENT automatically uses the most secure TLS version available.
# check_hostname=True and verify_mode=CERT_REQUIRED mean:
#   - The server MUST present a valid certificate
#   - The certificate's domain MUST match HOST
# This is how HTTPS provides authentication.
tls_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
tls_context.check_hostname = True                        # Verify the domain name matches
tls_context.verify_mode = ssl.CERT_REQUIRED              # Reject invalid/untrusted certs

# Step 3: Wrap our plain socket in TLS — this triggers the TLS handshake.
# server_hostname is used for SNI (Server Name Indication) — it lets one server
# host multiple HTTPS sites on the same IP.
secure_socket = tls_context.wrap_socket(raw_socket, server_hostname=HOST)

# Step 4: Connect — the TLS handshake happens automatically during wrap_socket
secure_socket.connect((HOST, PORT))

# Step 5: Inspect the certificate the server sent us
server_certificate = secure_socket.getpeercert()
print("=== SERVER CERTIFICATE INFO ===")
print(f"Issued to:  {server_certificate.get('subject')}")
print(f"Issued by:  {server_certificate.get('issuer')}")
print(f"Valid from: {server_certificate.get('notBefore')}")
print(f"Valid until:{server_certificate.get('notAfter')}")
print(f"TLS version in use: {secure_socket.version()}")

# Step 6: Now send an HTTP request — same format as before, but encrypted by TLS
http_request = (
    "GET /get HTTP/1.1\r\n"        # /get endpoint returns request info as JSON
    f"Host: {HOST}\r\n"
    "Connection: close\r\n"
    "\r\n"
)
secure_socket.sendall(http_request.encode("utf-8"))

# Step 7: Receive the encrypted response (TLS decrypts it transparently for us)
response_chunks = []
while True:
    chunk = secure_socket.recv(4096)
    if not chunk:
        break
    response_chunks.append(chunk)

secure_socket.close()

full_response = b"".join(response_chunks).decode("utf-8", errors="replace")

# The response has headers and a body — split on the blank line
header_section, _, body_section = full_response.partition("\r\n\r\n")

print("\n=== HTTP RESPONSE STATUS ===")
print(header_section.split("\r\n")[0])  # Just the first line, e.g., 'HTTP/1.1 200 OK'

# Parse the JSON body to show the request info the server echoed back
try:
    response_data = json.loads(body_section)
    print("\n=== SERVER SAW OUR REQUEST ORIGIN ===")
    print(f"Our IP address (as seen by server): {response_data.get('origin')}")
    print(f"URL requested: {response_data.get('url')}")
except json.JSONDecodeError:
    print("(Could not parse JSON — check your network connection)")

import urllib.request
import urllib.error
import json

# We'll use httpbin.org — a free service that mirrors back whatever you send it.
# This is the same site professional developers use to test HTTP behaviour.

BASE_URL = "https://httpbin.org"

def make_request(method: str, path: str, payload: dict = None) -> None:
    """Send an HTTP request and print the status code and response summary."""
    url = f"{BASE_URL}{path}"
    
    # Encode the payload as JSON bytes if there is one
    body_bytes = json.dumps(payload).encode("utf-8") if payload else None
    
    # Build the request object with the correct method and headers
    request = urllib.request.Request(
        url,
        data=body_bytes,
        method=method,
        headers={
            "Content-Type": "application/json",       # Tell server we're sending JSON
            "Accept": "application/json",              # Tell server we want JSON back
            "User-Agent": "TheCodeForge-Demo/1.0"     # Identify our client
        }
    )
    
    try:
        with urllib.request.urlopen(request) as response:
            status_code = response.status              # e.g., 200, 201
            response_body = json.loads(response.read().decode("utf-8"))
            print(f"[{method}] {url}")
            print(f"  Status: {status_code}")
            
            # For POST/PUT, the server echoes back the JSON data we sent
            if "json" in response_body:
                print(f"  Server received our JSON: {response_body['json']}")
            else:
                # For GET, show the request headers the server saw
                print(f"  Headers server saw: User-Agent = {response_body.get('headers', {}).get('User-Agent')}")
    except urllib.error.HTTPError as error:
        # HTTPError is raised for 4xx and 5xx status codes
        print(f"[{method}] {url}")
        print(f"  Status: {error.code} — {error.reason}")
    
    print()

# --- Demonstrate different HTTP methods ---

# GET: Retrieve data — no body, just headers
make_request("GET", "/get")

# POST: Send a new user object to 'create' it
new_user = {"name": "Alice", "email": "alice@example.com", "role": "developer"}
make_request("POST", "/post", payload=new_user)

# PUT: Replace a user record entirely
updated_user = {"name": "Alice Smith", "email": "alice.smith@example.com", "role": "senior-developer"}
make_request("PUT", "/put", payload=updated_user)

# DELETE: Remove a resource — httpbin echoes this back too
make_request("DELETE", "/delete")

# 404 example — request a path that doesn't exist
make_request("GET", "/this-page-does-not-exist")