**विकल्प 2: स्रोत से निर्माण करें**```bash
git clone https://github.com/umpolungfish/byvalver.git
cd byvalver
make
sudo make install
sudo make install-man  # Install man page

**BAD-BYTE प्रोफाइल का उपयोग करना:**```bash
# HTTP contexts (removes null, newline, carriage return)
byvalver --profile http-newline input.bin output.bin

# SQL injection contexts
byvalver --profile sql-injection input.bin output.bin

# Alphanumeric-only shellcode (most restrictive)
byvalver --profile alphanumeric-only input.bin output.bin

**उन्नत सुविधाएँ:**```bash
# Add obfuscation layer before denullification
byvalver --biphasic input.bin output.bin

# Enable ML-powered strategy selection
byvalver --ml input.bin output.bin

# Generate XOR-encoded shellcode with decoder stub
byvalver --xor-encode DEADBEEF input.bin output.bin

# Output in different formats
byvalver --format c input.bin output.c      # C array
byvalver --format python input.bin output.py # Python bytes
byvalver --format hexstring input.bin output.hex # Hex string

### क्रॉस-आर्किटेक्चर समर्थन

`byvalver` `--arch` फ्लैग के माध्यम से कई आर्किटेक्चर का समर्थन करता है:

**x86 (32-bit Intel/AMD)** - पूरी तरह से समर्थित, 150+ रणनीतियों के साथ```bash
byvalver --arch x86 --bad-bytes "00" x86_shellcode.bin output.bin

**ARM (32-bit)** - प्रायोगिक समर्थन बुनियादी रणनीतियों के साथ```bash
byvalver --arch arm --bad-bytes "00" arm_shellcode.bin output.bin

**नोट्स:**
- ARM/ARM64 समर्थन मुख्य निर्देशों (MOV, अंकगणित, लोड/स्टोर) पर केंद्रित है
- ARM के लिए सरल bad-byte प्रोफ़ाइल का उपयोग करें (जैसे, केवल null-byte)
- ARM/ARM64 चुने जाने पर प्रयोगात्मक चेतावनियाँ प्रदर्शित की जाती हैं
- मूल आर्किटेक्चर बेमेल पहचान चेतावनी देता है यदि शेलकोड गलत आर्किटेक्चर का प्रतीत होता है
- भविष्य के रिलीज़ में स्वचालित आर्किटेक्चर पहचान की योजना है

### बैच प्रसंस्करण

पूर्ण निर्देशिकाओं को प्रसंस्कृत करें:```bash
# Process all .bin files recursively
byvalver -r --pattern "*.bin" input_dir/ output_dir/

# Apply HTTP profile to all shellcode in directory
byvalver -r --profile http-newline input_dir/ output_dir/

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

TUI सभी CLI कार्यक्षमता को कवर करने वाले 9 मुख्य मेनू विकल्प प्रदान करता है:

1. **एकल फ़ाइल प्रक्रिया** - दृश्य प्रतिक्रिया के साथ व्यक्तिगत शेलकोड फ़ाइलों को प्रोसेस करें
2. **बैच प्रक्रिया निर्देशिका** - लाइव प्रगति ट्रैकिंग के साथ संपूर्ण निर्देशिकाओं को प्रोसेस करें
3. **प्रोसेसिंग विकल्प कॉन्फ़िगर करें** - बाइफेसिक मोड, PIC जनरेशन, ML, वर्बोज़, ड्राई-रन टॉगल करें
4. **खराब बाइट्स सेट करें** - मैन्युअल प्रविष्टि या 13 पूर्वनिर्धारित प्रोफाइल में से चुनें
5. **आउटपुट फ़ॉर्मेट सेटिंग्स** - 5 आउटपुट फ़ॉर्मेट (raw, C, Python, PowerShell, hexstring) में से चुनें
6. **ML मीट्रिक्स कॉन्फ़िगरेशन** - ML रणनीति चयन और मीट्रिक्स ट्रैकिंग कॉन्फ़िगर करें
7. **उन्नत विकल्प** - XOR एन्कोडिंग, टाइमआउट, सीमाएँ, मान्यता सेटिंग्स
8. **कॉन्फ़िगरेशन लोड/सेव करें** - INI-शैली कॉन्फ़िगरेशन फ़ाइल प्रबंधन
9. **byvalver के बारे में** - संस्करण और सहायता जानकारी

### विज़ुअल फ़ाइल ब्राउज़र:

- **निर्देशिका नेविगेशन** तीर कुंजियों या vi-शैली j/k कुंजियों के साथ
- **[FILE] और [DIR] संकेतकों के साथ फ़ाइल/निर्देशिका अंतर**
- **फ़ाइल आकार प्रदर्शन** मानव-पठनीय प्रारूपों (B, KB, MB, GB) में
- **एक्सटेंशन फ़िल्टरिंग** (जैसे, *.bin)
- **बुद्धिमान पथ प्रबंधन** - यदि फ़ाइल पथ प्रदान किया जाता है तो स्वचालित रूप से पैरेंट निर्देशिका पर जाएँ
- **क्रमबद्ध प्रदर्शन** - पहले निर्देशिकाएँ, फिर वर्णमाला क्रम
- **एकाधिक चयन मोड**:
  - फ़ाइल चयन मोड: निर्देशिकाओं में नेविगेट करें, केवल फ़ाइलें चुनें
  - निर्देशिका चयन मोड: बैच प्रोसेसिंग के लिए निर्देशिकाएँ चुनें
  - दोनों मोड: फ़ाइलें या निर्देशिकाएँ चुनें

### लाइव अपडेट के साथ बैच प्रोसेसिंग:

बैच प्रोसेसिंग स्क्रीन **रीयल-टाइम फीडबैक** प्रदान करती है:

