记录黑客技术中优秀的内容, 传播黑客文化,分享黑客技术精华

从0开始的PHP RASP的学习

2020-03-06 10:10

基础

RASP 设计思路

RASP(Runtime Application self-protection)是一种在运行时检测攻击并且进行自我保护的一种技术。PHP RASP的设计思路很直接,安全圈有一句名言叫一切输入都是有害的,我们就跟踪这些有害变量,看它们是否对系统造成了危害。我们跟踪了HTTP请求中的所有参数、HTTP Header等一切client端可控的变量,随着这些变量被使用、被复制,信息随之流动,我们也跟踪了这些信息的流动。我们还选取了一些敏感函数,这些函数都是引发漏洞的函数,例如require函数能引发文件包含漏洞,mysqli->query方法能引发SQL注入漏洞。简单来说,这些函数都是大家在代码审计时关注的函数。我们利用某些方法为这些函数添加安全检查代码。当跟踪的信息流流入敏感函数时,触发安全检查代码,如果通过安全检查,开始执行敏感函数,如果没通过安全检查,阻断执行,通过SAPI向HTTP Server发送403 Forbidden信息。当然,这一切都在PHP代码运行过程中完成。
这里主要有两个技术问题,一个是如何跟踪信息流,另一个是如何安全检查到底是怎样实现的。
有两个技术思路来解决两个问题,第一个是动态污点跟踪,另一个是基于词法分析的漏洞检测。本文用主要分析的是污点标记的方法。

参考一类PHP RASP实现所述

技术栈

  • taint污点分析模式
    • 命令执行
    • XSS
    • SQL
  • payload模式:重命名+phpwaf
    • 特征捕获检测

简而言之taint检测未知,payload上线前Fuzz检测
taint:污点标记,对参数传递过程进行判断清除或保留标记
payload模式:忽略参数传递过程,只分析最后作用于敏感函数的参数是否恶意

PHP生命周期

简而言之,无论以哪种方式启动php程序,经过下边四个步骤:模块初始化(MINIT)、请求初始化(RINIT)、请求处理、请求结束(RSHUTDOWN)、模块结束(MSHUTDOWN)

这四个阶段对应扩展开发中PHP_MINIT_FUNCTIONPHP_MSHUTDOWN_FUNCTIONPHP_RINIT_FUNCTIONPHP_RSHUTDOWN_FUNCTION四个函数来处理对应的功能。

php opcode

opcode是计算机指令中的一部分,用于指定要执行的操作,指令的格式和规范由处理器的指令规范指定。

记录一下php解析的过程:

  • 旧版本:php代码—>词法、语法分析->直接生成opcode指令
  • php7:php代码—>词法、语法分析生成抽象语法树AST->opcode指令

简单概括一下,所有php代码最终以opcode指令的形式在zend虚拟机中执行。

函数实现

PHP中函数的存储结构:/Zend/zend_compile.h#404

union _zend_function {
zend_uchar type; /* MUST be the first element of this struct! */

struct {
zend_uchar type; /* never used */
zend_uchar arg_flags[3]; /* bitset of arg_info.pass_by_reference */
uint32_t fn_flags;
zend_string *function_name;
zend_class_entry *scope;
union _zend_function *prototype;
uint32_t num_args;
uint32_t required_num_args;
zend_arg_info *arg_info;
} common;

zend_op_array op_array;
zend_internal_function internal_function;
};

这个联合体里边定义了四个结构体,内部函数通过扩展或者内核提供的C函数,比如time、array等,编译后用的internal_function结构;用户自定函数编译后为普通的opcode数组,用的op_array结构。剩下的commontype可以看做是internal_functionop_array的header。

实际上还有其他几类函数,暂时还没太明白:

内部函数

内部函数是指由内核、扩展提供的C语言编写的function,这类函数不用经过opcode的编译过程,效率高于php用户自定义函数,调用时与普通的C程序没有差异。

Zend引擎中定义了很多内部函数供用户在PHP中使用,比如:define、defined、strlen、method_exists、class_exists、function_exist等等,除了Zend引擎中定义的内部函数,PHP扩展中也提供了大量内部函数,我们也可以灵活的通过扩展自行定制。

前文介绍zend_functionunion,其中internal_function就是内部函数用到的具体结构:/Zend/zend_compile.h#384

