OSINT para rastrear pegadas digitais e senhas vazadas em redes sociais

DARK WEB INFORMER - INTELIGÊNCIA DE AMEAÇAS CIBERNÉTICAS

1 de janeiro de 2025. 18:12  

7 min de leitura

• 𝕏
• Compartilhe no Facebook
• Compartilhe no Pinterest
• Compartilhe no LinkedIn
• Compartilhe no WhatsApp
• Compartilhar via e-mail

---

GitHub: https://github.com/ibnaleem/gosearch

---

Este projeto depende muito de colaboradores. Veja  Contribuições  para mais detalhes.
git clone https://github.com/ibnaleem/gosearch.git && cd gosearch && go build && ./gosearch [username]

      

---

O que é  GoSearch?

GoSearch é uma ferramenta OSINT eficiente e confiável, projetada para descobrir pegadas digitais associadas a um determinado nome de usuário. É rápido, direto e confiável, permitindo que os usuários rastreiem a presença online de um indivíduo em várias plataformas.  GoSearch também integra dados do Banco de Dados de Inteligência de Crimes Cibernéticos da HudsonRock para fornecer insights sobre informações relacionadas a crimes cibernéticos. Ele também acessa  BreachDirectory.orgo banco de dados do oferecendo acesso a uma lista abrangente de violações de dados, senhas em texto simples e com hash vinculadas ao nome de usuário. Esta ferramenta é ideal para aqueles que precisam de resultados precisos e sem frescuras ao investigar identidades online.

Instalação e uso

$ git clone https://github.com/ibnaleem/gosearch.git && cd gosearch

$ go build

Para Unix:

$ ./gosearch <username>

Recomendo adicionar o  gosearch binário ao seu  /bin para uso universal:

$ sudo mv gosearch ~/usr/bin

Para Windows:

C:\Users\***\gosearch> gosearch.exe <username>

Casos de uso

O GoSearch permite que você pesquise  no breachdirectory.org  por senhas comprometidas associadas a um nome de usuário específico. Para utilizar totalmente o GoSearch, siga estas etapas:

1. Obtenha uma   chave de API  gratuitahttps://rapidapi.com/rohan-patra/api/breachdirectory em .
2. Inclua a chave da API nos argumentos do comando como este:

$ gosearch [username] [api-key]

O GoSearch gerará automaticamente endereços de e-mail populares para um determinado nome de usuário.

Por que  GoSearch?

GoSearch é inspirado por  Sherlock , uma ferramenta popular de busca de nome de usuário. No entanto,  GoSearch melhora Sherlock ao abordar várias de suas principais limitações:

1. Sherlock é baseado em Python, o que o torna mais lento quando comparado ao Go.
2. Sherlock está desatualizado e carece de atualizações.
3. Às vezes, Sherlock relata falsos positivos como resultados válidos.
4. Sherlock frequentemente deixa passar nomes de usuários reais, o que leva a falsos negativos.

O problema principal com Sherlock são os falsos negativos — quando um nome de usuário existe em uma plataforma, mas não é detectado. O problema secundário são os falsos positivos, quando um nome de usuário é incorretamente sinalizado como disponível.  GoSearch aborda esses problemas codificando por cores os resultados incertos como amarelo, o que indica potenciais falsos positivos. Isso permite que os usuários filtrem facilmente links irrelevantes. Se houver demanda suficiente, podemos implementar uma opção para relatar apenas resultados confirmados ou focar apenas na detecção de falsos negativos.

Contribuindo

GoSearch depende do  arquivo data.json  que contém uma lista de sites para pesquisar. Os usuários podem contribuir adicionando novos sites para expandir os recursos de pesquisa da ferramenta. É aqui que a maioria das contribuições são necessárias. O formato para adicionar novos sites é o seguinte:

{
"name": "Nome do site",
"base_url": "https://www.website.com/profiles/{}",
"url_probe": "opcional, veja abaixo",
"errorType": "errorMsg/status_code/profilePresence/unknown",
"errorMsg/errorCode": "errorMsg",
"cookies": [
{
"name": "nome do cookie",
"value": "valor do cookie"
}
]
}