- **प्रगति पट्टी** प्रोसेस की गई फ़ाइलें दिखाती है (जैसे, `[==============        ] 52/100 files`)
- **कॉन्फ़िगरेशन प्रदर्शन** सक्रिय सेटिंग्स दिखाता है:
  - बैड बाइट्स गिनती और उपयोग की गई प्रोफ़ाइल
  - प्रोसेसिंग विकल्प (`Biphasic`, `PIC`, `XOR`, ML)
  - आउटपुट फ़ॉर्मेट
- **लाइव फ़ाइल सांख्यिकी** रंग-कोडित स्थिति के साथ:
  - पूर्ण: X / Y (प्रयास की गई फ़ाइलें / कुल)
  - ✅ सफल (हरा) - शून्य बैड बाइट्स शेष
  - ❌ विफल (लाल) - त्रुटियाँ या शेष बैड बाइट्स
  - सफलता दर प्रतिशत
- **वर्तमान फ़ाइल प्रदर्शन** बोल्ड टेक्स्ट में
- **अगली फ़ाइल पूर्वावलोकन** पीले/मंद टेक्स्ट में
- **गतिशील रणनीति सांख्यिकी तालिका** दिखाती है:
  - **सभी सक्रिय रणनीतियाँ** (कोई 10-रणनीति सीमा नहीं)
  - **पूर्ण रणनीति नाम** (50 वर्णों तक, कोई छंटाई नहीं)
  - प्रति रणनीति सफलता/विफलता गणना
  - सफलता दर प्रतिशत
  - प्रदर्शन के अनुसार रंग-कोडित (हरा ≥80%, पीला 50-79%, लाल <50%)
  - प्रत्येक 50ms पर रीयल-टाइम अपडेट

### कॉन्फ़िगरेशन प्रबंधन:

