Ronin ist ein kostenloses und quelloffenes Ruby-Toolkit für Sicherheitsforschung und -entwicklung. Ronin ermöglicht zudem die schnelle Entwicklung und Verteilung von Code, Exploits, Payloads usw. über Drittanbieter-Git-Repositories.
Ronin ist ein kostenloser und Open Source Ruby-Toolkit für Sicherheitsforschung und -entwicklung. Ronin enthält viele verschiedene CLI-Befehle und Ruby-Bibliotheken für eine Vielzahl von Sicherheitsaufgaben, wie z. B. Kodieren/Dekodieren von Daten, Filtern von IPs/Hosts/URLs, Abfragen von ASNs, DNS-Abfragen, HTTP, Scannen nach Websicherheitslücken, Websites spidern, Installieren von Drittanbieter-Repositories von Exploits und/oder Payloads, Ausführen von Exploits, Entwickeln neuer Exploits, Verwalten lokaler Datenbanken, Fuzzing von Daten, Durchführen von Recon und vielem mehr.
ronin-Befehlen.ronin irb Ruby-REPL.ronin-Bibliotheken.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 der ronin-Befehle:```shell
$ ronin help
Eine Manpage für einen Befehl anzeigen:```shell $ ronin help COMMAND
Erhalte einen zufälligen Tipp zur Verwendung von `ronin`:```shell
$ ronin tips
Öffnen Sie die 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)>
Startet und öffnet die interaktive Web-Benutzeroberfläche für Ronin:```
$ ronin-app
Erstellt Hex-Dumps von Daten in verschiedenen Formaten:```shell $ ronin hexdump /bin/ls
Wandelt eine Hexdump-Datei zurück in ihre ursprünglichen rohen Binärdaten:```shell
$ ronin unhexdump -o data.bin hexdump.txt
Alle druckbaren Zeichenfolgen aus einer Datei ausgeben:```shell $ ronin strings /bin/ls
Alle alphabetischen Zeichenketten aus einer Datei ausgeben:```shell
$ ronin strings --alpha /bin/ls
Alle alphanumerischen Zeichenketten aus einer Datei ausgeben:```shell $ ronin strings --alpha-num /bin/ls
Gib alle numerischen Zeichenketten aus einer Datei aus:```shell
$ ronin strings --numeric /bin/ls
Alle hexadezimalen Zeichenketten aus einer Datei ausgeben:```shell $ ronin strings --hex /bin/ls
Alle Bit-Flips eines Domainnamens aufzählen:```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
...
Base64-codieren Sie eine Zeichenkette:```shell $ ronin encode --base64 --string "foo bar baz" Zm9vIGJhciBiYXo=
Zlib komprimiert, Base64 kodiert und dann URI kodiert einen 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
Base64-String dekodieren:```shell $ ronin decode --base64 --string "Zm9vIGJhciBiYXo=" foo bar baz
URI-Decodierung, Base64-Decodierung und dann zlib-Dekomprimierung eines Strings:```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
URI-Escape einer Zeichenkette:```shell $ ronin escape --uri --string "foo bar" foo%20bar
URI-Dekodierung eines Strings:```shell
$ ronin unescape --uri --string "foo%20bar"
foo bar
Konvertiere eine Datei in einen zitierten C-String:```shell $ ronin quote --c file.bin "..."
Konvertieren Sie eine Datei in einen in Anführungszeichen gesetzten JavaScript-String:```shell
$ ronin quote --js file.bin
Entferne die Anführungszeichen eines C-Strings:```shell $ ronin unquote --c --string '"\x66\x6f\x6f\x20\x62\x61\x72"' foo bar
### Text
Daten mit hoher Entropie aus einer Datei extrahieren:```shell
$ ronin entropy -e 5.0 index.html
Grep für gängige Datenmuster:```shell $ ronin grep --hash index.html
Häufige Muster aus Daten extrahieren:```shell
$ ronin extract --hash index.html
Erzeuge einen zufälligen Tippfehler eines Wortes:```shell $ ronin typo microsoft microssoft
Alle Tippfehlervarianten eines Wortes aufzählen:```shell
$ ronin typo --enum microsoft
microosoft
microsooft
microssoft
Generiere eine zufällige Homoglyph-Version eines Wortes:```shell $ ronin homoglyph CEO CＥO
Alle Homoglyph-Variationen eines Wortes aufzählen:```shell
$ ronin homoglyph --enum CEO
ϹEO
СEO
ⅭEO
ＣEO
CΕO
CЕO
CＥO
CEΟ
CEО
CEＯ
Hebt die Syntax einer Datei hervor:```shell $ ronin highlight index.html
### Kryptographie
AES-256 eine Datei verschlüsseln:```shell
$ ronin encrypt --cipher aes-256-cbc --password "..." file.txt > encrypted.bin
Daten entschlüsseln:```shell $ ronin decrypt --cipher aes-256-cbc --password "..." encrypted.bin
Erzeugt einen HMAC für eine Datei:```shell
$ ronin hmac --hash sha1 --password "too many secrets" data.txt
Erzeugt einen HMAC für einen String:```shell $ ronin hmac --hash sha1 --password "too many secrets" --string "..."
Berechnen Sie eine MD5-Prüfsumme einer Zeichenfolge:```shell
$ ronin md5 --string "hello world"
5eb63bbbe01eeed093cb22bb8f5acdc3
Berechnen Sie die MD5-Prüfsumme einer Datei:```shell $ ronin md5 file.txt
Berechne die MD5-Prüfsumme jeder Zeile in einer Datei:```shell
$ ronin md5 --multiline file.txt
Berechne eine SHA1-Prüfsumme einer Zeichenkette:```shell $ ronin sha1 --string "hello world" 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed
SHA1-Prüfsumme einer Datei berechnen:```shell
$ ronin sha1 file.txt
Berechne die SHA1-Prüfsumme jeder Zeile in einer Datei:```shell $ ronin sha1 --multiline file.txt
Berechnen Sie eine SHA256-Prüfsumme eines Strings:```shell
$ ronin sha256 --string "hello world"
b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
Berechne die SHA256-Prüfsumme einer Datei:```shell $ ronin sha256 file.txt
Berechne die SHA256-Prüfsumme jeder Zeile in einer Datei:```shell
$ ronin sha256 --multiline file.txt
Berechnen Sie einen SHA512-Prüfsumme eines Strings:```shell $ ronin sha512 --string "hello world" 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f
Berechne die SHA512-Prüfsumme einer Datei:```shell
$ ronin sha512 file.txt
Berechnen Sie die SHA512-Prüfsumme jeder Zeile in einer Datei:```shell $ ronin sha512 --multiline file.txt
ROT-13 kodiert eine Zeichenkette:```shell
$ ronin rot --string "The quick brown fox jumps over the lazy dog"
Gur dhvpx oebja sbk whzcf bire gur ynml qbt
XOR kodiert einen 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&,&"
### Netzwerk
ASN einer IP-Adresse abfragen:```shell
$ ronin asn -I 4.2.2.1
4.0.0.0/9 AS3356 (US) LEVEL3
Externe/öffentliche IP-Adresse des Systems abrufen:```shell $ ronin ip --public
Konvertiere eine IP-Adresse in das Dezimalformat:```shell
$ ronin ip --decimal 127.0.0.1
2130706433
Konvertieren Sie eine Datei mit IP-Adressen in URLs:```shell $ ronin ip --file targets.txt --http
Alle IP-Adressen im IP-CIDR-Bereich auflisten:```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
...
Jede IP-Adresse im IP-Glob-Bereich aufzählen:```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 ...
Alle IP-Adressen zwischen zwei IP-Adressen auflisten:```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
Mit einem entfernten TCP-Dienst verbinden:```shell $ ronin netcat -v example.com 80
Auf einem lokalen TCP-Port lauschen:```shell
$ ronin netcat -v -l 1337
Mit einem entfernten SSL/TLS-Dienst verbinden:```shell $ ronin netcat -v --ssl example.com 443
Mit einem entfernten UDP-Dienst verbinden:```shell
$ ronin netcat -v -u example.com 1337
Auf einem lokalen UDP-Port hören:```shell $ ronin netcat -v -u -l 1337
Öffnet einen UNIX-Socket:```shell
$ ronin netcat -v --unix /path/to/unix.socket
Hexdump alle Daten, die von einem Socket empfangen werden:```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
DNS-Einträge abfragen:```shell
$ ronin dns -t TXT github.com
Finde alle registrierten TLDs für einen Hostnamen:```shell $ ronin host --enum-tlds --registered github.com github.ac github.actor github.ae github.africa github.agency github.ai ...
Finden Sie alle registrierten öffentlichen Suffixe für einen Hostnamen:```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
...
Finde alle Subdomains, die Adressen haben:```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 ...
Zähle jede mögliche Typosquat-Variation einer Domain auf:```shell
$ ronin typosquat microsoft.com
microosoft.com
microsooft.com
microssoft.com
Finde alle registrierten Typosquat-Domains für eine gültige Domain:```shell $ ronin typosquat --registered microsoft.com
Finde alle Typosquat-Domains mit Adressen für eine gültige Domain:```shell
$ ronin typosquat --has-addresses microsoft.com
Finde alle nicht registrierten Typosquat-Domains für eine gültige Domain:```shell $ ronin typosquat --unregistered microsoft.com
E-Mail-Adresse deobfuskieren:```shell
$ ronin email-addr --deobfuscate "john [dot] smith [at] example [dot] com"
[email protected]
Alle Obfuskationen einer E-Mail-Adresse durchlaufen:```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 ...
#### SSL/TLS Certs
Gib Informationen über ein SSL/TLS-Zertifikat aus:```shell
$ ronin cert-dump https://example.com/
Ein SSL/TLS-Zertifikat von einem Host und Port herunterladen:```shell $ ronin cert-grab github.com:443
Generieren Sie ein neues SSL/TLS-Zertifikat:```shell
$ ronin cert-gen -c test.com -O "Test Co" -U "Test Dept" \
-L "Test City" -S NY -C US
Führen Sie eine HTTP-GET-Anfrage durch (mit Syntax-Hervorhebung):```shell
$ ronin http https://example.com/
Sende eine HTTP-Anfrage mit zusätzlichen Headern:```shell
$ ronin http --post --header "Authorization: ..." https://foo.bar/
Senden Sie eine HTTP-Anfrage mit einem bekannten User-Agent-String:```shell
$ ronin http --post --user-agent chrome-android https://foo.bar/
Senden Sie eine HTTP-Anfrage mit einem benutzerdefinierten `User-Agent`-String:```shell
$ ronin http --post --user-agent-string "..." https://foo.bar/
Öffne eine interaktive HTTP-Shell:```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
Gib den HTTP-Status jeder URL in einer Datei aus:```shell
$ ronin url --file urls.txt --status
Erstellen Sie ein neues Ruby-Skript mit vorinstalliertem ronin-support:```shell $ ronin new script foo.rb
Erstelle ein neues Ruby-Projekt mit einer `Gemfile`:```shell
$ ronin new project foo
Generiere ein neues nokogiri Ruby-Skript zum Parsen von HTML/XML:
$ ronin new nokogiri foo.rb
Generiere ein neues [ronin-web-server] Ruby-Skript:```shell
$ ronin new web-server my_server.rb
Erstelle eine neue auf ronin-web-server basierende Web-App:```shell $ ronin new web-app my_app
Generieren Sie ein neues [ronin-web-spider] Ruby-Skript:```shell
$ ronin new web-spider --host=example.com my_spider.rb
Erstelle ein ronin-listener-dns-Skript:```shell $ ronin new dns-listener my_dns_listener.rb
Generiere ein [ronin-dns-proxy] Skript:```shell
$ ronin new dns-proxy my_dns_proxy.rb
Erstelle ein ronin-listener-http-Skript:```shell $ ronin new http-listener my_http_listener.rb
Erstelle ein [ronin-exploits] Skript:```shell
$ ronin new exploit my_exploit.rb
Erstelle ein ronin-payloads Skript:```shell $ ronin new payload my_payload.rb
### Archive
Archivdateien:```shell
$ ronin archive -o archive.zip file1.txt file2.txt
Archivieren Sie Dateien im tar-Format:```shell $ ronin archive -o archive.tar file1.txt file2.txt
Dateien entpacken:```shell
$ ronin unarchive arch1.tar arch2.zip
Entpacken Sie eine Datei mit explizitem Format:```shell $ ronin unarchive -f zip arch2.jar
### Siehe auch
* [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)
## Voraussetzungen
* [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
## Installation
### Bash Script```shell
curl -o ronin-install.sh https://raw.githubusercontent.com/ronin-rb/scripts/main/ronin-install.sh && bash ronin-install.sh
Siehe die manuelle Installation für Anweisungen zur Installation von Ronin und dessen zusätzlichen Abhängigkeiten auf Ihrer Plattform.
Wenn Sie Docker bevorzugen, gibt es auch Docker images verfügbar:```shell docker pull roninrb/ronin docker run -it roninrb/ronin
Zusätzlich, wenn Sie Ihr Home-Verzeichnis in das docker image einbinden möchten:```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 ist freie Software: Sie können es weiterverbreiten und/oder modifizieren unter den Bedingungen der GNU General Public License, wie von der Free Software Foundation veröffentlicht, entweder Version 3 der Lizenz oder (nach Ihrer Wahl) jeder späteren Version.
Ronin wird in der Hoffnung, dass es nützlich sein wird, aber OHNE JEDE GEWÄHRLEISTUNG, sogar ohne die implizite Gewährleistung der MARKTGÄNGIGKEIT oder EIGNUNG FÜR EINEN BESTIMMTEN ZWECK, verbreitet. Weitere Details finden Sie in der GNU General Public License.
Sie sollten eine Kopie der GNU General Public License zusammen mit Ronin erhalten haben. Falls nicht, siehe https://www.gnu.org/licenses/.