ronin

• वेबसाइट
• स्रोत
• मुद्दे
• दस्तावेज़ीकरण
• डिस्कॉर्ड | मास्टोडॉन

विवरण

Ronin एक मुफ्त और ओपन सोर्स Ruby टूलकिट है जो सुरक्षा अनुसंधान और विकास के लिए है। Ronin में विभिन्न सुरक्षा कार्यों के लिए कई CLI कमांड और Ruby लाइब्रेरियाँ शामिल हैं, जैसे डेटा को एन्कोड/डिकोड करना, IP/होस्ट/URL को फ़िल्टर करना, ASN को क्वेरी करना, DNS को क्वेरी करना, HTTP, वेब कमजोरियों के लिए स्कैन करना, वेबसाइटों को स्पाइडर करना, एक्सप्लॉइट्स और/या पेलोड्स के तृतीय-पक्ष रिपॉजिटरीज़ स्थापित करना, एक्सप्लॉइट्स चलाना, नए एक्सप्लॉइट्स विकसित करना, स्थानीय डेटाबेस प्रबंधित करना, डेटा फ़ज़ करना, रीकॉन करना, और भी बहुत कुछ।

Ronin किसके लिए है?

• CTF खिलाड़ी
• बग बाउंटी शिकारी
• सुरक्षा शोधकर्ता
• सुरक्षा इंजीनियर
• डेवलपर्स
• छात्र

Ronin क्या प्रदान करता है?

• उपयोगी कमांड्स का एक टूलकिट।
• पूरी तरह से लोडेड Ruby REPL।
• उच्च गुणवत्ता वाली सुरक्षा संबंधित Ruby लाइब्रेरियों, APIs और कमांड्स का एक इकोसिस्टम।
• एक हल्का स्थानीय वेब UI।

आप Ronin के साथ क्या कर सकते हैं?

• ronin कमांड्स का उपयोग करके विभिन्न डेटा को तुरंत प्रोसेस करें और क्वेरी करें।
• ronin irb Ruby REPL में कोड और डेटा के साथ कुशलतापूर्वक काम करें।
• ronin-support और अन्य ronin लाइब्रेरियों का उपयोग करके तेजी से Ruby स्क्रिप्ट प्रोटोटाइप करें।
• ronin-repos का उपयोग करके एक्सप्लॉइट्स, पेलोड्स या अन्य कोड के तृतीय-पक्ष git रिपॉजिटरीज़ इंस्टॉल करें।
• ronin-db डेटाबेस का उपयोग करके डेटा आयात करें और क्वेरी करें।
• ronin-fuzzer का उपयोग करके डेटा फ़ज़ करें।
• ronin-recon का उपयोग करके रीकॉन करें।
• ronin-payloads का उपयोग करके सामान्य पेलोड्स का उपयोग करें या अपने खुद के लिखें।
• ronin-exploits का उपयोग करके एक्सप्लॉइट्स लिखें/चलाएँ।
• ronin-vulns का उपयोग करके वेब कमजोरियों के लिए स्कैन करें।
• ronin-app का उपयोग करके अपने ब्राउज़र में स्कैन करें और डेटाबेस ब्राउज़ करें।

सारांश```

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

ronin कमांड सूचीबद्ध करें:```shell
$ ronin help

किसी कमांड के लिए मैन-पेज देखें:```shell $ ronin help COMMAND

`ronin` का उपयोग करने पर एक यादृच्छिक सुझाव प्राप्त करें:```shell
$ ronin tips

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

रोनिन के लिए इंटरैक्टिव वेब UI प्रारंभ और खोलता है:```
$ ronin-app

बाइनरी

Hexdumps डेटा को विभिन्न प्रारूपों में:```shell $ ronin hexdump /bin/ls

एक hexdump फ़ाइल को उसके मूल कच्चे बाइनरी डेटा में वापस परिवर्तित करता है:```shell
$ ronin unhexdump -o data.bin hexdump.txt

फ़ाइल से सभी मुद्रण योग्य स्ट्रिंग्स प्रिंट करें:```shell $ ronin strings /bin/ls

एक फ़ाइल से सभी अक्षर स्ट्रिंग्स प्रिंट करें:```shell
$ ronin strings --alpha /bin/ls

फ़ाइल से सभी अल्फ़ा-न्यूमेरिक स्ट्रिंग्स प्रिंट करें:```shell $ ronin strings --alpha-num /bin/ls

फ़ाइल से सभी संख्यात्मक स्ट्रिंग्स प्रिंट करें:```shell
$ ronin strings --numeric /bin/ls

फ़ाइल से सभी हेक्साडेसिमल स्ट्रिंग प्रिंट करें:```shell $ ronin strings --hex /bin/ls