**INI-शैली प्रारूप** में कॉन्फ़िगरेशन लोड और सेव करें:```ini
[general]
verbose = 0
quiet = 0
show_stats = 1

[processing]
use_biphasic = 0
use_pic_generation = 0
encode_shellcode = 0
xor_key = 0xDEADBEEF

[output]
output_format = raw

[bad_bytes]
bad_bytes = 00

[ml]
use_ml_strategist = 0
metrics_enabled = 0

[batch]
file_pattern = *.bin
recursive = 0
preserve_structure = 1

एप्लिकेशन स्वचालित रूप से पता लगाएगा कि ncurses उपलब्ध है या नहीं और तदनुसार TUI समर्थन सक्षम करेगा।

### BUILD OPTIONS:

TUI समर्थन ncurses उपलब्धता के आधार पर सशर्त रूप से संकलित किया जाता है:

- डिफ़ॉल्ट बिल्ड: `make` - TUI शामिल करता है यदि ncurses उपलब्ध है
- TUI बिल्ड को बाध्य करें: `make with-tui` - TUI समर्थन के साथ बनाता है (यदि ncurses उपलब्ध नहीं है तो विफल हो जाता है)
- TUI को बाहर करें: `make no-tui` - छोटे बाइनरी के लिए TUI समर्थन के बिना बनाता है

### EXAMPLE WORKFLOWS:

**एकल फ़ाइल प्रसंस्करण:**
1. TUI लॉन्च करें: `byvalver --menu`
2. "1. Process Single File" चुनें
3. विज़ुअल फ़ाइल ब्राउज़र का उपयोग करके इनपुट फ़ाइल ब्राउज़ करें
4. आउटपुट फ़ाइल स्थान ब्राउज़ करें
5. प्रसंस्करण शुरू करें और परिणाम देखें

**बैच प्रसंस्करण:**
1. TUI लॉन्च करें: `byvalver --menu`
2. "2. Batch Process Directory" चुनें
3. शेलकोड फ़ाइलों वाली इनपुट निर्देशिका ब्राउज़ करें
4. आउटपुट निर्देशिका ब्राउज़ करें
5. फ़ाइल पैटर्न (डिफ़ॉल्ट: <file>.bin) और रिकर्सिव विकल्प कॉन्फ़िगर करें
6. बैच प्रसंस्करण शुरू करें और रणनीति आँकड़ों के साथ लाइव प्रगति देखें

**कॉन्फ़िगरेशन प्रबंधन:**
1. TUI में सभी विकल्प कॉन्फ़िगर करें (बैड बाइट्स, आउटपुट फॉर्मेट, ML, आदि)
2. "8. Load/Save Configuration" चुनें
3. वर्तमान कॉन्फ़िगरेशन को फ़ाइल में सहेजें (जैसे, `my_config.conf`)
4. बाद में: सभी सेटिंग्स को पुनर्स्थापित करने के लिए कॉन्फ़िगरेशन फ़ाइल लोड करें

### PERFORMANCE NOTES:

- **एकल फ़ाइल प्रसंस्करण**: तत्काल दृश्य प्रतिक्रिया, सामान्य शेलकोड के लिए <1 सेकंड
- **बैच प्रसंस्करण**: दृश्य अपडेट के लिए फ़ाइलों के बीच 50ms की देरी
- **बड़ी निर्देशिकाएँ (100+ फ़ाइलें)**: स्कैन करने में 1-2 सेकंड लग सकते हैं
- **रणनीति आरंभीकरण**: पहली बार चलाने पर 2-5 सेकंड (प्रति सत्र एक बार की लागत)

### TERMINAL COMPATIBILITY:

TUI का परीक्षण निम्नलिखित के साथ किया गया है:
- GNOME Terminal
- Konsole
- xterm
- iTerm2 (macOS)
- Windows Terminal (WSL)
- tmux/screen (काम करता है लेकिन रंग सीमाएँ हो सकती हैं)

**न्यूनतम अनुशंसित टर्मिनल आकार**: 80x24 कैरेक्टर (बैच प्रसंस्करण के दौरान पूर्ण रणनीति तालिका के लिए 100x30 या बड़ा अनुशंसित)

पूर्ण TUI दस्तावेज़ीकरण, समस्या निवारण और उन्नत उपयोग के लिए, देखें [TUI_README.md](https://github.com/umpolungfish/byvalver/blob/main/TUI_README.md)।

## TARGETED BAD-BYTE BANISHMENT

### OVERVIEW

`--bad-bytes` विकल्प आपको अपने शेलकोड से बाहर निकालने के लिए बाइट्स का कोई भी सेट निर्दिष्ट करने की अनुमति देता है।

### IMPLEMENTATION DETAILS

`byvalver` निम्नलिखित तरीके से काम करता है:
1. अल्पविराम से अलग किए गए हेक्स बाइट सूची को पार्स करना (जैसे, `"00,0a,0d"`)
2. निर्देशों में बैड बाइट्स की पहचान करने के लिए O(1) बिटमैप लुकअप का उपयोग करना
3. NULL-बाइट उन्मूलन के लिए उपयोग की जाने वाली समान 153+ ट्रांसफ़ॉर्मेशन रणनीतियों को लागू करना
4. सत्यापित करना कि आउटपुट में निर्दिष्ट बैड बाइट्स नहीं हैं

### EXPECTED BEHAVIOR

- **केवल NULL बाइट्स** (`--bad-bytes "00"` या डिफ़ॉल्ट): उच्च सफलता दर (परीक्षण कोष्ठ पर 100%)
- **एकाधिक बैड बाइट्स** (`--bad-bytes "00,0a,0d"`): सफलता दर इसके आधार पर महत्वपूर्ण रूप से भिन्न हो सकती है:
  - कौन सी विशिष्ट बाइट्स को बैड के रूप में चिह्नित किया गया है
  - इनपुट शेलकोड की जटिलता
  - मूल शेलकोड में बैड बाइट्स की आवृत्ति
  - क्या विशिष्ट बैड बाइट सेट के लिए प्रभावी वैकल्पिक एन्कोडिंग मौजूद हैं

### RECOMMENDATIONS

1. **उत्पादन उपयोग के लिए:** डिफ़ॉल्ट NULL-बाइट निष्कासन मोड पर बने रहें
2. **प्रयोग के लिए:** `--bad-bytes` सुविधा को अपने विशिष्ट उपयोग मामले के साथ परीक्षण करें और आउटपुट को मान्य करें
3. **हमेशा सत्यापित करें:** सभी बैड बाइट्स को समाप्त करने की पुष्टि करने के लिए `verify_denulled.py --bad-bytes "XX,YY"` का उपयोग करें
4. **परिवर्तनशीलता की अपेक्षा करें:** कुछ शेलकोड निश्चित बैड बाइट सेट के साथ पूरी तरह से साफ नहीं हो सकते हैं

### FUTURE IMPROVEMENTS

सामान्य बैड-बाइट सुविधा निम्नलिखित के लिए एक आधार प्रदान करती है:
- विशिष्ट बैड बाइट पैटर्न के लिए रणनीति अनुकूलन
- सामान्य बैड बाइट संयोजनों को लक्षित करने वाली नई रणनीतियों की स्वचालित खोज
- विविध बैड बाइट प्रशिक्षण डेटा के साथ ML मॉडल पुनर्प्रशिक्षण
- विस्तारित परीक्षण और सत्यापन

> [!CAUTION]
> एकाधिक बैड बाइट्स के साथ `--bad-bytes` का उपयोग करने से रूपांतरण कार्य की जटिलता काफी बढ़ जाती है। यदि बहुत अधिक बाइट्स को बैड के रूप में चिह्नित किया जाता है तो कुछ शेलकोड को रूपांतरित करना असंभव हो सकता है, क्योंकि उपकरण के पास वैकल्पिक एन्कोडिंग खत्म हो सकती है। छोटे बैड बाइट सेट (जैसे, `"00,0a"`) से शुरू करें और आउटपुट का परीक्षण करते हुए धीरे-धीरे विस्तार करें। परिनियोजन से पहले हमेशा `verify_denulled.py` के साथ परिणाम सत्यापित करें।

## BAD-BYTE PROFILES

### OVERVIEW

उपयोगकर्ता **बैड-बाइट प्रोफाइल** भी चुन सकते हैं - सामान्य शोषण परिदृश्यों के लिए पूर्व-कॉन्फ़िगर किए गए बाइट्स के सेट। हेक्स मानों को मैन्युअल रूप से निर्दिष्ट करने के बजाय, अपने संदर्भ से मेल खाने वाले प्रोफाइल नाम का उपयोग करें।

### AVAILABLE PROFILES

| Profile | Difficulty | Bad Bytes | Use Case |
|---------|-----------|-----------|----------|
| `null-only` | ░░░░░ Trivial | 1 | क्लासिक बफर ओवरफ़्लो (डिफ़ॉल्ट) |
| `http-newline` | █░░░░ Low | 3 | `HTTP` हेडर, लाइन-आधारित प्रोटोकॉल |
| `http-whitespace` | █░░░░ Low | 5 | `HTTP` पैरामीटर, कमांड इंजेक्शन |
| `url-safe` | ███░░ Medium | 23 | `URL` पैरामीटर, `GET` अनुरोध |
| `sql-injection` | ███░░ Medium | 5 | `SQL` इंजेक्शन संदर्भ |
| `xml-html` | ███░░ Medium | 6 | `XML`/`HTML` इंजेक्शन, `XSS` |
| `json-string` | ███░░ Medium | 34 | `JSON` API इंजेक्शन |
| `format-string` | ███░░ Medium | 3 | फ़ॉर्मेट स्ट्रिंग कमजोरियाँ |
| `buffer-overflow` | ███░░ Medium | 5 | फ़िल्टरिंग के साथ स्टैक/हीप ओवरफ़्लो |
| `command-injection` | ███░░ Medium | 20 | शेल कमांड इंजेक्शन |
| `ldap-injection` | ███░░ Medium | 5 | `LDAP` क्वेरी |
| `printable-only` | ████░ High | 161 | टेक्स्ट-आधारित प्रोटोकॉल (केवल प्रिंटेबल ASCII) |
| `alphanumeric-only` | █████ Extreme | 194 | केवल अल्फ़ान्यूमेरिक शेलकोड (0-9, A-Z, a-z) |

### USAGE```bash
# List all available profiles
byvalver --list-profiles

