pagodo - निष्क्रिय Google Dork

परिचय

pagodo इंटरनेट पर संभावित रूप से कमजोर वेब पेजों और एप्लिकेशनों की खोज के लिए Google खोज को स्वचालित करता है। यह मैन्युअल रूप से वेब GUI ब्राउज़र के साथ Google dork खोज करने के स्थान पर काम करता है।

इसमें 2 भाग हैं। पहला भाग ghdb_scraper.py है जो नवीनतम Google dorks प्राप्त करता है और दूसरा भाग pagodo.py है जो ghdb_scraper.py द्वारा एकत्रित जानकारी का उपयोग करता है।

कोर Google खोज लाइब्रेरी अब अधिक लचीले yagooglesearch का उपयोग करती है, googlesearch के बजाय। लाइब्रेरी के अंतर और क्षमताओं की गहन व्याख्या के लिए yagooglesearch README देखें।

pagodo का यह संस्करण मूल HTTP(S) और SOCKS5 एप्लिकेशन समर्थन भी प्रदान करता है, इसलिए यदि आपको प्रॉक्सी समर्थन की आवश्यकता है तो इसे proxychains4 जैसे टूल में लपेटने की आवश्यकता नहीं है। आप -p स्विच का उपयोग करके प्रॉक्सी की अल्पविराम से अलग की गई स्ट्रिंग प्रदान करके राउंड-रॉबिन फैशन में उपयोग करने के लिए कई प्रॉक्सी निर्दिष्ट कर सकते हैं।

Google dorks क्या हैं?

Offensive Security Google Hacking Database (GHDB) का रखरखाव करता है, जो यहाँ पाया जाता है: https://www.exploit-db.com/google-hacking-database। यह Google खोजों का एक संग्रह है, जिसे dorks कहा जाता है, जिसका उपयोग संभावित रूप से कमजोर बक्से या अन्य रसदार जानकारी खोजने के लिए किया जा सकता है जो Google के खोज बॉट्स द्वारा उठाई जाती है।

नियम और शर्तें

pagodo के नियम और शर्तें वही हैं जो yagooglesearch में पाए जाते हैं।

यह कोड "जैसा है" प्रदान किया जाता है और इसके उपयोग के लिए आप पूरी तरह से जिम्मेदार हैं। Google खोज परिणामों को स्क्रैप करना उनकी सेवा की शर्तों का उल्लंघन कर सकता है। एक अन्य Python Google खोज लाइब्रेरी में इस पर कुछ रोचक जानकारी/चर्चा थी:

मूल मुद्दा
एक प्रतिक्रिया
लेखक ने एक अलग नियम और शर्तें बनाई
...जिसमें इस ब्लॉग का लिंक था

Google की पसंदीदा विधि उनके API का उपयोग करना है।

स्थापना

स्क्रिप्ट Python 3.6+ के लिए लिखी गई हैं। git रिपॉजिटरी को क्लोन करें और आवश्यकताओं को स्थापित करें।

git clone https://github.com/opsdisk/pagodo.git
cd pagodo
python3 -m venv .venv  # यदि वर्चुअल वातावरण का उपयोग कर रहे हैं।
source .venv/bin/activate  # यदि वर्चुअल वातावरण का उपयोग कर रहे हैं।
pip install --upgrade pip setuptools
pip install -r requirements.txt

ghdb_scraper.py

शुरू करने के लिए, pagodo.py को सभी वर्तमान Google dorks की एक सूची की आवश्यकता होती है। रिपॉजिटरी में dorks/ निर्देशिका है जिसमें ghdb_scraper.py अंतिम बार चलाए जाने पर वर्तमान dorks हैं। pagodo.py चलाने से पहले नवीनतम डेटा प्राप्त करने के लिए ghdb_scraper.py चलाने की सलाह दी जाती है। dorks/ निर्देशिका में शामिल हैं:

all_google_dorks.txt फ़ाइल जिसमें सभी Google dorks हैं, प्रति पंक्ति एक
all_google_dorks.json फ़ाइल जो GHDB से JSON प्रतिक्रिया है
व्यक्तिगत श्रेणी dorks

Dork श्रेणियाँ:

categories = {
    1: "Footholds",
    2: "File Containing Usernames",
    3: "Sensitives Directories",
    4: "Web Server Detection",
    5: "Vulnerable Files",
    6: "Vulnerable Servers",
    7: "Error Messages",
    8: "File Containing Juicy Info",
    9: "File Containing Passwords",
    10: "Sensitive Online Shopping Info",
    11: "Network or Vulnerability Data",
    12: "Pages Containing Login Portals",
    13: "Various Online devices",
    14: "Advisories and Vulnerabilities",
}

ghdb_scraper.py को स्क्रिप्ट के रूप में उपयोग करना

सभी dorks को all_google_dorks.txt, all_google_dorks.json, और यदि आप प्रत्येक dork के बारे में अधिक प्रासंगिक डेटा चाहते हैं तो व्यक्तिगत श्रेणियों में लिखें।

python ghdb_scraper.py -s -j -i

ghdb_scraper को मॉड्यूल के रूप में उपयोग करना