डोमेन नाम के सभी बिट-फ्लिप्स की गणना करें:```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 में एक स्ट्रिंग को एन्कोड करें:```shell $ ronin encode --base64 --string "foo bar baz" Zm9vIGJhciBiYXo=

Zlib संपीड़ित करता है, Base64 एन्कोड करता है, और फिर URI एन्कोड करता है एक स्ट्रिंग:```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 डीकोड एक स्ट्रिंग:```shell $ ronin decode --base64 --string "Zm9vIGJhciBiYXo=" foo bar baz

URI डीकोड, Base64 डीकोड, और फिर zlib एक स्ट्रिंग को इन्फ्लेट करता है:```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 एस्केप करें:```shell $ ronin escape --uri --string "foo bar" foo%20bar

URI अनएस्केप करें एक स्ट्रिंग:```shell
$ ronin unescape --uri --string "foo%20bar"
foo bar

एक फ़ाइल को उद्धृत C स्ट्रिंग में बदलें:```shell $ ronin quote --c file.bin "..."

एक फ़ाइल को उद्धृत जावास्क्रिप्ट स्ट्रिंग में बदलें:```shell
$ ronin quote --js file.bin

C स्ट्रिंग को अनकोट करें:```shell $ ronin unquote --c --string '"\x66\x6f\x6f\x20\x62\x61\x72"' foo bar

### Text

फ़ाइल से उच्च-एंट्रॉपी डेटा निकालें:```shell
$ ronin entropy -e 5.0 index.html

डेटा के सामान्य पैटर्न के लिए Grep करें:```shell $ ronin grep --hash index.html

डेटा से सामान्य पैटर्न निकालें:```shell
$ ronin extract --hash index.html

एक शब्द की यादृच्छिक टाइपो उत्पन्न करें:```shell $ ronin typo microsoft microssoft

एक शब्द के प्रत्येक टाइपो वेरिएशन को सूचीबद्ध करें:```shell
$ ronin typo --enum microsoft
microosoft
microsooft
microssoft

एक शब्द का यादृच्छिक होमोग्लिफ़ संस्करण उत्पन्न करें:```shell $ ronin homoglyph CEO CＥO

एक शब्द की प्रत्येक समरूपी विविधता पर गणना करें:```shell
$ ronin homoglyph --enum CEO
ϹEO
СEO
ⅭEO
ＣEO
CΕO
CЕO
CＥO
CEΟ
CEО
CEＯ

एक फ़ाइल को सिंटैक्स-हाइलाइट करता है:```shell $ ronin highlight index.html

### क्रिप्टोग्राफी

AES-256 के साथ एक फ़ाइल को एन्क्रिप्ट करें:```shell
$ ronin encrypt --cipher aes-256-cbc --password "..." file.txt > encrypted.bin

डिक्रिप्ट डेटा:```shell $ ronin decrypt --cipher aes-256-cbc --password "..." encrypted.bin

एक फ़ाइल के लिए HMAC उत्पन्न करता है:```shell
$ ronin hmac --hash sha1 --password "too many secrets" data.txt

एक स्ट्रिंग के लिए HMAC उत्पन्न करता है:```shell $ ronin hmac --hash sha1 --password "too many secrets" --string "..."

एक स्ट्रिंग का MD5 चेकसम गणना करें:```shell
$ ronin md5 --string "hello world"
5eb63bbbe01eeed093cb22bb8f5acdc3

किसी फ़ाइल का MD5 checksum की गणना करें:```shell $ ronin md5 file.txt

फ़ाइल की प्रत्येक पंक्ति के MD5 चेकसम की गणना करें:```shell
$ ronin md5 --multiline file.txt

एक स्ट्रिंग के SHA1 चेकसम की गणना करें:```shell $ ronin sha1 --string "hello world" 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed

किसी फ़ाइल का SHA1 चेकसम गणना करें:```shell
$ ronin sha1 file.txt

फ़ाइल की प्रत्येक पंक्ति के SHA1 checksum की गणना करें:```shell $ ronin sha1 --multiline file.txt

एक स्ट्रिंग का SHA256 चेकसम गणना करें:```shell
$ ronin sha256 --string "hello world"
b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9

एक फ़ाइल का SHA256 checksum गणना करें:```shell $ ronin sha256 file.txt

किसी फ़ाइल में प्रत्येक पंक्ति के SHA256 चेकसम की गणना करें:```shell
$ ronin sha256 --multiline file.txt

एक स्ट्रिंग का SHA512 चेकसम निकालें:```shell $ ronin sha512 --string "hello world" 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f

