Cloud Networking — VPC, Subnet ও Security Group দিয়ে shared physical network-এর ভেতরে নিজের একচ্ছত্র জগৎ বানানো

এই প্রোগ্রামটাই এই লেসনের প্রধান “সত্যিই চালানো” প্রমাণ — পূর্ববর্তী experiment সেকশনে দেখানো হয়েছে বাস্তব cloud API call এই sandbox-এ সম্ভব না, কিন্তু pure Python-এ পুরো VPC CIDR-গণিত আর security-group/NACL-এর filtering-logic হুবহু বাস্তব semantics মেনে সিমুলেট করা যায়, কোনো external dependency ছাড়াই।

#!/usr/bin/env python3
"""
vpc_sim.py — দুইটা স্বাধীন অংশ:
  (১) ipaddress module দিয়ে একটা VPC CIDR block-কে সমান-মাপের subnet-এ ভাগ করা
  (২) security group (stateful) বনাম NACL (stateless) packet-filtering simulation
"""
import ipaddress


# ---------- অংশ ১: VPC CIDR carving ----------

def carve_subnets(vpc_cidr, new_prefix, how_many=None):
    """vpc_cidr-কে new_prefix-মাপের সমান subnet-এ ভাগ করে, প্রথম how_many-টা
    (না দিলে সবগুলো) ফেরত দেয়। ipaddress.subnets() নিজেই CIDR-alignment মেনে চলে।"""
    vpc = ipaddress.ip_network(vpc_cidr)
    if new_prefix <= vpc.prefixlen:
        raise ValueError(f"new_prefix ({new_prefix}) must exceed vpc prefix ({vpc.prefixlen})")
    all_subnets = list(vpc.subnets(new_prefix=new_prefix))
    chosen = all_subnets[:how_many] if how_many else all_subnets
    return len(all_subnets), chosen


def describe(net):
    hosts = list(net.hosts())
    return {
        "cidr": str(net), "network": str(net.network_address),
        "broadcast": str(net.broadcast_address),
        "first_usable": str(hosts[0]) if hosts else "-",
        "last_usable": str(hosts[-1]) if hosts else "-",
        "usable": len(hosts),
    }


print("== অংশ ১: VPC 10.0.0.0/16 কে /24 subnet-এ ভাগ করা ==\n")

vpc_cidr = "10.0.0.0/16"
total_possible, subnets = carve_subnets(vpc_cidr, new_prefix=24, how_many=6)
print(f"VPC {vpc_cidr} থেকে /24-মাপের মোট সম্ভাব্য subnet: {total_possible}")
print(f"এই দৃশ্যকল্পে প্রথম {len(subnets)}-টা — ৩টা AZ, প্রতিটাতে ১ public + ১ private:\n")

roles = [("public-a", "ap-south-1a"), ("private-a", "ap-south-1a"),
         ("public-b", "ap-south-1b"), ("private-b", "ap-south-1b"),
         ("public-c", "ap-south-1c"), ("private-c", "ap-south-1c")]

for (role, az), net in zip(roles, subnets):
    d = describe(net)
    print(f"[{role:11s}] {az:12s} {d['cidr']:15s} "
          f"network={d['network']:10s} broadcast={d['broadcast']:11s} "
          f"usable={d['first_usable']}..{d['last_usable']} ({d['usable']} hosts)")


# ---------- অংশ ২: security group (stateful) বনাম NACL (stateless) ----------

print("\n== অংশ ২: security group (stateful) বনাম NACL (stateless) ==\n")


class Packet:
    def __init__(self, proto, src_ip, src_port, dst_ip, dst_port):
        self.proto, self.src_ip, self.src_port = proto, src_ip, src_port
        self.dst_ip, self.dst_port = dst_ip, dst_port

    def flow_key(self):
        return (self.proto, self.src_ip, self.src_port, self.dst_ip, self.dst_port)

    def reverse_flow_key(self):
        # এই packet যদি কোনো পূর্ববর্তী inbound request-এর *reply* হয়,
        # সেই request-এর flow_key() ঠিক এটাই হতো
        return (self.proto, self.dst_ip, self.dst_port, self.src_ip, self.src_port)

    def __repr__(self):
        return f"{self.proto} {self.src_ip}:{self.src_port} -> {self.dst_ip}:{self.dst_port}"


def port_match(lo, hi, port):
    return lo <= port <= hi


class SecurityGroup:
    """Instance-level, STATEFUL। শুধু inbound rule — matching response
    automatically অনুমোদিত হয়, কোনো outbound rule ছাড়াই।"""

    def __init__(self, name, inbound_rules):
        self.name, self.inbound_rules = name, inbound_rules
        self.connection_table = set()

    def evaluate_inbound(self, pkt):
        allowed = any(pkt.proto == p and port_match(lo, hi, pkt.dst_port)
                      for p, lo, hi in self.inbound_rules)
        if allowed:
            self.connection_table.add(pkt.flow_key())
        return allowed

    def evaluate_outbound(self, pkt):
        # কোনো outbound rule নেই — connection_table-এ matching reverse-flow
        # আছে কি না দেখাই statefulness-এর সংজ্ঞা
        return pkt.reverse_flow_key() in self.connection_table