typedef struct _zend_internal_function {
/* Common elements */
zend_uchar type;
zend_uchar arg_flags[3]; /* bitset of arg_info.pass_by_reference */
uint32_t fn_flags;
zend_string* function_name;
zend_class_entry *scope;
zend_function *prototype;
uint32_t num_args;
uint32_t required_num_args;
zend_internal_arg_info *arg_info;
/* END of common elements */

void (*handler)(INTERNAL_FUNCTION_PARAMETERS);
struct _zend_module_entry *module;
void *reserved[ZEND_MAX_RESERVED_RESOURCES];
} zend_internal_function;

zend_internal_function头部是一个与zend_op_array完全相同的common结构。

环境搭建

开发流程

php版本7.0.33,为了方便开发扩展,先下载源码:

wget https://github.com/php/php-src/archive/php-7.0.33.zip

解压后,在php源码里有一个代码生成器ext_skel,位于php-src-php-7.0.33/ext,先构建扩展基本文件:

./ext_skel --extname=passer6y

config.m4文件中这几行前的dnl去掉:

在头文件php_passer6y.h文件中声明扩展函数:

PHP_FUNCTION(passer6y_helloworld);

接着编辑passer6y.c,添加一行:PHP_FE(passer6y_helloworld, NULL)

最后在文件末尾加入passer6y_helloworld函数代码

PHP_FUNCTION(passer6y_helloworld)
{
char *arg = NULL;
int arg_len, len;
char *strg;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
return;
}
php_printf("my first ext,Hello World!\n");
RETRUN_TRUE;
}

编译扩展:

apt-get install php7.0-dev
phpize
./configure --with-php-config=/usr/bin/php-config7.0
make && make install

测试插件:

php -d "extension=passer6y.so" -r "passer6y_helloworld('123');"

GDB调试

参考文章:https://www.cnblogs.com/iamstudy/articles/php_code_rasp_1.html
下载php7.0.23:http://mirrors.sohu.com/php/php-7.0.23.tar.gz
重新编译php,开启--enable-debug

./configure \
--prefix=/opt/php_debug/ \
--enable-debug \
--enable-cli \
--without-pear \
--enable-embed \
--enable-inline-optimization \
--enable-shared \
--enable-opcache \
--enable-fpm \
--with-gettext \
--enable-mbstring \
--with-iconv=/usr/local/libiconv \


make && make install
mkdir /opt/php_debug/conf/
cp php.ini-development /opt/php_debug/conf/php.ini

再加个软连接方便执行:

ln -s /opt/php_debug/bin/php /usr/bin/php_debug
ln -s /opt/php_debug/bin/phpize /usr/bin/phpize_debug

创建插件的步骤和之前一样,在config.m4最后加上:

if test -z "$PHP_DEBUG"; then
AC_ARG_ENABLE(debug,
[--enable-debug compile with debugging system],
[PHP_DEBUG=$enableval], [PHP_DEBUG=no]
)
fi

然后再编译即可用gdb调试了

在make的时候可能会遇到libiconv的报错问题,参考这个文章安装一下就OK了,https://www.cnblogs.com/rwxwsblog/p/5451467.html

vld查看代码opcode

参考文章:https://www.cnblogs.com/miao-zp/p/6374311.html
安装vld:

wget http://pecl.php.net/get/vld-0.14.0.tgz
tar zxvf vld-0.14.0.tgz
cd vld-0.14.0/

找到php-config路径: locate php-config
编译:

./configure --with-php-config=/usr/bin/php-config7.0 --enable-vld
make && make install

检查是否编译成功:

修改php.ini /etc/php/7.0/cli/php.ini,在最后加上:

extension=vld.so

检测是否安装成功:php -r "phpinfo();" | grep "vld"

功能测试:
写一个phpinfo,然后执行下边命令,-dvld.active参数为1时使用vld扩展,-dvld.execute为1时执行改文件,这里不需要执行文件,就看一下php代码转换对应的opcode指令:

php -dvld.active=1 -dvld.execute=0 1.php

apache配置

还是之前的源码,重新编译php

./buildconf --force && ./configure --disable-all --enable-debug --prefix=/opt/php --with-apxs2=/usr/bin/apxs && make && make install

爆了一个线程安全的问题,执行下面两个命令凑合用着(每个子进程只有一个线程):

