ronin

• Sito web
• Codice sorgente
• Problemi
• Documentazione
• Discord | Mastodon

Descrizione

Ronin è un toolkit gratuito e open source in Ruby per la ricerca e lo sviluppo sulla sicurezza. Ronin contiene molti diversi comandi CLI e librerie Ruby per una varietà di attività di sicurezza, come codifica/decodifica dati, filtraggio IP/host/URL, interrogazione ASN, interrogazione DNS, HTTP, scansione di vulnerabilità web, spidering di siti web, installazione di repository di terze parti di exploit e/o payload, esecuzione di exploit, sviluppo di nuovi exploit, gestione di database locali, fuzzing di dati, ricognizione e molto altro.

A chi è rivolto Ronin?

• Giocatori di CTF
• Cacciatori di bug bounty
• Ricercatori di sicurezza
• Ingegneri della sicurezza
• Sviluppatori
• Studenti

Cosa fornisce Ronin?

• Un toolkit di comandi utili.
• Una REPL Ruby completa.
• Un ecosistema di librerie Ruby di alta qualità relative alla sicurezza, API e comandi.
• Un'interfaccia web locale leggera.

Cosa puoi fare con Ronin?

• Elaborare e interrogare rapidamente vari dati utilizzando i comandi ronin.
• Lavorare in modo efficiente con codice e dati nella REPL Ruby ronin irb.
• Prototipare rapidamente script Ruby utilizzando ronin-support e altre librerie ronin.
• Installare repository git di terze parti di exploit, payload o altro codice, utilizzando ronin-repos.
• Importare e interrogare dati utilizzando il database ronin-db.
• Eseguire fuzzing dei dati utilizzando ronin-fuzzer.
• Eseguire ricognizione utilizzando ronin-recon.
• Usare payload comuni o scrivere i propri utilizzando ronin-payloads.
• Scrivere/eseguire exploit utilizzando ronin-exploits.
• Eseguire scansioni di vulnerabilità web utilizzando ronin-vulns.
• Eseguire scansioni e navigare nel database nel tuo browser utilizzando ronin-app.

Sinossi```

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

Elenco dei comandi di ronin:```shell
$ ronin help

Visualizza una pagina man per un comando:```shell $ ronin help COMMAND

Ottieni un suggerimento casuale su come usare `ronin`:```shell
$ ronin tips

Apri il REPL Ruby di 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)>

Avvia e apre l'interfaccia web interattiva per Ronin:```
$ ronin-app

Binario

Esegue dump esadecimali dei dati in vari formati:```shell $ ronin hexdump /bin/ls

Ripristina un file hexdump nei suoi dati binari grezzi originali:```shell
$ ronin unhexdump -o data.bin hexdump.txt

Stampa tutte le stringhe stampabili da un file:```shell $ ronin strings /bin/ls

Stampa tutte le stringhe alfabetiche da un file:```shell
$ ronin strings --alpha /bin/ls

Stampa tutte le stringhe alfanumeriche da un file:```shell $ ronin strings --alpha-num /bin/ls

Stampa tutte le stringhe numeriche da un file:```shell
$ ronin strings --numeric /bin/ls

Stampa tutte le stringhe esadecimali da un file:```shell $ ronin strings --hex /bin/ls

Enumera attraverso tutti i bit-flip di un nome di 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
...

Codifica

Codifica una stringa in Base64:```shell $ ronin encode --base64 --string "foo bar baz" Zm9vIGJhciBiYXo=

Zlib comprime, codifica in Base64 e poi codifica URI una stringa:```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

Decodifica Base64 di una stringa:```shell $ ronin decode --base64 --string "Zm9vIGJhciBiYXo=" foo bar baz

URI decode, Base64 decode, and then zlib inflates a string:
→
Decodifica URI, decodifica Base64, e poi decomprime zlib una stringa:```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

Escape URI di una stringa:```shell $ ronin escape --uri --string "foo bar" foo%20bar

Decodifica URI di una stringa:```shell
$ ronin unescape --uri --string "foo%20bar"
foo bar

Converti un file in una stringa C tra virgolette:```shell $ ronin quote --c file.bin "..."

Converti un file in una stringa JavaScript tra virgolette:```shell
$ ronin quote --js file.bin

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

### Text

Estrai dati ad alta entropia da un file:```shell
$ ronin entropy -e 5.0 index.html

Grep per pattern comuni di dati:```shell $ ronin grep --hash index.html

Estrai schemi comuni dai dati:```shell
$ ronin extract --hash index.html

Genera un typo casuale di una parola:```shell $ ronin typo microsoft microssoft

Enumera ogni variazione di errore di battitura di una parola:```shell
$ ronin typo --enum microsoft
microosoft
microsooft
microssoft

Genera una versione casuale di una parola in omoglifi:```shell $ ronin homoglyph CEO CＥO

Enumera ogni variazione omoglifica di una parola:```shell
$ ronin homoglyph --enum CEO
ϹEO
СEO
ⅭEO
ＣEO
CΕO
CЕO
CＥO
CEΟ
CEО
CEＯ

Evidenzia la sintassi di un file:```shell $ ronin highlight index.html

### Crittografia

AES-256 cifra un file:```shell
$ ronin encrypt --cipher aes-256-cbc --password "..." file.txt > encrypted.bin

Decriptare i dati:```shell $ ronin decrypt --cipher aes-256-cbc --password "..." encrypted.bin

Genera un HMAC per un file:```shell
$ ronin hmac --hash sha1 --password "too many secrets" data.txt

Genera un HMAC per una stringa:```shell $ ronin hmac --hash sha1 --password "too many secrets" --string "..."

Calcola un checksum MD5 di una stringa:```shell
$ ronin md5 --string "hello world"
5eb63bbbe01eeed093cb22bb8f5acdc3

Calcola il checksum MD5 di un file:```shell $ ronin md5 file.txt

Calcola il checksum MD5 di ogni riga in un file:```shell
$ ronin md5 --multiline file.txt

Calcola un checksum SHA1 di una stringa:```shell $ ronin sha1 --string "hello world" 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed

Calcola il checksum SHA1 di un file:```shell
$ ronin sha1 file.txt

Calcola il checksum SHA1 di ogni riga in un file:```shell $ ronin sha1 --multiline file.txt

Calcola un checksum SHA256 di una stringa:```shell
$ ronin sha256 --string "hello world"
b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9

Calcola il checksum SHA256 di un file:```shell $ ronin sha256 file.txt

Calcola il checksum SHA256 di ogni riga in un file:```shell
$ ronin sha256 --multiline file.txt

Calcola un checksum SHA512 di una stringa:```shell $ ronin sha512 --string "hello world" 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f

Calcola il checksum SHA512 di un file:```shell
$ ronin sha512 file.txt

Calcola il checksum SHA512 di ogni riga in un file:```shell $ ronin sha512 --multiline file.txt

ROT-13 codifica una stringa:```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 stringa:```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&,&"

### Networking

Interroga l'ASN di un indirizzo IP:```shell
$ ronin asn -I 4.2.2.1
4.0.0.0/9 AS3356 (US) LEVEL3

Ottieni l'indirizzo IP esterno/pubblico del sistema:```shell $ ronin ip --public

Converti un indirizzo IP in formato decimale:```shell
$ ronin ip --decimal 127.0.0.1
2130706433

Converti un file di indirizzi IP in URL:```shell $ ronin ip --file targets.txt --http

Enumera tutti gli indirizzi IP nell'intervallo 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 ogni indirizzo IP nell'intervallo di 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 ...

Enumerare tutti gli indirizzi IP tra due indirizzi 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

Connetti a un servizio TCP remoto:```shell $ ronin netcat -v example.com 80

Ascolta su una porta TCP locale:```shell
$ ronin netcat -v -l 1337

Connettersi a un servizio SSL/TLS remoto:```shell $ ronin netcat -v --ssl example.com 443

Connettersi a un servizio UDP remoto:```shell
$ ronin netcat -v -u example.com 1337

Ascolta su una porta UDP locale:```shell $ ronin netcat -v -u -l 1337

Apre un socket UNIX:```shell
$ ronin netcat -v --unix /path/to/unix.socket

Hexdump di tutti i dati ricevuti da 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

Interroga i record DNS:```shell
$ ronin dns -t TXT github.com

Trova tutti i TLD registrati per un nome host:```shell $ ronin host --enum-tlds --registered github.com github.ac github.actor github.ae github.africa github.agency github.ai ...

Trova tutti i suffissi pubblici registrati per un nome 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
...

Trova tutti i sottodomini che hanno indirizzi:```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 ...

Enumera tutte le possibili variazioni typosquat di un dominio:```shell
$ ronin typosquat microsoft.com
microosoft.com
microsooft.com
microssoft.com

Trova tutti i domini typosquat registrati per un dominio valido:```shell $ ronin typosquat --registered microsoft.com

Trova tutti i domini typosquat con indirizzi per un dominio valido:```shell
$ ronin typosquat --has-addresses microsoft.com

