String-X: Manipulação de Strings para Operadores Cansados
Ferramenta de Automatização para Manipulação de Strings
Salve, Osinteir(o|a)s!
Em meus estudos de Python + OSINT, resolvi codar uma tool compatível com minhas necessidades atuais de automação e execução modular de comandos shell.
Bom, depois de diversas cervejas e muito code Python, criei a tool STRING-X (aka strx). Ferramenta criada com ideias de um ser humano preguiçoso. Afinal, existe algo mais empolgante para um preguiçoso do que eliminar processos e comandos repetidos? Atribuí o nome STRING-X à ferramenta porque utilizo, em boa parte dos processos da tool, o conceito de replace de strings para criar comandos e passar informações para módulos internos.
Se tem uma coisa que aprendemos nas trincheiras do OSINT e nas coletas da vida, é que nem sempre a quantidade de dados garante a qualidade informacional. Scripts, comandos, regex e tools com diversas gambiarras podem ajudar no processo para coletar um intel mais relevante, eliminando ruídos desnecessários.
Tendo em mente o contexto operacional no qual nem sempre atuamos dentro de um ambiente corp (com regras e playbooks), efetuamos diligências dentro de um cenário, às vezes, informal ou clandestino. Visando isso, estabeleci na ferramenta um padrão de módulos e organização com nomenclaturas claras que ajudam o operador a organizar melhor seu fluxo de extração.
WARNING: Esta ferramenta foi desenvolvida para usuários adultos com conhecimentos básicos de shell, Linux, OPSEC e minimamente alfabetizados. Espera-se que o operador compreenda o impacto de suas ações, saiba interpretar comandos antes de executá-los e não atribua comportamentos inesperados à “mágica” do sistema.
Seguindo a filosofia da preguiça
Faça uma coisa, mas, se for repetir, crie um script.
mrcl0wn
STRING-X (strx)
String-X (strx) é uma ferramenta modular de automatização desenvolvida para profissionais de Infosec e entusiastas de hacking. Especializada na manipulação dinâmica de strings em ambiente Linux.
Com arquitetura modular, oferece recursos avançados para OSINT, pentest e análise de dados, incluindo processamento paralelo, módulos especializados de extração, coleta e integração com APIs externas. Sistema baseado em templates flexíveis com mais de 25 funções integradas.
Pois é. Eu estava cansado de ver scripts quebrando por causa de aspas, explodindo a RAM com subprocessos desnecessários ou, simplesmente, de nem lembrar dos comandos usados.
Foi nessa busca por ordem no caos que “pari” o String-X (strx). Não é só mais um utilitário para encher linguiça no seu arsenal; é um orquestrador desenvolvido em Python 3.12+ que traz a lógica de scripts parrudos direto para linha de comando. É a ferramenta que transforma dados estáticos em pipelines de inteligência ativa.
Se você deseja um contexto rápido sobre a ferramenta, disponibilizei este vídeo gerado pelo Notebook LM. É possível que existam alguns erros técnicos ou de escrita, mas ele ajuda a introduzir a ideia.
Instalação via pip (Recomendado)
- Repositório: https://github.com/MrCl0wnLab/
# Instalar diretamente do repositório
pip install git+https://github.com/MrCl0wnLab/string-x.git
# Ou instalar em modo desenvolvimento
git clone https://github.com/MrCl0wnLab/string-x.git
cd string-x
pip install -e .
# Teste a instalação
strx -help
# Lista tipos de módulos
strx -types
# Lista módulos e exemplos de uso
strx -examples
# Lista funções
strx -funcs
# Testando com string única
strx -s "exemplo.com" -st "dig {STRING}"
Code language: PHP (php)Fluxo de Processamento
- Entrada: Dados via arquivo (
-l) ou stdin (pipe) - Template: Aplicação do template com
{STRING} - Processamento: Execução de comandos/módulos
- Pipe: Processamento adicional opcional (
-p) - Saída: Resultado final (tela ou arquivo)
Estrutura de Diretórios
string-x/
.
├── asset # Imagens, banners e logos usados na documentação e interface CLI
├── config # Arquivos de configuração global do projeto (settings)
├── core # Núcleo da aplicação, engine principal e lógica central
│ └── banner # Submódulo para banners ASCII art
│ └── asciiart # Arquivos de arte ASCII para exibição no terminal
├── output # Diretório padrão para arquivos de saída e logs
└── utils # Utilitários e módulos auxiliares para extensões e integrações
├── auxiliary # Módulos auxiliares organizados por função
│ ├── ai # Módulos de inteligência artificial (ex: prompts Gemini)
│ ├── clc # Módulos coletores (busca, DNS, whois, APIs externas)
│ ├── con # Módulos de conexão (SSH, FTP, HTTP probe)
│ ├── ext # Módulos extratores (regex: email, domínio, IP, hash, etc)
│ └── out # Módulos de saída/integradores (JSON, CSV, banco de dados, APIs)
└── helper # Funções utilitárias e helpers usados em todo o projeto
Menu
usage: strx [-h] [-types] [-examples] [-functions] [-list file] [-s string] [-str cmd]
[-out file] [-pipe cmd] [-verbose] [-thread <10>] [-pf] [-of]
[-filter value] [-sleep <5>] [-module <type:module>] [-pm] [-proxy PROXY]
[-format <format>] [-upgrade] [-retry <1>] [-no-shell]
_
(T) _
_ .=. (R)
(S) _ /\/(`)_ ▓
▒ /\/`\/ |\ 0`\ ░
b |░-.\_|_/.-||
r )/ |_____| \( _
█ 0 #/\ /\# ░ (X)
░ _| + o |_ ░
b _ ((|, ^ ,|)) b
r (1) `||\_/||` r
|| _ || _
▓ | \_/ ░ (V)
b 0.__.\ /.__.0 ░
r `._ `"` _.' ▒
) ; \ ( b
░ 1'-' )/`'-1 r
0`
██████ ▄▄▄█████▓ ██▀███ ▒██ ██▒
▒██ ▒ ▓ ██▒ ▓▒ ▓██ ▒ ██▒ ░▒ █ █ ▒░
░ ▓██▄ ▒ ▓██░ ▒░ ▓██ ░▄█ ▒ ░░ █ ░
▒ ██▒ ░ ▓██▓ ░ ▒██▀▀█▄ ░ █ █ ▒
▒██████▒▒ ▒██▒ ░ ░██▓ ▒██▒ ▒██▒ ▒██▒
▒ ▒▓▒ ▒ ░ ▒ ░░ ░ ▒▓ ░▒▓░ ▒▒ ░ ░▓ ░
░ ░▒ ░ ░ ░ ░▒ ░ ▒░ ░░ ░▒ ░
░ ░ ░ ░ ░░ ░ ░ ░
░ ░ ░ ░
░
String-X: Tool for automating commands 1.0
options:
-h, -help show this help message and exit
-types Lista tipos de módulos
-examples Lista módulos e exemplos de uso
-functions, -funcs Lista funções
-list, -l file Arquivo com strings para execução
-s string String única para execução
-str, -st cmd String template de comando
-out, -o file Arquivo output de valores da execução shell
-pipe, -p cmd Comando que será executado depois de um pipe |
-verbose, -v Modo verboso
-thread, -t <10> Quantidade de threads
-pf Mostrar resultados da execução de função, ignora shell
-of Habilitar output de valores da execução de função
-filter, -f value Valor para filtrar strings para execução
-iff value Filtrar resultados de função: retorna apenas resultados que contenham o valor especificado
-ifm value Filtrar resultados de módulo: retorna apenas resultados que contenham o valor especificado
-sleep <5> Segundos de delay entre threads
-module <type:module> Selecionar o tipo e module, possível usar encadeamento type1:module1|type:module2
-pm Mostrar somente resultados de execução do module
-pmc Mostrar resultados de cada módulo no encadeamento separadamente
-no-shell, -ns Processar entrada diretamente através de módulos/funções sem execução de comandos shell
-proxy PROXY Setar um proxy para request
-format <format> Formato de saída (txt, csv, json)
-upgrade Atualizar String-X via Git
-retry, -r <1> Quantidade de tentativas
Code language: HTML, XML (xml)Exemplos práticos
Elaborei uns 20 comandos práticos, organizados por categorias, para uma introdução do uso
1. Análise de Phishing e Reconhecimento
- Verificar palavras-chave suspeitas em sites:
strx -l domains_suspicious.txt -st "curl -skL https://{STRING}/" -p "grep -i 'phish\|scam\|fake'" - Extrair títulos de páginas para identificar clones:
strx -l domains.txt -st "curl -sL https://{STRING}" -p "grep -o '<title>.*</title>'" - Análise inteligente de URLs com Gemini IA:
strx -l urls.txt -st "echo 'Analisar URL em busca de comportamentos maliciosos: {STRING}'" -module "ai:gemini" -pm - Coletar informações de certificados SSL/TLS:
strx -l domains.txt -st "echo {STRING}" -module "clc:crtsh" -pm - Sondagem HTTP/HTTPS para análise de cabeçalhos de servidor:
strx -l urls.txt -st "echo {STRING}" -module "clc:http_probe" -pm
2. Fuzzing e Testes de Força Bruta
- Fuzzing de diretórios em massa:
strx -l wordlist.txt -st "curl -s -o /dev/null -w '%{http_code}' https://target.com/{STRING}" -p "grep '^200$'" - Verificação massiva de status HTTP com 50 threads:
strx -l urls.txt -st "curl -I {STRING}" -p "grep 'HTTP/'" -t 50 - Geração dinâmica de nomes de subdomínios comuns:
strx -l domains.txt -st "subdomain_gen({STRING})" -ns -pf - Fuzzing de parâmetros de API com valores aleatórios:
strx -l apis.txt -st "curl '{STRING}?id=int_rand(6)'" -pf - Port scanning automatizado com filtragem de portas abertas:
strx -l ip_list.txt -st "nmap -p 80,443 {STRING}" -p "grep 'open'" -t 20
3. Google Dorking e Motores de Busca
- Dorking básico automatizado a partir de uma lista:
strx -l dorks.txt -st "echo {STRING}" -module "clc:google" -pm - Busca por arquivos confidenciais em sites governamentais:
echo 'site:gov filetype:pdf "confidential"' | strx -st "echo {STRING}" -module "clc:google" -pm - Localizar painéis de login expostos usando Yahoo:
echo 'inurl:admin intitle:"login"' | strx -st "echo {STRING}" -module "clc:yahoo" -pm - Comparar resultados de busca entre Google e Bing simultaneamente:
strx -l dorks.txt -st "echo {STRING}" -module "clc:google|clc:bing" -pmc -pm
4. Grep de Dados e Filtragem Inteligente
- Buscar padrões específicos em arquivos de leaks ou diretórios:
strx -l patterns.txt -st "grep -Ei '{STRING}' -R ./database/" -v 1 - Extrair apenas e-mails de domínios governamentais de um dump:
strx -l data.txt -st "echo {STRING}" -module "ext:email" -pm -f ".gov" - Extrair e-mails únicos de um dump SQL:
strx -l dump.txt -st "echo {STRING}" -module "ext:email" -pm | sort -u - Filtrar resultados de funções que contenham o termo “admin”:
strx -l urls.txt -st "{STRING}; md5({STRING})" -pf -iff "admin"
5. Extração de URLs e Domínios
- Web spider para coleta recursiva de URLs de um alvo:
strx -s "https://example.com" -st "echo {STRING}" -module "clc:spider" -op depth=3,max_urls=50 -pm - Extração de URLs diretamente de uma página via pipe:
curl -s "https://target.com" | strx -st "{STRING}" -module "ext:url" -ns -pm - Pipeline completo: extrair URL -> extrair domínio -> coletar DNS:
strx -l data.txt -st "{STRING}" -module "ext:url|ext:domain|clc:dns" -ns -pm
- Execução básica:
cat hosts.txt | strx -str 'host {STRING}'
- Executando comando shell com uma complexidade:
cat hosts.txt | strx -str "curl -Iksw 'CODE:%{response_code};IP:%{remote_ip};HOST:%{url.host};SERVER:%header{server}' https://{STRING}" -p "grep -o -E 'CODE:.(.*)|IP:.(.*)|HOST:.(.*)|SERVER:.(.*)'" -t 30
Dica de Performance: Utilize sempre a flag -ns (No-Shell) ao trabalhar apenas com módulos e funções integradas para obter uma execução mais rápida e segura.
Cenário – Threat Intelligence
Você faz parte da rotina de análises de phishing para mapear paths, verificar a existência de keywords relacionadas ao cliente e executar processos de fuzzing.
Suponha que, durante um processo de fuzzing aplicado a uma campanha de phishing, você identifique, de forma inesperada, o acesso a um painel admin. No entanto, você não deseja repetir manualmente todo esse procedimento sempre que precisar reproduzir o acesso, e sim reutilizar o “bypass” identificado para chegar ao painel de forma consistente.
Para atender a esse cenário, foram criadas estruturas modulares, permitindo o desenvolvimento de módulos personalizados voltados para tarefas específicas, como a automação de bypasses, o reaproveitamento de fluxos de acesso e a padronização de técnicas já validadas.
Exemplo de uso para seu módulo personalizado adicionada na categoria clc (utils/auxiliary/clc):
strx -l urls.txt -st "{STRING}" -module "clc:meu_module" -ns -pm
# Efetuando filtro de URLS usando módulo URL antes de enviar para seu coletor personalizado.
strx -l urls.txt -st "{STRING}" -module "ext:url|clc:meu_module" -ns -pm
Code language: Bash (bash)- Documentação / Desenvolvimento: https://github.com/MrCl0wnLab/string-x/blob/main/docs/dev/README.md
O Caos das Strings
Para o profissional de Infosec moderno, simplicidade demais às vezes atrapalha. Você quer processar volumes massivos de dados brutos, criar um padrão para execução de tarefas mas as vezes só o uso comandos anotados em um bloco de texto qualquer vira um caos. O strx chega para resolver isso, permitindo manipular strings de forma dinâmica, segura e modular. É sair do “grep” básico e ir para uma estrutura de automação de verdade.
O “Pulo do Gato”: O Placeholder {STRING}
A curva de aprendizado de automação costuma ser chata, mas o String-X nivela o jogo com o placeholder {STRING}.
Aqui entra a diferença de mindset (palavra proibida de coaching): validar 10 mil domínios não é difícil por causa do código, e sim porque ninguém quer digitar, lembrar e repetir o mesmo ritual indefinidamente.
Abordagem Tradicional (Com bondade no coração):
cat dominios.txt | while read line; do host $line; done
# E rezar para não travar no meio...
Code language: Bash (bash)Abordagem String-X (Coração peludo e sem tempo):
strx -l dominios.txt -st "host {STRING}"
Code language: Bash (bash)Essa redução não é só estética, é estratégica. O sistema de templates dinâmicos elimina a necessidade daqueles loops manuais chatos, permitindo que até quem tá começando agora automatize tarefas de nível possa brincart um pouco em segundos (claro seja alfabetizado e leia a documentação).
Arquitetura Modular: De Extratores à Inteligência Artificial
O grande diferencial do strx é a estrutura modular. Quem curte a vibe do Nuclei vai se sentir em casa. Ele cobre todas as fases do engajamento:
| Tipo | Código | Descrição | Localização |
|---|---|---|---|
| Extractor | ext | Extração de dados específicos (email, URL, domain, phone) | utils/auxiliary/ext/ |
| Collector | clc | Coleta e agregação de informações (DNS, whois) visando um contexto externo | utils/auxiliary/clc/ |
| Output | out | Formatação e envio de resultados (DB, API, files) | utils/auxiliary/out/ |
| Connection | con | Conexões especializadas (SSH, FTP, etc) | utils/auxiliary/con/ |
| Inteligência artificial | ai | Envio de dados para apis externas de AI. | utils/auxiliary/ai/ |
Comando: strx -types
Comando: strx -examples
Funções Integradas
São mais de 25 functions integradas. Você decodifica payloads com jwt_decode, expande redes com cidr_expand e audita certificados com cert_info sem sair da ferramenta. Detalhe você pode criar suas functions para uso.
Comando: strx -funcs
Sintaxe
# Função simples
strx -l data.txt -st "funcao({STRING})" -pf
# Múltiplas funções
strx -l data.txt -st "{STRING}; md5({STRING}); base64({STRING})" -pf
# Função com parâmetros
strx -l data.txt -st "str_rand(10); int_rand(5)" -pf
Code language: Bash (bash)- Documentação / functions: https://github.com/MrCl0wnLab/string-x/tree/main?tab=readme-ov-file#-fun%C3%A7%C3%B5es-integradas, https://github.com/MrCl0wnLab/string-x/blob/main/docs/dev/criacao-funcoes.md, https://github.com/MrCl0wnLab/string-x/tree/main?tab=readme-ov-file#m%C3%B3dulos-intelig%C3%AAncia-artificial–ai
Modo “No-Shell”: Velocidade e Segurança
Aqui tá o ouro. O processamento via shell tradicional tem um overhead monstro de criar novos subprocessos para cada linha. Sem contar o risco de Command Injection se você não sanitizar a entrada.
O strx traz a flag -no-shell (-ns).
Ao ativar o -ns, a ferramenta processa tudo pelos módulos internos do Python, sem invocar o shell do sistema.
Você é adulto, então se der merda é sua responsabilidade
Elimina riscos de injeção shell e remove overhead de subprocessos.
E para garantir que ninguém faça “besteira”, existe um if de segurança nativo que bloqueia padrões perigosos (mas dá para desabilitar com-dsse você for root na vida e souber o que tá fazendo).
O Próximo Nível: Google Gemini no Pipeline
A integração com o módulo ai:gemini transforma o strx num analista automatizado. Você espeta sua API Key e pode mandar prompts em lote.
Exemplo prático de Threat Intel: Coletar URLs suspeitas e pedir para IA analisar vulnerabilidades em massa.
strx -l urls.txt -st "Analisar comportamento desta URL: {STRING}" -module "ai:gemini" -pm
Code language: Bash (bash)Você pode carregar uma lista de prompts complexos e processar logs identificando anomalias, mantendo a saída limpa com a flag -pm (Print Module).
- Documentação / AI: https://github.com/MrCl0wnLab/string-x/tree/main?tab=readme-ov-file#m%C3%B3dulos-intelig%C3%AAncia-artificial–ai
Multi-Threading e Pipes Complexos
Para galera do Recon pesado, o String-X usa multi-threading configurável (-t). Mas o poder de depuração surge com a flag -pmc (Print Module Chain).
Dá para encadear módulos tipo pipe unix (ext:url|ext:domain|clc:dns) e visualizar o resultado de cada etapa. E o suporte a Dorking pode ajudar: Google, Bing, Naver (Coreano) e Sogou (Chinês).
Exemplo de Pipeline:
strx -l targets.txt -st "{STRING}" -module "ext:url|ext:domain|clc:dns" -ns -pmc -pm -t 50
# Executar uma lista de dorks no Google
strx -l dorks.txt -st "echo {STRING}" -module "clc:google" -pm
# Buscar PDFs confidenciais em sites governamentais
echo 'site:gov filetype:pdf "confidential"' | strx -st "echo {STRING}" -module "clc:googlecse" -pm
# Localizar arquivos PDF de um domínio específico (exemplo: FBI)
echo 'site:fbi.gov filetype:pdf' | strx -st "echo {STRING}" -module "clc:google" -pm
# Descoberta de Painéis e Possíveis Exposições
echo 'inurl:admin intitle:"login"' | strx -st "echo {STRING}" -module "clc:yahoo" -pm
# Buscar diretórios administrativos no GitHub
echo 'site:github.com inurl:admin' | strx -st "echo {STRING}" -module "clc:googlecse" -pm
# Identificar termos de uso interno via DuckDuckGo
echo 'intext:"internal use only"' | strx -st "echo {STRING}" -module "clc:duckduckgo" -pm
# Consulta simultânea em Google, Yahoo e Bing
strx -l dorks.txt -st "echo {STRING}" -module "clc:google|clc:yahoo|clc:bing" -pmc -pm
# Análise encadeada com extração de domínios e resolução DNS
strx -l dorks.txt -st "echo {STRING}" -module "clc:google|ext:domain|clc:dns" -pmc
# Uso de lista de proxies para coleta distribuída
cat proxy_list.txt | while read proxy; do
strx -l target_dorks.txt -st "echo {STRING}" -module "clc:bing" -proxy "$proxy" -pm -t 3 -sleep 2
done
# Salvar resultados em formato JSON
echo 'com.br' | strx -st "echo {STRING}" -module "clc:bing" -format json -o resultados.json -pm
# Dorking com saída JSON utilizando proxy autenticado
strx -l sqli_dorks.txt -st "echo {STRING}" -module "clc:googlecse|out:json" -proxy "http://user:pass@host:port" -pm
Code language: Bash (bash)STRING-X como Python lib
Para criar um script Python avulso utilizando o String-X (strx) como biblioteca para realizar dorking no Google, você deve aproveitar a arquitetura modular da ferramenta, especificamente o núcleo (Core) e os módulos de coleta (Collector)
Como você já instalou via pip, a estrutura da biblioteca está disponível no seu ambiente Python. Abaixo, apresento um exemplo de como instanciar o módulo de dorking do Google dentro de um código Python:
Exemplo de Script Python (Dorking Google)
Este script demonstra como importar e utilizar o módulo clc:google diretamente:
import sys
# A importação depende de como o pacote foi estruturado no site-packages
# Baseado na arquitetura, os módulos ficam em utils.auxiliary
from stringx.utils.auxiliary.clc.google import Google
def realizar_dork(termo_busca):
# Instancia o módulo do Google
google_search = Google()
# Define as opções necessárias para o módulo
# O "data" é o placeholder que o módulo usará como dork
google_search.options.update({
"data": termo_busca,
"proxy": "" # Você pode adicionar um proxy aqui se necessário
})
print(f"[*] Iniciando busca por: {termo_busca}")
# Executa a lógica de coleta
google_search.run()
# Obtém os resultados capturados
resultados = google_search.get_result()
if resultados:
for link in resultados:
print(f"[+] Encontrado: {link}")
else:
print("[-] Nenhum resultado encontrado ou bloqueio de bot.")
if __name__ == "__main__":
minha_dork = 'site:gov.ar ".sql"'
realizar_dork(minha_dork)
Code language: Python (python)- Documentação / Biblioteca Python: https://github.com/MrCl0wnLab/string-x/blob/main/docs/dev/uso-como-biblioteca.md
Conclusão
O String-X não foi projetado para uso pontual, mas sim para automatização, reutilização de fluxos e padronização de processos. O foco não está apenas na dork em si, mas na cadeia de execução, permitindo repetir análises complexas com consistência e menor esforço operacional.
O STRX não tem como objetivo substituir ferramentas consagradas nem ser superior a um bash script bem executado. Seu valor está em cenários onde o analista precisa reutilizar código, requisições ou fluxos de execução, oferecendo uma forma organizada, modular e consistente de estruturar essas tarefas.
Em um campo onde cada segundo conta, continuar dependendo de scripts Bash frágeis ou da sua memória bugada é pedir para ter dor de cabeça. A automação inteligente e modular do String-X tá pronta para substituir aqueles seus arquivos .txts jogados no /Documents.
E como disse o grande profeta: Hacker Hackeia!
Post feito ao som de:
