ronin

Descripción

[Ronin][website] es un conjunto de herramientas [Ruby] gratuito y de código abierto para la investigación y el desarrollo en seguridad. Ronin contiene muchos comandos CLI y [bibliotecas Ruby][ronin-rb] diferentes para una variedad de tareas de seguridad, como codificar/decodificar datos, filtrar IPs/hosts/URLs, consultar ASNs, consultar DNS, HTTP, [escanear vulnerabilidades web][ronin-vulns-synopsis], [navegar por sitios web][ronin-web-spider], [instalar repositorios de terceros][ronin-repos-synopsis] de [exploits][ronin-exploits] y/o [payloads][ronin-payloads], [ejecutar exploits][ronin-exploits-synopsis], [desarrollar nuevos exploits][ronin-exploits-examples], [gestionar bases de datos locales][ronin-db-synopsis], [fuzzear datos][ronin-fuzzer], [realizar reconocimiento][ronin-recon-synopsis] y mucho más.

¿Para quién es Ronin?

Jugadores de CTF
Cazadores de Bug Bounties
Investigadores de seguridad
Ingenieros de seguridad
Desarrolladores
Estudiantes

¿Qué ofrece Ronin?

Un conjunto de comandos útiles.
Un REPL de Ruby completamente equipado.
Un ecosistema de bibliotecas, API y comandos de Ruby de alta calidad relacionados con la seguridad.
Una interfaz web local ligera.

¿Qué puedes hacer con Ronin?

Procesar y consultar rápidamente diversos datos usando los comandos ronin.
Trabajar eficientemente con código y datos en el REPL de Ruby ronin irb.
Prototipar rápidamente scripts de Ruby usando [ronin-support] y otras bibliotecas ronin.
Instalar repositorios [git] de terceros de exploits, payloads u otro código, usando [ronin-repos].
Importar y consultar datos usando la base de datos [ronin-db].
Fuzzear datos usando [ronin-fuzzer].
Realizar reconocimiento usando [ronin-recon].
Usar payloads comunes o escribir los tuyos usando [ronin-payloads].
Escribir/ejecutar exploits usando [ronin-exploits].
Escanear vulnerabilidades web usando [ronin-vulns].
Realiza escaneos y navega la base de datos en tu navegador usando [ronin-app].

Sinopsis```

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

Lista de comandos de ronin:```shell
$ ronin help

Ver una página de manual para un comando:```shell $ ronin help COMMAND

Obtén un consejo aleatorio sobre cómo usar `ronin`:```shell
$ ronin tips

Abre el REPL de Ruby de Ronin:``` $ 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 y abre la interfaz web interactiva para Ronin:```
$ ronin-app

Binary

Realiza volcados hexadecimales de datos en una variedad de formatos:```shell $ ronin hexdump /bin/ls

Convierte un archivo hexdump de vuelta a sus datos binarios originales en bruto:```shell
$ ronin unhexdump -o data.bin hexdump.txt

Imprimir todas las cadenas imprimibles de un archivo:```shell $ ronin strings /bin/ls

Imprimir todas las cadenas alfabéticas de un archivo:```shell
$ ronin strings --alpha /bin/ls

Imprimir todas las cadenas alfanuméricas de un archivo:```shell $ ronin strings --alpha-num /bin/ls

Imprimir todas las cadenas numéricas de un archivo:```shell
$ ronin strings --numeric /bin/ls

Imprimir todas las cadenas hexadecimales de un archivo:```shell $ ronin strings --hex /bin/ls

Enumerar todas las inversiones de bits de un nombre de dominio:```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
...

Codificación

Codificar una cadena en Base64:```shell $ ronin encode --base64 --string "foo bar baz" Zm9vIGJhciBiYXo=

Comprime con Zlib, codifica en Base64 y luego codifica en URI una cadena:```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 una cadena en Base64:```shell $ ronin decode --base64 --string "Zm9vIGJhciBiYXo=" foo bar baz

Decodificar URI, decodificar Base64 y luego inflar con zlib una cadena:```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 una cadena para URI:```shell $ ronin escape --uri --string "foo bar" foo%20bar

Desescapar un URI de una cadena:```shell
$ ronin unescape --uri --string "foo%20bar"
foo bar

Convertir un archivo en una cadena C entrecomillada:```shell $ ronin quote --c file.bin "..."

Convertir un archivo en una cadena de JavaScript entrecomillada:```shell
$ ronin quote --js file.bin

Desencomillar una cadena C:```shell $ ronin unquote --c --string '"\x66\x6f\x6f\x20\x62\x61\x72"' foo bar

### Texto

Extraer datos de alta entropía de un archivo:```shell
$ ronin entropy -e 5.0 index.html