ghdb_scraper.retrieve_google_dorks() फ़ंक्शन निम्नलिखित डेटा संरचना के साथ एक शब्दकोश लौटाता है:

ghdb_dict = {
    "total_dorks": total_dorks,
    "extracted_dorks": extracted_dorks,
    "category_dict": category_dict,
}

डेटा का पता लगाने के लिए Python शेल (जैसे python या ipython) का उपयोग करना:

import ghdb_scraper

dorks = ghdb_scraper.retrieve_google_dorks(save_all_dorks_to_file=True)
dorks.keys()
dorks["total_dorks"]

dorks["extracted_dorks"]

dorks["category_dict"].keys()

dorks["category_dict"][1]["category_name"]

pagodo.py

pagodo.py को स्क्रिप्ट के रूप में उपयोग करना

python pagodo.py -d example.com -g dorks.txt

pagodo को मॉड्यूल के रूप में उपयोग करना

pagodo.Pagodo.go() फ़ंक्शन नीचे दी गई डेटा संरचना के साथ एक शब्दकोश लौटाता है (उपयोग किए गए dorks काल्पनिक उदाहरण हैं):

{
    "dorks": {
        "inurl:admin": {
            "urls_size": 3,
            "urls": [
                "https://github.com/marmelab/ng-admin",
                "https://github.com/settings/admin",
                "https://github.com/akveo/ngx-admin",
            ],
        },
        "inurl:gist": {
            "urls_size": 3,
            "urls": [
                "https://gist.github.com/",
                "https://gist.github.com/index",
                "https://github.com/defunkt/gist",
            ],
        },
    },
    "initiation_timestamp": "2021-08-27T11:35:30.638705",
    "completion_timestamp": "2021-08-27T11:36:42.349035",
}

डेटा का पता लगाने के लिए Python शेल (जैसे python या ipython) का उपयोग करना:

import pagodo

pg = pagodo.Pagodo(
    google_dorks_file="dorks.txt",
    domain="github.com",
    max_search_result_urls_to_return_per_dork=3,
    save_pagodo_results_to_json_file=None,  # None = फ़ाइल नाम स्वतः उत्पन्न, अन्यथा पथ और फ़ाइल नाम के लिए स्ट्रिंग पास करें।
    save_urls_to_file=None,  # None = फ़ाइल नाम स्वतः उत्पन्न, अन्यथा पथ और फ़ाइल नाम के लिए स्ट्रिंग पास करें।
    verbosity=5,
)
pagodo_results_dict = pg.go()

pagodo_results_dict.keys()

pagodo_results_dict["initiation_timestamp"]

pagodo_results_dict["completion_timestamp"]

for key,value in pagodo_results_dict["dorks"].items():
    print(f"dork: {key}")
    for url in value["urls"]:
        print(url)

परिणामों को ट्यून करना

किसी विशिष्ट डोमेन तक सीमित करना

-d स्विच का उपयोग परिणामों को किसी विशिष्ट डोमेन तक सीमित करने के लिए किया जा सकता है और यह Google खोज ऑपरेटर के रूप में कार्य करता है:

site:github.com

Google dork खोजों के बीच प्रतीक्षा समय

-i - Dork खोजों के बीच न्यूनतम विलंब निर्दिष्ट करें, सेकंड में। इसे बहुत छोटा न करें, अन्यथा आपका IP जल्दी HTTP 429 प्राप्त करेगा।
-x - Dork खोजों के बीच अधिकतम विलंब निर्दिष्ट करें, सेकंड में। इसे बहुत बड़ा न करें अन्यथा खोजों में लंबा समय लगेगा।

-i और -x द्वारा प्रदान किए गए मानों का उपयोग 20 यादृच्छिक प्रतीक्षा समय की एक सूची उत्पन्न करने के लिए किया जाता है, जो प्रत्येक अलग Google dork खोज के बीच यादृच्छिक रूप से चुने जाते हैं।

लौटाने के लिए परिणामों की संख्या

-m - प्रति Google dork लौटाए जाने वाले कुल अधिकतम खोज परिणाम। प्रत्येक Google खोज अनुरोध एक बार में अधिकतम 100 परिणाम प्राप्त कर सकता है, इसलिए यदि आप -m 500 चुनते हैं, तो प्रत्येक Google dork खोज के लिए 5 अलग-अलग खोज क्वेरी करनी होंगी, जिससे पूरा होने का समय बढ़ जाएगा।

आउटपुट सहेजें

-o [optional/path/to/results.json] - आउटपुट को JSON फ़ाइल में सहेजें। यदि आप फ़ाइल नाम निर्दिष्ट नहीं करते हैं, तो एक डेटटाइमस्टैम्प वाली फ़ाइल उत्पन्न होगी।

-s [optional/path/to/results.txt] - URL को टेक्स्ट फ़ाइल में सहेजें। यदि आप फ़ाइल नाम निर्दिष्ट नहीं करते हैं, तो एक डेटटाइमस्टैम्प वाली फ़ाइल उत्पन्न होगी।

pagodo

सबसे लोकप्रिय