//  apache2 -t 查看错误日志
a2dismod mpm_event
a2enmod mpm_prefork

也可以用康师傅写的dockerfile,一键拉取环境:Dockerfile

命令备忘:

php --ini        // 查看php.ini默认配置路径

函数Hook

两种方式:

  • 重命名函数,并在function_table删除原函数定义,接着在php中重新定义一个该函数(像waf一样在入口include),并对参数进行威胁判断(prvd的payload模式)
  • 直接在底层Hook opcode,并检测函数函数(taint模式)

重命名函数

这里的重命名内部函数是在MINIT阶段进行实现的,在RINIT阶段是无法对已有的内部函数进行修改名称,只能对用户函数修改(即php中自定义的函数)。

参考fate0师傅的xmark项目实现的PHP_FUNCTION(xrename_function)函数,核心在这段:

// ...
Bucket *p = rename_hash_key(EG(function_table), orig_fname, new_fname, XMARK_IS_FUNCTION);

跟进rename_hash_key函数:

static zend_always_inline Bucket *rename_hash_key(HashTable *ht, zend_string *orig_name, zend_string *new_name, int type)
{
zend_ulong h;
uint32_t nIndex;
uint32_t idx;
Bucket *p = NULL, *arData, *prev = NULL;
zend_bool found = 0;

orig_name = zend_string_tolower(orig_name);
new_name = zend_string_tolower(new_name);

if (zend_hash_exists(ht, new_name)) {
zend_string_release(orig_name);
zend_string_release(new_name);
zend_error(E_ERROR, "function/class '%s' already exists", ZSTR_VAL(new_name));
return NULL;
}

h = zend_string_hash_val(orig_name);
arData = ht->arData;
nIndex = h | ht->nTableMask;
idx = HT_HASH_EX(arData, nIndex);
while (EXPECTED(idx != HT_INVALID_IDX)) {
prev = p;
p = HT_HASH_TO_BUCKET_EX(arData, idx);
if (EXPECTED(p->key == orig_name)) { /* check for the same interned string */
found = 1;
break;
} else if (EXPECTED(p->h == h) &&
EXPECTED(p->key) &&
EXPECTED(ZSTR_LEN(p->key) == ZSTR_LEN(orig_name)) &&
EXPECTED(memcmp(ZSTR_VAL(p->key), ZSTR_VAL(orig_name), ZSTR_LEN(orig_name)) == 0)) {
found = 1;
break;
}
idx = Z_NEXT(p->val);
}

if (!found) {
zend_string_release(orig_name);
zend_string_release(new_name);
zend_error(E_ERROR, "function/class '%s' does not exists", ZSTR_VAL(orig_name));
return NULL;
}

// rehash
if (!prev && Z_NEXT(p->val) == HT_INVALID_IDX) { // only p
HT_HASH(ht, nIndex) = HT_INVALID_IDX;
} else if (prev && Z_NEXT(p->val) != HT_INVALID_IDX) { // p in middle
Z_NEXT(prev->val) = Z_NEXT(p->val);
} else if (prev && Z_NEXT(p->val) == HT_INVALID_IDX) { // p in tail
Z_NEXT(prev->val) = HT_INVALID_IDX;
} else if (!prev && Z_NEXT(p->val) != HT_INVALID_IDX) { // p in head
HT_HASH(ht, nIndex) = Z_NEXT(p->val);
}

zend_string_release(p->key);
p->key = zend_string_init_interned(ZSTR_VAL(new_name), ZSTR_LEN(new_name), 1);
p->h = h = zend_string_hash_val(p->key);
nIndex = h | ht->nTableMask;

// 重命名函数名
if (type == XMARK_IS_FUNCTION) {
zend_string_release(p->val.value.func->common.function_name);
zend_string_addref(p->key);
p->val.value.func->common.function_name = p->key;
}


if (HT_HASH(ht, nIndex) != HT_INVALID_IDX)
Z_NEXT(p->val) = HT_HASH(ht, nIndex);

HT_HASH(ht, nIndex) = idx;

zend_string_release(orig_name);
zend_string_release(new_name);

return p;
}

Hook opcode

为什么要hook opcode呢?在后来的测试中发现像echoeval这些,它是一个语言特性,而不是一个函数,在EG(function_table)这个记录所有PHP函数的哈希表中找不到,但是他们最终都要解析成opcode,所以可以通过这种方式来劫持函数。

