Container Networking — veth, bridge, ও NAT দিয়ে একটা isolated namespace-কে জগতের সাথে জোড়া লাগানো

এই প্রোগ্রামটা এই লেসনের প্রধান “সত্যিই চালানো” প্রমাণ, কারণ পূর্ববর্তী experiment সেকশনে দেখানো হয়েছে raw Linux netlink কমান্ড এই macOS sandbox-এ চালানো সম্ভব না। এই simulation সেই সীমাবদ্ধতা থেকে সম্পূর্ণ মুক্ত — pure Python, কোনো OS-নির্দিষ্ট syscall লাগে না, কিন্তু প্রতিটা hop হুবহু বাস্তব kernel-এর veth/bridge/iptables যুক্তি অনুসরণ করে।

#!/usr/bin/env python3
"""
container_net_sim.py — একটা Docker-style single-host container network-এর
packet-path simulation: veth pair, Linux bridge (docker0), MAC learning
(switching-arp লেসনের এক্সাক্ট মডেল পুনর্ব্যবহার), আর outbound NAT/MASQUERADE।
"""

class VethPair:
    """একটা virtual ethernet cable — দুই প্রান্ত, in-kernel, তারবিহীন।
    এক প্রান্তে যা ঢোকে, অন্য প্রান্তে হুবহু তাৎক্ষণিক বেরিয়ে আসে।"""
    def __init__(self, container_end_name, host_end_name):
        self.container_end = container_end_name   # container namespace-এ eth0
        self.host_end = host_end_name              # host namespace-এ vethXXXX

    def cross(self, frame_desc):
        return f"[veth in-kernel copy: {self.container_end} -> {self.host_end}] {frame_desc}"


class Container:
    def __init__(self, name, ip, mac, veth):
        self.name = name
        self.ip = ip
        self.mac = mac
        self.veth = veth   # এই container-এর veth pair


class Bridge:
    """docker0 — host namespace-এ চলা একটা software switch।
    switching-arp লেসনের এক্সাক্ট মডেল: learn() source দেখে শেখে,
    forward() destination lookup করে FORWARD/FLOOD সিদ্ধান্ত নেয়।"""
    def __init__(self, name, gateway_ip):
        self.name = name
        self.gateway_ip = gateway_ip
        self.mac_table = {}          # mac -> veth host-end name (port)
        self.ports = {}              # veth host-end name -> Container

    def attach(self, container):
        self.ports[container.veth.host_end] = container
        print(f"  [bridge {self.name}] {container.veth.host_end} attached "
              f"(container {container.name}, {container.mac})")

    def learn(self, mac, port):
        if self.mac_table.get(mac) != port:
            self.mac_table[mac] = port
            print(f"  [bridge {self.name}] LEARN {mac} -> {port}")

    def forward(self, src_container, dst_mac, trace):
        self.learn(src_container.mac, src_container.veth.host_end)
        out_port = self.mac_table.get(dst_mac)
        if out_port is None:
            other_ports = [p for p in self.ports if p != src_container.veth.host_end]
            trace.append(f"  [bridge {self.name}] dst {dst_mac} unknown -> FLOOD {other_ports}")
            return None
        trace.append(f"  [bridge {self.name}] dst {dst_mac} known -> FORWARD {out_port}")
        return self.ports[out_port]


class NatTable:
    """host-এর iptables POSTROUTING MASQUERADE rule-এর একটা mapping-টেবিল রূপ।
    NAT-এর মূল ধারণা (private->public address rewrite, reply-তে reverse
    lookup) এখানে অনুমিত জ্ঞান — শুধু docker0/veth context-এ প্রয়োগ করছি।"""
    def __init__(self, host_public_ip):
        self.host_public_ip = host_public_ip
        self.table = {}   # (container_ip, container_port) -> ephemeral_port
        self._next_ephemeral = 40001

    def masquerade(self, container_ip, container_port, dst_ip, dst_port, trace):
        key = (container_ip, container_port)
        if key not in self.table:
            self.table[key] = self._next_ephemeral
            self._next_ephemeral += 1
        eph = self.table[key]
        trace.append(
            f"  [iptables MASQUERADE] {container_ip}:{container_port} -> "
            f"{self.host_public_ip}:{eph}  (conntrack entry তৈরি/আপডেট)"
        )
        trace.append(
            f"  [host eth0 -> internet] src={self.host_public_ip}:{eph} dst={dst_ip}:{dst_port}"
        )
        return eph

    def reverse_lookup(self, eph, trace):
        for (cip, cport), e in self.table.items():
            if e == eph:
                trace.append(
                    f"  [conntrack reverse] {self.host_public_ip}:{eph}-এ আসা reply -> "
                    f"{cip}:{cport}-এ ফেরত রুট"
                )
                return cip, cport
        return None