# Use a specific profile
byvalver --profile http-newline input.bin output.bin

# Combine with other options
byvalver --profile sql-injection --biphasic --format c input.bin output.c

**SQL इंजेक्शन** (NULL, उद्धरण, अर्धविराम समाप्त करता है):```bash
byvalver --profile sql-injection payload.bin sql_safe.bin

विस्तृत प्रोफ़ाइल दस्तावेज़ीकरण के लिए, देखें [docs/BAD_BYTE_PROFILES.md](https://github.com/umpolungfish/byvalver/blob/main/docs/BAD_BYTE_PROFILES.md)।


## विशेषताएँ

### NULL-बाइट निष्कासन की उच्च सफलता दर
<div align="center">
  <strong>सामान्य और जटिल null स्रोतों का प्रतिनिधित्व करने वाले एक विविध परीक्षण कोष पर 100% null-बाइट निष्कासन प्राप्त किया गया।</strong>
</div>

> यह सफलता दर विशेष रूप से null-बाइट (`\x00`) उन्मूलन पर लागू होती है, जिसका व्यापक रूप से परीक्षण और अनुकूलन किया गया है।

### उन्नत रूपांतरण इंजन
170+ रणनीति कार्यान्वयन जो लगभग सभी सामान्य null-बाइट स्रोतों और सामान्य बुरे-बाइट पैटर्न को कवर करते हैं (v3.0, v3.6, v3.7, v3.8, v4.0, और v4.1 में कई नए रणनीति परिवार जोड़े गए):
- `CALL/POP` और स्टैक-आधारित तत्काल लोडिंग
- हैशित API रिज़ॉल्यूशन के साथ `PEB` ट्रैवर्सल
- जटिल एल्गोरिदम के साथ उन्नत हैश-आधारित API रिज़ॉल्यूशन
- एकाधिक DLL लोडिंग के लिए बहु-चरण `PEB` ट्रैवर्सल
- `SALC`, `XCHG`, और फ्लैग-आधारित शून्यीकरण
- अंकगणितीय प्रतिस्थापन के लिए `LEA`
- `Shift` और अंकगणितीय मान निर्माण
- मल्टी-`PUSH` स्ट्रिंग निर्माण
- विंडोज संरचनाओं के लिए स्टैक-आधारित संरचना निर्माण
- उन्नत पैटर्न के साथ स्टैक-आधारित स्ट्रिंग निर्माण
- `SIB` और विस्थापन पुनर्लेखन
- सशर्त जंप विस्थापन हैंडलिंग
- रजिस्टर रीमैपिंग और चेनिंग
- बफर इनिशियलाइज़ेशन के लिए उन्नत `SALC`+`REP STOSB`
- उन्नत स्ट्रिंग ऑपरेशन ट्रांसफ़ॉर्मेशन
- परमाणु ऑपरेशन एन्कोडिंग चेन
- `FPU` स्टैक-आधारित तत्काल एन्कोडिंग
- `XLAT` तालिका-आधारित बाइट अनुवाद
- `LAHF`/`SAHF` फ्लैग संरक्षण चेन
- **v3.6 में नया**: `BCD` अंकगणितीय अस्पष्टीकरण (`AAM`/`AAD`)
- **v3.6 में नया**: `ENTER`/`LEAVE` स्टैक फ्रेम विकल्प
- **v3.6 में नया**: `POPCNT`/`LZCNT`/`TZCNT` बिट काउंटिंग स्थिरांक के लिए
- **v3.6 में नया**: `SIMD` `XMM` रजिस्टर तत्काल लोडिंग
- **v3.6 में नया**: `JECXZ`/`JRCXZ` शून्य-परीक्षण जंप ट्रांसफ़ॉर्मेशन
- **v3.7 में नया**: सशर्त जंप ऑपकोड बुरे-बाइट उन्मूलन (बुरे ऑपकोड के साथ JE/JNE/JG/JL)
- **v3.7 में नया**: रजिस्टर-से-रजिस्टर ट्रांसफर बुरे-बाइट ऑपकोड (MOV/XCHG विकल्प)
- **v3.7 में नया**: स्टैक फ्रेम पॉइंटर बुरे-बाइट उन्मूलन (PUSH/POP EBP विकल्प)
- **v3.7 में नया**: ModR/M और SIB बाइट बुरे-बाइट उन्मूलन (वैकल्पिक रजिस्टर संयोजन)
- **v3.7 में नया**: मल्टी-बाइट तत्काल आंशिक बुरा-बाइट (रोटेशन अनुकूलन)
- **v3.7 में नया**: बिटवाइज़ ऑपरेशन तत्काल बुरा-बाइट (AND/OR/XOR/TEST रजिस्टरों के साथ)
- **v3.7 में नया**: एक-बाइट ऑपकोड प्रतिस्थापन (INC/DEC/PUSH/POP विकल्प)
- **v3.7 में नया**: स्ट्रिंग निर्देश उपसर्ग बुरा-बाइट (REP उपसर्ग से लूप रूपांतरण)
- **v3.7 में नया**: ऑपरेंड आकार उपसर्ग बुरा-बाइट (16-बिट से 32-बिट रूपांतरण)
- **v3.7 में नया**: सेगमेंट रजिस्टर बुरा-बाइट डिटेक्शन (FS/GS उपसर्ग डिटेक्शन)
- **v3.8 में नया**: प्रोफ़ाइल-जागरूक SIB जनरेशन सिस्टम (हार्डकोडेड 0x20 SIB बाइट को समाप्त करता है)
- **v3.8 में नया**: सशर्त जंप हैंडलिंग और आंशिक रजिस्टर अनुकूलन के लिए महत्वपूर्ण सुधार
 - **v3.9 में नया**: बहुरूपी NOP सम्मिलन एकाधिक NOP समकक्षों के साथ
 - **v3.9 में नया**: तत्काल मान अस्पष्टीकरण के लिए स्थिरांक अनफोल्डिंग
 - **v3.9 में नया**: XCHG पैटर्न के साथ रजिस्टर नाम बदलना अस्पष्टीकरण
 - **v3.9 में नया**: अंकगणितीय संक्रियाओं के लिए स्टैक स्पिल अस्पष्टीकरण
 - **v3.9 में नया**: NOP सम्मिलन के साथ निर्देश पुनर्क्रमण
 - **v3.9 में नया**: रनटाइम स्व-संशोधन रणनीति (मूल कार्यान्वयन)
 - **v3.9 में नया**: अतिव्यापी निर्देश जनरेशन
  - **v4.0 में नया**: Capstone गतिशील मोड चयन के साथ ARM/ARM64 क्रॉस-आर्किटेक्चर समर्थन
  - **v4.0 में नया**: MVN ट्रांसफ़ॉर्मेशन के साथ ARM तत्काल एन्कोडिंग
  - **v4.0 में नया**: ARM MOV रणनीतियाँ (मूल, MVN-आधारित null परिहार)
  - **v4.0 में नया**: ARM अंकगणितीय रणनीतियाँ (ADD SUB ट्रांसफ़ॉर्मेशन के साथ)
  - **v4.0 में नया**: ARM मेमोरी रणनीतियाँ (LDR/STR पास-थ्रू)
  - **v4.0 में नया**: ARM शाखा रणनीतियाँ (B/BL पास-थ्रू)
  - **v4.1 में नया**: SETcc फ्लैग संचयन चेन (सशर्त जंप उन्मूलन)
  - **v4.1 में नया**: बहुरूपी तत्काल मान निर्माण (एकाधिक एन्कोडिंग वेरिएंट)
  - **v4.1 में नया**: रजिस्टर निर्भरता श्रृंखला अनुकूलन (बहु-निर्देश पैटर्न)
  - **v4.1 में नया**: RIP-सापेक्ष पता अनुकूलन (x64 PIC सुधार)
  - **v4.1 में नया**: ऋणात्मक विस्थापन मेमोरी एड्रेसिंग (विस्थापन विकल्प)
  - **v4.1 में नया**: मल्टी-बाइट NOP अंतर्संबंध (अस्पष्टीकरण NOP वेरिएंट)
  - **v4.1 में नया**: बिट हेरफेर स्थिरांक निर्माण (BSWAP, BSF, POPCNT, BMI2)
  - **v4.2 में नया**: x86/x64 रणनीति संगतता परत (x64 पर 128+ x86 रणनीतियों को सक्षम करता है)
  - **v4.2 में नया**: MOVABS 64-बिट तत्काल रणनीतियाँ (REX.W MOV XOR/ADD निर्माण के साथ)
  - **v4.2 में नया**: SBB तत्काल शून्य रणनीतियाँ (SBB AL/AX/EAX, 0 ट्रांसफ़ॉर्मेशन)
  - **v4.2 में नया**: TEST बड़ा तत्काल रणनीतियाँ (TEST EAX/RAX, imm32 रजिस्टर ऑपरेंड के साथ)
  - **v4.2 में नया**: SSE मेमोरी ऑपरेशन रणनीतियाँ (MOVUPS/MOVAPS/MOVDQU/MOVDQA null उन्मूलन)
  - **v4.2 में नया**: LEA x64 विस्थापन रणनीतियाँ (REX उपसर्गों के साथ बड़े विस्थापन हैंडलिंग)
  - **v4.2 में नया**: विस्तारित रजिस्टर समर्थन (R8-R15 रजिस्टर एन्कोडिंग उपयोगिताएँ)
 - `MOV`, `ADD/SUB`, `XOR`, `LEA`, `CMP`, `PUSH`, और अधिक के लिए व्यापक समर्थन

यह इंजन किनारे के मामलों के लिए मजबूत फॉलबैक तंत्र के साथ मल्टी-पास प्रोसेसिंग (अस्पष्टीकरण → डिनलिंग) का उपयोग करता है

**v3.8 महत्वपूर्ण सुधार**: http-whitespace प्रोफ़ाइल के लिए मल्टी-रणनीति फिक्स
- **समस्या**: हार्डकोडेड बुरे बाइट्स के कारण 79.1% विफलता दर (158 फाइलों में से 125 विफल)
- **पहचाने गए मूल कारण**:
  - 15 रणनीति फाइलों में 45+ हार्डकोडेड SIB बाइट 0x20 (SPACE) के उदाहरण
  - सशर्त जंप कोर लॉजिक सत्यापन के बिना बुरे बाइट स्किप ऑफ़सेट का उपयोग कर रहा है
  - आंशिक रजिस्टर अनुकूलन सीधे बुरे बाइट्स लिख रहा है
  - 5 उच्च प्राथमिकता वाली रणनीति फाइलों में अतिरिक्त हार्डकोडेड बुरे बाइट्स
- **लागू किए गए समाधान**:
  - 3-स्तरीय फॉलबैक (STANDARD → DISP8 → PUSHPOP) के साथ केंद्रीकृत प्रोफ़ाइल-जागरूक SIB जनरेशन
  - बुरे बाइट्स से बचने के लिए सशर्त जंप स्किप ऑफ़सेट के लिए गतिशील NOP पैडिंग
  - अपघटन का उपयोग करके आंशिक रजिस्टर मानों के लिए बुद्धिमान बाइट निर्माण
  - हार्डकोडेड बाइट्स का प्रोफ़ाइल-जागरूक विकल्पों के साथ व्यवस्थित प्रतिस्थापन
- **प्रभाव**: **79.1% विफलता → 35.4% विफलता** (सफलता दर: **20.9% → 64.6%**)
- **ठीक की गई फाइलें**: 102 फाइलें अब सफलतापूर्वक प्रक्रिया करती हैं (+69 फाइलें, 3.09x सुधार)
- **रणनीति सफलता दरें**:
  - आंशिक रजिस्टर अनुकूलन: 25% → **100%** (12/12 ट्रांसफ़ॉर्मेशन)
  - mov_mem_disp_enhanced: 0% → **98.5%** (1605/1629 ट्रांसफ़ॉर्मेशन)
  - indirect_call_mem: 0% → **98.5%** (135/137 ट्रांसफ़ॉर्मेशन)
  - indirect_jmp_mem: 0% → **98.5%** (134/136 ट्रांसफ़ॉर्मेशन)
- **प्रदर्शन**: बुद्धिमान कैशिंग के माध्यम से शून्य ओवरहेड, औसत आकार में <2% वृद्धि

### प्रदर्शन मेट्रिक्स

184 विविध शेलकोड नमूनों को संसाधित करने से वास्तविक दुनिया का प्रदर्शन डेटा:```
📊 Batch Processing Statistics:

