Stack Buffer Overflow — Return Address দখল করার ক্লাসিক কৌশল

লক্ষ্য: শুধু বলা নয়, দেখানো — একই attacker-নিয়ন্ত্রিত ইনপুট, একই ফাংশনের দুইটা ভিন্ন বাস্তবায়নে গেলে, একবার return address চুরি হয়ে যায়, আরেকবার একটা byte-ও নড়ে না।

# stack_sim.py — vulnerable_copy (strcpy-faithful) বনাম safe_copy (bounds-checked)
import struct

BUF_SIZE = 8

class StackFrame:
    """একটা function-এর stack frame-এর byte-level সিমুলেশন — ঠিক আগের
    (assembly) লেসনের diagram-এর ক্রম মেনে: buf সর্বনিম্ন ঠিকানায়,
    তারপর saved rbp, তারপর সবচেয়ে উঁচু ঠিকানায় return address।
    offset 0..7   -> buf        (8 byte, local variable)
    offset 8..15  -> saved_rbp  (8 byte, caller-র frame pointer)
    offset 16..23 -> return_addr(8 byte, call-এর push করা ঠিকানা)
    """
    def __init__(self, legit_return):
        self.mem = bytearray(24)
        self.mem[16:24] = struct.pack("<Q", legit_return)

    @property
    def return_address(self):
        return struct.unpack("<Q", self.mem[16:24])[0]

    @property
    def saved_rbp(self):
        return self.mem[8:16]


def vulnerable_copy(frame, data: bytes):
    """strcpy(buf, data)-এর faithful আচরণ: buf মাত্র ৮ byte, কিন্তু এই
    ফাংশন সেই সীমা সম্পর্কে কিছুই জানে না — data ফুরানো পর্যন্ত
    frame.mem-এ offset 0 থেকে byte-by-byte লিখে যায়, buf-এর সীমানা
    তো দূরের কথা, পুরো frame-এর সীমানাও চেক করে না।"""
    for i, b in enumerate(data):
        frame.mem[i] = b


def safe_copy(frame, data: bytes, max_len=BUF_SIZE):
    """একই কাজ, কিন্তু bounds-checked — buf-এর ঘোষিত সীমার বেশি কখনো
    লেখে না। max_len-এর বেশি হলে truncate করে, ফেরত দেয় কতটা সত্যিই
    গ্রহণ করা হলো।"""
    accepted = data[:max_len]
    for i, b in enumerate(accepted):
        frame.mem[i] = b
    return accepted


LEGIT_RETURN = 0x0000555555555169   # ফাংশন যেখানে স্বাভাবিকভাবে ফেরার কথা
ATTACKER_TARGET = 0x0000555555de0d0d  # attacker-এর engineered return address

# attacker_input: ৮ byte buf-filler + ৮ byte saved_rbp-filler + ঠিক ৮ byte
# attacker-এর target — এই তিনটা মিলিয়ে ঠিক ২৪ byte, যাতে শেষ ৮ byte-ই
# return_address স্লটের ওপর হুবহু গিয়ে বসে।
attacker_input = b"A" * 8 + b"B" * 8 + struct.pack("<Q", ATTACKER_TARGET)
print(f"attacker_input length = {len(attacker_input)} byte")
print(f"attacker_input (hex)  = {attacker_input.hex()}")

print("\n--- vulnerable_copy: unbounded, strcpy-স্টাইল ---")
frame = StackFrame(LEGIT_RETURN)
print(f"overflow-এর আগে return_address = {frame.return_address:#018x}  (legit)")
vulnerable_copy(frame, attacker_input)
print(f"overflow-এর পরে  return_address = {frame.return_address:#018x}")
assert frame.return_address == ATTACKER_TARGET, "attacker return address বসাতে ব্যর্থ হলো!"
print(f"assert frame.return_address == ATTACKER_TARGET  ->  PASSED")
print("-> শুধু একটা 'strcpy(buf, input)'-এর unbounded copy দিয়েই")
print("   attacker নিজের পছন্দমতো ঠিকানা return_address-এ বসিয়ে দিয়েছে।")