Búsqueda con Grep de patrones comunes de datos:```shell $ ronin grep --hash index.html

Extraer patrones comunes de datos:```shell
$ ronin extract --hash index.html

Genera un error tipográfico aleatorio de una palabra:```shell $ ronin typo microsoft microssoft

Enumerar cada variación tipográfica de una palabra:```shell
$ ronin typo --enum microsoft
microosoft
microsooft
microssoft

Genera una versión aleatoria de homoglifo de una palabra:```shell $ ronin homoglyph CEO CＥO

Enumera todas las variaciones de homoglifos de una palabra:```shell
$ ronin homoglyph --enum CEO
ϹEO
СEO
ⅭEO
ＣEO
CΕO
CЕO
CＥO
CEΟ
CEО
CEＯ

Resalta sintácticamente un archivo:

$ ronin highlight index.html
```
### Criptografía

Cifrar un archivo con AES-256:```shell
$ ronin encrypt --cipher aes-256-cbc --password "..." file.txt > encrypted.bin
```
Descifrar datos:```shell
$ ronin decrypt --cipher aes-256-cbc --password "..." encrypted.bin
```
Genera un HMAC para un archivo:```shell
$ ronin hmac --hash sha1 --password "too many secrets" data.txt
```
Genera un HMAC para una cadena:```shell
$ ronin hmac --hash sha1 --password "too many secrets" --string "..."
```
Calcula una suma de comprobación MD5 de una cadena:```shell
$ ronin md5 --string "hello world"
5eb63bbbe01eeed093cb22bb8f5acdc3
```
Calcular la suma de verificación MD5 de un archivo:```shell
$ ronin md5 file.txt
```
Calcular el checksum MD5 de cada línea en un archivo:```shell
$ ronin md5 --multiline file.txt
```
Calcular un checksum SHA1 de una cadena:```shell
$ ronin sha1 --string "hello world"
2aae6c35c94fcfb415dbe95f408b9ce91ee846ed
```
Calcula la suma de comprobación SHA1 de un archivo:```shell
$ ronin sha1 file.txt
```
Calcular el checksum SHA1 de cada línea de un archivo:```shell
$ ronin sha1 --multiline file.txt
```
Calcular una checksum SHA256 de una cadena:```shell
$ ronin sha256 --string "hello world"
b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
```
Calcula el checksum SHA256 de un archivo:```shell
$ ronin sha256 file.txt
```
Calcular el checksum SHA256 de cada línea en un archivo:```shell
$ ronin sha256 --multiline file.txt
```
Calcula un checksum SHA512 de una cadena:```shell
$ ronin sha512 --string "hello world"
309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f
```
Calcular el checksum SHA512 de un archivo:```shell
$ ronin sha512 file.txt
```
Calcular el checksum SHA512 de cada línea en un archivo:```shell
$ ronin sha512 --multiline file.txt
```
ROT-13 codifica una cadena:```shell
$ ronin rot --string "The quick brown fox jumps over the lazy dog"
Gur dhvpx oebja sbk whzcf bire gur ynml qbt
```
XOR codifica una cadena:```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 el ASN de una dirección IP:```shell
$ ronin asn -I 4.2.2.1
4.0.0.0/9 AS3356 (US) LEVEL3
```
Obtener la dirección IP externa/pública del sistema:```shell
$ ronin ip --public
```
Convierte una dirección IP a formato decimal:```shell
$ ronin ip --decimal 127.0.0.1
2130706433
```
Convertir un archivo de direcciones IP en URLs:```shell
$ ronin ip --file targets.txt --http
```
Enumerar cada dirección IP en el rango IP CIDR:```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
...
```
Enumera sobre cada dirección IP en el rango glob IP:```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
...
```
Enumerar cada dirección IP entre dos direcciones 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
```
Conectar a un servicio TCP remoto:```shell
$ ronin netcat -v example.com 80
```
Escucha en un puerto TCP local:```shell
$ ronin netcat -v -l 1337
```
Conectar a un servicio SSL/TLS remoto:```shell
$ ronin netcat -v --ssl example.com 443
```
Conectar a un servicio UDP remoto:```shell
$ ronin netcat -v -u example.com 1337
```
Escuche en un puerto UDP local:```shell
$ ronin netcat -v -u -l 1337
```
Abre un socket UNIX:```shell
$ ronin netcat -v --unix /path/to/unix.socket
```
Volcar en hexadecimal todos los datos recibidos de un 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
```
Encuentra todos los TLDs registrados para un nombre de host:```shell
$ ronin host --enum-tlds --registered github.com
github.ac
github.actor
github.ae
github.africa
github.agency
github.ai
...
```
Encuentra todos los sufijos públicos registrados para un nombre 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
...
```
Encuentra todos los subdominios que tengan direcciones:```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
...
```
Enumerar cada variación posible de typosquat de un dominio:```shell
$ ronin typosquat microsoft.com
microosoft.com
microsooft.com
microssoft.com
```
Encuentra todos los dominios de typosquatting registrados para un dominio válido:```shell
$ ronin typosquat --registered microsoft.com
```
Encuentra todos los dominios de typosquatting con direcciones para un dominio válido:```shell
$ ronin typosquat --has-addresses microsoft.com
```
Encuentra todos los dominios de typosquat no registrados para un dominio válido:```shell
$ ronin typosquat --unregistered microsoft.com
```
Desofuscar una dirección de correo electrónico:```shell
$ ronin email-addr --deobfuscate "john [dot] smith [at] example [dot] com"
[email protected]
```
Enumera todas las ofuscaciones de una dirección de correo electrónico:```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