Success Rate:            184/184             █████████████████████████   100.00%
Files Processed:         184                 █████████████████████████   100.00%
Failed:                  0                   ░░░░░░░░░░░░░░░░░░░░░░░░░   00.00%
Skipped:                 0                   ░░░░░░░░░░░░░░░░░░░░░░░░░   00.00%

Please provide the Markdown content to translate.```
🏆 Top Performing Denullification Strategies:

Strategy                                  Attempts    Success%    Confidence
--------                                  --------    --------    ----------
ret_immediate                                  134    █████████████░░░░░░░░░░░░   50.00%
MOVZX/MOVSX Null-Byte banishment              162    █████████████░░░░░░░░░░░░   50.00%
transform_mov_reg_mem_self                     774    █████████████░░░░░░░░░░░░   50.00%
cmp_mem_reg_null                                96    ████████████░░░░░░░░░░░░░   46.88%
cmp_mem_reg                                    264    ████████████░░░░░░░░░░░░░   46.97%
lea_disp_null                                 3900    ███████████░░░░░░░░░░░░░░   45.38%
transform_add_mem_reg8                        2012    ███████████░░░░░░░░░░░░░░   43.49%
Push Optimized                                4214    ███████░░░░░░░░░░░░░░░░░░   29.31%
ModRM Byte Null Bypass                          82    ██████░░░░░░░░░░░░░░░░░░░   25.61%
conservative_arithmetic                       5172    █████░░░░░░░░░░░░░░░░░░░░   21.37%
arithmetic_addsub_enhanced                    1722    ████░░░░░░░░░░░░░░░░░░░░░   18.12%
PUSH Immediate Null-Byte banishment          3066    ████░░░░░░░░░░░░░░░░░░░░░   16.54%
SIB Addressing                                9560    ████░░░░░░░░░░░░░░░░░░░░░   16.03%
generic_mem_null_disp_enhanced               22130    ███░░░░░░░░░░░░░░░░░░░░░░   15.52%
SALC-based Zero Comparison                    1654    ███░░░░░░░░░░░░░░░░░░░░░░   12.88%

### अस्पष्टीकरण स्तर
`--biphasic` मोड नल-हटाने से पहले विश्लेषण-रोधी अस्पष्टीकरण जोड़ता है:
- नियंत्रण प्रवाह समतलन
- डिस्पैचर पैटर्न
- रजिस्टर पुनर्नियोजन
- स्थिति अस्पष्टीकरण
- मृत कोड सम्मिलन
- NOP स्लेज
- निर्देश प्रतिस्थापन
- समतुल्य संक्रियाएँ
- स्टैक फ्रेम हेरफेर
- API रिजॉल्यूशन छिपाना
- स्ट्रिंग एन्कोडिंग
- कॉन्स्टेंट एन्कोडिंग
- एंटी-डिबगिंग
- VM पहचान तकनीकें

### ML-संचालित रणनीति चयन

> **परिपक्वता: बीटा v2.0** — नल-बाइट उन्मूलन डेटासेट पर प्रशिक्षित। सामान्य खराब-बाइट उपयोग मामलों के लिए पुनः प्रशिक्षण की आवश्यकता है।

**आर्किटेक्चर**:
- **वन-हॉट निर्देश एन्कोडिंग** (51 आयाम) अदिश निर्देश आईडी को बदलता है
- **संदर्भ विंडो** जिसमें 4 निर्देशों का स्लाइडिंग बफर (वर्तमान + 3 पिछले) होता है
- **स्थिर फीचर निष्कर्षण** प्रति निर्देश स्थिर 84-आयामी लेआउट के साथ
- **स्थिर रणनीति रजिस्ट्री** जो सुसंगत NN आउटपुट मैपिंग सुनिश्चित करती है
- **सभी परतों के माध्यम से पूर्ण बैकप्रोपेगेशन** (इनपुट→हिडन→आउटपुट)
- **सॉफ्टमैक्स + क्रॉस-एंट्रॉपी हानि के लिए सही ग्रेडिएंट गणना**
- **आउटपुट मास्किंग** सॉफ्टमैक्स से पहले अमान्य रणनीतियों को फ़िल्टर करता है
- **उचित वेट इनिशियलाइज़ेशन के लिए He/Xavier इनिशियलाइज़ेशन**
- 3-परत फीडफॉरवर्ड तंत्रिका नेटवर्क (336→512→200)
- सफलता/विफलता प्रतिक्रिया से अनुकूली शिक्षा
- पूर्वानुमान, सटीकता और आत्मविश्वास को ट्रैक करता है
- नियतात्मक क्रम में सुंदर फॉलबैक

> [!चेतावनी]
> ML मोड प्रयोगात्मक है और नए आर्किटेक्चर के साथ और प्रशिक्षण/सत्यापन की आवश्यकता है।

### बैच प्रोसेसिंग
- पुनरावर्ती निर्देशिका ट्रैवर्सल (`-r`)
- कस्टम फ़ाइल पैटर्न (`--pattern "*.bin"`)
- संरचना संरक्षण या समतलन
- त्रुटि पर जारी रखें या सख्त मोड
- सभी विकल्पों के साथ संगत (biphasic, PIC, `XOR`, आदि)
- **उन्नत आउटपुट**:
  - फ़ाइल-वार आकार परिवर्तन अनुपात के साथ
  - विफलताओं पर विस्तृत खराब बाइट पहचान
  - सारांश में सफलता/विफलता प्रतिशत
  - विफल फ़ाइलों की सूची (पहली 10 इनलाइन दिखाई गईं)
  - सख्त सफलता परिभाषा: शेष खराब बाइट्स वाली फ़ाइलें विफल के रूप में चिह्नित

**बैच प्रोसेसिंग आउटपुट उदाहरण:**```
===== BATCH PROCESSING SUMMARY =====
Total files:       8
Successfully processed: 1 (12.5%)
Failed:            7 (87.5%)
Skipped:           0

