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 को टेक्स्ट फ़ाइल में सहेजें। यदि आप फ़ाइल नाम निर्दिष्ट नहीं करते हैं, तो एक डेटटाइमस्टैम्प वाली फ़ाइल उत्पन्न होगी।

लॉग सहेजें

--log [optional/path/to/file.log] - लॉग को निर्दिष्ट फ़ाइल में सहेजें। यदि आप फ़ाइल नाम निर्दिष्ट नहीं करते हैं, तो डिफ़ॉल्ट फ़ाइल pagodo.py.log का उपयोग pagodo निर्देशिका के मूल में किया जाएगा।

Google मुझे ब्लॉक कर रहा है!

जितनी जल्दी हो सके Google पर 7300+ खोज अनुरोध करना बस काम नहीं करेगा। Google उचित रूप से इसे एक बॉट के रूप में पहचानेगा और आपके IP को एक निश्चित अवधि के लिए ब्लॉक कर देगा। एक समाधान HTTP(S)/SOCKS प्रॉक्सी के बैंक का उपयोग करना और उन्हें pagodo में पास करना है।

मूल प्रॉक्सी समर्थन

-p स्विच का उपयोग करके pagodo को प्रॉक्सी की अल्पविराम से अलग की गई स्ट्रिंग पास करें।

python pagodo.py -g dorks.txt -p http://myproxy:8080,socks5h://127.0.0.1:9050,socks5h://127.0.0.1:9051

आप -i और -x मानों को भी कम कर सकते हैं क्योंकि आप विभिन्न प्रॉक्सी IP का लाभ उठा रहे होंगे। pagodo को पास किए गए प्रॉक्सी राउंड रॉबिन द्वारा चुने जाते हैं।

proxychains4 समर्थन

एक अन्य समाधान राउंड रॉबिन लुकअप के लिए proxychains4 का उपयोग करना है।

proxychains4 स्थापित करें

apt install proxychains4 -y

लुकअप को विभिन्न प्रॉक्सी सर्वरों के माध्यम से राउंड रॉबिन करने के लिए /etc/proxychains4.conf कॉन्फ़िगरेशन फ़ाइल को संपादित करें। नीचे दिए गए उदाहरण में, अलग-अलग स्थानीय लिसनिंग पोर्ट (9050 और 9051) के साथ 2 अलग-अलग डायनेमिक socks प्रॉक्सी स्थापित किए गए हैं।

vim /etc/proxychains4.conf

round_robin
chain_len = 1
proxy_dns
remote_dns_subnet 224
tcp_read_time_out 15000
tcp_connect_time_out 8000
[ProxyList]
socks4 127.0.0.1 9050
socks4 127.0.0.1 9051

pagodo.py स्क्रिप्ट के सामने proxychains4 रखें और प्रत्येक अनुरोध लुकअप एक अलग प्रॉक्सी (और इस प्रकार एक अलग IP से स्रोत) से गुज़रेगा।

proxychains4 python pagodo.py -g dorks/all_google_dorks.txt -o [optional/path/to/results.json] -s [optional/path/to/results.txt]

ध्यान दें कि यदि आप निम्न कार्य करते हैं तो यह Google को स्वाभाविक नहीं लग सकता है:

1. IP #1 से google.com पर "ब्राउज़" करने का अनुकरण करें
2. IP #2 से पहली खोज क्वेरी करें
3. IP #3 से दूसरी खोज क्वेरी करने के लिए "Next" पर क्लिक करने का अनुकरण करें
4. IP #1 से तीसरी खोज क्वेरी करने के लिए "Next" पर क्लिक करने का अनुकरण करें

इस कारण से, अंतर्निहित -p प्रॉक्सी समर्थन का उपयोग करना बेहतर है क्योंकि, जैसा कि yagooglesearch दस्तावेज़ीकरण में कहा गया है, "प्रदान किया गया प्रॉक्सी खोज के पूरे जीवनचक्र के लिए उपयोग किया जाता है ताकि यह अधिक मानवीय दिखे, बजाय खोज के विभिन्न भागों के लिए विभिन्न प्रॉक्सी के माध्यम से घूमने के।"

लाइसेंस

GNU General Public License v3.0 के तहत वितरित। अधिक जानकारी के लिए LICENSE देखें।

संपर्क

@opsdisk

प्रोजेक्ट लिंक: https://github.com/opsdisk/pagodo