再举一个遇到的例子,比如在污点标记的时候,用户可控$a,但在后文经过字符串拼接$b = "xx".$a,将恶意代码传递给$b变量,这个时候我们是没有办法在函数层面控制的标记的,这个时候通过处理CONCAT指令即可解决:

Demo: Hook ZEND_ECHO

基础,php执行流程、全局变量等

这种方式要求我们知道函数所对应的opcode代码,可以通过gdb调试的办法查找,这里以echo为例,其opcode为ZEND_ECHO

passer6y.h中添加定义:

int fake_echo(ZEND_OPCODE_HANDLER_ARGS);

然后在passer6y.c中添加

int fake_echo(ZEND_OPCODE_HANDLER_ARGS)
{
php_printf("hook success");
return ZEND_USER_OPCODE_RETURN;
}

并在模块初始化PHP_MINIT_FUNCTION函数中添加调用:

PHP_MINIT_FUNCTION(passer6y)
{
/* If you have INI entries, uncomment these lines
REGISTER_INI_ENTRIES();
*/
//php_override_func("echo", sizeof("echo"), PHP_FN(fake_echo), NULL TSRMLS_CC);
zend_set_user_opcode_handler(ZEND_ECHO, fake_echo);
return SUCCESS;
}

编译运行:

敏感函数hook

  • eval: INCLUDE_OR_EVAL

    php-src-php-7.0.33/Zend/zend_ast.c#1258还有其他几个也使用了相同的opcode:
case ZEND_AST_INCLUDE_OR_EVAL:
switch (ast->attr) {
case ZEND_INCLUDE_ONCE: FUNC_OP("include_once");
case ZEND_INCLUDE: FUNC_OP("include");
case ZEND_REQUIRE_ONCE: FUNC_OP("require_once");
case ZEND_REQUIRE: FUNC_OP("require");
case ZEND_EVAL: FUNC_OP("eval");
EMPTY_SWITCH_DEFAULT_CASE();
}
break;

显然,include_onceincluderequire_oncerequireeval这5个函数的功能一样。

  • system: DO_ICALL
  • 变量函数执行:DO_FCALL
    $a="system";$a("whoami");

总结一下,hook这几个opcode指令:

  • INCLUDE_OR_EVAL
  • DO_ICALL
  • DO_FCALL
具体实现

opcode hook
通过zend_set_user_opcode_handler(zend_uchar opcode, user_opcode_handler_t handler)函数实现将指定的opcode,替换成我们自定义的。

其中user_opcode_handler_t类型是zend_execute_data *execute_data的别名:

第一次见typedef的这种用法,参考这篇文章:http://c.biancheng.net/view/298.html

zend_execute_data结构的注解在文档中有解释:https://www.kancloud.cn/nickbai/php7/363280

#define EX(element)             ((execute_data)->element)

//zend_compile.h
struct _zend_execute_data {
const zend_op *opline; //指向当前执行的opcode,初始时指向zend_op_array起始位置
zend_execute_data *call; /* current call */
zval *return_value; //返回值指针
zend_function *func; //当前执行的函数(非函数调用时为空)
zval This; //这个值并不仅仅是面向对象的this,还有另外两个值也通过这个记录:call_info + num_args,分别存在zval.u1.reserved、zval.u2.num_args
zend_class_entry *called_scope; //当前call的类
zend_execute_data *prev_execute_data; //函数调用时指向调用位置作用空间
zend_array *symbol_table; //全局变量符号表
#if ZEND_EX_USE_RUN_TIME_CACHE
void **run_time_cache; /* cache op_array->run_time_cache */
#endif
#if ZEND_EX_USE_LITERALS
zval *literals; //字面量数组,与func.op_array->literals相同
#endif
};

其中第一个车管员opline的结构定义:

struct _zend_op {
const void *handler; //对应执行的C语言function,即每条opcode都有一个C function处理
znode_op op1; //操作数1
znode_op op2; //操作数2
znode_op result; //返回值
uint32_t extended_value;
uint32_t lineno;
zend_uchar opcode; //opcode指令
zend_uchar op1_type; //操作数1类型
zend_uchar op2_type; //操作数2类型
zend_uchar result_type; //返回值类型
};

还有成员func的定义:

union _zend_function {
zend_uchar type; /* MUST be the first element of this struct! */

struct {
zend_uchar type; /* never used */
zend_uchar arg_flags[3]; /* bitset of arg_info.pass_by_reference */
uint32_t fn_flags;
zend_string *function_name;
zend_class_entry *scope; //成员方法所属类,面向对象实现中用到
union _zend_function *prototype;
uint32_t num_args; //参数数量
uint32_t required_num_args; //必传参数数量
zend_arg_info *arg_info; //参数信息
} common;

zend_op_array op_array; //函数实际编译为普通的zend_op_array
zend_internal_function internal_function;
};

现在我们要实现一个执行该opcode的函数以及参数的功能:

static int php_do_fcall_handler(zend_execute_data *execute_data){
const zend_op *opline = execute_data->opline;
zend_execute_data *call = execute_data->call;
zend_function *fbc = call->func;

if (fbc->type == ZEND_INTERNAL_FUNCTION) {
// 获取参数个数
int arg_count = ZEND_CALL_NUM_ARGS(call);
if (!arg_count) {
return ZEND_USER_OPCODE_DISPATCH;
}

// 如果不在类中
if (fbc->common.scope == NULL){
zend_string *fname = fbc->common.function_name;
char *funcname = ZSTR_VAL(fname);
int len = strlen(funcname);
if (fname) {
if (strncmp("passthru", funcname, len) == 0
|| strncmp("system", funcname, len) == 0
|| strncmp("exec", funcname, len) == 0
|| strncmp("shell_exec", funcname, len) == 0
|| strncmp("proc_open", funcname, len) == 0 ) {
zend_error(E_WARNING, funcname);
}
}
}
}
zend_error(E_WARNING, "ZEND_DO_FCALL Hook success");
return ZEND_USER_OPCODE_DISPATCH;
}

函数参数获取
参考php7内核剖析文章的函数参数解析部分,获取到第一个参数:

static int php_do_fcall_handler(zend_execute_data *execute_data){
// ...
zend_execute_data *call = execute_data->call;
zval *arg = ZEND_CALL_ARG(call, 1);

格式化输出

static void php_warning(const char *fname, const char *arg, const char *format, ...) /* {{{ */ {
char *buffer, *msg;
va_list args;
//EG(error_reporting) = 1;
va_start(args, format);
vspprintf(&buffer, 0, format, args);
spprintf(&msg, 0, "%s(\"%s\"): %s", fname, arg, buffer);
efree(buffer);
zend_error(E_WARNING, msg);
efree(msg);
va_end(args);
} /* }}} */

//... php_do_fcall_handler()
php_warning(funcname, ZSTR_VAL(Z_STR_P(arg)), "warning function");

接下来写一个循环遍历,获取全部参数:

// 创建一个数组,记录参数
ZVAL_NEW_ARR(&z_params);
zend_hash_init(Z_ARRVAL(z_params), arg_count, NULL, ZVAL_PTR_DTOR, 0);
for (i=0; i<arg_count; i++) {
zval *p = ZEND_CALL_ARG(call, i + 1);
if (Z_REFCOUNTED_P(p)) Z_ADDREF_P(p);
zend_hash_next_index_insert(Z_ARRVAL(z_params), p);

}

剩下几个opcode挖坑

污点标记

继续参考fate0师傅的xmark项目,在扩展中通过PHP_FUNCTION来定义xmark函数,帮助我们标记字符串,传递一个字符串引用,返回是否标记成功。

PHP_FUNCTION(xmark)
{
zval *z_str;

if (!XMARK_G(enable)) {
RETURN_FALSE;
}
// 获取参数,第一个参数为接收参数的个数,ZEND_NUM_ARGS()为有多少要多少,z为zval类型,引用传参通过zend_parse_parameters只能用z,第三个为存储参数变量的指针
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &z_str) == FAILURE) {
return;
}
ZVAL_DEREF(z_str); // 在php-src-php-7.0.33/Zend/zend_types.h中定义,如果z_str是引用则找到其具体引用的zval

// 只能标记字符串,所以array和其他类型得先遍历一下
if (IS_STRING != Z_TYPE_P(z_str) || Z_STRLEN_P(z_str) == 0) {
RETURN_FALSE;
}
if (xmark_zstr(z_str) == FAILURE) {
RETURN_FALSE;
}
RETURN_TRUE;
}