फ़ाइल का SHA512 चेकसम की गणना करें:```shell
$ ronin sha512 file.txt

एक फ़ाइल में प्रत्येक पंक्ति के SHA512 चेकसम की गणना करें:```shell $ ronin sha512 --multiline file.txt

ROT-13 एक स्ट्रिंग को एन्कोड करता है:```shell
$ ronin rot --string "The quick brown fox jumps over the lazy dog"
Gur dhvpx oebja sbk whzcf bire gur ynml qbt

XOR एक स्ट्रिंग को एन्कोड करता है:```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&,&"

### नेटवर्किंग

किसी IP address के ASN की पूछताछ करें:```shell
$ ronin asn -I 4.2.2.1
4.0.0.0/9 AS3356 (US) LEVEL3

सिस्टम का बाहरी/सार्वजनिक IP पता प्राप्त करें:```shell $ ronin ip --public

IP पते को दशमलव प्रारूप में बदलें:```shell
$ ronin ip --decimal 127.0.0.1
2130706433

IP पतों की एक फ़ाइल को URLs में बदलें:```shell $ ronin ip --file targets.txt --http

IP 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
...

IP ग्लोब रेंज में प्रत्येक 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 ...

दो IP पतों के बीच प्रत्येक 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

एक दूरस्थ TCP सेवा से कनेक्ट करें:```shell $ ronin netcat -v example.com 80

एक स्थानीय TCP पोर्ट पर सुनें:```shell
$ ronin netcat -v -l 1337

दूरस्थ SSL/TLS सेवा से कनेक्ट करें:```shell $ ronin netcat -v --ssl example.com 443

Connect to a remote UDP service:```shell
$ ronin netcat -v -u example.com 1337

एक स्थानीय UDP पोर्ट पर सुनें:```shell $ ronin netcat -v -u -l 1337

एक UNIX सॉकेट खोलता है:```shell
$ ronin netcat -v --unix /path/to/unix.socket

Hexdump सॉकेट से प्राप्त सभी डेटा:```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 रिकॉर्ड क्वेरी करें:```shell
$ ronin dns -t TXT github.com

एक होस्ट नाम के लिए सभी पंजीकृत TLDs खोजें:```shell $ ronin host --enum-tlds --registered github.com github.ac github.actor github.ae github.africa github.agency github.ai ...

एक होस्ट नाम के लिए सभी पंजीकृत सार्वजनिक प्रत्यय खोजें:```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
...

उन सभी उपडोमेन को खोजें जिनके पास पते हैं:```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 ...

एक डोमेन के सभी संभावित typosquat वेरिएशन को सूचीबद्ध करें:```shell
$ ronin typosquat microsoft.com
microosoft.com
microsooft.com
microssoft.com

किसी वैध डोमेन के लिए सभी पंजीकृत टाइपोस्क्वाट डोमेन खोजें:```shell $ ronin typosquat --registered microsoft.com

किसी मान्य डोमेन के लिए सभी टाइपोस्क्वाट डोमेन को उनके पतों के साथ खोजें:```shell
$ ronin typosquat --has-addresses microsoft.com

एक मान्य डोमेन के लिए सभी अपंजीकृत टाइपोस्क्वाट डोमेन खोजें:```shell $ ronin typosquat --unregistered microsoft.com

ईमेल पते को डी-ऑबफस्केट करें:```shell
$ ronin email-addr --deobfuscate "john [dot] smith [at] example [dot] com"
[email protected]

एक ईमेल पते के सभी अस्पष्टीकरणों की गणना करें:```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 (प्रमाणपत्र)

एक SSL/TLS प्रमाणपत्र के बारे में जानकारी डंप करें:```shell
$ ronin cert-dump https://example.com/

किसी होस्ट और पोर्ट से SSL/TLS प्रमाणपत्र डाउनलोड करें:```shell $ ronin cert-grab github.com:443

एक नया SSL/TLS प्रमाणपत्र उत्पन्न करें:```shell
$ ronin cert-gen -c test.com -O "Test Co" -U "Test Dept" \
                 -L "Test City" -S NY -C US

HTTP

एक HTTP GET अनुरोध करें (सिंटैक्स हाइलाइटिंग के साथ):```shell $ ronin http https://example.com/

अतिरिक्त हेडर के साथ HTTP अनुरोध भेजें:```shell
$ ronin http --post --header "Authorization: ..." https://foo.bar/

एक ज्ञात User-Agent स्ट्रिंग के साथ एक HTTP अनुरोध भेजें:```shell $ ronin http --post --user-agent chrome-android https://foo.bar/

एक कस्टम `User-Agent` स्ट्रिंग के साथ HTTP अनुरोध भेजें:```shell
$ ronin http --post --user-agent-string "..." https://foo.bar/