Cada entrada deve incluir um nome de site claro e conciso para facilitar pesquisas manuais, ajudando a evitar envios duplicados.

base_url

O  base_url é o URL  GoSearch usado para pesquisar nomes de usuários, a menos que a  url_probe seja especificado (veja  url_probe). Sua primeira tarefa é identificar a localização dos perfis de usuário em um site. Por exemplo, no Twitter, os perfis de usuário estão localizados no caminho raiz  /, então você definiria  "base_url": "https://twitter.com/{}". O  {} é um  espaço reservado  que  GoSearch será substituído automaticamente pelo nome de usuário ao executar a pesquisa.

Por exemplo, se você executar a consulta  ./gosearch ibnaleem,  GoSearch substituirá o  {} placeholder por "ibnaleem", resultando na URL  https://shaffan.dev/user/ibnaleem, assumindo que o  base_url esteja definido como  https://shaffan.dev/user/{}. Isso permite  GoSearch gerar automaticamente a URL correta para verificar o perfil do usuário.

url_probe

Em alguns casos, os sites podem bloquear solicitações diretas por motivos de segurança, mas oferecem uma API ou serviço alternativo para recuperar as mesmas informações. O  url_probe campo é usado para especificar uma API ou URL de serviço que verifica a disponibilidade do nome de usuário. Ao contrário do  base_url, que é usado para pesquisar diretamente URLs de perfil, o  url_probe gera uma solicitação de API diferente, e o GoSearch exibirá a URL da API no terminal em vez da URL do perfil.

Por exemplo, os perfis do Duolingo estão disponíveis em  https://duolingo.com/profile/{}, mas para verificar se um nome de usuário está disponível, o Duolingo fornece uma URL de API:  https://www.duolingo.com/2017-06-30/users?username={}. Se usássemos o  url_probe como  base_url, o terminal mostraria algo como  https://www.duolingo.com/2017-06-30/users?username=ibnaleem em vez da URL do perfil do usuário  https://duolingo.com/profile/ibnaleem, o que poderia confundir os usuários. Essa distinção ajuda a manter o processo mais claro e intuitivo, especialmente para aqueles que podem estar menos familiarizados com programação.

errorType

Existem 4 tipos de erro

1. status_code - um código de status específico que é retornado se um nome de usuário não existir (normalmente  404)
2. errorMsg - uma mensagem de erro personalizada que o site exibe e que é exclusiva para nomes de usuários que não existem
3. profilePresence uma mensagem personalizada que o site exibe e que é exclusiva para nomes de usuários existentes.
4. unknown - quando não há como verificar a diferença entre um nome de usuário que existe e um que não existe no site

status_code

A maneira mais fácil de contribuir é simplesmente encontrar um perfil existente e fazer uma solicitação com o seguinte código:

pacote principal

importação (
"fmt"
"log"
"net/http"
"os"
)

func MakeRequest(url string) {
resp, err := http.Get(url)
if err != nil {
log.Fatal(err)
}

adiar resp.Body.Close()

fmt.Println("Resposta:", resp.Status)
}

func main() {
var url string = os.Args[1]
MakeRequest(url)
}

$ go build

$ ./request https://yourwebsite.com/username
Response: 200 OK

Onde username é o nome de usuário existente no site. Então, faça a mesma solicitação com um nome de usuário que não existe no site:

$ ./request https://yourwebsite.com/usernamedoesnotexist
Response: 404 Not Found

Copie e defina  errorCode, o campo abaixo  errorType, como o código que será impresso no terminal (neste caso é  404).

errorMsg

Isso é mais complicado, então o que você precisa fazer é baixar o corpo da resposta para um arquivo. Felizmente, eu já escrevi o código para você:

pacote principal

importação (
"fmt"
"io"
"log"
"net/http"
"os"
)

func MakeRequest(url string) {
resp, err := http.Get(url)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
corpo, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(corpo))
os.WriteFile("response.txt", []byte(corpo), 0644)
}

