pagodo - Dorking Pasivo de Google

Introducción

pagodo automatiza la búsqueda en Google de páginas web y aplicaciones potencialmente vulnerables en Internet. Reemplaza la realización manual de búsquedas de dorks de Google con un navegador web con interfaz gráfica.

Hay 2 partes. La primera es ghdb_scraper.py que recupera los últimos dorks de Google y la segunda parte es pagodo.py que aprovecha la información recopilada por ghdb_scraper.py.

La librería central de búsqueda de Google ahora utiliza yagooglesearch más flexible en lugar de googlesearch. Consulta el README de yagooglesearch para una explicación más profunda de las diferencias y capacidades de la librería.

Esta versión de pagodo también soporta nativamente aplicaciones HTTP(S) y SOCKS5, por lo que ya no es necesario envolverla en una herramienta como proxychains4 si necesitas soporte de proxy. Puedes especificar múltiples proxies para usar de forma round-robin proporcionando una cadena separada por comas de proxies usando el parámetro -p.

¿Qué son los Google dorks?

Offensive Security mantiene la Google Hacking Database (GHDB) que se encuentra aquí: https://www.exploit-db.com/google-hacking-database. Es una colección de búsquedas de Google, llamadas dorks, que se pueden usar para encontrar equipos potencialmente vulnerables u otra información jugosa que es recogida por los bots de búsqueda de Google.

Términos y Condiciones

Los términos y condiciones de pagodo son los mismos términos y condiciones que se encuentran en yagooglesearch.

Este código se proporciona tal cual y eres totalmente responsable de cómo se utiliza. Hacer scraping de los resultados de búsqueda de Google puede violar sus Términos de Servicio. Otra librería de búsqueda de Google en Python tenía información/discusión interesante al respecto:

• Problema original
• Una respuesta
• El autor creó un Términos y Condiciones separado
• ...que contenía un enlace a este blog

El método preferido de Google es utilizar su API.

Instalación

Los scripts están escritos para Python 3.6+. Clona el repositorio git e instala los requisitos.

git clone https://github.com/opsdisk/pagodo.git
cd pagodo
python3 -m venv .venv  # Si se usa un entorno virtual.
source .venv/bin/activate  # Si se usa un entorno virtual.
pip install --upgrade pip setuptools
pip install -r requirements.txt

ghdb_scraper.py

Para empezar, pagodo.py necesita una lista de todos los dorks de Google actuales. El repositorio contiene un directorio dorks/ con los dorks actuales cuando se ejecutó ghdb_scraper.py por última vez. Se recomienda ejecutar ghdb_scraper.py para obtener los datos más recientes antes de ejecutar pagodo.py. El directorio dorks/ contiene:

• el archivo all_google_dorks.txt que contiene todos los dorks de Google, uno por línea
• el archivo all_google_dorks.json que es la respuesta JSON de GHDB
• Dorks de categorías individuales

Categorías de dorks:

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

Usando ghdb_scraper.py como script

Escribe todos los dorks en all_google_dorks.txt, all_google_dorks.json y categorías individuales si deseas más datos contextuales sobre cada dork.

python ghdb_scraper.py -s -j -i

Usando ghdb_scraper como módulo

La función ghdb_scraper.retrieve_google_dorks() devuelve un diccionario con la siguiente estructura de datos:

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

Usando un shell de Python (como python o ipython) para explorar los datos:

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

Usando pagodo.py como script

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

Usando pagodo como módulo

La función pagodo.Pagodo.go() devuelve un diccionario con la estructura de datos a continuación (los dorks utilizados son ejemplos inventados):

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

Usando un shell de Python (como python o ipython) para explorar los datos:

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)

Ajuste de Resultados

Alcance a un dominio específico

El parámetro -d se puede usar para limitar los resultados a un dominio específico y funciona como el operador de búsqueda de Google:

site:github.com

Tiempo de espera entre búsquedas de dorks de Google

• -i - Especifica la demora mínima entre búsquedas de dorks, en segundos. No lo hagas demasiado pequeño, o tu IP recibirá un HTTP 429 rápidamente.
• -x - Especifica la demora máxima entre búsquedas de dorks, en segundos. No lo hagas demasiado grande o las búsquedas llevarán mucho tiempo.

Los valores proporcionados por -i y -x se utilizan para generar una lista de 20 tiempos de espera aleatorios, que se seleccionan aleatoriamente entre cada búsqueda de dork de Google diferente.

Número de resultados a devolver

-m - El número máximo total de resultados de búsqueda a devolver por dork de Google. Cada solicitud de búsqueda de Google puede devolver como máximo 100 resultados a la vez, por lo que si eliges -m 500, se tendrán que hacer 5 consultas de búsqueda separadas por cada búsqueda de dork de Google, lo que aumentará la cantidad de tiempo para completar.

Guardar salida

-o [ruta opcional para results.json] - Guarda la salida en un archivo JSON. Si no especificas un nombre de archivo, se generará uno con marca de fecha y hora.

-s [ruta opcional para results.txt] - Guarda las URL en un archivo de texto. Si no especificas un nombre de archivo, se generará uno con marca de fecha y hora.

Guardar registros

--log [ruta opcional para file.log] - Guarda los registros en el archivo especificado. Si no especificas un nombre de archivo, se usará el archivo predeterminado pagodo.py.log en la raíz del directorio de pagodo.

¡Google me está bloqueando!

Realizar más de 7300 solicitudes de búsqueda a Google lo más rápido posible simplemente no funcionará. Google lo detectará legítimamente como un bot y bloqueará tu IP por un período de tiempo determinado. Una solución es usar un grupo de proxies HTTP(S)/SOCKS y pasarlos a pagodo

Soporte nativo de proxy

Pasa una cadena separada por comas de proxies a pagodo usando el parámetro -p.

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

Incluso podrías disminuir los valores de -i y -x porque estarás aprovechando diferentes IPs de proxy. Los proxies pasados a pagodo se seleccionan por round robin.

Soporte de proxychains4

Otra solución es usar proxychains4 para hacer round robin de las consultas.

Instala proxychains4

apt install proxychains4 -y

Edita el archivo de configuración /etc/proxychains4.conf para hacer round robin de las consultas a través de diferentes servidores proxy. En el ejemplo a continuación, se han configurado 2 proxies socks dinámicos diferentes con puertos de escucha locales diferentes (9050 y 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

Pon proxychains4 delante del script pagodo.py y cada consulta request pasará por un proxy diferente (y por lo tanto se originará desde una IP diferente).

proxychains4 python pagodo.py -g dorks/all_google_dorks.txt -o [ruta opcional para results.json] -s [ruta opcional para results.txt]

Ten en cuenta que esto puede no parecer natural para Google si:

1. Simulas "navegar" a google.com desde la IP #1
2. Realizas la primera consulta de búsqueda desde la IP #2
3. Simulas hacer clic en "Siguiente" para hacer la segunda consulta de búsqueda desde la IP #3
4. Simulas hacer clic en "Siguiente" para hacer la tercera consulta de búsqueda desde la IP #1

Por esa razón, se prefiere usar el soporte de proxy -p incorporado porque, como se indica en la documentación de yagooglesearch, "el proxy proporcionado se utiliza durante todo el ciclo de vida de la búsqueda para hacerla parecer más humana, en lugar de rotar a través de varios proxies para diferentes partes de la búsqueda".

Licencia

Distribuido bajo la Licencia Pública General de GNU v3.0. Consulta LICENSE para más información.

Contacto

@opsdisk

Enlace del proyecto: https://github.com/opsdisk/pagodo