Trova tutti i domini typosquat non registrati per un dominio valido:```shell $ ronin typosquat --unregistered microsoft.com

De-offuscare un indirizzo email:```shell
$ ronin email-addr --deobfuscate "john [dot] smith [at] example [dot] com"
[email protected]

Enumera attraverso tutte le offuscazioni di un indirizzo email:```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 ...

#### Certificati SSL/TLS

Estrai informazioni su un certificato SSL/TLS:```shell
$ ronin cert-dump https://example.com/

Scarica un certificato SSL/TLS da un host e una porta:```shell $ ronin cert-grab github.com:443

Genera un nuovo certificato SSL/TLS:```shell
$ ronin cert-gen -c test.com -O "Test Co" -U "Test Dept" \
                 -L "Test City" -S NY -C US

HTTP

Esegui una richiesta HTTP GET (con evidenziazione della sintassi):```shell $ ronin http https://example.com/

Invia una richiesta HTTP con intestazioni aggiuntive:```shell
$ ronin http --post --header "Authorization: ..." https://foo.bar/

Invia una richiesta HTTP con una stringa User-Agent nota:```shell $ ronin http --post --user-agent chrome-android https://foo.bar/

Invia una richiesta HTTP con una stringa `User-Agent` personalizzata:```shell
$ ronin http --post --user-agent-string "..." https://foo.bar/

Apri una shell HTTP interattiva:```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

Stampa lo stato HTTP di ogni URL in un file:```shell
$ ronin url --file urls.txt --status

Generatori

Genera un nuovo script Ruby con ronin-support preinstallato:```shell $ ronin new script foo.rb

Genera un nuovo progetto Ruby con un `Gemfile`:```shell
$ ronin new project foo

Genera un nuovo script Ruby nokogiri per il parsing di HTML/XML:

$ ronin new nokogiri foo.rb

Genera un nuovo script Ruby [ronin-web-server]:```shell
$ ronin new web-server my_server.rb

Genera una nuova web app basata su ronin-web-server:```shell $ ronin new web-app my_app

Genera un nuovo [ronin-web-spider] Ruby script:```shell
$ ronin new web-spider --host=example.com my_spider.rb

Genera uno script ronin-listener-dns:```shell $ ronin new dns-listener my_dns_listener.rb

Genera uno script [ronin-dns-proxy]:```shell
$ ronin new dns-proxy my_dns_proxy.rb

Genera uno ronin-listener-http script:```shell $ ronin new http-listener my_http_listener.rb

Genera uno script [ronin-exploits]:```shell
$ ronin new exploit my_exploit.rb

Genera un ronin-payloads script:```shell $ ronin new payload my_payload.rb

### Archivio

File di archivio:```shell
$ ronin archive -o archive.zip file1.txt file2.txt

Archivia i file usando il formato tar:```shell $ ronin archive -o archive.tar file1.txt file2.txt

Estrarre file:```shell
$ ronin unarchive arch1.tar arch2.zip

Decomprimere un file con formato esplicito:```shell $ ronin unarchive -f zip arch2.jar

### Vedi Anche

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

## Requisiti

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

## Installazione

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

Manualmente

Consulta le istruzioni di installazione manuale per installare Ronin e le sue dipendenze aggiuntive sulla tua piattaforma.

Docker

Se preferisci usare Docker, sono disponibili anche Docker images:```shell docker pull roninrb/ronin docker run -it roninrb/ronin

Inoltre, se desideri montare la tua directory home nell'immagine docker:```shell
docker run --mount type=bind,source="$HOME",target=/home/ronin -it ronin

Sviluppo

1. Forka!
2. Clona!
3. cd ronin
4. ./scripts/setup
5. git checkout -b my_feature
6. Codifica!
7. bundle exec rake spec
8. git push origin my_feature

Licenza

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

Ronin è un software libero: puoi ridistribuirlo e/o modificarlo sotto i termini della GNU General Public License come pubblicata dalla Free Software Foundation, versione 3 della Licenza, o (a tua scelta) qualsiasi versione successiva.

Ronin è distribuito nella speranza che sia utile, ma SENZA ALCUNA GARANZIA; senza nemmeno la garanzia implicita di COMMERCIABILITÀ o IDONEITÀ PER UN PARTICOLARE SCOPO. Vedi la GNU General Public License per maggiori dettagli.

Dovresti aver ricevuto una copia della GNU General Public License insieme a Ronin. Se non l'hai ricevuta, visita https://www.gnu.org/licenses/.