घोस्टवायर: ब्राउज़र जावास्क्रिप्ट के लिए फ्रिडा-नैदानिक रनटाइम इंस्ट्रमेंटेशन

TL;DR:

• Ghostwire एक रनटाइम इंस्ट्रूमेंटेशन है जो ब्राउज़र JavaScript के लिए है, जो Frida की समान श्रेणी में है। दोनों लाइव फ़ंक्शन सीमा का अवलोकन करते हैं बजाय इसके कि स्रोत को पढ़ने और उम्मीद रखने के। लक्ष्य भिन्न है: Frida स्थानीय और मोबाइल प्रक्रियाओं को इंस्ट्रूमेंट करती है, Ghostwire Chrome के अंदर JavaScript को इंस्ट्रूमेंट करती है।
• परिवहन Chrome DevTools प्रोटोकॉल के माध्यम से एक OS पाइप है। Ghostwire Chrome को --remote-debugging-pipe के साथ लॉन्च करती है, इसलिए कनेक्ट करने के लिए कोई डिबगिंग पोर्ट नहीं होता और कोर के लिए कोई थर्ड-पार्टी निर्भरता स्थापित करने की आवश्यकता नहीं होती।
• हुक डिबगिंग ब्रेकपॉइंट हैं, रैपर नहीं। लाइव फ़ंक्शन ऑब्जेक्ट कभी भी प्रतिस्थापित नहीं होती है, इसलिए fn.toString() हमेशा मूल स्रोत को वापस करता है।
• दिलचस्प हिस्सा ओरेकल है। आप वास्तविक (इनपुट → आउटपुट) जोड़े कैप्चर करते हैं, एक उम्मीदवार पुन: कार्यान्वयन लिखते हैं, और Ghostwire को इसे गलत साबित करने देते हैं एक ठोस प्रतिकूल उदाहरण के साथ।
• एक लाइव रन ने एक संभावित उम्मीदवार को अस्वीकार कर दिया। बारह कैप्चर किए गए जोड़े ने सही फ़ंक्शन की पुष्टि की 12/12; एक संस्करण जिसमें एकल +1 गायब था 0/13 से मेल खाता था और सटीक असफल इनपुट उत्पन्न करता था।
• Ghostwire आज एक स्थानीय-Chrome टूल है। यह एक दूरस्थ WebSocket CDP अंत बिंदु से कनेक्ट नहीं करता, इसलिए वर्तमान में यह Scrapeless Scraping Browser सत्र को संचालित नहीं कर सकता।
• इसे केवल वहीं उपयोग करें जहां आप अधिकृत हैं। सामान्य ब्राउज़र डेटा संग्रह के लिए एक मुफ्त Scrapeless खाता प्रारंभ करें, जो रनटाइम विश्लेषण से अलग काम है।

आपराधिक JavaScript पढ़ने से आपको एक परिकल्पना मिलती है। इसे चलाने से आपको एक तथ्य मिलता है। Ghostwire का उद्देश्य पहले को दूसरे में बदलना है: यह अवलोकन करता है कि एक फ़ंक्शन वास्तव में रनटाइम पर क्या लौटाता है, फिर आपके पुन: कार्यान्वयन की जांच उस ग्राउंड ट्रूथ के खिलाफ करता है और हर इनपुट की रिपोर्ट करता है जहाँ आप गलत थे।

Ghostwire क्या है

Ghostwire एक Python इंस्ट्रूमेंटेशन लाइब्रेरी है जो Chrome के अंदर JavaScript चलाने के लिए है। यह Chrome DevTools प्रोटोकॉल के माध्यम से संलग्न करती है, लाइव फ़ंक्शन ऑब्जेक्ट पर हुक सेट करती है, तर्क और लौटाने के मान रिकॉर्ड करती है, और एक उम्मीदवार कार्यान्वयन की तुलना कैप्चर की गई व्यवहार के खिलाफ करती है।

यहाँ उपयोग किया गया संस्करण 0.1.0 है जो अपस्ट्रीम कमिट a3fe4ef1e27804ab1e976e28dfa1801ee53aabf8 पर है। यह Python 3.9 या बाद की आवश्यकता है और MIT लाइसेंसिंग है, और कोर में कोई थर्ड-पार्टी निर्भरता नहीं है क्योंकि प्रोटोकॉल OS पाइप के माध्यम से चलता है न कि WebSocket क्लाइंट लाइब्रेरी के माध्यम से।