Total input size:  650 bytes
Total output size: 764 bytes
Average size ratio: 1.18x

Bad bytes:    5 configured
Configured set:    0x00, 0x09, 0x0a, 0x0d, 0x20

FAILED FILES (7):
  - shellcode1.bin
  - shellcode2.bin
  ...

### सत्यापन सूट
मान्यता के लिए पायथन उपकरण:
- `verify_denulled.py`: शून्य खराब बाइट्स सुनिश्चित करता है (कस्टम सत्यापन के लिए `--bad-bytes` का समर्थन करता है)
- `verify_functionality.py`: निष्पादन पैटर्न की जाँच करता है
- `verify_semantic.py`: समतुल्यता को मान्य करता है

## आर्किटेक्चर

`byvalver` एक मॉड्यूलर रणनीति-पैटर्न डिज़ाइन का उपयोग करता है:
- पास 1: (वैकल्पिक) एंटी-विश्लेषण के लिए अस्पष्टीकरण
- पास 2: नल-बाइट हटाने के लिए डिनलिफिकेशन
- रणनीति अनुकूलन के लिए एमएल परत
- स्केलेबल प्रसंस्करण के लिए बैच सिस्टम

<div align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/9982/8d3a1e20481460fedecaecda6f87bc21355fbbb1f1ef58d7fef4427eda36a381.png" alt="रणनीति श्रेणियाँ वर्गीकरण" width="700">
</div>

