Integer Overflow-এর নিরাপত্তা পরিণতি — সংখ্যা থেকে Heap Corruption পর্যন্ত

Allocation-Size Overflow — একটা toy heap-এ আসলে চালিয়ে দেখা

নিচের সিমুলেশন একটা flat bytearray heap আর একটা bump allocator ব্যবহার করে — আগের দুই লেসনের chunk/free-list মডেলের চেয়ে সহজ, কারণ আজকের বাগের কেন্দ্র reuse-এ না, size-এর হিসাবে। ধারাবাহিক alloc() কল ধারাবাহিক ঠিকানায় বসে — ঠিক একটা real arena/bump allocator, বা glibc-র chunk-splitting-এর adjacency-র মতোই।

# alloc_overflow.py -- size = count * element_size overflows (32-bit) to a
# small value; malloc() hands back an undersized buffer; the write step
# still writes the attacker's real payload, stomping into adjacent heap
# memory.

MASK32 = 0xFFFFFFFF
ELEMENT_SIZE = 4        # a uint32_t "record" -- e.g. a handle/pointer table entry

def compute_alloc_size(count, element_size):
    # size_t size = count * element_size;  -- on a 32-bit size_t (or a
    # 32-bit count/size variable on a 64-bit system, equally common),
    # this multiplication wraps silently. No language-level warning.
    return (count * element_size) & MASK32

class ToyHeap:
    """A flat bytearray heap + a bump allocator. Each alloc() call places
    the new chunk immediately after the previous one -- no free-list
    needed for this bug, because the flaw lives entirely in the size
    *computation* handed to malloc(), not in chunk reuse."""
    def __init__(self, size=256):
        self.mem = bytearray(size)
        self._next = 0

    def alloc(self, nbytes):
        addr = self._next
        self._next += nbytes
        return addr

    def write_u32(self, addr, offset, value):
        self.mem[addr + offset: addr + offset + 4] = value.to_bytes(4, "little")

    def read_u32(self, addr):
        return int.from_bytes(self.mem[addr:addr + 4], "little")


heap = ToyHeap()

print("== ধাপ ১: attacker একটা 'count' field পাঠাচ্ছে (protocol-এর অংশ) ==")
count = 0x40000001                       # attacker-controlled, sent on the wire
print(f"  attacker-sent count = {count}  ({hex(count)})")
print(f"  ELEMENT_SIZE        = {ELEMENT_SIZE} byte")
raw_product = count * ELEMENT_SIZE
print(f"  সত্যিকারের গাণিতিক ফল = count * ELEMENT_SIZE = {raw_product}  ({hex(raw_product)})")

alloc_size = compute_alloc_size(count, ELEMENT_SIZE)
print(f"  32-bit-এ mask করা ফল (size_t size)  = {alloc_size}  ({hex(alloc_size)})")
print(f"  -> malloc()-কে বলা হচ্ছে মাত্র {alloc_size} byte বরাদ্দ করতে,")
print(f"     যদিও attacker আসলে {count:,}টা {ELEMENT_SIZE}-byte record পাঠানোর দাবি করছে")

print("\n== ধাপ ২: buf = malloc(size) -- undersized buffer বরাদ্দ হলো ==")
buf_addr = heap.alloc(alloc_size)
print(f"  buf_addr = {hex(buf_addr)}   allocated size = {alloc_size} byte")

print("\n== ধাপ ৩: এর ঠিক পরেই allocator পরবর্তী object বসায় (victim) ==")
SENTINEL = 0xCAFEBABE
victim_addr = heap.alloc(4)
heap.write_u32(victim_addr, 0, SENTINEL)
print(f"  victim_addr = {hex(victim_addr)}  (= buf_addr + {alloc_size}, বাস্তব bump/arena allocator-এর adjacency)")
print(f"  victim-এর আসল মান = {hex(SENTINEL)}")

print("\n== ধাপ ৪: copy loop -- 'count'-এর ওপর ভিত্তি করেই লেখে, alloc_size-এর ওপর না ==")
ACTUAL_RECORDS_SENT = 3     # attacker's real wire payload for this PoC
print(f"  demo-তে দেখানোর জন্য প্রথম {ACTUAL_RECORDS_SENT}টা record লেখা হচ্ছে "
      f"(বাস্তবে attacker চাইলে আরও {count - ACTUAL_RECORDS_SENT:,}টা লিখতে পারত)")
