Use-After-Free ও Double-Free — মৃত মেমরির উপর দাঁড়িয়ে থাকা পয়েন্টার

# double_free.py -- same ToyAllocator, showing double-free corrupting the
# free-list into a cycle (aliasing), then a UAF write turning that cycle
# into a write-what-where: malloc() handing back an attacker-chosen address.

class Chunk:
    __slots__ = ("addr", "size", "in_use", "data", "fd")
    def __init__(self, addr, size):
        self.addr = addr
        self.size = size
        self.in_use = False
        self.data = None
        self.fd = None

class ToyAllocator:
    def __init__(self):
        self.heap = {}
        self.free_head = None
        self._next_addr = 0x1000

    def alloc(self, size, value):
        if self.free_head is not None:
            addr = self.free_head
            chunk = self.heap.get(addr)
            if chunk is None:
                # allocator TRUSTS the free-list link blindly -- it never
                # validates that `addr` was ever a real chunk it handed out.
                # A real allocator does the equivalent: it reads whatever
                # bytes sit at that address as if they were a chunk header.
                chunk = Chunk(addr, size)
                self.heap[addr] = chunk
            self.free_head = chunk.fd
            chunk.fd = None
        else:
            addr = self._next_addr
            self._next_addr += size
            self.heap[addr] = Chunk(addr, size)
            chunk = self.heap[addr]
        chunk.in_use = True
        chunk.data = value
        return addr

    def free(self, addr):
        # NO double-free check -- exactly like a raw fastbin free()
        chunk = self.heap[addr]
        chunk.fd = self.free_head
        self.free_head = addr
        chunk.in_use = False

    def read(self, addr):
        return self.heap[addr].data

    def write_fd(self, addr, fake_fd):
        # simulates a UAF *write* through a stale pointer: attacker
        # overwrites the fd field living in the freed chunk's own
        # user-data area
        self.heap[addr].fd = fake_fd

    def free_list_chain(self, limit=6):
        out, cur, seen = [], self.free_head, set()
        while cur is not None and len(out) < limit:
            out.append(hex(cur))
            if cur in seen:
                out.append("...(cycle)")
                break
            seen.add(cur)
            cur = self.heap[cur].fd
        return " -> ".join(out) if out else "(empty)"


alloc = ToyAllocator()

print("== ধাপ ১: A আর B allocate করা হলো ==")
a = alloc.alloc(16, "chunk-A")
b = alloc.alloc(16, "chunk-B")
print(f"  A={hex(a)}  B={hex(b)}")

print("\n== ধাপ ২: free(A), free(B) -- স্বাভাবিক free ==")
alloc.free(a)
alloc.free(b)
print(f"  free-list এখন: {alloc.free_list_chain()}")

print("\n== ধাপ ৩: free(A) আবার -- DOUBLE FREE, কোনো check নেই ==")
alloc.free(a)
print(f"  free-list এখন: {alloc.free_list_chain()}")
print("  -> A নিজের fd দিয়ে B-কে দেখাচ্ছে, B-র fd আবার A-কে দেখাচ্ছে -- একটা CYCLE")

print("\n== ধাপ ৪: এখন তিনটা alloc() ডাকা হলো ==")
c1 = alloc.alloc(16, "attacker-obj-1")
c2 = alloc.alloc(16, "attacker-obj-2")
c3 = alloc.alloc(16, "attacker-obj-3")
print(f"  alloc#1 -> {hex(c1)}   (data={alloc.read(c1)!r})")
print(f"  alloc#2 -> {hex(c2)}   (data={alloc.read(c2)!r})")
print(f"  alloc#3 -> {hex(c3)}   (data={alloc.read(c3)!r})")
print(f"  alloc#1 == alloc#3 (একই address দুইবার ফেরত এসেছে)? {c1 == c3}")
print(f"  alloc#1-এর data এখন আসলে alloc#3-এর লেখা মান : {alloc.read(c1) == alloc.read(c3)}")
print("  -> দুইটা 'independent' object আসলে একই মেমরিকে alias করছে --")
print("     একটাতে লিখলে অন্যটাও বদলে যায়, allocator নিজে জানেই না।")

print("\n== ধাপ ৫: write-what-where -- UAF-write দিয়ে fd corrupt করা ==")
alloc2 = ToyAllocator()
a = alloc2.alloc(16, "chunk-A")
b = alloc2.alloc(16, "chunk-B")
alloc2.free(a)
alloc2.free(b)
alloc2.free(a)                       # double-free -> cycle, যেমন আগে
print(f"  double-free-এর পরের free-list: {alloc2.free_list_chain()}")