print("\n--- safe_copy: bounds-checked, একই attacker_input দিয়ে ---")
frame2 = StackFrame(LEGIT_RETURN)
print(f"overflow-চেষ্টার আগে return_address = {frame2.return_address:#018x}  (legit)")
accepted = safe_copy(frame2, attacker_input, max_len=BUF_SIZE)
print(f"safe_copy গ্রহণ করল মাত্র {len(accepted)} byte (max_len={BUF_SIZE}): {accepted!r}")
print(f"overflow-চেষ্টার পরে  return_address = {frame2.return_address:#018x}")
assert frame2.return_address == LEGIT_RETURN, "safe_copy-তেও return address বদলে গেছে!"
print(f"assert frame2.return_address == LEGIT_RETURN  ->  PASSED")
zero8 = b"\x00" * 8
print(f"assert frame2.saved_rbp == zero8                 -> {frame2.saved_rbp == zero8}")
print("-> একই attacker_input, শুধু একটা length-check যোগ করাতেই")
print("   saved_rbp আর return_address অক্ষত রয়ে গেছে — buf নিজেই truncate হয়েছে।")

প্রত্যাশিত output (deterministic — হুবহু এটাই আসবে):

attacker_input length = 24 byte
attacker_input (hex)  = 414141414141414142424242424242420d0dde5555550000

--- vulnerable_copy: unbounded, strcpy-স্টাইল ---
overflow-এর আগে return_address = 0x0000555555555169  (legit)
overflow-এর পরে  return_address = 0x0000555555de0d0d
assert frame.return_address == ATTACKER_TARGET  ->  PASSED
-> শুধু একটা 'strcpy(buf, input)'-এর unbounded copy দিয়েই
   attacker নিজের পছন্দমতো ঠিকানা return_address-এ বসিয়ে দিয়েছে।

--- safe_copy: bounds-checked, একই attacker_input দিয়ে ---
overflow-চেষ্টার আগে return_address = 0x0000555555555169  (legit)
safe_copy গ্রহণ করল মাত্র 8 byte (max_len=8): b'AAAAAAAA'
overflow-চেষ্টার পরে  return_address = 0x0000555555555169
assert frame2.return_address == LEGIT_RETURN  ->  PASSED
assert frame2.saved_rbp == zero8                 -> True
-> একই attacker_input, শুধু একটা length-check যোগ করাতেই
   saved_rbp আর return_address অক্ষত রয়ে গেছে — buf নিজেই truncate হয়েছে।

দুইটা assert-ই পাস করেছে, আর সেটাই মূল কথা। vulnerable_copy-তে frame.return_address হুবহু ATTACKER_TARGET-এ পরিণত হয়েছে — কোনো hand-wave না, সরাসরি byte-arithmetic-এর ফলাফল। safe_copy-তে একই attacker_input, একই ২৪ byte চেষ্টা করা হয়েছে, কিন্তু max_len=8 check-এ accepted truncate হয়ে গেছে মাত্র b'AAAAAAAA'-এ — saved_rbp আর return_address কোনোটাই touch হয়নি, কারণ safe_copy কখনো frame.mem -এর ৮ offset-এর বাইরে লেখেইনি।

নিজে বাড়ান:

1. safe_copy-তে max_len-এর বদলে buffer পুরোপুরি ভরে না গিয়ে একটা null-terminator-এর জন্য জায়গা রাখা দরকার কিনা ভাবুন — বাস্তব C-তে strncpy এখানেই একটা কুখ্যাত ফাঁদ ফেলে (null-terminate না করেই থেমে যায়), সেটা কেন সমস্যা তা strncpy-র man page থেকে যাচাই করুন
2. StackFrame-এ একটা চতুর্থ region caller_frame যোগ করুন, আর attacker_input-কে ২৫+ byte বানিয়ে দেখুন সেটা কীভাবে return-address-এর পরেও লেখা চালিয়ে যায় — বাস্তবে এটাই caller-এর frame corrupt করে বা unmapped page-এ পৌঁছে segfault ঘটায়
3. vulnerable_copy-কে real strcpy-র আরও কাছাকাছি করুন — একটা null-byte (\x00) পেলে থেমে যাওয়ার logic যোগ করুন, তারপর দেখান attacker_input-এর মাঝখানে একটা \x00 থাকলে attack কীভাবে ব্যর্থ হয় (এটাই বাস্তব shellcode-এ null byte এড়ানোর কৌশলের কারণ)