class NetworkACL:
    """Subnet-level, STATELESS। inbound/outbound সম্পূর্ণ আলাদা, কোনো memory নেই।"""

    def __init__(self, name, inbound_rules, outbound_rules):
        self.name = name
        self.inbound_rules, self.outbound_rules = inbound_rules, outbound_rules

    def evaluate_inbound(self, pkt):
        return any(pkt.proto == p and port_match(lo, hi, pkt.dst_port)
                   for p, lo, hi in self.inbound_rules)

    def evaluate_outbound(self, pkt):
        # outbound rule-এর port-range মিলে packet-এর destination port-এর
        # সাথে — server-এর নিজের src-port ৪৪৩-এর সাথে না
        return any(pkt.proto == p and port_match(lo, hi, pkt.dst_port)
                   for p, lo, hi in self.outbound_rules)


def run_case(label, request, response, sg, nacl_no_out, nacl_with_out):
    print(f"--- {label} ---")
    print(f"  inbound request : {request}")
    print(f"  outbound response: {response}\n")

    print(f"  [security group '{sg.name}'] inbound  -> "
          f"{'ALLOW' if sg.evaluate_inbound(request) else 'DENY'}")
    print(f"  [security group '{sg.name}'] outbound -> "
          f"{'ALLOW' if sg.evaluate_outbound(response) else 'DENY'}"
          f"  (connection_table-এ matching entry, আলাদা rule ছাড়াই)")

    print(f"  [NACL '{nacl_no_out.name}'] inbound  -> "
          f"{'ALLOW' if nacl_no_out.evaluate_inbound(request) else 'DENY'}")
    print(f"  [NACL '{nacl_no_out.name}'] outbound -> "
          f"{'ALLOW' if nacl_no_out.evaluate_outbound(response) else 'DENY'}"
          f"  (কোনো outbound rule নেই -> reply বেরোতে পারবে না)")

    print(f"  [NACL '{nacl_with_out.name}'] inbound  -> "
          f"{'ALLOW' if nacl_with_out.evaluate_inbound(request) else 'DENY'}")
    print(f"  [NACL '{nacl_with_out.name}'] outbound -> "
          f"{'ALLOW' if nacl_with_out.evaluate_outbound(response) else 'DENY'}"
          f"  (explicit ephemeral-range outbound rule বসানো -> এবার allow)")
    print()


request = Packet("tcp", "203.0.113.5", 54321, "10.0.0.5", 443)
response = Packet("tcp", "10.0.0.5", 443, "203.0.113.5", 54321)

web_sg = SecurityGroup("web-sg", inbound_rules=[("tcp", 443, 443)])
broken_nacl = NetworkACL("subnet-nacl (misconfigured)",
                          inbound_rules=[("tcp", 443, 443)], outbound_rules=[])
fixed_nacl = NetworkACL("subnet-nacl (fixed)",
                         inbound_rules=[("tcp", 443, 443)],
                         outbound_rules=[("tcp", 1024, 65535)])

run_case("HTTPS request + তার reply", request, response, web_sg, broken_nacl, fixed_nacl)

spoofed = Packet("tcp", "10.0.0.5", 443, "198.51.100.9", 9999)
print("--- একটা outbound packet যেটা আসলে কোনো প্রকৃত request-এর জবাব না ---")
print(f"  outbound packet: {spoofed}\n")
print(f"  [security group 'web-sg'] outbound -> "
      f"{'ALLOW' if web_sg.evaluate_outbound(spoofed) else 'DENY'}"
      f"  (এই reverse-flow-এর কোনো connection_table entry নেই -> block)")
print(f"  [NACL 'subnet-nacl (fixed)'] outbound -> "
      f"{'ALLOW' if fixed_nacl.evaluate_outbound(spoofed) else 'DENY'}"
      f"  (stateless -> শুধু port-range মিললেই allow, কে request করেছিল তা কখনো চেক হয় না)")

এই sandbox-এ সত্যিই চালিয়ে পাওয়া output (macOS-এ Python 3.9.6):

== অংশ ১: VPC 10.0.0.0/16 কে /24 subnet-এ ভাগ করা ==

VPC 10.0.0.0/16 থেকে /24-মাপের মোট সম্ভাব্য subnet: 256
এই দৃশ্যকল্পে প্রথম 6-টা — ৩টা AZ, প্রতিটাতে ১ public + ১ private:

