OSINT para rastrear pegadas digitais e senhas vazadas em redes sociais
OSINT para rastrear pegadas digitais e senhas vazadas em redes sociais
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:
- Obtenha uma chave de API gratuita
https://rapidapi.com/rohan-patra/api/breachdirectoryem . - 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:
- Sherlock é baseado em Python, o que o torna mais lento quando comparado ao Go.
- Sherlock está desatualizado e carece de atualizações.
- Às vezes, Sherlock relata falsos positivos como resultados válidos.
- 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
status_code- um código de status específico que é retornado se um nome de usuário não existir (normalmente404)errorMsg- uma mensagem de erro personalizada que o site exibe e que é exclusiva para nomes de usuários que não existemprofilePresenceuma mensagem personalizada que o site exibe e que é exclusiva para nomes de usuários existentes.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.
Comentários
Postar um comentário