## सिस्टम आवश्यकताएँ

- **OS**: Linux (Ubuntu/Debian/Fedora), macOS (होमब्रे के साथ), Windows (WSL/MSYS2 के माध्यम से)
- **CPU**: x86/x64 आधुनिक निर्देशों के साथ
- **RAM**: 1GB मुक्त
- **Disk**: 50MB मुक्त
- **Tools**: `C` कंपाइलर, Make, Git (अनुशंसित)

## निर्भरताएँ

- **कोर**: GCC/Clang, GNU Make, `Capstone` (v4.0+), `NASM` (v2.13+), xxd
- **वैकल्पिक**: Clang-Format, Cppcheck, Valgrind
- **एमएल प्रशिक्षण**: गणित पुस्तकालय (शामिल)

### इंस्टॉलेशन कमांड्स

**Ubuntu/Debian:**```bash
sudo apt update
sudo apt install build-essential nasm xxd pkg-config libcapstone-dev clang-format cppcheck valgrind

### macOS/Homebrew बिल्ड फिक्सेस (रिपॉजिटरी बदलाव)
macOS/Homebrew संगतता (विशेष रूप से Apple silicon + Homebrew prefix `/opt/homebrew` पर) में सुधार के लिए हाल ही में बदलाव किए गए:
- `Makefile` और `makefile` को अपडेट किया गया ताकि **संकलन के दौरान `CPPFLAGS`** और **लिंकिंग के दौरान `LDLIBS`** का उपयोग किया जा सके, ताकि `pkg-config` द्वारा खोजे गए Capstone फ़्लैग का सम्मान किया जा सके।
- Homebrew के `pkg-config` द्वारा उत्पन्न Capstone include पथ को `.../include/capstone` से `.../include` में सामान्यीकृत किया गया ताकि प्रोजेक्ट का `#include <capstone/capstone.h>` सही ढंग से हल हो सके।

