pagodo - Google Dork Passivo

Introduzione

pagodo automatizza la ricerca su Google di pagine web e applicazioni potenzialmente vulnerabili su Internet. Sostituisce l'esecuzione manuale delle ricerche Google dork con un browser GUI web.

Ci sono 2 parti. La prima è ghdb_scraper.py che recupera gli ultimi Google dork, e la seconda parte è pagodo.py che sfrutta le informazioni raccolte da ghdb_scraper.py.

La libreria principale di ricerca Google ora utilizza yagooglesearch più flessibile al posto di googlesearch. Consulta il README di yagooglesearch per una spiegazione più approfondita delle differenze e delle capacità delle librerie.

Questa versione di pagodo supporta anche nativamente HTTP(S) e SOCKS5, quindi non è più necessario avvolgerlo in uno strumento come proxychains4 se hai bisogno del supporto proxy. Puoi specificare più proxy da utilizzare in modo round-robin fornendo una stringa separata da virgole di proxy usando l'opzione -p.

Cosa sono i Google dork?

Offensive Security mantiene il Google Hacking Database (GHDB) che si trova qui: https://www.exploit-db.com/google-hacking-database. È una raccolta di ricerche Google, chiamate dork, che possono essere utilizzate per trovare macchine potenzialmente vulnerabili o altre informazioni interessanti catturate dai bot di ricerca di Google.

Termini e Condizioni

I termini e le condizioni per pagodo sono gli stessi termini e condizioni presenti in yagooglesearch.

Questo codice è fornito così com'è e sei pienamente responsabile di come viene utilizzato. Lo scraping dei risultati di ricerca di Google potrebbe violare i loro Termini di Servizio. Un'altra libreria Python di ricerca Google ha avuto alcune informazioni/discussioni interessanti a riguardo:

• Problema originale
• Una risposta
• L'autore ha creato dei Termini e Condizioni separati
• ...che conteneva un link a questo blog

Il metodo preferito di Google è utilizzare la loro API.

Installazione

Gli script sono scritti per Python 3.6+. Clona il repository git e installa i requisiti.

git clone https://github.com/opsdisk/pagodo.git
cd pagodo
python3 -m venv .venv  # If using a virtual environment.
source .venv/bin/activate  # If using a virtual environment.
pip install --upgrade pip setuptools
pip install -r requirements.txt

ghdb_scraper.py

Per iniziare, pagodo.py ha bisogno di un elenco di tutti i Google dork attuali. Il repository contiene una directory dorks/ con i dork correnti al momento dell'ultima esecuzione di ghdb_scraper.py. Si consiglia di eseguire ghdb_scraper.py per ottenere i dati più aggiornati prima di eseguire pagodo.py. La directory dorks/ contiene:

• il file all_google_dorks.txt che contiene tutti i Google dork, uno per riga
• il file all_google_dorks.json che è la risposta JSON da GHDB
• Dork di categoria individuali

Categorie di 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",
}

Utilizzare ghdb_scraper.py come script

Scrive tutti i dork in all_google_dorks.txt, all_google_dorks.json e categorie individuali se si desiderano più dati contestuali su ogni dork.

python ghdb_scraper.py -s -j -i

Utilizzare ghdb_scraper come modulo

La funzione ghdb_scraper.retrieve_google_dorks() restituisce un dizionario con la seguente struttura dati:

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

Utilizzando una shell Python (come python o ipython) per esplorare i dati:

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

Utilizzare pagodo.py come script

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

Utilizzare pagodo come modulo

La funzione pagodo.Pagodo.go() restituisce un dizionario con la struttura dati di seguito (i dork usati sono esempi fittizi):

{
    "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",
}

Utilizzando una shell Python (come python o ipython) per esplorare i dati:

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 = Auto-generate file name, otherwise pass a string for path and filename.
    save_urls_to_file=None,  # None = Auto-generate file name, otherwise pass a string for path and filename.
    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)

Ottimizzazione dei risultati

Limitare a un dominio specifico

L'opzione -d può essere utilizzata per limitare i risultati a un dominio specifico e funge da operatore di ricerca Google:

site:github.com

Tempo di attesa tra le ricerche di Google dork

• -i - Specifica il ritardo minimo tra le ricerche di dork, in secondi. Non renderlo troppo piccolo, altrimenti il tuo IP verrà HTTP 429 rapidamente.
• -x - Specifica il ritardo massimo tra le ricerche di dork, in secondi. Non renderlo troppo grande altrimenti le ricerche richiederanno molto tempo.

I valori forniti da -i e -x vengono utilizzati per generare una lista di 20 tempi di attesa casuali, che vengono selezionati casualmente tra ogni diversa ricerca di Google dork.

Numero di risultati da restituire

-m - Il numero massimo totale di risultati di ricerca da restituire per Google dork. Ogni richiesta di ricerca Google può recuperare al massimo 100 risultati alla volta, quindi se scegli -m 500, dovranno essere effettuate 5 query di ricerca separate per ogni ricerca di Google dork, il che aumenterà il tempo necessario per completare.

Salva output

• -o [percorso/opzionale/a/results.json] - Salva l'output in un file JSON. Se non specifichi un nome file, ne verrà generato uno con data e ora.
• -s [percorso/opzionale/a/results.txt] - Salva gli URL in un file di testo. Se non specifichi un nome file, ne verrà generato uno con data e ora.

Salva log

• --log [percorso/opzionale/a/file.log] - Salva i log nel file specificato. Se non specifichi un nome file, verrà utilizzato il file predefinito pagodo.py.log nella radice della directory di pagodo.

Google mi sta bloccando!

Effettuare più di 7300 richieste di ricerca a Google il più velocemente possibile semplicemente non funzionerà. Google lo rileverà giustamente come un bot e bloccherà il tuo IP per un periodo di tempo prestabilito. Una soluzione è quella di utilizzare un pool di proxy HTTP(S)/SOCKS e passarli a pagodo.

Supporto proxy nativo

Passa una stringa separata da virgole di proxy a pagodo usando l'opzione -p.

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

Potresti anche diminuire i valori di -i e -x perché sfrutterai diversi IP proxy. I proxy passati a pagodo vengono selezionati in round robin.

Supporto proxychains4

Un'altra soluzione è utilizzare proxychains4 per fare round robin delle ricerche.

Installa proxychains4

apt install proxychains4 -y

Modifica il file di configurazione /etc/proxychains4.conf per fare round robin delle ricerche attraverso diversi server proxy. Nell'esempio seguente, sono stati configurati 2 proxy socks dinamici diversi con porte di ascolto locali diverse (9050 e 9051).

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

Metti proxychains4 davanti allo script pagodo.py e ogni richiesta di ricerca passerà attraverso un proxy diverso (quindi proveniente da un IP diverso).

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

Nota che questo potrebbe non sembrare naturale a Google se:

1. Simuli la "navigazione" verso google.com dall'IP #1
2. Effettui la prima query di ricerca dall'IP #2
3. Simuli il clic su "Avanti" per effettuare la seconda query dall'IP #3
4. Simuli il clic su "Avanti per effettuare la terza query dall'IP #1

Per questo motivo, è preferibile utilizzare il supporto proxy integrato -p perché, come indicato nella documentazione di yagooglesearch, il "proxy fornito viene utilizzato per l'intero ciclo di vita della ricerca per renderla più umana, invece di ruotare attraverso vari proxy per diverse parti della ricerca."

Licenza

Distribuito sotto la GNU General Public License v3.0. Vedi LICENSE per maggiori informazioni.

Contatti

@opsdisk

Link del progetto: https://github.com/opsdisk/pagodo