Busca por Urls com dalfox e GAU | Script automatizados | Solyd One

Busca por Urls com dalfox e GAU | Script automatizados | Solyd One

Dependências para executar

O script usa três ferramentas principais:

gau — coleta URLs históricas / archive / Common Crawl. Instalação recomendada via go install ou binários. ([GitHub][1])
gf — filtra URLs por patterns (padrões de vulnerabilidades). Instalação via go install e patterns em ~/.gf. ([GitHub][2])
dalfox — scanner de XSS / gerador de POC. Instalação via Homebrew / Snap / go install. ([GitHub][3])

Instalação (passo a passo)

Ter o Go instalado (se ainda não tiver)

Exemplos:

Debian/Ubuntu:

sudo apt update
sudo apt install -y golang-go git

Fedora / CentOS (dnf/yum):

sudo dnf install -y golang git   # ou yum em distros antigas

Arch:

sudo pacman -Syu go git

macOS (Homebrew):

brew install go git

Depois verifique: go version

Instalar `gau`, `gf` e `dalfox` (recomendado — via `go install`)

gau

go install github.com/lc/gau/v2/cmd/gau@latest

(O binário ficará em $(go env GOPATH)/bin, normalmente ~/go/bin — adicione ao PATH se necessário.) ([GitHub][1])

gf (ferramenta)

go install github.com/tomnomnom/gf@latest

Depois mova/copie o binário para um diretório no PATH se necessário, ou adicione $(go env GOPATH)/bin ao PATH. ([GitHub][2])

dalfox

go install github.com/hahwul/dalfox/v2@latest

Também é possível instalar via Homebrew (brew install dalfox) ou snap (sudo snap install dalfox). ([GitHub][3])

Instalar / configurar os patterns do `gf` (recomendado)

É prático ter um conjunto de patterns (~/.gf) para usar o -v all ou padrões comuns.

Exemplo (usar um repositório conhecido de patterns e copiá-los para ~/.gf):

# clonar um repositório de patterns (exemplos públicos)
git clone https://github.com/1ndianl33t/Gf-Patterns.git ~/Gf-Patterns