def send_packet(src, dst_ip, dst_port, bridge, containers_by_ip, nat, subnet_prefix):
    """একটা container থেকে packet পাঠানোর সম্পূর্ণ hop trace।
    subnet-এর ভেতরে হলে bridge-এর মধ্য দিয়ে সরাসরি, বাইরে হলে NAT দিয়ে।"""
    trace = [f"== {src.name} ({src.ip}) -> {dst_ip}:{dst_port} =="]
    trace.append(f"  [{src.name} eth0] packet built, dst={dst_ip}:{dst_port}")

    is_local = dst_ip.startswith(subnet_prefix)

    if is_local:
        dst = containers_by_ip[dst_ip]
        trace.append(f"  [{src.name} eth0 -> veth] {src.veth.cross(f'frame dst-mac={dst.mac}')}")
        winner = bridge.forward(src, dst.mac, trace)
        if winner is None:
            trace.append(f"  (flood-এর ভেতর {dst.name}-ও frame পেল, ARP-এর মতোই MAC শিখে নিল)")
            winner = dst
        trace.append(f"  [veth -> {winner.name} eth0] {winner.veth.cross('frame delivered')}")
        trace.append(f"  [{winner.name} eth0] packet received from {src.ip}")
    else:
        # subnet-এর বাইরে -> bridge-এর gateway IP-ই default route, তারপর NAT
        trace.append(f"  [{src.name} eth0 -> veth] dst-mac={bridge.gateway_ip}-এর MAC (bridge নিজেই gateway)")
        trace.append(f"  [bridge {bridge.name}] local subnet-এ নেই -> host routing stack-এ up")
        eph = nat.masquerade(src.ip, 34000 + hash(src.name) % 1000, dst_ip, dst_port, trace)
        trace.append(f"  [internet] {dst_ip}:{dst_port} প্যাকেট পেল, src দেখছে শুধু {nat.host_public_ip}:{eph}")
        trace.append(f"  [internet -> host eth0] reply আসছে dst={nat.host_public_ip}:{eph}")
        nat.reverse_lookup(eph, trace)
        trace.append(f"  [host -> bridge -> veth -> {src.name} eth0] reply {src.name}-এ ফিরে গেল")

    print("\n".join(trace))
    print()


if __name__ == "__main__":
    bridge = Bridge("docker0", gateway_ip="172.17.0.1")
    nat = NatTable(host_public_ip="203.0.113.10")

    c1 = Container("web",   "172.17.0.2", "02:42:ac:11:00:02", VethPair("eth0", "veth1a2b3c"))
    c2 = Container("cache", "172.17.0.3", "02:42:ac:11:00:03", VethPair("eth0", "veth4d5e6f"))
    c3 = Container("db",    "172.17.0.4", "02:42:ac:11:00:04", VethPair("eth0", "veth7g8h9i"))

    for c in (c1, c2, c3):
        bridge.attach(c)
    print()

    containers_by_ip = {c.ip: c for c in (c1, c2, c3)}

    print("---- container-to-container (একই bridge, একই host) ----\n")
    send_packet(c1, "172.17.0.3", 6379, bridge, containers_by_ip, nat, "172.17.")
    send_packet(c1, "172.17.0.3", 6379, bridge, containers_by_ip, nat, "172.17.")

    print("---- container-to-outside (internet-এর দিকে, NAT দিয়ে) ----\n")
    send_packet(c1, "93.184.216.34", 443, bridge, containers_by_ip, nat, "172.17.")
    send_packet(c2, "93.184.216.34", 443, bridge, containers_by_ip, nat, "172.17.")

    print("---- চূড়ান্ত bridge MAC table ----")
    for mac, port in sorted(bridge.mac_table.items()):
        print(f"  {mac} -> {port}")

    print("\n---- চূড়ান্ত NAT table ----")
    for (cip, cport), eph in nat.table.items():
        print(f"  {cip}:{cport} <-> {nat.host_public_ip}:{eph}")

এই sandbox-এ সত্যিই চালিয়ে পাওয়া output (macOS-এ Python 3.9.6, সম্পূর্ণ portable কোড — কোনো Linux syscall লাগেনি):

  [bridge docker0] veth1a2b3c attached (container web, 02:42:ac:11:00:02)
  [bridge docker0] veth4d5e6f attached (container cache, 02:42:ac:11:00:03)
  [bridge docker0] veth7g8h9i attached (container db, 02:42:ac:11:00:04)

---- container-to-container (একই bridge, একই host) ----

  [bridge docker0] LEARN 02:42:ac:11:00:02 -> veth1a2b3c
== web (172.17.0.2) -> 172.17.0.3:6379 ==
  [web eth0] packet built, dst=172.17.0.3:6379
  [web eth0 -> veth] [veth in-kernel copy: eth0 -> veth1a2b3c] frame dst-mac=02:42:ac:11:00:03
  [bridge docker0] dst 02:42:ac:11:00:03 unknown -> FLOOD ['veth4d5e6f', 'veth7g8h9i']
  (flood-এর ভেতর cache-ও frame পেল, ARP-এর মতোই MAC শিখে নিল)
  [veth -> cache eth0] [veth in-kernel copy: eth0 -> veth4d5e6f] frame delivered
  [cache eth0] packet received from 172.17.0.2