[public-a   ] ap-south-1a  10.0.0.0/24     network=10.0.0.0   broadcast=10.0.0.255  usable=10.0.0.1..10.0.0.254 (254 hosts)
[private-a  ] ap-south-1a  10.0.1.0/24     network=10.0.1.0   broadcast=10.0.1.255  usable=10.0.1.1..10.0.1.254 (254 hosts)
[public-b   ] ap-south-1b  10.0.2.0/24     network=10.0.2.0   broadcast=10.0.2.255  usable=10.0.2.1..10.0.2.254 (254 hosts)
[private-b  ] ap-south-1b  10.0.3.0/24     network=10.0.3.0   broadcast=10.0.3.255  usable=10.0.3.1..10.0.3.254 (254 hosts)
[public-c   ] ap-south-1c  10.0.4.0/24     network=10.0.4.0   broadcast=10.0.4.255  usable=10.0.4.1..10.0.4.254 (254 hosts)
[private-c  ] ap-south-1c  10.0.5.0/24     network=10.0.5.0   broadcast=10.0.5.255  usable=10.0.5.1..10.0.5.254 (254 hosts)

== অংশ ২: security group (stateful) বনাম NACL (stateless) ==

--- HTTPS request + তার reply ---
  inbound request : tcp 203.0.113.5:54321 -> 10.0.0.5:443
  outbound response: tcp 10.0.0.5:443 -> 203.0.113.5:54321

  [security group 'web-sg'] inbound  -> ALLOW
  [security group 'web-sg'] outbound -> ALLOW  (connection_table-এ matching entry, আলাদা rule ছাড়াই)
  [NACL 'subnet-nacl (misconfigured)'] inbound  -> ALLOW
  [NACL 'subnet-nacl (misconfigured)'] outbound -> DENY  (কোনো outbound rule নেই -> reply বেরোতে পারবে না)
  [NACL 'subnet-nacl (fixed)'] inbound  -> ALLOW
  [NACL 'subnet-nacl (fixed)'] outbound -> ALLOW  (explicit ephemeral-range outbound rule বসানো -> এবার allow)

--- একটা outbound packet যেটা আসলে কোনো প্রকৃত request-এর জবাব না ---
  outbound packet: tcp 10.0.0.5:443 -> 198.51.100.9:9999

  [security group 'web-sg'] outbound -> DENY  (এই reverse-flow-এর কোনো connection_table entry নেই -> block)
  [NACL 'subnet-nacl (fixed)'] outbound -> ALLOW  (stateless -> শুধু port-range মিললেই allow, কে request করেছিল তা কখনো চেক হয় না)

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

প্রথম — একই inbound-request/outbound-response জোড়ায় security group সবসময় সঠিকভাবে reply allow করেছে, কোনো outbound rule ছাড়াই — statefulness-এর সংজ্ঞাই এখানে বাস্তব output।

দ্বিতীয় — misconfigured NACL (inbound rule আছে, outbound rule ফাঁকা)-এ inbound ঠিকঠাক ঢুকেছে কিন্তু outbound reply DENY হয়েছে — এটাই সেই বাস্তব connection-breaking bug যা এই লেসনের concept সেকশনে বর্ণনা করা হয়েছিল, এখন প্রমাণিত output-এ।

তৃতীয়, সবচেয়ে গুরুত্বপূর্ণ — একটা সম্পূর্ণ ভুয়া, কোনো request-এর জবাব-না-হওয়া outbound packet security group ঠিকই block করেছে (কোনো connection_table entry নেই), কিন্তু “fixed” NACL সেটাকেও ALLOW করে দিয়েছে, শুধু কারণ destination port 9999-ও ephemeral range-এর ভেতরে পড়ে। এটাই stateless firewall-এর মূল দুর্বলতার একটা বাস্তব, executed প্রমাণ: port-range-ভিত্তিক outbound rule শুধু বৈধ reply-ই না, port-criteria-মেলা যেকোনো traffic পাস করিয়ে দেয় — কারণ NACL কখনো জানেই না কে আসলে request করেছিল।

নিজে বাড়ান:

1. NetworkACL-এ rule-numbering আর “প্রথম-match-জেতে” evaluation যোগ করুন (এখন সব ALLOW-rule-এর union হিসেবে কাজ করছে) — একটা DENY rule-ও যোগ করে দেখান সেটা কীভাবে একটা পরের ALLOW rule-কে override করে
2. একটা SymmetricSecurityGroup variant বানান যেখানে একাধিক security group একসাথে একটা instance-এ থাকতে পারে (effective rule-set = union), আর দুইটা আলাদা SG-র rule মিলিয়ে একটা connection allow হওয়া দেখান
3. NAT gateway যোগ করুন — private subnet থেকে internet-এ একটা packet পাঠিয়ে দেখান route-table lookup, NAT rewrite, আর ফেরত-আসা reply-র পুরো hop-trace (এই লেসনের LayerTrace-এর executable রূপ)