Extraer información de un certificado SSL/TLS:```shell
$ ronin cert-dump https://example.com/
```
Descargar un certificado SSL/TLS de un host y puerto:```shell
$ ronin cert-grab github.com:443
```
Generar un nuevo certificado SSL/TLS:```shell
$ ronin cert-gen -c test.com -O "Test Co" -U "Test Dept" \
                 -L "Test City" -S NY -C US
```
#### HTTP

Realiza una solicitud HTTP `GET` (con resaltado de sintaxis):```shell
$ ronin http https://example.com/
```
Enviar una solicitud HTTP con encabezados adicionales:```shell
$ ronin http --post --header "Authorization: ..." https://foo.bar/
```
Envía una solicitud HTTP con una cadena `User-Agent` conocida:```shell
$ ronin http --post --user-agent chrome-android https://foo.bar/
```
Envía una solicitud HTTP con una cadena `User-Agent` personalizada:```shell
$ ronin http --post --user-agent-string "..." https://foo.bar/
```
Abre un shell HTTP interactivo:```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
```
Imprime el estado HTTP de cada URL en un archivo:```shell
$ ronin url --file urls.txt --status
```
### Generadores

Genera un nuevo script de Ruby con [ronin-support] precargado:```shell
$ ronin new script foo.rb
```
Genera un nuevo proyecto de Ruby con un `Gemfile`:```shell
$ ronin new project foo
```
Generar un nuevo script Ruby [nokogiri] para analizar HTML/XML:

[nokogiri]: https://nokogiri.org/%60%60%60shell
$ ronin new nokogiri foo.rb
```
Genera un nuevo [ronin-web-server] script Ruby:```shell
$ ronin new web-server my_server.rb
```
Genera una nueva aplicación web basada en [ronin-web-server]:```shell
$ ronin new web-app my_app
```
Genera un nuevo [ronin-web-spider] script Ruby:```shell
$ ronin new web-spider --host=example.com my_spider.rb
```
Generar un script [ronin-listener-dns]:```shell
$ ronin new dns-listener my_dns_listener.rb
```
Genera un [ronin-dns-proxy] script:```shell
$ ronin new dns-proxy my_dns_proxy.rb
```
Genera un script [ronin-listener-http]:```shell
$ ronin new http-listener my_http_listener.rb
```
Genera un script [ronin-exploits]:```shell
$ ronin new exploit my_exploit.rb
```
Generar un [ronin-payloads] script:```shell
$ ronin new payload my_payload.rb
```
### Archivo

Archivos de archivo:```shell
$ ronin archive -o archive.zip file1.txt file2.txt
```
Archivar archivos usando el formato tar:```shell
$ ronin archive -o archive.tar file1.txt file2.txt
```
Descomprimir archivos:```shell
$ ronin unarchive arch1.tar arch2.zip
```
Descomprimir un archivo con formato explícito:```shell
$ ronin unarchive -f zip arch2.jar
```
### Véase también

* [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

## Instalación

### Script de Bash```shell
curl -o ronin-install.sh https://raw.githubusercontent.com/ronin-rb/scripts/main/ronin-install.sh && bash ronin-install.sh
```
### Manual

Consulte las instrucciones de [instalación manual][manual-instructions] para saber cómo instalar
Ronin y sus dependencias adicionales en su plataforma.

[manual-instructions]: https://ronin-rb.dev/install/#manual-instructions

### Docker

Si prefiere usar [Docker], también hay [imágenes de Docker] disponibles:```shell
docker pull roninrb/ronin
docker run -it roninrb/ronin
```
Además, si deseas montar tu directorio de inicio en la imagen de docker:```shell
docker run --mount type=bind,source="$HOME",target=/home/ronin -it ronin
```
[Docker]: https://www.docker.com/
[Docker images]: https://hub.docker.com/r/roninrb/ronin

## Desarrollo

1. ¡Haz un Fork! (https://github.com/ronin-rb/ronin/fork)
2. ¡Clónalo!
3. `cd ronin`
4. `./scripts/setup`
5. `git checkout -b mi_caracteristica`
6. ¡Escríbelo!
7. `bundle exec rake spec`
8. `git push origin mi_caracteristica`

## Licencia

Copyright (c) 2006-2026 Hal Brodigan (postmodern.mod3 at gmail.com)

Ronin es software libre: puedes redistribuirlo y/o modificarlo
bajo los términos de la Licencia Pública General GNU publicada por
la Free Software Foundation, ya sea la versión 3 de la Licencia, o
(a tu elección) cualquier versión posterior.

Ronin se distribuye con la esperanza de que sea útil,
pero SIN NINGUNA GARANTÍA; sin siquiera la garantía implícita de
COMERCIABILIDAD o IDONEIDAD PARA UN PROPÓSITO PARTICULAR.  Véase la
Licencia Pública General GNU para más detalles.

Deberías haber recibido una copia de la Licencia Pública General GNU
junto con Ronin.  Si no es así, visita <https://www.gnu.org/licenses/>.

[website]: https://ronin-rb.dev/
[ronin-rb]: https://github.com/ronin-rb/

[gcc]: http://gcc.gnu.org/
[clang]: http://clang.llvm.org/
[git]: https://git-scm.com/
[make]: https://www.gnu.org/software/automake/
[libsqlite3]: https://www.sqlite.org/index.html
[Ruby]: https://www.ruby-lang.org
[open_namespace]: https://github.com/postmodern/open_namespace#readme
[rouge]: https://github.com/rouge-ruby/rouge#readme
[io-endpoint]: https://github.com/socketry/io-endpoint#readme
[io-stream]: https://github.com/socketry/io-stream#readme
[wordlist]: https://github.com/postmodern/wordlist.rb#readme

[ronin-support]: https://github.com/ronin-rb/ronin-support#readme
[ronin-dns-proxy]: https://github.com/ronin-rb/ronin-dns-proxy#readme
[ronin-repos]: https://github.com/ronin-rb/ronin-repos#readme
[ronin-repos-synopsis]: https://github.com/ronin-rb/ronin-repos#readme
[ronin-wordlists]: https://github.com/ronin-rb/ronin-wordlists#readme
[ronin-wordlists-synopsis]: https://github.com/ronin-rb/ronin-wordlists#readme
[ronin-core]: https://github.com/ronin-rb/ronin-core#readme
[ronin-db]: https://github.com/ronin-rb/ronin-db#readme
[ronin-db-synopsis]: https://github.com/ronin-rb/ronin-db#readme
[ronin-listener]: https://github.com/ronin-rb/ronin-listener#readme
[ronin-listener-dns]: https://github.com/ronin-rb/ronin-listener-dns#readme
[ronin-listener-http]: https://github.com/ronin-rb/ronin-listener-http#readme
[ronin-nmap]: https://github.com/ronin-rb/ronin-nmap#readme
[ronin-masscan]: https://github.com/ronin-rb/ronin-masscan#readme
[ronin-recon]: https://github.com/ronin-rb/ronin-recon#readme
[ronin-recon-synopsis]: https://github.com/ronin-rb/ronin-recon#readme
[ronin-fuzzer]: https://github.com/ronin-rb/ronin-fuzzer#readme
[ronin-web]: https://github.com/ronin-rb/ronin-web#readme
[ronin-web-server]: https://github.com/ronin-rb/ronin-web-server#readme
[ronin-web-spider]: https://github.com/ronin-rb/ronin-web-spider#readme
[ronin-web-user_agents]: https://github.com/ronin-rb/ronin-web-user_agents#readme
[ronin-code-asm]: https://github.com/ronin-rb/ronin-code-asm#readme
[ronin-code-sql]: https://github.com/ronin-rb/ronin-code-sql#readme
[ronin-payloads]: https://github.com/ronin-rb/ronin-payloads#readme
[ronin-exploits]: https://github.com/ronin-rb/ronin-exploits#readme
[ronin-exploits-synopsis]: https://github.com/ronin-rb/ronin-exploits#readme
[ronin-exploits-examples]: https://github.com/ronin-rb/ronin-exploits#readme
[ronin-vulns]: https://github.com/ronin-rb/ronin-vulns#readme
[ronin-vulns-synopsis]: https://github.com/ronin-rb/ronin-vulns#readme
[ronin-app]: https://github.com/ronin-rb/ronin-app#readme

Más Populares

ronin

ronin

Descripción

¿Para quién es Ronin?

¿Qué ofrece Ronin?

¿Qué puedes hacer con Ronin?

Sinopsis```

Binary

Codificación