अंतर सारांश (उच्च स्तर):
- `$(CC) $(CFLAGS) -c ...` → `$(CC) $(CFLAGS) $(CPPFLAGS) -c ...`
- `$(CC) $(CFLAGS) -o ... $(LDFLAGS)` → `$(CC) $(CFLAGS) $(CPPFLAGS) -o ... $(LDFLAGS) $(LDLIBS)`
- `CAPSTONE_CFLAGS := pkg-config --cflags capstone` → `<capstone/capstone.h>` के साथ संगत include पथ में सामान्यीकृत किया गया

### समस्या निवारण (macOS)```bash
# Verify xxd is available (macOS usually ships /usr/bin/xxd)
command -v xxd

# Verify Capstone is discoverable via pkg-config
pkg-config --cflags capstone
pkg-config --libs capstone

# Clean rebuild
make clean
make

कॉन्फ़िग देखें: `make info`

## इंस्टॉलेशन

वैश्विक इंस्टॉलेशन:```bash
sudo make install
sudo make install-man

GitHub से:```bash
curl -sSL https://raw.githubusercontent.com/umpolungfish/byvalver/main/install.sh | bash

- Input/output can be files or directories (auto-batch)

**मुख्य विकल्प:**
- `-h, --help`: सहायता
- `-v, --version`: संस्करण
- `-V, --verbose`: विस्तृत
- `-q, --quiet`: शांत
- `--bad-bytes BYTES`: निष्कासित करने के लिए अल्पविराम से अलग किए गए हेक्स बाइट्स (डिफ़ॉल्ट: "00")
- `--profile NAME`: पूर्वनिर्धारित खराब-बाइट प्रोफ़ाइल का उपयोग करें (जैसे, http-newline, sql-injection)
- `--list-profiles`: सभी उपलब्ध खराब-बाइट प्रोफ़ाइलों की सूची दिखाएँ
- `--biphasic`: अस्पष्टीकरण + डीनल
- `--pic`: स्थिति-स्वतंत्र
- `--ml`: ML रणनीति चयन
- `--xor-encode KEY`: स्टब के साथ `XOR` एन्कोड करें
- `--format FORMAT`: raw|c|python|hexstring
- `-r, --recursive`: पुनरावर्ती बैच
- `--pattern PATTERN`: फ़ाइल ग्लोब
- `--no-preserve-structure`: आउटपुट को समतल करें
- `--no-continue-on-error`: त्रुटि पर रुकें
- `--menu`: इंटरैक्टिव TUI मेनू प्रारंभ करें

**उदाहरण:**```bash
# Default: banish null bytes only (well-tested, recommended)
byvalver shellcode.bin clean.bin

# v3.0 NEW: List available bad-byte profiles
byvalver --list-profiles

# v3.0 NEW: Use predefined profile for HTTP contexts (eliminates 0x00, 0x0A, 0x0D)
byvalver --profile http-newline shellcode.bin clean.bin

# v3.0 NEW: Use profile for SQL injection contexts
byvalver --profile sql-injection shellcode.bin clean.bin

# v3.0 NEW: Use profile for URL-safe shellcode
byvalver --profile url-safe shellcode.bin clean.bin

# v3.0 NEW: Manual bad-byte specification (experimental - not extensively tested)
byvalver --bad-bytes "00,0a,0d" shellcode.bin clean.bin

# Combined with other features
byvalver --profile http-newline --biphasic --ml input.bin output.bin

# Batch processing with profile
byvalver -r --profile http-whitespace --pattern "*.bin" shellcodes/ output/

# Launch interactive TUI mode
byvalver --menu

**RECOMMENDATION:** ML मोड को उत्पादन उपयोग से पहले विविध बैड-बाइट डेटासेट के साथ पुनः प्रशिक्षण की आवश्यकता है। वर्तमान में केवल null-बाइट निष्कासन के लिए अनुकूलित।

## एजेंट मेनजरी

`byvalver` एक **AI-संचालित एजेंट पाइपलाइन** (`agents/`) शिप करता है जो स्वायत्त रूप से रणनीति रजिस्ट्री में अंतराल खोज सकती है, एक नवीन बैड-बाइट उन्मूलन तकनीक प्रस्तावित कर सकती है, एक पूर्ण C कार्यान्वयन उत्पन्न कर सकती है, और इसे परियोजना में जोड़ सकती है — यह सब एक ही कमांड में।

पाइपलाइन [AjintK](https://github.com/umpolungfish/byvalver/blob/main/AjintK) बहु-प्रदाता एजेंट ढाँचे पर निर्मित है और **Anthropic**, **DeepSeek**, **Qwen**, **Mistral**, और **Google** को LLM बैकएंड के रूप में समर्थन करती है।

### त्वरित आरंभ```bash
# Requires API key for your chosen provider
export ANTHROPIC_API_KEY="..."   # or DEEPSEEK_API_KEY, QWEN_API_KEY, etc.

# --- Specialized Generators ---

# 1. General Technique Generator (discover → propose → generate → implement)
python3 run_technique_generator.py

# 2. Obfuscation Technique Generator (specifically for anti-analysis/evasion)
python3 run_obfuscation_generator.py

# 3. Bad-Byte Removal Generator (targeting restricted byte elimination)
python3 run_badbyte_generator.py

# 4. Profile-Specific Strategy Generator (targeting a specific bad-byte profile)
python3 run_profile_generator.py --profile alphanumeric-only

# --- Common Options ---

# Dry-run: discover and propose only, no files written
python3 run_technique_generator.py --dry-run

# Target a specific architecture
python3 run_technique_generator.py --arch x64

# Use a different provider / model
python3 run_technique_generator.py --provider deepseek --model deepseek-chat

### आवश्यकताएँ```bash
# Install Python dependencies (uses AjintK framework)
pip install anthropic tenacity httpx pyyaml

# Or with uv (faster)
uv pip install -r AjintK/requirements.txt