यह गाइड एक सिंथेटिक स्थानीय पृष्ठ का उपयोग करता है। रनटाइम इंस्ट्रूमेंटेशन किसी अन्य सुरक्षा उपकरण की समान अधिकार प्राप्ति श्रेणी में आती है: ऐसे सिस्टम का विश्लेषण करें जो आप अपने पास रखते हैं या जिनका परीक्षण करने की स्पष्ट अनुमति है।

Ghostwire और Frida: जहाँ तुलना सही है

Ghostwire को "ब्राउज़र JavaScript के लिए Frida" कहना एक उपयोगी संक्षेप है, और यह कार्य विधि के बारे में सही है न कि कार्यान्वयन के।

Frida का JavaScript API उस प्रक्रिया के अंदर एक एजेंट चलाता है जिसे वह निरीक्षण कर रहा है। Ghostwire कभी भी पृष्ठ में कोड नहीं डालता। वह अंतर जानबूझकर है: लाइव फ़ंक्शन ऑब्जेक्ट पर एक ब्रेकपॉइंट ऑब्जेक्ट को अपरिवर्तित छोड़ता है, इसलिए पृष्ठ का अपना fn.toString() चेक मूल स्रोत को देखता है।

जहाँ तुलना सही है वह कार्यशील मॉडल है। दोनों स्थिर पढ़ाई को लाइव अवलोकन से बदलते हैं, और दोनों अधिकृत विश्लेषण के लिए हैं न कि उत्पादन डेटा संग्रह के लिए।

पूर्वापेक्षाएँ

• Python 3.9 या बाद का।
• स्थानीय रूप से Google Chrome या Chromium स्थापित किया गया हो।
• Ghostwire भंडार का एक चेकआउट एक पिन की गई कमिट पर।
• केवल वही लक्ष्य जो आपके पास हैं या जिनका विश्लेषण करने के लिए आपको अधिकृत किया गया है।

स्थापित करें

कोर में स्थापित करने के लिए कोई पैकेज नहीं है, इसलिए एक पिन की गई चेकआउट ही पूरी सेटअप है:

git clone https://github.com/sofianeelhor/ghostwire.git
cd ghostwire
git checkout a3fe4ef1e27804ab1e976e28dfa1801ee53aabf8

कुछ भी चलाने से पहले pyproject.toml पढ़ें। यह version = "0.1.0", requires-python = ">=3.9", और एक खाली dependencies सूची की घोषणा करता है, जिसमें mcp>=1.0 केवल MCP सर्वर के लिए एक वैकल्पिक अतिरिक्त है।

सिंथेटिक लक्ष्य

यह फिक्स्चर लोकलहोस्ट से सेवा दी जाती है और जानबूझकर एक सरल मान की गणना करती है। इसमें कोई प्रमाणीकरण जानकारी, कोई एंटी-बोट तर्क और कोई थर्ड-पार्टी कोड नहीं है:

PAGE = b"""<!doctype html><html><body><script>
function transform(name, value) {
  return btoa(name + ':' + (value * 7 + 1));
}
window.transform = transform;
let i = 0;
setInterval(function () {
  window.lastResult = transform('sample' + i, 10 + i);
  i += 1;
}, 120);
</script></body></html>"""

टाइमर महत्वपूर्ण है। गोस्टवायर कॉल्स को जब होते हैं तब कैप्चर करता है, इसलिए एक सीमा जो बार-बार व्यायाम की जाती है, बिना किसी इंटरैक्शन के एक कॉर्पस उत्पन्न करती है।

अटैच और हुक

ghostwire.attach() क्रोम को लॉन्च करता है, डिफ़ॉल्ट प्रॉब्स को वायर्ड करता है, और एक Inspector लौटाता है:

import ghostwire

with ghostwire.attach("http://localhost:8000/", headless=True) as gw:
    gw.wait(1.0)
    gw.hook("window.transform", capture_returns=True, label="transform")
    gw.wait(1.5)
    corpus = gw.corpus("transform")
    print("captured pairs:", len(corpus))

