गो में तेज़, शून्य-निर्भरता क्रेडेंशियल परीक्षण उपकरण। SSH, MySQL, PostgreSQL, Redis, MongoDB, SMB और 20+ प्रोटोकॉल पर ब्रूट फोर्स। नेटिव नर्वा/नाबू पाइपलाइन एकीकरण के साथ हाइड्रा विकल्प।
<img width="2752" height="1536" alt="Brutus - Social" src="https://assets.kitploit.com/production/public/readmes/11715/32309a4ca6e7282c8dcd718e2b275a392b73a81f51cbd5d1738464eb3933fd22.png" />
<h1 align="center">Brutus</h1>
<p align="center">
<em>"Et tu, Brute?" — क्रेडेंशियल्स गिरने से पहले के अंतिम शब्द।</em>
</p>
<p align="center">
<strong>शुद्ध Go में आधुनिक क्रेडेंशियल परीक्षण उपकरण</strong>
</p>
<p align="center">
<a href="#installation">इंस्टॉलेशन</a> •
<a href="#quick-start">क्विक स्टार्ट</a> •
<a href="#pipeline-integration">पाइपलाइन</a> •
<a href="#supported-protocols">प्रोटोकॉल</a> •
<a href="#account-enumeration">एन्यूमरेशन</a> •
<a href="#socks5-proxy-support">प्रॉक्सी</a> •
<a href="#library-integration">लाइब्रेरी</a>
</p>
---
## अवलोकन
Brutus एक बहु-प्रोटोकॉल प्रमाणीकरण परीक्षण उपकरण है जिसे आक्रामक सुरक्षा टूलिंग में एक महत्वपूर्ण कमी को दूर करने के लिए डिज़ाइन किया गया है: विविध नेटवर्क सेवाओं में कुशल क्रेडेंशियल सत्यापन। जहाँ HTTP-केंद्रित उपकरण प्रचुर मात्रा में हैं, वहीं पेनिट्रेशन टेस्टर और रेड टीम ऑपरेटर अक्सर डेटाबेस, SSH, SMB, और अन्य नेटवर्क सेवाओं का सामना करते हैं जिनके लिए विशेष-निर्मित प्रमाणीकरण परीक्षण क्षमताओं की आवश्यकता होती है।
Go में एकल बाइनरी के रूप में शून्य बाहरी निर्भरताओं के साथ निर्मित, Brutus स्वचालित सेवा खोज के लिए [Nerva](https://github.com/praetorian-inc/nerva) के साथ सहजता से एकीकृत होता है, जिससे ऑपरेटर पूरे नेटवर्क रेंज में प्रमाणीकरण वेक्टर की तेजी से पहचान और परीक्षण कर सकते हैं।
**मुख्य विशेषताएँ:**
- **शून्य निर्भरताएँ:** एकल बाइनरी, क्रॉस-प्लेटफ़ॉर्म (Linux, Windows, macOS)
- **43 प्रोटोकॉल:** SSH, RDP, MySQL, PostgreSQL, MSSQL, Oracle, Redis, SMB, LDAP, WinRM, SNMP, HTTP Basic Auth, MQTT, और अधिक
- **SOCKS5 प्रॉक्सी समर्थन:** `--proxy` के साथ सभी ट्रैफ़िक को SOCKS5 प्रॉक्सी के माध्यम से रूट करें
- **आक्रामकता मोड:** कवरेज बनाम सुरक्षा को ट्यून करने के लिए `--mode cautious|default|aggressive`
- **पाइपलाइन एकीकरण:** Nerva, naabu, nmap, और masscan वर्कफ़्लो के लिए मूल समर्थन
- **एम्बेडेड बैड कीज़:** ज्ञात SSH कुंजियों का अंतर्निहित संग्रह (Vagrant, F5, ExaGrid, आदि)
- **खाता एन्यूमरेशन:** account-existence oracle enumeration, Kerberos उपयोगकर्ता एन्यूमरेशन, ईमेल जनरेशन, Microsoft Teams/Entra ID डिवाइस कोड प्रमाणीकरण
- **Go लाइब्रेरी:** सीधे अपने सुरक्षा ऑटोमेशन उपकरणों में आयात करें
- **प्रोडक्शन रेडी:** रेट लिमिटिंग, कनेक्शन पूलिंग, और व्यापक त्रुटि प्रबंधन
---
## Brutus क्यों?
**THC Hydra** जैसे पारंपरिक उपकरणों ने सुरक्षा समुदाय की अच्छी सेवा की है, लेकिन वे महत्वपूर्ण बाधाओं के साथ आते हैं: जटिल निर्भरता श्रृंखलाएँ, प्लेटफ़ॉर्म-विशिष्ट संकलन समस्याएँ, और आधुनिक टोही वर्कफ़्लो के साथ कोई मूल एकीकरण नहीं।
**Brutus** आधुनिक आक्रामक सुरक्षा के लिए विशेष रूप से निर्मित है:
- **वास्तविक शून्य-निर्भरता परिनियोजन:** एकल बाइनरी डाउनलोड करें और चलाएँ। कोई `libssh-dev` नहीं, कोई `libmysqlclient-dev` नहीं, कोई संकलन त्रुटि नहीं। Linux, macOS, और Windows पर समान रूप से काम करता है।
- **मूल पाइपलाइन एकीकरण:** Brutus JSON बोलता है और सीधे [Nerva](https://github.com/praetorian-inc/nerva), [naabu](https://github.com/projectdiscovery/naabu), [nmap](https://nmap.org), और [masscan](https://github.com/robertdavidgraham/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 से पहचानती है, और समझौता किए गए key को सामान्य usernames के विरुद्ध परीक्षण करती है—जिससे सेकंडों में lateral movement के अवसरों का पता चलता है।
### Web Admin Panel Testing
HTTP सेवाओं की खोज करें और AI-संचालित detection या manual credential सूचियों का उपयोग करके credentials का परीक्षण करें:
```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/
```
```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
```
---
## त्वरित शुरुआत
### उप-आदेश
<!-- BEGIN generated: cli-subcommands -->
Brutus अपनी कार्यक्षमता को इन केंद्रित उप-आदेशों में व्यवस्थित करता है:
```bash
brutus badkeys # Test known weak/compromised SSH keys against targets
brutus creds # Test default credentials on non-HTTP services (SSH, databases, SMB, etc.)
brutus enum # Enumerate accounts against account-existence oracles or Active Directory
brutus logon # Detect Windows logon-screen backdoors (runs both sticky keys and utilman)
brutus snmp # Test SNMP community strings against targets
brutus stickykeys # Detect the Windows sticky-keys (sethc.exe) logon backdoor only
brutus template # Run product-specific default-credential templates
brutus utilman # Detect the Windows utilman (Ease of Access) logon backdoor only
brutus web # Audit HTTP/web panel credentials (AI-powered or credential list)
```
<!-- END generated: cli-subcommands -->
<!-- BEGIN generated: cli-aliases -->
कुछ सबकमांड में खोजने में आसानी के लिए उपनाम होते हैं:
| सबकमांड | उपनाम |
| --- | --- |
| `badkeys` | `keys`, `ssh-keys`, `badkey` |
| `creds` | `services`, `defaults`, `credentials` |
| `snmp` | `community` |
| `web` | `http`, `panels` |
पूरा संदर्भ — प्रत्येक सबकमांड, उपनाम और फ़्लैग, जिनमें `--help` से छिपे हुए भी शामिल हैं — [docs/CLI.md](https://github.com/praetorian-inc/brutus/blob/main/docs/CLI.md) में जनरेट किया गया है।
<!-- END generated: cli-aliases -->
```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](https://github.com/praetorian-inc/nerva)** और **[naabu](https://github.com/projectdiscovery/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: लक्ष्य डोमेन पर बग बाउंटी रेकॉन
```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
```
### स्कैन टूल आयात (Nmap और Masscan)
Brutus **nmap** और **masscan** स्कैन आउटपुट फ़ाइलों से सीधे लक्ष्य आयात कर सकता है, जिससे प्रारूप रूपांतरण या मध्यवर्ती टूल की आवश्यकता समाप्त हो जाती है।
#### Nmap XML आयात (`--nmap-file`)
nmap के XML आउटपुट (`-oX`) से लक्ष्य आयात करें। Nmap सेवा फिंगरप्रिंटिंग प्रदान करता है, इसलिए 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"` विशेषता से पहचाना जाता है। केवल up होस्ट्स पर खुले पोर्ट्स ही आयात किए जाते हैं।
#### 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 scheme, और bare target formats को parse करता है
- services को protocols से map करता है
- उपयुक्त default credentials का परीक्षण करता है
- परिणामों को matching JSON format में output करता है
### Pipeline Output Format
Brutus केवल सफल credentials को JSONL format में output करता है (प्रति पंक्ति एक JSON object):
```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`) द्वारा सुझाए गए हों।
---
## तुलना
| विशेषता | Hydra | Medusa | Ncrack | **Brutus** |
|---------|:-----:|:------:|:------:|:----------:|
| सिंगल बाइनरी | ❌ | ❌ | ❌ | ✅ |
| शून्य निर्भरताएँ | ❌ | ❌ | ❌ | ✅ |
| SOCKS5 प्रॉक्सी | ✅ | ❌ | ❌ | ✅ |
| Nerva पाइपलाइन | ❌ | ❌ | ❌ | ✅ |
| Nmap/Masscan आयात | ❌ | ❌ | ❌ | ✅ |
| JSON स्ट्रीमिंग | ⚠️ | ❌ | ❌ | ✅ |
| क्रॉस-प्लेटफ़ॉर्म | ⚠️ | ⚠️ | ⚠️ | ✅ |
| सुसंगत त्रुटियाँ | ⚠️ | ⚠️ | ⚠️ | ✅ |
| सक्रिय विकास | ✅ | ⚠️ | ❌ | ✅ |
| एम्बेडेड बैड कीज़ | ❌ | ❌ | ❌ | ✅ |
| Go लाइब्रेरी आयात | ❌ | ❌ | ❌ | ✅ |
---
## समर्थित प्रोटोकॉल
Brutus **43 प्रोटोकॉल** का समर्थन करता है:
### नेटवर्क सेवाएँ
| प्रोटोकॉल | पोर्ट | प्रमाणीकरण विधियाँ | उपयोग का मामला |
|----------|------|--------------|----------|
| SSH | 22 | पासवर्ड, निजी कुंजियाँ | सर्वर, नेटवर्क उपकरण |
| FTP | 21 | पासवर्ड | फ़ाइल सर्वर, NAS उपकरण |
| rsync | 873 | मॉड्यूल रहस्य, अनाम | फ़ाइल सिंक |
| Telnet | 23 | पासवर्ड | लीगेसी सिस्टम, IoT उपकरण |
| VNC | 5900 | पासवर्ड | रिमोट डेस्कटॉप |
| RDP | 3389 | NLA/CredSSP, पासवर्ड | Windows सर्वर, वर्कस्टेशन |
| SNMP | 161 | कम्युनिटी स्ट्रिंग | नेटवर्क उपकरण, प्रिंटर |
| IPMI | 623/udp | RMCP | BMC / लाइट्स-आउट |
| OPC UA | 4840 | उपयोगकर्ता नाम टोकन, अनाम | ICS/SCADA |
### वेब सेवाएँ
| प्रोटोकॉल | पोर्ट | प्रमाणीकरण विधियाँ | उपयोग का मामला |
|----------|------|--------------|----------|
| HTTP | 80 | बेसिक ऑथ | एडमिन पैनल (Grafana, Jenkins, आदि) |
| HTTPS | 443 | बेसिक ऑथ | सुरक्षित एडमिन पैनल |
| ब्राउज़र | 80/443 | फ़ॉर्म | ब्राउज़र-आधारित Microsoft/Entra लॉगिन |
### एंटरप्राइज़ अवसंरचना
| प्रोटोकॉल | पोर्ट | प्रमाणीकरण विधियाँ | उपयोग का मामला |
|----------|------|--------------|----------|
| SMB | 445 | पासवर्ड, NTLM | Windows नेटवर्क, फ़ाइल शेयर |
| LDAP | 389/636 | बाइंड DN | Active Directory, पहचान |
| WinRM | 5985/5986 | NTLM | Windows रिमोट प्रबंधन |
### डेटाबेस
| प्रोटोकॉल | पोर्ट | प्रमाणीकरण विधियाँ | उपयोग का मामला |
|----------|------|--------------|----------|
| MySQL | 3306 | पासवर्ड | वेब एप्लिकेशन |
| PostgreSQL | 5432 | पासवर्ड | आधुनिक एप्लिकेशन |
| MSSQL | 1433 | पासवर्ड | एंटरप्राइज़ एप्लिकेशन |
| MongoDB | 27017 | पासवर्ड | NoSQL बैकएंड |
| Redis | 6379 | पासवर्ड | कैशिंग, सत्र |
| Memcached | 11211 | SASL, अनाम | कैशिंग |
| Neo4j | 7687 | पासवर्ड | ग्राफ़ डेटाबेस |
| Cassandra | 9042 | पासवर्ड | वितरित डेटाबेस |
| CouchDB | 5984 | HTTP बेसिक | दस्तावेज़ स्टोर |
| Elasticsearch | 9200 | HTTP बेसिक | सर्च इंजन |
| InfluxDB | 8086 | HTTP बेसिक | टाइम-सीरीज़ डेटा |
| Oracle | 1521 | पासवर्ड | एंटरप्राइज़ डेटाबेस |
| DB2 | 50000 | पासवर्ड | एंटरप्राइज़ डेटाबेस |
| Firebird | 3050 | पासवर्ड | एम्बेडेड डेटाबेस |
### कंटेनर और ऑर्केस्ट्रेशन
| प्रोटोकॉल | पोर्ट | प्रमाणीकरण विधियाँ | उपयोग का मामला |
|----------|------|--------------|----------|
| Docker | 2375/2376 | अनप्रमाणित | उजागर Docker डेमॉन |
| Kubernetes | 6443/10250 | अनप्रमाणित | उजागर K8s API/kubelet |
### संचार
| प्रोटोकॉल | पोर्ट | प्रमाणीकरण विधियाँ | उपयोग का मामला |
|----------|------|--------------|----------|
| SMTP | 25/587 | पासवर्ड | मेल रिले |
| IMAP | 143/993 | पासवर्ड | मेलबॉक्स एक्सेस |
| POP3 | 110/995 | पासवर्ड | मेलबॉक्स एक्सेस |
| ActiveMQ | 61616 | पासवर्ड | OpenWire ब्रोकर |
| SIP | 5060/5061 | डाइजेस्ट | VoIP |
| TURN | 3478 | पासवर्ड | TURN रिले |
| ZooKeeper | 2181 | डाइजेस्ट, अनाम | समन्वय |
| NATS | 4222 | पासवर्ड, अनाम | मैसेजिंग |
| XMPP | 5222 | SASL PLAIN | चैट |
| MQTT | 1883/8883 | पासवर्ड, अनाम | IoT ब्रोकर |
| AMQP | 5672/5671 | SASL PLAIN | RabbitMQ |
| Kafka | 9092 | SASL/PLAIN | ब्रोकर |
| SOCKS5 | 1080 | SOCKS5 प्रॉक्सी ऑथ | प्रॉक्सी |
---
## एम्बेडेड SSH बैड कीज़
बिना किसी बाहरी कुंजी फ़ाइल की आवश्यकता के सिंगल बाइनरी परिनियोजन। प्रत्येक कुंजी को स्मार्ट क्रेडेंशियल मैपिंग के लिए उसके डिफ़ॉल्ट उपयोगकर्ता नाम के साथ जोड़ा गया है, और CVE ट्रैकिंग अनुपालन क्वेरीज़ को सक्षम बनाती है।
Brutus बाइनरी में एम्बेडेड **[rapid7/ssh-badkeys](https://github.com/rapid7/ssh-badkeys)** और **[Vagrant](https://github.com/hashicorp/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"
```
---
[Read more](https://github.com/praetorian-inc/brutus)