== web (172.17.0.2) -> 172.17.0.3:6379 ==
  [web eth0] packet built, dst=172.17.0.3:6379
  [web eth0 -> veth] [veth in-kernel copy: eth0 -> veth1a2b3c] frame dst-mac=02:42:ac:11:00:03
  [bridge docker0] dst 02:42:ac:11:00:03 unknown -> FLOOD ['veth4d5e6f', 'veth7g8h9i']
  (flood-এর ভেতর cache-ও frame পেল, ARP-এর মতোই MAC শিখে নিল)
  [veth -> cache eth0] [veth in-kernel copy: eth0 -> veth4d5e6f] frame delivered
  [cache eth0] packet received from 172.17.0.2

---- container-to-outside (internet-এর দিকে, NAT দিয়ে) ----

== web (172.17.0.2) -> 93.184.216.34:443 ==
  [web eth0] packet built, dst=93.184.216.34:443
  [web eth0 -> veth] dst-mac=172.17.0.1-এর MAC (bridge নিজেই gateway)
  [bridge docker0] local subnet-এ নেই -> host routing stack-এ up
  [iptables MASQUERADE] 172.17.0.2:34729 -> 203.0.113.10:40001  (conntrack entry তৈরি/আপডেট)
  [host eth0 -> internet] src=203.0.113.10:40001 dst=93.184.216.34:443
  [internet] 93.184.216.34:443 প্যাকেট পেল, src দেখছে শুধু 203.0.113.10:40001
  [internet -> host eth0] reply আসছে dst=203.0.113.10:40001
  [conntrack reverse] 203.0.113.10:40001-এ আসা reply -> 172.17.0.2:34729-এ ফেরত রুট
  [host -> bridge -> veth -> web eth0] reply web-এ ফিরে গেল

== cache (172.17.0.3) -> 93.184.216.34:443 ==
  [cache eth0] packet built, dst=93.184.216.34:443
  [cache eth0 -> veth] dst-mac=172.17.0.1-এর MAC (bridge নিজেই gateway)
  [bridge docker0] local subnet-এ নেই -> host routing stack-এ up
  [iptables MASQUERADE] 172.17.0.3:34264 -> 203.0.113.10:40002  (conntrack entry তৈরি/আপডেট)
  [host eth0 -> internet] src=203.0.113.10:40002 dst=93.184.216.34:443
  [internet] 93.184.216.34:443 প্যাকেট পেল, src দেখছে শুধু 203.0.113.10:40002
  [internet -> host eth0] reply আসছে dst=203.0.113.10:40002
  [conntrack reverse] 203.0.113.10:40002-এ আসা reply -> 172.17.0.3:34264-এ ফেরত রুট
  [host -> bridge -> veth -> cache eth0] reply cache-এ ফিরে গেল

---- চূড়ান্ত bridge MAC table ----
  02:42:ac:11:00:02 -> veth1a2b3c

---- চূড়ান্ত NAT table ----
  172.17.0.2:34729 <-> 203.0.113.10:40001
  172.17.0.3:34264 <-> 203.0.113.10:40002

দুইটা ফলাফল বিশেষভাবে লক্ষ করার মতো, দুটোই এই sandbox-এ সত্যিই দেখা গেছে, কল্পনা করা হয়নি:

প্রথম — web -> cache দুইবার পাঠানো হয়েছে, কিন্তু দুইবারই FLOOD হয়েছে, দ্বিতীয়বারও FORWARD না। কারণ: cache container কখনো নিজে থেকে কিছু transmit করেনি এই simulation-এ (শুধু receive করেছে), তাই bridge কখনো তার MAC শেখেইনি — এটা “hood” সেকশনের callout-এ যা বলা হয়েছিল তার সরাসরি, প্রমাণিত উদাহরণ।

দ্বিতীয় — চূড়ান্ত bridge MAC table-এ শুধু web-এর MAC আছে, cache-এর না — একই কারণে। bridge শেখে শুধু কে পাঠিয়েছে, কে পেয়েছে তা না।

নিজে বাড়ান:

1. cache থেকে web-এ একটা reply পাঠানোর event যোগ করুন — দেখুন এরপর bridge টেবিলে cache-এর MAC-ও যোগ হয়, আর তৃতীয়বার web -> cache পাঠালে এবার FLOOD-এর বদলে FORWARD হয় কি না
2. একটা দ্বিতীয় bridge (br1) আর একটা দ্বিতীয় subnet (10.0.0.0/24) যোগ করুন — দুই bridge-এর মধ্যে সরাসরি কোনো সংযোগ না থাকলে কী হয়, সেটা trace করুন
3. db container একটা port-এ inbound connection accept করবে এমন দৃশ্যকল্প মডেল করুন — এতে DNAT (iptables -t nat -A PREROUTING, port mapping-এর ভিত্তি — docker run -p-এর মেকানিজম) যোগ করা লাগবে, যা এই লেসনের MASQUERADE-এর ঠিক বিপরীত দিক