其中标记字符部分在xmark_zstr函数中处理:

static zend_always_inline int xmark_zstr(zval *z_str)
{
if (!XCHECK_FLAG(Z_STR_P(z_str))) {
zend_string *str = zend_string_init(Z_STRVAL_P(z_str), Z_STRLEN_P(z_str), 0);
ZSTR_LEN(str) = Z_STRLEN_P(z_str);
zend_string_release(Z_STR_P(z_str)); // 释放z_str字符串
XMARK_FLAG(str); // 标记字符串
ZVAL_STR(z_str, str); // 标记完了后,将z_str的值设为str
}
return SUCCESS;
}

在具体的XMARK_FLAGXCHECK_FLAG函数这样实现的,xmark/php_xmark.h#41

#if PHP_VERSION_ID < 70300
# define IS_XMARK_FLAG (1<<6)
# define XMARK_FLAG(str) (GC_FLAGS((str)) |= IS_XMARK_FLAG)
# define XCLEAR_FLAG(str) (GC_FLAGS((str)) &= ~IS_XMARK_FLAG)
# define XCHECK_FLAG(str) (GC_FLAGS((str)) & IS_XMARK_FLAG)
#else
# define EX_CONSTANT(op) RT_CONSTANT(EX(opline), op)
# define IS_XMARK_FLAG (1<<5)
# define XMARK_FLAG(str) GC_ADD_FLAGS(str, IS_XMARK_FLAG)
# define XCLEAR_FLAG(str) GC_DEL_FLAGS(str, IS_XMARK_FLAG)
# define XCHECK_FLAG(str) (GC_FLAGS((str)) & IS_XMARK_FLAG)
#endif

先判断php版本,7.0.3为分界线,我这里是7.0.33,通过宏定义实现标记、清除、检测flag的功能,其中GC_FLAGS函数为php内核中php-src-php-7.0.33/Zend/zend_types.h的宏定义,借助了垃圾回收结构的gc.u.v.flags字段的未被使用的标记位来记录是否被污染:

而在清除标记、检测标记的实现中思路也和这个类似,通过xmark/php_xmark.h的宏进行运算。

威胁判断

思路是这样的,像phpwaf一样在项目最开始的地方,污点标记HTTP请求中可控的参数,称之为source点标记:

prvd_xmark($_GET, true);
prvd_xmark($_POST, true);
prvd_xmark($_COOKIE, true);
prvd_xmark($_FILES, true);
prvd_xmark($_REQUEST, true);

foreach ($_SERVER as $key => &$value) {
if (stripos($key, 'HTTP_') === 0) {
prvd_xmark($value);
}
}

这些参数经过拼接、赋值等操作不断的传递,我们把他称之为filter点,在这个过程标记也要随之传递,一个例子:

function base64_decode($data, ...$args) {
$result = call_user_func(PRVD_RENAME_PREFIX."base64_decode", $data, ...$args);
if (PRVD_TAINT_ENABLE && prvd_xcheck($data)) {
prvd_xmark($result);
}
return $result;
}

在遇到base64解码操作时,如果source点已被标记,则传递标记给解码后的字符串。

最后就是威胁判断的过程,这些数据在最后到达敏感函数的sink点,比如systemeval这些高危函数,判断标记是否还存在,即检测是否有可控的风险。

上报平台

最后

最后想了一下payload模式的缺点,在多入口php文件时,容易产生遗漏包含waf的情况,导致误报的问题,当然如果把全部逻辑都写到扩展中,与之而言的代价就是开发难度极高。其次Fuzz模式特殊漏洞检测需要指定的payload,且检测的精度取决于payload的精度。不过我觉得有污点检测功能就够了。

花了差不多半个月的时间来研究PHP的RASP机制,从php内核到各种开源的rasp项目都有了一个深入的学习。写C语言扩展,研究php底层太硬核了,属实自闭,以后打算再研究一下java的rasp机制。

最后膜前辈们的探索和分享。

参考文章:

知识来源: xz.aliyun.com/t/7316

阅读:17595 | 评论:0 | 标签:学习

想收藏或者和大家分享这篇好文章→复制链接地址

“从0开始的PHP RASP的学习”共有0条留言

发表评论

姓名:

邮箱:

网址:

验证码:

公告

九层之台,起于累土;黑客之术,始于阅读

推广

工具

标签云

本页关键词