FAKE_TARGET = 0xdeadbeef             # attacker-chosen arbitrary "address"
alloc2.write_fd(b, FAKE_TARGET)      # stale pointer দিয়ে B-র fd সরাসরি ওভাররাইট
print(f"  attacker stale-write করল heap[B].fd = {hex(FAKE_TARGET)}")
print(f"  free-list এখন (আংশিক, দেখানোর জন্য ৩টা hop): "
      f"{hex(alloc2.free_head)} -> {hex(alloc2.heap[alloc2.free_head].fd)} -> "
      f"{hex(alloc2.heap[alloc2.heap[alloc2.free_head].fd].fd)}")

d1 = alloc2.alloc(16, "victim-obj")            # pops A
d2 = alloc2.alloc(16, "victim-obj-2")          # pops B, exposes FAKE_TARGET as new head
d3 = alloc2.alloc(16, "attacker-write-here")   # pops FAKE_TARGET !!
print(f"  alloc#1 -> {hex(d1)}")
print(f"  alloc#2 -> {hex(d2)}")
print(f"  alloc#3 -> {hex(d3)}")
print(f"  alloc#3 attacker-এর বেছে-নেওয়া FAKE_TARGET-এর সমান? {d3 == FAKE_TARGET}")
print("  -> allocator attacker-নির্ধারিত একটা arbitrary address ফেরত দিল --")
print("     caller এখন সেখানে 'নিজের' object মনে করে লিখবে: write-what-where.")

প্রকৃত চালিয়ে পাওয়া output (deterministic — হুবহু এটাই আসবে):

== ধাপ ১: A আর B allocate করা হলো ==
  A=0x1000  B=0x1010

== ধাপ ২: free(A), free(B) -- স্বাভাবিক free ==
  free-list এখন: 0x1010 -> 0x1000

== ধাপ ৩: free(A) আবার -- DOUBLE FREE, কোনো check নেই ==
  free-list এখন: 0x1000 -> 0x1010 -> 0x1000 -> ...(cycle)
  -> A নিজের fd দিয়ে B-কে দেখাচ্ছে, B-র fd আবার A-কে দেখাচ্ছে -- একটা CYCLE

== ধাপ ৪: এখন তিনটা alloc() ডাকা হলো ==
  alloc#1 -> 0x1000   (data='attacker-obj-3')
  alloc#2 -> 0x1010   (data='attacker-obj-2')
  alloc#3 -> 0x1000   (data='attacker-obj-3')
  alloc#1 == alloc#3 (একই address দুইবার ফেরত এসেছে)? True
  alloc#1-এর data এখন আসলে alloc#3-এর লেখা মান : True
  -> দুইটা 'independent' object আসলে একই মেমরিকে alias করছে --
     একটাতে লিখলে অন্যটাও বদলে যায়, allocator নিজে জানেই না।

== ধাপ ৫: write-what-where -- UAF-write দিয়ে fd corrupt করা ==
  double-free-এর পরের free-list: 0x1000 -> 0x1010 -> 0x1000 -> ...(cycle)
  attacker stale-write করল heap[B].fd = 0xdeadbeef
  free-list এখন (আংশিক, দেখানোর জন্য ৩টা hop): 0x1000 -> 0x1010 -> 0xdeadbeef
  alloc#1 -> 0x1000
  alloc#2 -> 0x1010
  alloc#3 -> 0xdeadbeef
  alloc#3 attacker-এর বেছে-নেওয়া FAKE_TARGET-এর সমান? True
  -> allocator attacker-নির্ধারিত একটা arbitrary address ফেরত দিল --
     caller এখন সেখানে 'নিজের' object মনে করে লিখবে: write-what-where.

ধাপ ৪-এর alloc#1-এর data এখন আসলে alloc#3-এর লেখা মান : True লাইনটা সবচেয়ে গুরুত্বপূর্ণ — এটা দেখায় দুইটা সম্পূর্ণ ভিন্ন “handle” (c1, c3) আসলে একই মেমরির ওপর কাজ করছে, allocator নিজেই এই দ্বৈত-মালিকানা সম্পর্কে কিছু জানে না। আর ধাপ ৫ দেখায় এই একই দুর্বলতা কতদূর বাড়ানো যায় — বাস্তব CTF আর real-world exploit-এ এই কৌশলটার নাম fastbin dup (double-free করে একটা fastbin-এ duplicate entry তৈরি করা), আর এর সম্প্রসারণ (fake chunk প্লান্ট করে arbitrary address মেমরি বরাদ্দ পাওয়া) পরিচিত House of Spirit-জাতীয় কৌশল হিসেবে। glibc-র আধুনিক সংস্করণে tcache/fastbin-এ এখন সাধারণ ক্ষেত্রে একটা সরল double-free check আছে (সরাসরি পরপর একই chunk free করলে ধরা পড়ে) — কিন্তু মাঝখানে একটা ভিন্ন chunk free করে সেই check bypass করা সম্ভব, যা দেখায় mitigation প্রায়ই “সহজ কেস” ধরে, প্যাটার্ন সম্পূর্ণ বন্ধ করে না।