for i in range(ACTUAL_RECORDS_SENT):
    record_value = 0x41414141 + i     # attacker-chosen payload bytes
    heap.write_u32(buf_addr, i * ELEMENT_SIZE, record_value)
    print(f"    write record[{i}] = {hex(record_value)}  at offset {i*ELEMENT_SIZE} "
          f"(absolute addr {hex(buf_addr + i*ELEMENT_SIZE)})")

print("\n== ধাপ ৫: ফলাফল -- victim-এর মান কি বদলে গেছে? ==")
new_victim = heap.read_u32(victim_addr)
print(f"  victim_addr এখনও একই ঠিকানা : {hex(victim_addr)}")
print(f"  victim-এর আসল মান ছিল      : {hex(SENTINEL)}")
print(f"  victim-এর এখনকার মান       : {hex(new_victim)}")
print(f"  victim corrupted হয়েছে?    : {new_victim != SENTINEL}")

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

== ধাপ ১: attacker একটা 'count' field পাঠাচ্ছে (protocol-এর অংশ) ==
  attacker-sent count = 1073741825  (0x40000001)
  ELEMENT_SIZE        = 4 byte
  সত্যিকারের গাণিতিক ফল = count * ELEMENT_SIZE = 4294967300  (0x100000004)
  32-bit-এ mask করা ফল (size_t size)  = 4  (0x4)
  -> malloc()-কে বলা হচ্ছে মাত্র 4 byte বরাদ্দ করতে,
     যদিও attacker আসলে 1,073,741,825টা 4-byte record পাঠানোর দাবি করছে

== ধাপ ২: buf = malloc(size) -- undersized buffer বরাদ্দ হলো ==
  buf_addr = 0x0   allocated size = 4 byte

== ধাপ ৩: এর ঠিক পরেই allocator পরবর্তী object বসায় (victim) ==
  victim_addr = 0x4  (= buf_addr + 4, বাস্তব bump/arena allocator-এর adjacency)
  victim-এর আসল মান = 0xcafebabe

== ধাপ ৪: copy loop -- 'count'-এর ওপর ভিত্তি করেই লেখে, alloc_size-এর ওপর না ==
  demo-তে দেখানোর জন্য প্রথম 3টা record লেখা হচ্ছে (বাস্তবে attacker চাইলে আরও 1,073,741,822টা লিখতে পারত)
    write record[0] = 0x41414141  at offset 0 (absolute addr 0x0)
    write record[1] = 0x41414142  at offset 4 (absolute addr 0x4)
    write record[2] = 0x41414143  at offset 8 (absolute addr 0x8)

== ধাপ ৫: ফলাফল -- victim-এর মান কি বদলে গেছে? ==
  victim_addr এখনও একই ঠিকানা : 0x4
  victim-এর আসল মান ছিল      : 0xcafebabe
  victim-এর এখনকার মান       : 0x41414142
  victim corrupted হয়েছে?    : True

মূল মুহূর্তটা ধাপ ৫-এ: victim-এর মান 0xcafebabe থেকে 0x41414142-এ বদলে গেছে — অথচ প্রোগ্রামের কোনো লাইন সরাসরি victim-কে touch করেনি। buf-এ লেখা তৃতীয় record (0x41414143, offset ৮-এ, absolute address 0x8-এ) মূলত buf-এর নিজের ৪-byte সীমা (0x0 থেকে 0x3) থেকে অনেক দূরে লেখা হয়েছে — কিন্তু ঠিক victim_addr-এর ৪ byte-এর মধ্যেই দ্বিতীয় write-টা (record[1], absolute address 0x4) পড়েছে, আর সেটাই victim-এর পুরনো মান সম্পূর্ণ প্রতিস্থাপন করে দিয়েছে। শুধু ৩টা record লিখেই — যেখানে attacker-এর দাবি করা count ছিল এক বিলিয়নেরও বেশি — corruption ঘটে গেছে, কারণ malloc()-এর কাছে “৪ byte” ছাড়া আর কিছুই জানা ছিল না।