capture_returns=True लौटने वाले मान को तर्कों के साथ रिकॉर्ड करता है, जिससे कॉर्पस को ग्राउंड ट्रूथ के रूप में उपयोगी बनाता है। label उन जोड़ों को बाद में सत्यापन के लिए समूहित करता है।

क्या आप चलाने के व्यवहार का विश्लेषण करने के बजाय सामान्य पृष्ठ डेटा इकट्ठा करने के लिए तैयार हैं? एक मुफ्त स्क्रैपलेस खाता खोलें और उस काम के लिए एक प्रबंधित ब्राउज़र का उपयोग करें।

वास्तविकता के खिलाफ एक उम्मीदवार को सत्यापित करें

आप एक पुनः कार्यान्वयन प्रदान करते हैं, और गोस्टवायर इसे कैप्चर किए गए कॉर्पस के खिलाफ एक अलग पृष्ठ में चलाता है जो असली कार्य को नहीं देख सकता:

good = "(name,value)=>btoa(name+':'+(value*7+1))"
wrong = "(name,value)=>btoa(name+':'+(value*7))"

good_result = gw.verify("window.transform", good, label="transform")
wrong_result = gw.verify("window.transform", wrong, label="transform")

दूसरा उम्मीदवार वास्तविकता में असफलता है: व्याकरणिक रूप से सही, अर्थगत रूप से एक द्वारा गलत। एक मॉडल जो मिनिफाइड स्रोत को पढ़ता है, नियमित रूप से इस प्रकार की गलती करता है, और यह आकस्मिक समीक्षा को सहन करता है क्योंकि आउटपुट अभी भी मान्य बेस64 की तरह दिखता है।

संपूर्ण चलने योग्य स्क्रिप्ट

सत्यापन के लिए उपयोग की जाने वाली कंटेनर को दो समायोजन की आवश्यकता थी, दोनों पर्यावरणीय न कि गोस्टवायर दोष: क्रोम को रूट के रूप में चलाते समय --no-sandbox की आवश्यकता होती है, और पहले HTTP नेविगेशन की गति काफी धीमी होती है कि यह स्टॉक 20-सेकंड CDP समय सीमा को पार कर जाता है।

import base64
import http.server
import socketserver
import sys
import threading
from pathlib import Path

HERE = Path(__file__).resolve().parent
UPSTREAM = next(
    p / "upstream" for p in (HERE, *HERE.parents)
    if (p / "upstream" / "ghostwire").is_dir()
)
sys.path.insert(0, str(UPSTREAM))
from ghostwire import Browser, Engine, Tracer
from ghostwire.api import Inspector
from ghostwire.crypto import CryptoLogger
from ghostwire.dataflow import DataflowTracer
from ghostwire.objects import LiveObjects
from ghostwire.oracle import Oracle
from ghostwire.origin import OriginTracer
from ghostwire.probes import NetLog, ScriptWatcher


def attach_local(url, extra_flags):
    """ghostwire.attach() के समान वायर्ड, कंटेनर-सुरक्षित Chrome फ्लैग के साथ।"""
    browser = Browser(headless=True, extra_flags=extra_flags)
    browser.cdp.default_timeout = 90.0
    engine = Engine(browser=browser)
    scripts, net, tracer = ScriptWatcher(), NetLog(), Tracer()
    for probe in (scripts, net, tracer):
        engine.add_probe(probe)
    oracle = Oracle(engine, tracer)
    engine.start()
    engine.navigate(url)
    return Inspector(
        engine, scripts, net, tracer, oracle,
        OriginTracer(engine), DataflowTracer(engine),
        LiveObjects(engine), CryptoLogger(engine),
    )


PAGE = b"""<!doctype html><html><body><script>
function transform(name, value) {
  return btoa(name + ':' + (value * 7 + 1));
}
window.transform = transform;
let i = 0;
setInterval(function () {
  window.lastResult = transform('sample' + i, 10 + i);
  i += 1;
}, 120);
</script></body></html>"""