एक इंटरैक्टिव HTTP शेल खोलें:```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

फ़ाइल में प्रत्येक URL की HTTP स्थिति प्रिंट करें:```shell
$ ronin url --file urls.txt --status

जनरेटर

ronin-support प्रीलोडेड के साथ एक नई Ruby स्क्रिप्ट जनरेट करें:```shell $ ronin new script foo.rb

एक नया Ruby प्रोजेक्ट `Gemfile` के साथ बनाएं:```shell
$ ronin new project foo

HTML/XML को पार्स करने के लिए एक नया nokogiri Ruby स्क्रिप्ट उत्पन्न करें:

$ ronin new nokogiri foo.rb

एक नया [ronin-web-server] Ruby स्क्रिप्ट उत्पन्न करें:```shell
$ ronin new web-server my_server.rb

एक नया ronin-web-server आधारित वेब ऐप जनरेट करें:```shell $ ronin new web-app my_app

एक नया [ronin-web-spider] Ruby स्क्रिप्ट उत्पन्न करें:```shell
$ ronin new web-spider --host=example.com my_spider.rb

एक ronin-listener-dns स्क्रिप्ट जनरेट करें:```shell $ ronin new dns-listener my_dns_listener.rb

एक [ronin-dns-proxy] स्क्रिप्ट जनरेट करें:```shell
$ ronin new dns-proxy my_dns_proxy.rb

एक ronin-listener-http स्क्रिप्ट जनरेट करें:```shell $ ronin new http-listener my_http_listener.rb

एक [ronin-exploits] स्क्रिप्ट उत्पन्न करें:```shell
$ ronin new exploit my_exploit.rb

एक ronin-payloads स्क्रिप्ट जनरेट करें:```shell $ ronin new payload my_payload.rb

### संग्रह

संग्रह फ़ाइलें:```shell
$ ronin archive -o archive.zip file1.txt file2.txt

tar प्रारूप का उपयोग करके फ़ाइलों को संग्रहित करें:```shell $ ronin archive -o archive.tar file1.txt file2.txt

फ़ाइलों को अनार्काइव करें:```shell
$ ronin unarchive arch1.tar arch2.zip

एक फ़ाइल को स्पष्ट प्रारूप के साथ संग्रह से बाहर निकालें:```shell $ ronin unarchive -f zip arch2.jar

### यह भी देखें

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

## आवश्यकताएँ

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

## स्थापित करें

### बैश स्क्रिप्ट```shell
curl -o ronin-install.sh https://raw.githubusercontent.com/ronin-rb/scripts/main/ronin-install.sh && bash ronin-install.sh

Manually

Ronin और इसकी अतिरिक्त निर्भरताओं को अपने प्लेटफॉर्म पर कैसे स्थापित करें, इसके लिए manual install निर्देश देखें।

Docker

यदि आप Docker का उपयोग करना पसंद करते हैं, तो Docker images भी उपलब्ध हैं:```shell docker pull roninrb/ronin docker run -it roninrb/ronin

इसके अतिरिक्त, यदि आप अपनी होम निर्देशिका को डॉकर इमेज में माउंट करना चाहते हैं:```shell
docker run --mount type=bind,source="$HOME",target=/home/ronin -it ronin

विकास

1. इसे फोर्क करें!
2. इसे क्लोन करें!
3. cd ronin
4. ./scripts/setup
5. git checkout -b my_feature
6. कोड लिखें!
7. bundle exec rake spec
8. git push origin my_feature

लाइसेंस

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

Ronin मुक्त सॉफ्टवेयर है: आप इसे पुनर्वितरित और संशोधित कर सकते हैं यह GNU जनरल पब्लिक लाइसेंस की शर्तों के तहत, जैसा कि प्रकाशित किया गया है फ्री सॉफ्टवेयर फाउंडेशन द्वारा, लाइसेंस के संस्करण 3 या (आपकी पसंद पर) किसी भी बाद के संस्करण के तहत।

Ronin को इस उम्मीद में वितरित किया जाता है कि यह उपयोगी होगा, लेकिन बिना किसी वारंटी के; यहाँ तक कि व्यापारिकता या किसी विशेष उद्देश्य के लिए उपयुक्तता की निहित वारंटी के बिना। देखें GNU जनरल पब्लिक लाइसेंस अधिक जानकारी के लिए।

आपको GNU जनरल पब्लिक लाइसेंस की एक प्रति प्राप्त होनी चाहिए थी Ronin के साथ। यदि नहीं, तो देखें https://www.gnu.org/licenses/।