Ronin é um Kit de Ferramentas Ruby gratuito e de código aberto para Pesquisa e Desenvolvimento em Segurança. O Ronin também permite o rápido desenvolvimento e distribuição de código, exploits, payloads, etc., por meio de repositórios git de terceiros.
Ronin é um kit Ruby gratuito e de código aberto para pesquisa e desenvolvimento em segurança. Ronin contém muitos comandos CLI e bibliotecas Ruby diferentes para uma variedade de tarefas de segurança, como codificação/decodificação de dados, filtrar IPs/hosts/URLs, consultar ASNs, consultar DNS, HTTP, varredura por vulnerabilidades web, rastreamento de sites, instalação de repositórios de terceiros de exploits e/ou payloads, execução de exploits, desenvolvimento de novos exploits, gerenciamento de bancos de dados locais, fuzzing de dados, realização de reconhecimento, e muito mais.
ronin.ronin irb.ronin.Usage: ronin [options] [COMMAND [ARGS...]]
Options: -h, --help Print help information
Arguments: [COMMAND] The command name to run [ARGS ...] Additional arguments for the command
Commands: archive asn banner-grab bitflip cert-dump cert-gen cert-grab completion decode, dec decrypt dns dns-proxy email-addr encode, enc encrypt entropy escape extract grep help hexdump highlight hmac homoglyph host http ip iprange irb md5 netcat, nc new pack proxy public-suffix-list quote rot sha1 sha256 sha512 strings tld-list tips typo typosquat unarchive unescape unhexdump unpack unquote url xor
Additional Ronin Commands: $ ronin-repos $ ronin-wordlists $ ronin-db $ ronin-web $ ronin-fuzzer $ ronin-masscan $ ronin-nmap $ ronin-recon $ ronin-payloads $ ronin-exploits $ ronin-vulns $ ronin-app
Liste os comandos do ronin:```shell
$ ronin help
Ver uma página de manual para um comando:```shell $ ronin help COMMAND
Obtenha uma dica aleatória sobre como usar `ronin`:```shell
$ ronin tips
Abra o Ronin Ruby REPL:```
$ ronin irb
, Jµ ▓▓█▓
J▌ ▐▓██▌ ████ ██ ▐███D
╓▄▓▓█████▌ ██µ ████ ▄███ÖJ██▌ ███▌
,╓µ▄▄▄▄▄▄▄▄µ;, ,▄▓██████████ ▐███ ▐███▀ ███▌ ████µ ▄███
¬∞MÆ▓███████████████████████▓M ▄██████▀▀╙████▌ ████▌ ████ ▄███ J█████ ███▌
█████▀▀▀▀▀███████ -████▀└ ████ ▐█████n ▄███O ███▌ ██████████ ▓████L ████▀ ▓████ ▓███Ö ███████ ███▌ ▓███ ▐█████████▀ ▄████▀ ,╓▄▄▄█████ J████Ü ,███▌ ▄███████████ J███▀ ████ █████ J█████████████████─ ████▌ ████ ██████████▌ ████ ▐███Ü ▐███Ü
███████████▀▀▀╙└ ▐████ J███▌ ▓███▌ ²█████ J███Ü ███▌ ▀█▌
▓██████████▌ ████▌ ████ ;████ ▀███▀ ███▌ J▀▀▀- █
▄█████▀ ▀█████µ ▐████ ,▄▓████▀ ████▀ ███ J███ `
J█████- ╙▀███▄ ████████████▀╙ J█▀▀▀ █U ▀█▌
████▀ ▀███ ▄████████▀▀ ╨ █
▓██▀ ²▀█▄ █▀▀▀╙└
▄██╜ ╙W
J█▀
▌└
┘
irb(ronin)>
Inicia e abre a interface web interativa do Ronin:```
$ ronin-app
Exibe dados em hexadecimal em uma variedade de formatos:```shell $ ronin hexdump /bin/ls
Desfaz o hexdump de um arquivo hexdump de volta para seus dados binários brutos originais:```shell
$ ronin unhexdump -o data.bin hexdump.txt
Imprimir todas as strings imprimíveis de um arquivo:```shell $ ronin strings /bin/ls
Imprimir todas as strings alfabéticas de um arquivo:```shell
$ ronin strings --alpha /bin/ls
Imprimir todas as strings alfanuméricas de um arquivo:```shell $ ronin strings --alpha-num /bin/ls
Imprimir todas as strings numéricas de um arquivo:```shell
$ ronin strings --numeric /bin/ls
Imprimir todas as strings hexadecimais de um arquivo:```shell $ ronin strings --hex /bin/ls
Enumere todos os Bit-flips de um nome de domínio:```shell
$ ronin bitflip microsoft --alpha-num --append .com
licrosoft.com
oicrosoft.com
iicrosoft.com
eicrosoft.com
Microsoft.com
mhcrosoft.com
mkcrosoft.com
mmcrosoft.com
macrosoft.com
mycrosoft.com
...
Codificar uma string em Base64:```shell $ ronin encode --base64 --string "foo bar baz" Zm9vIGJhciBiYXo=
Comprime com Zlib, codifica em Base64 e, em seguida, codifica em URI uma string:```shell
$ ronin encode --zlib --base64 --uri --string "foo bar"
%65%4A%78%4C%79%38%39%58%53%45%6F%73%41%67%41%4B%63%41%4B%61%0A
Decodificar uma string Base64:```shell $ ronin decode --base64 --string "Zm9vIGJhciBiYXo=" foo bar baz
Decodifica URI, decodifica Base64 e então descomprime com zlib uma string:```shell
$ ronin decode --uri --base64 --zlib --string "%65%4A%78%4C%79%38%39%58%53%45%6F%73%41%67%41%4B%63%41%4B%61%0A"
foo bar
Escapar uma string para URI:```shell $ ronin escape --uri --string "foo bar" foo%20bar
Desescapar uma string de URI:```shell
$ ronin unescape --uri --string "foo%20bar"
foo bar
Converter um arquivo em uma string C entre aspas:```shell $ ronin quote --c file.bin "..."
Converta um arquivo em uma string JavaScript entre aspas:```shell
$ ronin quote --js file.bin
Desquote uma string C:```shell $ ronin unquote --c --string '"\x66\x6f\x6f\x20\x62\x61\x72"' foo bar
### Texto
Extrair dados de alta entropia de um arquivo:```shell
$ ronin entropy -e 5.0 index.html
Grep para padrões comuns de dados:```shell $ ronin grep --hash index.html
Extrair padrões comuns dos dados:```shell
$ ronin extract --hash index.html
Gere um erro de digitação aleatório de uma palavra:```shell $ ronin typo microsoft microssoft
Enumere cada variação de erro de digitação de uma palavra:```shell
$ ronin typo --enum microsoft
microosoft
microsooft
microssoft
Gere uma versão aleatória de homóglifo de uma palavra:```shell $ ronin homoglyph CEO CＥO
Enumere sobre cada variação de homóglifo de uma palavra:```shell
$ ronin homoglyph --enum CEO
ϹEO
СEO
ⅭEO
ＣEO
CΕO
CЕO
CＥO
CEΟ
CEО
CEＯ
Destaca a sintaxe de um arquivo:```shell $ ronin highlight index.html
### Criptografia
Criptografar um arquivo com AES-256:```shell
$ ronin encrypt --cipher aes-256-cbc --password "..." file.txt > encrypted.bin
Descriptografar dados:```shell $ ronin decrypt --cipher aes-256-cbc --password "..." encrypted.bin
Gera um HMAC para um arquivo:```shell
$ ronin hmac --hash sha1 --password "too many secrets" data.txt
Gera um HMAC para uma string:```shell $ ronin hmac --hash sha1 --password "too many secrets" --string "..."
Calcule um checksum MD5 de uma string:```shell
$ ronin md5 --string "hello world"
5eb63bbbe01eeed093cb22bb8f5acdc3
Calcule o checksum MD5 de um arquivo:```shell $ ronin md5 file.txt
Calcule o checksum MD5 de cada linha em um arquivo:```shell
$ ronin md5 --multiline file.txt
Calcule um checksum SHA1 de uma string:```shell $ ronin sha1 --string "hello world" 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed
Calcule a soma de verificação SHA1 de um arquivo:```shell
$ ronin sha1 file.txt
Calcule o checksum SHA1 de cada linha em um arquivo:```shell $ ronin sha1 --multiline file.txt
Calcular um checksum SHA256 de uma string:```shell
$ ronin sha256 --string "hello world"
b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
Calcular o checksum SHA256 de um arquivo:```shell $ ronin sha256 file.txt
Calcular o checksum SHA256 de cada linha em um arquivo:```shell
$ ronin sha256 --multiline file.txt
Calcule um checksum SHA512 de uma string:```shell $ ronin sha512 --string "hello world" 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f
Calcule o checksum SHA512 de um arquivo:```shell
$ ronin sha512 file.txt
Calcular o checksum SHA512 de cada linha em um arquivo:```shell $ ronin sha512 --multiline file.txt
ROT-13 codifica uma string:```shell
$ ronin rot --string "The quick brown fox jumps over the lazy dog"
Gur dhvpx oebja sbk whzcf bire gur ynml qbt
XOR codifica uma string:```shell $ ronin xor --key ABC --string "The quick brown fox jumps over the lazy dog" "\x15*&a36(!(a 1.5-a$,9b)4/32b,7'1a6+$b/ 8:a&,&"
### Redes
Consultar o ASN de um endereço IP:```shell
$ ronin asn -I 4.2.2.1
4.0.0.0/9 AS3356 (US) LEVEL3
Obter o endereço IP externo/público do sistema:```shell $ ronin ip --public
Converta um endereço IP para o formato decimal:```shell
$ ronin ip --decimal 127.0.0.1
2130706433
Converter um arquivo de endereços IP em URLs:```shell $ ronin ip --file targets.txt --http
Enumere cada endereço IP no intervalo CIDR IP:```shell
$ ronin iprange 10.1.0.0/15
10.0.0.1
10.0.0.2
10.0.0.3
10.0.0.4
10.0.0.5
10.0.0.6
10.0.0.7
10.0.0.8
10.0.0.9
...
Enumere cada endereço IP no IP glob range:```shell $ ronin iprange 10.1-3.0.* 10.1.0.1 10.1.0.2 10.1.0.3 10.1.0.4 10.1.0.5 10.1.0.6 10.1.0.7 10.1.0.8 10.1.0.9 10.1.0.10 ...
Enumere todos os endereços IP entre dois endereços IP:```shell
$ ronin iprange --start 10.0.0.1 --stop 10.0.3.33
10.0.0.1
10.0.0.2
10.0.0.3
10.0.0.4
10.0.0.5
10.0.0.6
10.0.0.7
10.0.0.8
10.0.0.9
10.0.0.10
Conecte-se a um serviço TCP remoto:```shell $ ronin netcat -v example.com 80
Escute em uma porta TCP local:```shell
$ ronin netcat -v -l 1337
Conectar a um serviço SSL/TLS remoto:```shell $ ronin netcat -v --ssl example.com 443
Conectar a um serviço UDP remoto:```shell
$ ronin netcat -v -u example.com 1337
Escute em uma porta UDP local:```shell $ ronin netcat -v -u -l 1337
Abre um socket UNIX:```shell
$ ronin netcat -v --unix /path/to/unix.socket
Hexdump todos os dados recebidos de um socket:```shell $ ronin netcat --hexdump example.com 80 GET / HTTP/1.1 Host: example.com User-Agent: Ruby
00000000 48 54 54 50 2f 31 2e 31 20 32 30 30 20 4f 4b 0d |HTTP/1.1 200 OK.| 00000010 0a 41 67 65 3a 20 32 35 30 38 30 36 0d 0a 43 61 |.Age: 250806..Ca| 00000020 63 68 65 2d 43 6f 6e 74 72 6f 6c 3a 20 6d 61 78 |che-Control: max| 00000030 2d 61 67 65 3d 36 30 34 38 30 30 0d 0a 43 6f 6e |-age=604800..Con| 00000040 74 65 6e 74 2d 54 79 70 65 3a 20 74 65 78 74 2f |tent-Type: text/| 00000050 68 74 6d 6c 3b 20 63 68 61 72 73 65 74 3d 55 54 |html; charset=UT| ...
#### DNS
Consultar registros DNS:```shell
$ ronin dns -t TXT github.com
Encontre todos os TLDs registrados para um nome de host:```shell $ ronin host --enum-tlds --registered github.com github.ac github.actor github.ae github.africa github.agency github.ai ...
Encontre todos os sufixos públicos registrados para um nome de host:```shell
$ ronin host --enum-suffix --registered github.com
example.com.ag
example.ai
example.al
example.am
example.com.ar
example.at
example.co.at
example.or.at
example.com.au
example.be
example.com.bh
...
Encontre todos os subdomínios que têm endereços:```shell $ ronin host --enum-subdomains subdomains.txt --has-addresses google.com www.google.com mail.google.com smtp.google.com ns1.google.com ns2.google.com m.google.com ns.google.com blog.google.com admin.google.com news.google.com vpn.google.com ns3.google.com ...
Enumere todas as variações possíveis de typosquat de um domínio:```shell
$ ronin typosquat microsoft.com
microosoft.com
microsooft.com
microssoft.com
Encontre todos os domínios de typosquat registrados para um domínio válido:```shell $ ronin typosquat --registered microsoft.com
Encontre todos os domínios de typosquat com endereços para um domínio válido:```shell
$ ronin typosquat --has-addresses microsoft.com
Encontre todos os domínios typosquat não registrados para um domínio válido:```shell $ ronin typosquat --unregistered microsoft.com
Desobfuscar um endereço de email:```shell
$ ronin email-addr --deobfuscate "john [dot] smith [at] example [dot] com"
[email protected]
Enumere todas as ofuscações de um endereço de e-mail:```shell $ ronin email-addr --enum-obfuscations [email protected] john.smith @ example.com john.smith AT example.com john.smith at example.com john.smith[AT]example.com john.smith[at]example.com ...
#### Certificados SSL/TLS
Extrair informações sobre um certificado SSL/TLS:```shell
$ ronin cert-dump https://example.com/
Baixar um certificado SSL/TLS de um host e porta:```shell $ ronin cert-grab github.com:443
Gerar um novo certificado SSL/TLS:```shell
$ ronin cert-gen -c test.com -O "Test Co" -U "Test Dept" \
-L "Test City" -S NY -C US
Realizar uma requisição HTTP GET (com realce de sintaxe):```shell
$ ronin http https://example.com/
Envie uma requisição HTTP com cabeçalhos adicionais:```shell
$ ronin http --post --header "Authorization: ..." https://foo.bar/
Envie uma requisição HTTP com uma string User-Agent conhecida:```shell
$ ronin http --post --user-agent chrome-android https://foo.bar/
Envie uma requisição HTTP com uma string `User-Agent` personalizada:```shell
$ ronin http --post --user-agent-string "..." https://foo.bar/
Abra um shell HTTP interativo:```shell $ ronin http --shell https://example.com/ https://example.com/> help help [COMMAND] Prints the list of commands or additional help get PATH[?QUERY] [BODY] Performs a GET request head PATH[?QUERY] Performs a HEAD request patch PATH[?QUERY] [BODY] Performs a PATCH request post PATH[?QUERY] [BODY] Performs a POST request put PATH [BODY] Performs a PUT request copy PATH DEST Performs a COPY request delete PATH[?QUERY] Performs a DELETE request lock PATH[?QUERY] Performs a LOCK request options PATH[?QUERY] Performs a OPTIONS request mkcol PATH[?QUERY] Performs a MKCOL request move PATH[?QUERY] DEST Performs a MOVE request propfind PATH[?QUERY] Performs a PROPFIND request proppatch PATH[?QUERY] Performs a PROPPATCH request trace PATH[?QUERY] Performs a TRACE request unlock PATH[?QUERY] Performs a UNLOCK request cd PATH Changes the base URL path headers [{set | unset} NAME [VALUE]] Manages the request headers
Imprimir o status HTTP de cada URL em um arquivo:```shell
$ ronin url --file urls.txt --status
Gere um novo script Ruby com ronin-support pré-carregado:```shell $ ronin new script foo.rb
Crie um novo projeto Ruby com um `Gemfile`:```shell
$ ronin new project foo
Gere um novo nokogiri script Ruby para analisar HTML/XML:
$ ronin new nokogiri foo.rb
Gere um novo [ronin-web-server] script Ruby:```shell
$ ronin new web-server my_server.rb
Gere uma nova aplicação web baseada em ronin-web-server:```shell $ ronin new web-app my_app
Gerar um novo [ronin-web-spider] script Ruby:```shell
$ ronin new web-spider --host=example.com my_spider.rb
Gere um script ronin-listener-dns:```shell $ ronin new dns-listener my_dns_listener.rb
Gere um script [ronin-dns-proxy]:```shell
$ ronin new dns-proxy my_dns_proxy.rb
Gere um script ronin-listener-http:```shell $ ronin new http-listener my_http_listener.rb
Gere um script [ronin-exploits]:```shell
$ ronin new exploit my_exploit.rb
Gere um script ronin-payloads:```shell $ ronin new payload my_payload.rb
### Arquivo
Arquivos de arquivo:```shell
$ ronin archive -o archive.zip file1.txt file2.txt
Arquive arquivos usando o formato tar:```shell $ ronin archive -o archive.tar file1.txt file2.txt
Desarquivar arquivos:```shell
$ ronin unarchive arch1.tar arch2.zip
Desarquivar um arquivo com formato explícito:```shell $ ronin unarchive -f zip arch2.jar
### Consulte Também
* [ronin-repos](https://github.com/ronin-rb/ronin-repos#synopsis)
* [ronin-wordlists](https://github.com/ronin-rb/ronin-wordlists#synopsis)
* [ronin-db](https://github.com/ronin-rb/ronin-db#synopsis)
* [ronin-web](https://github.com/ronin-rb/ronin-web#synopsis)
* [ronin-fuzzer](https://github.com/ronin-rb/ronin-fuzzer#synopsis)
* [ronin-payloads](https://github.com/ronin-rb/ronin-payloads#synopsis)
* [ronin-exploits](https://github.com/ronin-rb/ronin-exploits#synopsis)
* [ronin-vulns](https://github.com/ronin-rb/ronin-vulns#synopsis)
## Requisitos
* [gcc] / [clang]
* [make]
* [git]
* [libsqlite3]
* [Ruby] >= 3.2.0
* [open_namespace] ~> 0.4
* [rouge] ~> 3.0
* [io-endpoint] ~> 0.15
* [io-stream] ~> 0.8
* [wordlist] ~> 1.1
* [ronin-support] ~> 1.1
* [ronin-dns-proxy] ~> 0.1
* [ronin-core] ~> 0.2
* [ronin-repos] ~> 0.1
* [ronin-wordlists] ~> 0.1
* [ronin-db] ~> 0.1
* [ronin-listener] ~> 0.1
* [ronin-nmap] ~> 0.1
* [ronin-masscan] ~> 0.1
* [ronin-recon] ~> 0.1
* [ronin-fuzzer] ~> 0.1
* [ronin-web] ~> 2.0
* [ronin-code-asm] ~> 1.0
* [ronin-code-sql] ~> 2.0
* [ronin-payloads] ~> 0.1
* [ronin-exploits] ~> 1.0
* [ronin-vulns] ~> 0.2
* [ronin-app] ~> 0.1
## Instalação
### Script Bash```shell
curl -o ronin-install.sh https://raw.githubusercontent.com/ronin-rb/scripts/main/ronin-install.sh && bash ronin-install.sh
Consulte as instruções de instalação manual para saber como instalar o Ronin e suas dependências adicionais na sua plataforma.
Se preferir usar o Docker, também há [imagens Docker] disponíveis:```shell docker pull roninrb/ronin docker run -it roninrb/ronin
Além disso, se você quiser montar seu diretório home na imagem Docker:```shell
docker run --mount type=bind,source="$HOME",target=/home/ronin -it ronin
cd ronin./scripts/setupgit checkout -b my_featurebundle exec rake specgit push origin my_featureCopyright (c) 2006-2026 Hal Brodigan (postmodern.mod3 at gmail.com)
Ronin é um software livre: você pode redistribuí-lo e/ou modificá-lo sob os termos da Licença Pública Geral GNU, conforme publicada pela Free Software Foundation, seja a versão 3 da Licença, ou (a seu critério) qualquer versão posterior.
Ronin é distribuído na esperança de que seja útil, mas SEM QUALQUER GARANTIA; sem sequer a garantia implícita de COMERCIALIZAÇÃO ou ADEQUAÇÃO A UM DETERMINADO FIM. Consulte a Licença Pública Geral GNU para obter mais detalhes.
Você deve ter recebido uma cópia da Licença Pública Geral GNU junto com o Ronin. Caso contrário, veja https://www.gnu.org/licenses/.