class Handler(http.server.BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header("Content-Type", "text/html")
        self.send_header("Content-Length", str(len(PAGE)))
        self.end_headers()
        self.wfile.write(PAGE)

    def log_message(self, *args):
        pass


class QuietServer(socketserver.TCPServer):
    allow_reuse_address = True

    def handle_error(self, request, client_address):
        pass


server = QuietServer(("127.0.0.1", 0), Handler)
port = server.server_address[1]
threading.Thread(target=server.serve_forever, daemon=True).start()

gw = attach_local(
    f"http://localhost:{port}/",
    ["--no-sandbox", "--disable-dev-shm-usage"],
)
try:
    gw.wait(1.0)
    gw.hook("window.transform", capture_returns=True, label="transform")
    gw.wait(1.5)

    corpus = gw.corpus("transform")
    good = "(name,value)=>btoa(name+':'+(value*7+1))"
Here is the translated text in Hindi:

```text
गलत = "(name,value)=>btoa(name+':'+(value*7))"
    अच्छा_result = gw.verify("window.transform", अच्छा, label="transform")
    गलत_result = gw.verify("window.transform", गलत, label="transform")
    ताज़ा = [["alpha", 1], ["beta", 2], ["", 0]]
    ताज़ा_result = gw.verify("window.transform", अच्छा, fresh_inputs=ताज़ा)

    असमानता = गलत_result["mismatches"][0]
    अपेक्षित_decoded = base64.b64decode(असमानता["expected"]).decode()
    हासिल_decoded = base64.b64decode(असमानता["got"]).decode()

    assert len(corpus) >= 5
    assert अच्छा_result["verified"] is True
    assert गलत_result["verified"] is False
    assert ताज़ा_result["verified"] is True

    print("ghostwire संस्करण: 0.1.0")
    print("पकड़े गए जोड़े:", len(corpus))
    print("सही उम्मीदवार:", अच्छा_result["verified"],
          "परीक्षित:", अच्छा_result["tested"], "मेल खाता:", अच्छा_result["matched"])
    print("गलत उम्मीदवार:", गलत_result["verified"],
          "परीक्षित:", गलत_result["tested"], "मेल खाता:", गलत_result["matched"])
    print("काउंटर उदाहरण इनपुट:", असमानता["input"])
    print("काउंटर उदाहरण अपेक्षित:", अपेक्षित_decoded)
    print("काउंटर उदाहरण मिला:", हासिल_decoded)
    print("ताज़ा इनपुट सत्यापित:", ताज़ा_result["verified"])
    print("ताज़ा इनपुट परीक्षण:", ताज़ा_result["tested"])
अंत में:
    gw.close()
    server.shutdown()

रन का परिणाम

ghostwire संस्करण: 0.1.0
पकड़े गए जोड़े: 12
सही उम्मीदवार: True परीक्षण: 12 मेल खाता: 12
गलत उम्मीदवार: False परीक्षण: 13 मेल खाता: 0
काउंटर उदाहरण इनपुट: ['sample8', 18]
काउंटर उदाहरण अपेक्षित: sample8:127
काउंटर उदाहरण मिला: sample8:126
ताज़ा इनपुट सत्यापित: True
ताज़ा इनपुट परीक्षण: 3

गलत उम्मीदवार ने 13 में से 0 मेल खाए, कुछ भी नहीं। क्योंकि गायब +1 हर परिणाम को स्थानांतरित करता है, कोरपस इसे हर जगह अस्वीकार करता है। एक सूक्ष्म बग आंशिक मेल पैदा करेगी, जो वास्तव में ऐसा संकेत है जो एक कोरपस को बाहर लाने में अच्छा है।

काउंटर उदाहरण ठोस है: इनपुट ['sample8', 18] को sample8:127 पैदा करना चाहिए क्योंकि 18 * 7 + 1 = 127, और उम्मीदवार ने sample8:126 produjo किया। यह एक डिकोड किया गया, क्रियाशील अंतर है बजाय एक बूलियन विफलता के।

ताज़ा-इनपुट जांच ने पूर्व कोरपस के बिना 3 इनपुट सत्यापित किए। Ghostwire ने उन मानों के लिए लाइव फ़ंक्शन को कॉल किया जो उसने कभी नहीं देखे, जो टाइमर द्वारा उत्पन्न नहीं किए गए किनारे मामलों को कवर करता है, जिसमें खाली स्ट्रिंग भी शामिल है।

ईमानदार सीमाएँ: Ghostwire और स्क्रेपिंग ब्राउज़र

Ghostwire वर्तमान में स्क्रेपलेस स्क्रेपिंग ब्राउज़र सत्र को संचालित नहीं कर सकता है, और कारण वास्तुशिल्प है न कि एक कॉन्फ़िगरेशन समस्या।

Browser.__init__ एक स्थानीय Chrome प्रक्रिया शुरू करता है --remote-debugging-pipe=JSON के साथ, बच्चे में दो फ़ाइल वर्णक्रमों को डुप्लीकेट करता है, और उन्हें PipeConnection को देता है। प्रत्येक प्रोटोकॉल संदेश उन वर्णक्रमों के माध्यम से बहता है। स्क्रेपिंग ब्राउज़र इसके बजाय एक दूरस्थ वेबस्कॉकेट एंडपॉइंट का प्रदर्शन करता है, और Ghostwire के पास इस पर बोलने के लिए कोई वेबस्कॉकेट परिवहन नहीं है।

Engine(browser=...) एक ब्राउज़र-नैतिक वस्तु को स्वीकार करता है, जो एक वास्तविक एक्सटेंशन सीम है - इस लेख का अपना धावक इसे कंटेनर-सेफ क्रोम ध्वज पास करने के लिए उपयोग करता है। लेकिन इसे एक दूरस्थ एंडपॉइंट पर पहुंचाने के लिए एक PipeConnection-अनुकूल वेबस्कॉकेट परिवहन के साथ-साथ जीवनचक्र परिवर्तनों की आवश्यकता होगी, क्योंकि Browser.close() मानता है कि इसका मालिक एक स्थानीय प्रक्रिया है जिसका वह अंत कर सकता है। यह कार्य अपस्ट्रीम में मौजूद नहीं है, इसलिए एक पुल को एक डिज़ाइन स्केच के रूप में मानें न कि एक समर्थित मार्ग के रूप में।

व्यावहारिक विभाजन साफ है। प्राधिकृत रनटाइम विश्लेषण के लिए Ghostwire को स्थानीय रूप से उपयोग करें। पैमाने पर डेटा संग्रहण के लिए ब्राउज़र-आधारित स्क्रेपिंग ब्राउज़र का उपयोग करें, जो Chrome DevTools Protocol अवलोकन कवर करता है।

समस्या निवारण

Chrome तुरंत बाहर निकलता है और पाइप टूट जाता है

cdp.py से BrokenPipeError का मतलब है कि Chrome लॉन्च के दौरान मर गया। कंटेनर में रूट के रूप में चलाना आमतौर पर इसका कारण होता है; --no-sandbox और --disable-dev-shm-usage के माध्यम से extra_flags पास करें।

CDPError: timeout: Page.navigate

नेविगेशन ने कनेक्शन की समय सीमा को पार कर लिया। Engine बनाते समय browser.cdp.default_timeout बढ़ाएँ। यहाँ वाले कंटेनर में, 127.0.0.1 पर पहला नेविगेशन लगभग 15 सेकंड लगा, जबकि localhost लगभग 0.1 सेकंड में हल हुआ, इसलिए केवल होस्ट नाम ने परिणाम को बदल दिया।

हुक कुछ भी कैप्चर नहीं करता

फंक्शन उस समय परिभाषित नहीं था जब हुक सेट किया गया था। पृष्ठ के शुरू होने की प्रतीक्षा करें, और पहले यह पुष्टि करें कि अभिव्यक्ति हल होती है typeof window.yourFunction का मूल्यांकन करके।

सत्यापन पास करता है लेकिन कोरपस बहुत छोटा है

कुछ जोड़े बहुत कम साबित करते हैं। सीमा का अधिक उपयोग करें, या fresh_inputs प्रदान करें जो उन किनारों को कवर करें जो अवलोकन किए गए ट्रैफ़िक ने कभी नहीं पहुंचा।

निष्कर्ष

कार्य जोड़ना आसान आधा है। वह आधा जो आपके काम करने के तरीके को बदलता है वह ओरेकल है, जो आपके फिर से कार्यान्वयन की जांच करता है दर्ज किए गए व्यवहार के खिलाफ और वह इनपुट वापस देता है जहां यह टूट गया। इस रन में वह इनपुट `['sample8', 18]` था, और उम्मीदवार असफल रहा क्योंकि उसने एकल `+1` को छोड़ दिया।

स्कोप को ईमानदार रखें। घोस्टवायर एक स्थानीय-क्रोम अनुसंधान उपकरण है उन सिस्टमों के लिए जिनका आप विश्लेषण करने के लिए अधिकृत हैं, और यह वर्तमान में दूरस्थ ब्राउज़र एंडपॉइंट्स से बात नहीं करता है।

[स्क्रैपलेस मुफ्त योजना पर शुरुआत करें](https://app.scrapeless.com/passport/login/?utm_source=website&utm_medium=blog&utm_campaign=scrapingbrowser&utm_term=ghostwire-browser-javascript-instrumentation) प्रबंधित ब्राउज़र डेटा संग्रहण के लिए, और [स्क्रैपलेस मूल्य निर्धारण की समीक्षा करें](https://www.scrapeless.com/hi/pricing?utm_source=website&utm_medium=blog&utm_campaign=scrapingbrowser&utm_term=ghostwire-browser-javascript-instrumentation) जब वह कार्यभार बढ़ता है।

## अक्सर पूछे जाने वाले प्रश्न

**प्रश्न: क्या घोस्टवायर वास्तव में ब्राउज़र के लिए फ्रिडा है?**

यह वही भूमिका निभाता है - लाइव रनटाइम उपकरणीकरण के बजाय स्थिर पढ़ाई - लेकिन कार्यान्वयन भिन्न होते हैं। फ्रिडा एक स्वदेशी प्रक्रिया में एक एजेंट इंजेक्ट करता है; घोस्टवायर क्रोम में एक डिबगर सत्र संलग्न करता है और कभी भी पृष्ठ में कोड नहीं रखता।

**प्रश्न: घोस्टवायर पाइप का उपयोग क्यों करता है न कि वेब-सॉकेट का?**

`--remote-debugging-pipe` एक डिबगिंग पोर्ट खोलने से बचता है जिसे पृष्ठ जावास्क्रिप्ट खोज सकती है, और यह कोर में एक वेब-सॉकेट निर्भरता की आवश्यकता को समाप्त करता है।

**प्रश्न: क्या किसी कार्य का हुक करना पृष्ठ को क्या देखता है में बदलाव करता है?**

सामान्य पहचान जांचों के लिए नहीं। हुक `Debugger.setBreakpointOnFunctionCall` के साथ लाइव वस्तु पर सेट किए जाते हैं, इसलिए वस्तु लपेटी नहीं जाती और `fn.toString()` अभी भी मूल स्रोत लौटाता है।

**प्रश्न: सत्यापन ओरेकल वास्तव में क्या साबित करता है?**

कि आपके उम्मीदवार ने हर परीक्षण किए गए इनपुट पर असली कार्य से मेल खाया। यह कवरेज द्वारा सीमित साक्ष्य है, न कि समानता का प्रमाण, इसलिए 12 जोड़ों के साथ एक पासिंग परिणाम का मतलब विस्तृत किनारे-केस कवरेज के साथ एक के मुकाबले कम है।

**प्रश्न: क्या घोस्टवायर स्क्रैपलेस स्क्रैपिंग ब्राउज़र से जुड़ सकता है?**

नहीं। घोस्टवायर 0.1.0 एक स्थानीय क्रोम को OS पाइप के माध्यम से लॉन्च और नियंत्रित करता है, जबकि स्क्रैपिंग ब्राउज़र एक दूरस्थ वेब-सॉकेट सीडीपी एंडपॉइंट को उजागर करता है। उन्हें ब्रिज करना एक वेब-सॉकेट परिवहन और दूरस्थ जीवनचक्र प्रबंधन की आवश्यकता होती है जो उपधारा प्रदान नहीं करता है।

**प्रश्न: क्या इसे किसी भी वेबसाइट के खिलाफ चलाना सुरक्षित है?**

नहीं। रनटाइम उपकरणीकरण को उन सिस्टमों तक सीमित होना चाहिए जो आपके पास हैं या जिनका परीक्षण करने के लिए आपके पास लिखित अनुमति है। लक्षित की शर्तों और <a href="https://datatracker.ietf.org/doc/html/rfc9309" rel="nofollow"><strong>रोबोट निर्देशों</strong></a> की समीक्षा करें, और तीसरे पक्ष के कोड का विश्लेषण करने से पहले कानूनी सलाह प्राप्त करें।