# criar ~/.gf e copiar os jsons
mkdir -p ~/.gf
cp ~/Gf-Patterns/*.json ~/.gf

# (opcional) remover o clone local se quiser
rm -rf ~/Gf-Patterns

Assim gf xss passará a funcionar com o padrão xss definido. ([GitHub][4])

Ajustando o PATH (se necessário)

Se os binários foram instalados em ~/go/bin, adicione ao seu ~/.bashrc / ~/.zshrc:

export PATH="$PATH:$(go env GOPATH)/bin"
# ou explicitamente:
export PATH="$PATH:$HOME/go/bin"

Depois recarregue o shell: source ~/.bashrc ou exec $SHELL.

Testando as ferramentas (após instalação)

gau --version
gf -h
dalfox version

Se qualquer comando não for encontrado, confirme se $(go env GOPATH)/bin está no PATH e se a instalação do go install foi executada sem erros.

Como usar

# tornar o script executável
chmod +x gau_dalfox_gf_scan.sh

# executar (exemplo básico)
./gau_dalfox_gf_scan.sh -i ./pastas-com-subdominios -o ./resultados-xss

# executar pedindo múltiplos patterns (ex.: xss e lfi) e usando pasta de saída customizada
./gau_dalfox_gf_scan.sh -i ./pastas-com-subdominios -o ./resultados-xss -v xss,lfi

# executar somente coleta + gf (não roda dalfox)
./gau_dalfox_gf_scan.sh -i ./pastas-com-subdominios --no-dalfox

Estrutura de pasta esperada de entrada

./pastas-com-subdominios/
├── exemplo1.com.txt    # cada linha: um subdomínio/host (ex: sub.exemplo1.com)
├── exemplo2.org.txt

Arquivos gerados (pasta de saída padrão ./resultados-xss ou o que você passar com -o):

exemplo1.com_urls.txt — todas as URLs coletadas pelo gau (únicas, ordenadas)
exemplo1.com_xss_urls.txt — URLs filtradas pelo gf para o pattern xss
exemplo1.com_xss_xss.txt — saída do dalfox para as URLs filtradas (nome seguindo o padrão do script)

Script gerado por IA

#!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'

# gau_dalfox_gf_scan.sh
# Lê subdomínios de arquivos contidos em pastas e executa gau + opcionalmente gf + dalfox

print_usage() {
  cat <<EOF
Uso: $0 -i PASTA_SUBDOMINIOS [-o PASTA_SAIDA] [-v VULNS] [--no-dalfox] [-h]

Opções:
  -i PASTA_SUBDOMINIOS   Caminho para pasta com arquivos de subdomínios (ex: ./targets)
  -o PASTA_SAIDA         Pasta onde salvar os resultados (default: ./xss-results)
  -v VULNS               Vulnerabilidade(s) para filtrar com gf (ex: xss,lfi).
                         Use 'all' para tentar todos os patterns disponíveis.
                         Se omitido, usa padrão: xss
  --no-dalfox            Não executar dalfox (apenas coletar URLs e aplicar gf)
  -h                     Mostrar esta ajuda

Exemplos:
  $0 -i ./targets -v xss
  $0 -i ./targets -v xss,lfi -o ./out
  $0 -i ./targets --no-dalfox
EOF
}

# Defaults
INPUT_DIR=""
OUTPUT_DIR="./xss-results"
VULNS=""
RUN_DALFOX=1

# parse args (supports --no-dalfox)
while [[ $# -gt 0 ]]; do
  case "$1" in
    -i) INPUT_DIR="$2"; shift 2 ;;
    -o) OUTPUT_DIR="$2"; shift 2 ;;
    -v) VULNS="$2"; shift 2 ;;
    --no-dalfox) RUN_DALFOX=0; shift ;;
    -h) print_usage; exit 0 ;;
    *) echo "[ERRO] Option inválida: $1"; print_usage; exit 1 ;;
  esac
done

if [[ -z "$INPUT_DIR" ]]; then
  echo "[ERRO] Pasta de subdomínios é obrigatória."
  print_usage
  exit 1
fi

# Verifica dependências
for tool in gau dalfox; do
  if ! command -v "$tool" &>/dev/null; then
    echo "[ERRO] Ferramenta '$tool' não encontrada. Instale antes de continuar."
    exit 1
  fi
done

GF_AVAILABLE=0
if command -v gf &>/dev/null; then
  GF_AVAILABLE=1
fi

mkdir -p "$OUTPUT_DIR"

# Lista padrão de patterns caso gf não esteja disponível ou --vulns poda não ser informada
DEFAULT_PATTERNS=(xss)

# Se VULNS vazio, default para xss
if [[ -z "$VULNS" ]]; then
  VULNS="xss"
fi

# Função para obter lista de patterns quando user pede 'all'
get_all_gf_patterns() {
  # Prioriza ~/.gf directory (padrão do repositório gf)
  if [[ -d "${HOME}/.gf" ]]; then
    # Remover sufixos .json se existirem
    ls "${HOME}/.gf" 2>/dev/null | sed -E 's/\.json$//' | tr '\n' ',' | sed 's/,$//'
    return
  fi

  # se existe /usr/share/gf ou similar (tentativa genérica)
  if [[ -d "/usr/share/gf" ]]; then
    ls /usr/share/gf 2>/dev/null | sed -E 's/\.json$//' | tr '\n' ',' | sed 's/,$//'
    return
  fi

  # fallback para lista conhecida
  echo "xss,lfi,sqli,ssrf,rce,redirect,openredirect,idor,ssti"
}

# Constrói array de patterns que vamos usar
IFS=',' read -r -a REQ_PATTERNS <<< "$VULNS"
PATTERNS=()

if [[ "${REQ_PATTERNS[0]}" == "all" ]]; then
  if [[ "$GF_AVAILABLE" -eq 1 ]]; then
    # tenta extrair da pasta ~/.gf se estiver lá
    if [[ -d "${HOME}/.gf" ]]; then
      while read -r p; do
        [[ -z "$p" ]] && continue
        PATTERNS+=("$p")
      done < <(ls "${HOME}/.gf" 2>/dev/null | sed -E 's/\.json$//')
    else
      # fallback para get_all_gf_patterns
      IFS=',' read -r -a PATTERNS <<< "$(get_all_gf_patterns)"
    fi
  else
    # gf não disponível -> usar fallback lista curta
    IFS=',' read -r -a PATTERNS <<< "$(get_all_gf_patterns)"
    echo "[WARN] 'gf' não encontrado; usando lista padrão de patterns para nomes de arquivo (filtragem gf será ignorada)."
  fi
else
  # usar o que usuário pediu explicitamente
  for p in "${REQ_PATTERNS[@]}"; do
    p_trimmed="$(echo "$p" | xargs)"  # trim
    [[ -z "$p_trimmed" ]] && continue
    PATTERNS+=("$p_trimmed")
  done
fi

echo "[INFO] Patterns a usar: ${PATTERNS[*]}"
if [[ "$GF_AVAILABLE" -eq 0 ]]; then
  echo "[INFO] Observação: 'gf' não está instalado — a filtragem por pattern será ignorada, mas urls serão coletadas."
fi

echo "[INFO] Iniciando análise com gau + gf + dalfox..."
for file in "$INPUT_DIR"/*; do
  [[ -f "$file" ]] || continue
  filename=$(basename "$file")
  domain_name="${filename%.*}"
  echo "[*] Processando arquivo: $filename"

  urls_file="$OUTPUT_DIR/${domain_name}_urls.txt"

  # Executa gau para cada subdomínio
  echo "[INFO] Executando gau para subdomínios em $filename..."
  # coletar todas as urls (não falhar se gau falhar em algum)
  (
    while read -r subdomain; do
      [[ -z "$subdomain" ]] && continue
      # prevenir que gau imprima erros que interrompam o pipeline
      gau "$subdomain" || true
    done < "$file"
  ) | sort -u > "$urls_file"

  echo "[INFO] URLs salvas em: $urls_file (total: $(wc -l < "$urls_file"))"

  # Se gf não disponível ou nenhuma pattern especificada, só roda dalfox no arquivo completo
  if [[ "$GF_AVAILABLE" -eq 0 ]]; then
    if [[ "$RUN_DALFOX" -eq 1 ]]; then
      xss_output_file="$OUTPUT_DIR/${domain_name}_xss.txt"
      echo "[INFO] Executando dalfox em todas as URLs (gf ausente)..."
      dalfox file "$urls_file" --silence --only-poc --output "$xss_output_file"
      echo "[✓] dalfox finalizado para $domain_name -> $xss_output_file"
    else
      echo "[INFO] --no-dalfox especificado; pulando execução do dalfox."
    fi
    continue
  fi

  # Para cada pattern: filtrar com gf e rodar dalfox
  for pattern in "${PATTERNS[@]}"; do
    [[ -z "$pattern" ]] && continue
    filtered_urls_file="$OUTPUT_DIR/${domain_name}_${pattern}_urls.txt"
    xss_output_file="$OUTPUT_DIR/${domain_name}_${pattern}_xss.txt"

    echo "[INFO] Filtrando com gf pattern='$pattern'..."
    # gf lê da stdin: cat file | gf pattern
    # Se o pattern não existir no ~/.gf, gf retornará erro; para evitar falha, verificamos antes:
    if gf -h >/dev/null 2>&1; then
      # Tentar filtrar. Se o pattern não existir, gf retorna não-zero; capturamos isso e criamos arquivo vazio.
      if ! cat "$urls_file" | gf "$pattern" | sort -u > "$filtered_urls_file" 2>/dev/null; then
        echo "[WARN] Pattern gf '$pattern' não existe ou não retornou resultados. Arquivo: $filtered_urls_file (vazio)."
        : > "$filtered_urls_file"
      fi
    else
      echo "[WARN] gf aparentemente não funcional — pulando pattern '$pattern'."
      : > "$filtered_urls_file"
    fi

    echo "[INFO] URLs filtradas para pattern '$pattern' salvas em: $filtered_urls_file (total: $(wc -l < "$filtered_urls_file"))"

    # Se não houver urls filtradas, pular dalfox
    if [[ "$(wc -l < "$filtered_urls_file")" -eq 0 ]]; then
      echo "[INFO] Nenhuma URL para pattern '$pattern' — pulando dalfox para esse pattern."
      continue
    fi

    if [[ "$RUN_DALFOX" -eq 1 ]]; then
      echo "[INFO] Executando dalfox para pattern '$pattern'..."
      dalfox file "$filtered_urls_file" --silence --only-poc --output "$xss_output_file"
      echo "[✓] dalfox finalizado para $domain_name pattern '$pattern' -> $xss_output_file"
    else
      echo "[INFO] --no-dalfox especificado; pulando dalfox para pattern '$pattern'."
    fi
  done

  echo "[✓] Análise concluída para $domain_name."
done

echo "[✔️] Todas análises concluídas. Resultados em: $OUTPUT_DIR"

Dependências para executar​

Instalação (passo a passo)​

Ter o Go instalado (se ainda não tiver)​

Instalar gau, gf e dalfox (recomendado — via go install)​

Instalar / configurar os patterns do gf (recomendado)​

Ajustando o PATH (se necessário)​

Testando as ferramentas (após instalação)​

Como usar​

Script gerado por IA​