func main() {
url := os.Args[1] // Pega URL como argumento da linha de comando
MakeRequest(url)
}

$ go build

./test https://website.com/username

Mais uma vez, o primeiro nome de usuário corresponde a uma conta existente, enquanto o segundo nome de usuário é para uma conta que não existe. Certifique-se de renomear  response.txt para evitar que meu código o sobrescreva.

$ mv response.txt username_found.txt

$ ./test https://website.com/username_does_not_exist

$ mv response.txt username_not_found.txt

Você precisará analisar o corpo da resposta de  username_not_found.txt e compará-lo com  username_found.txt. Procure por qualquer palavra, frase, tag HTML ou outro elemento exclusivo que apareça somente em  username_not_found.txt. Depois de identificar algo distinto, adicione-o ao  errorMsg campo abaixo do  errorType campo. Lembre-se de que  errorType só pode ter um campo abaixo dele: ou  errorCode ,  errorMsgmas  não ambos . Abaixo está  incorreto :

{
"errorType": "status_code",
"errorCode": 404,
"errorMsg": "<title>Olá, Mundo</title>"
}

errorMsg

O exato oposto de  errorMsg; em vez de analisar o  username_not_found.txtcorpo de resposta do , analise o  username_found.txtcorpo de resposta do para encontrar qualquer palavra, frase, tag HTML ou outro elemento exclusivo que apareça somente em  username_found.txt. Defina  errorType: profilePresence e defina o  errorMsg para o que você encontrou.

"unknown"

Ocasionalmente, o corpo da resposta pode estar vazio ou não ter nenhum conteúdo exclusivo nos  arquivos username_not_found.txt e  username_found.txt . Após tentar cookies, usando o  www. subdomínio, você fica sem respostas. Nesses casos, defina o  errorType para  "unknown" (como uma string) e inclua um  404 errorCode campo abaixo dele.

cookies

Alguns sites podem exigir cookies para recuperar dados específicos, como códigos de erro ou informações de sessão. Por exemplo, o site  dzen.ru exige o cookie  zen_sso_checked=1, que é incluído nos cabeçalhos de solicitação ao fazer uma solicitação do navegador. Para testar cookies e analisar a resposta, você pode usar o seguinte código Go:

pacote principal

import (
"fmt"
"log"
"net/http"
"os"
)

func MakeRequest(url string) {
client := &http.Client{}

// Cria uma nova solicitação HTTP GET
req, err := http.NewRequest("GET", url, nil)
if err != nil {
log.Fatalf("Erro ao criar solicitação: %v", err)
}

// Cria o cookie cookie
:= &http.Cookie{
Nome: "cookie_name",
Valor: "cookie_value",
}

// Adiciona o cookie à solicitação
req.AddCookie(cookie)

// Envia a solicitação
resp, err := client.Do(req)
if err != nil {
log.Fatalf("Erro ao fazer solicitação: %v", err)
}
defer resp.Body.Close()

// Exibe o status da resposta
fmt.Println("Status da resposta:", resp.Status)
}

func main() {
// Garanta que a URL seja fornecida como o primeiro argumento
se len(os.Args) < 2 {
log.Fatal("A URL é necessária como o primeiro argumento.")
}
url := os.Args[1]
MakeRequest(url)
}

Ao testar cookies, verifique o status e o corpo da resposta. Por exemplo, se você sempre recebe uma  200 OK resposta, tente adicionar  www. antes da URL, pois alguns sites redirecionam com base nisso:

$ curl -I https://pinterest.com/username
HTTP/2 308
...
location: https://www.pinterest.com/username

$ curl -I https://www.pinterest.com/username
HTTP/2 200

Além disso, certifique-se de usar o código acima para analisar o corpo da resposta ao incluir o  www. subdomínio e os cookies relevantes.

Para contribuir, siga o modelo acima, abra um PR e eu o mesclarei se  GoSearch conseguir detectar as contas com sucesso.

LICENÇA

Este projeto está licenciado sob a GNU General Public License - veja o  arquivo LICENSE  para mais detalhes.