ThinkPHP框架安全实现分析

ThinkPHP框架安全实现分析
ThinkPHP框架是国内比较流行的PHP框架之一，虽然跟国外的那些个框架没法比，但优点在于，恩，中文手册很全面。最近研究SQL注入，之前用TP框架的时候因为底层提供了安全功能，在开发过程中没怎么考虑安全问题。

一、不得不说的I函数

TP系统提供了I函数用于输入变量的过滤。整个函数主体的意义就是获取各种格式的数据，比如I(&＃039;get.&＃039;)、I(&＃039;post.id&＃039;)，然后用htmlspecialchars函数（默认情况下）进行处理。

如果需要采用其他的方法进行安全过滤，可以从/ThinkPHP/Conf/convention.php中设置：&＃039;DEFAULT_FILTER&＃039; => &＃039;strip_tags&＃039;,
//也可以设置多种过滤方法
&＃039;DEFAULT_FILTER&＃039; => &＃039;strip_tags,stripslashes&＃039;,从/ThinkPHP/Common/functions.php中可以找到I函数，源码如下：/**
* 获取输入参数 支持过滤和默认值
* 使用方法:
*
* I(&＃039;id&＃039;,0); 获取id参数 自动判断get或者post
* I(&＃039;post.name&＃039;,&＃039;&＃039;,&＃039;htmlspecialchars&＃039;); 获取$_POST[&＃039;name&＃039;]
* I(&＃039;get.&＃039;); 获取$_GET
*
* @param string $name 变量的名称 支持指定类型
* @param mixed $default 不存在的时候默认值
* @param mixed $filter 参数过滤方法
* @param mixed $datas 要获取的额外数据源
* @return mixed
*/
function I($name,$default=&＃039;&＃039;,$filter=null,$datas=null) {
static $_PUT = null;
if(strpos($name,&＃039;/&＃039;)){ // 指定修饰符
list($name,$type) = explode(&＃039;/&＃039;,$name,2);
}elseif(C(&＃039;VAR_AUTO_STRING&＃039;)){ // 默认强制转换为字符串
$type = &＃039;s&＃039;;
}
/*根据$name的格式获取数据：先判断参数的来源，然后再根据各种格式获取数据*/
if(strpos($name,&＃039;.&＃039;)) {list($method,$name) = explode(&＃039;.&＃039;,$name,2);} // 指定参数来源
else{$method = &＃039;param&＃039;;}//设定为自动获取
switch(strtolower($method)) {
case &＃039;get&＃039; : $input =& $_GET;break;
case &＃039;post&＃039; : $input =& $_POST;break;
case &＃039;put&＃039; : /*此处省略*/
case &＃039;param&＃039; : /*此处省略*/
case &＃039;path&＃039; : /*此处省略*/
}
/*对获取的数据进行过滤*/
if(&＃039;&＃039; // 获取全部变量
$data = $input;
$filters = isset($filter)?$filter:C(&＃039;DEFAULT_FILTER&＃039;);
if($filters) {
if(is_string($filters)){$filters = explode(&＃039;,&＃039;,$filters);} //为多种过滤方法提供支持
foreach($filters as $filter){
$data = array_map_recursive($filter,$data); //循环过滤
}
}
}elseif(isset($input[$name])) { // 取值操作
$data = $input[$name];
$filters = isset($filter)?$filter:C(&＃039;DEFAULT_FILTER&＃039;);
if($filters) { /*对参数进行过滤，支持正则表达式验证*/
/*此处省略*/
}
if(!empty($type)){ //如果设定了强制转换类型
switch(strtolower($type)){
case &＃039;a&＃039;: $data = (array)$data;break; // 数组
case &＃039;d&＃039;: $data = (int)$data;break; // 数字
case &＃039;f&＃039;: $data = (float)$data;break; // 浮点
case &＃039;b&＃039;: $data = (boolean)$data;break; // 布尔
case &＃039;s&＃039;: // 字符串
default:$data = (string)$data;
}
}
}else{ // 变量默认值
$data = isset($default)?$default:null;
}
is_array($data) && array_walk_recursive($data,&＃039;think_filter&＃039;); //如果$data是数组，那么用think_filter对数组过滤
return $data;
}恩，函数基本分成三块：

第一块，获取各种格式的数据。

第二块，对获取的数据进行循环编码，不管是二维数组还是三维数组。

第三块，也就是倒数第二行，调用了think_filter对数据进行了最后一步的神秘处理。

让我们先来追踪一下think_filter函数：//1536行 版本3.2.3最新添加
function think_filter(&$value){// 过滤查询特殊字符
if(preg_match(&＃039;/^(EXP|NEQ|GT|EGT|LT|ELT|OR|XOR|LIKE|NOTLIKE|NOT BETWEEN|NOTBETWEEN|BETWEEN|NOTIN|NOT IN|IN)$/i&＃039;,$value)){
$value .= &＃039; &＃039;;
}
}这个函数很简单，一眼就可以看出来，在一些特定的关键字后面加个空格。

但是这个叫think_filter的函数，仅仅加了一个空格，到底起到了什么过滤的作用？

我们都知道重要的逻辑验证，如验证是否已登录，用户是否能购买某商品等，必须从服务器端验证，如果从前端验证的话，就很容易被绕过。同一个道理，在程序中，in/exp一类的逻辑结构，最好也是由服务器端来控制。

当从传递到服务器端的数据是这样：id[0]=in&id[1]=1,2,3，如果没有think_filter函数的话，会被解析成下表中的1，也就会被当成服务器端逻辑解析。但如果变成如下表2的样子，因为多了一个空格，无法被匹配解析，也就避免了漏洞。$data[&＃039;id&＃039;]=array(&＃039;in&＃039;=>&＃039;1,2,3&＃039;)
//经过think_filter过滤之后，会变成介个样子：
$data[&＃039;id&＃039;]=array(&＃039;in &＃039;=>&＃039;1,2,3&＃039;)二、SQL注入

相关的文件为:/ThinkPHP/Library/Think/Db.class.php(在3.2.3中改为了/ThinkPHP/Library/Think/Db/Driver.class.php) 以及 /ThinkPHP/Library/Think/Model.class.php。其中Model.class.php文件提供的是curd直接调用的函数，直接对外提供接口，Driver.class.php中的函数被curd操作间接调用。//此次主要分析如下语句：
M(&＃039;user&＃039;)->where($map)->find(); //在user表根据$map的条件检索出一条数据大概说一下TP的处理思路:

首先将Model类实例化为一个user对象，然后调用user对象中的where函数处理$map，也就是将$map进行一些格式化处理之后赋值给user对象的成员变量$options（如果有其他的连贯操作，也是先赋值给user对象的对应成员变量，而不是直接拼接SQL语句，所以在写连贯操作的时候，无需像拼接SQL语句一样考虑关键字的顺序），接下来调用find函数。

find函数会调用底层的，也就是driver类中的函数――select来获取数据。到了select函数，又是另一个故事了。

select除了要处理curd操作，还要处理pdo绑定，我们这里只关心curd操作，所以在select中调用了buildSelectSql，处理分页信息，并且调用parseSQL按照既定的顺序把SQL语句组装进去。

虽然拼接SQL语句所需要的参数已经全部放在成员变量里了，但是格式不统一，有可能是字符串格式的，有可能是数组格式的，还有可能是TP提供的特殊查询格式，比如：$data[&＃039;id&＃039;]=array(&＃039;gt&＃039;,&＃039;100&＃039;);，所以在拼接之前，还要调用各自的处理函数，进行统一的格式化处理。我选取了parseWhere这个复杂的典型来分析。

关于安全方面的，如果用I函数来获取数据，那么会默认进行htmlspecialchars处理，能有效抵御xss攻击，但是对SQL注入没有多大影响。

在过滤有关SQL注入有关的符号的时候，TP的做法很机智：先是按正常逻辑处理用户的输入，然后在最接近最终的SQL语句的parseWhere、parseHaving等函数中进行安全处理。这样的顺序避免了在处理的过程中出现注入。

当然处理的方法是最普通的addslashes，根据死在沙滩上的前浪们说，推荐使用mysql_real_escape_string来进行过滤，但是这个函数只能在已经连接了数据库的前提下使用。

感觉TP在这个地方可以做一下优化，毕竟走到这一步的都是连接了数据库的。

恩，接下来，分析开始：

先说几个Model对象中的成员变量：// 主键名称
protected $pk = &＃039;id&＃039;;
// 字段信息
protected $fields = array();
// 数据信息
protected $data = array();
// 查询表达式参数
protected $optiOns= array();
// 链操作方法列表
protected $methods = array(&＃039;strict&＃039;,&＃039;order&＃039;,&＃039;alias&＃039;,&＃039;having&＃039;,&＃039;group&＃039;,&＃039;lock&＃039;,&＃039;distinct&＃039;,&＃039;auto&＃039;,&＃039;filter&＃039;,&＃039;validate&＃039;,&＃039;result&＃039;,&＃039;token&＃039;,&＃039;index&＃039;,&＃039;force&＃039;)
接下来分析where函数：
public function where($where,$parse=null){
//如果非数组格式，即where(&＃039;id=%d&name=%s&＃039;,array($id,$name))，对传递到字符串中的数组调用mysql里的escapeString进行处理
if(!is_null($parse) && is_string($where)) {
if(!is_array($parse)){ $parse = func_get_args();array_shift($parse);}
$parse = array_map(array($this->db,&＃039;escapeString&＃039;),$parse);
$where = vsprintf($where,$parse); //vsprintf() 函数把格式化字符串写入变量中
}elseif(is_object($where)){
$where = get_object_vars($where);
}
if(is_string($where) && &＃039;&＃039; != $where){
$map = array();
$map[&＃039;_string&＃039;] = $where;
$where = $map;
}
//将$where赋值给$this->where
if(isset($this->options[&＃039;where&＃039;])){
$this->options[&＃039;where&＃039;] = array_merge($this->options[&＃039;where&＃039;],$where);
}else{
$this->options[&＃039;where&＃039;] = $where;
}

return $this;
}where函数的逻辑很简单，如果是where(&＃039;id=%d&name=%s&＃039;,array($id,$name))这种格式，那就对$id,$name变量调用mysql里的escapeString进行处理。escapeString的实质是调用mysql_real_escape_string、addslashes等函数进行处理。

最后将分析之后的数组赋值到Model对象的成员函数――$where中供下一步处理。

再分析find函数：//model.class.php 行721 版本3.2.3
public function find($optiOns=array()) {
if(is_numeric($options) || is_string($options)){ /*如果传递过来的数据是字符串，不是数组*/
$where[$this->getPk()] = $options;
$optiOns= array();
$options[&＃039;where&＃039;] = $where; /*提取出查询条件，并赋值*/
}
// 根据主键查找记录
$pk = $this->getPk();
if (is_array($options) && (count($options) > 0) && is_array($pk)) {
/*构造复合主键查询条件，此处省略*/
}
$options[&＃039;limit&＃039;] = 1; // 总是查找一条记录
$optiOns= $this->_parseOptions($options); // 分析表达式
if(isset($options[&＃039;cache&＃039;])){
/*缓存查询，此处省略*/
}
$resultSet = $this->db->select($options);
if(false === $resultSet){ return false;}
if(empty($resultSet)) { return null; } // 查询结果为空
if(is_string($resultSet)){ return $resultSet;} //查询结果为字符串
// 读取数据后的处理，此处省略简写
$this->data = $this->_read_data($resultSet[0]);
return $this->data;
}$Pk为主键，$options为表达式参数，本函数的作用就是完善成员变量――options数组，然后调用db层的select函数查询数据，处理后返回数据。

跟进_parseOptions函数：protected function _parseOptions($optiOns=array()) { //分析表达式
if(is_array($options)){
$optiOns= array_merge($this->options,$options);
}
/*获取表名，此处省略*/
/*添加数据表别名，此处省略*/
$options[&＃039;model&＃039;] = $this->name;// 记录操作的模型名称
/*对数组查询条件进行字段类型检查，如果在合理范围内，就进行过滤处理；否则抛出异常或者删除掉对应字段*/
if(isset($options[&＃039;where&＃039;]) && is_array($options[&＃039;where&＃039;]) && !empty($fields) && !isset($options[&＃039;join&＃039;])){
foreach ($options[&＃039;where&＃039;] as $key=>$val){
$key = trim($key);
if(in_array($key,$fields,true)){ //如果$key在数据库字段内，过滤以及强制类型转换之
if(is_scalar($val)) {
/*is_scalar 检测是否为标量。标量是指integer、float、string、boolean的变量，array则不是标量。*/
$this->_parseType($options[&＃039;where&＃039;],$key);
}
}elseif(!is_numeric($key) && &＃039;_&＃039; != substr($key,0,1) && false === strpos($key,&＃039;.&＃039;) && false === strpos($key,&＃039;(&＃039;) && false === strpos($key,&＃039;|&＃039;) && false === strpos($key,&＃039;&&＃039;)){
// 如果$key不是数字且第一个字符不是_，不存在.(|&等特殊字符
if(!empty($this->options[&＃039;strict&＃039;])){ //如果是strict模式，抛出异常
E(L(&＃039;_ERROR_QUERY_EXPRESS_&＃039;).&＃039;:[&＃039;.$key.&＃039;=>&＃039;.$val.&＃039;]&＃039;);
}
unset($options[&＃039;where&＃039;][$key]); //unset掉对应的值
}
}
}
$this->optiOns= array(); // 查询过后清空sql表达式组装 避免影响下次查询
$this->_options_filter($options); // 表达式过滤
return $options;
}本函数的结构大概是，先获取了表名，模型名，再对数据进行处理：如果该条数据不在数据库字段内，则做出异常处理或者删除掉该条数据。否则，进行_parseType处理。parseType此处不再跟进，功能为:数据类型检测,强制类型转换包括int,float,bool型的三种数据。

函数运行到此处，就该把处理好的数据传到db层的select函数里了。此时的查询条件$options中的int,float,bool类型的数据都已经进行了强制类型转换，where（）函数中的字符串（非数组格式的查询）也进行了addslashes等处理。

继续追踪到select函数，就到了driver对象中了，还是先列举几个有用的成员变量：// 数据库表达式
protected $exp = array(&＃039;eq&＃039;=>&＃039;=&＃039;,&＃039;neq&＃039;=>&＃039;<>&＃039;,&＃039;gt&＃039;=>&＃039;>&＃039;,&＃039;egt&＃039;=>&＃039;>=&＃039;,&＃039;lt&＃039;=>&＃039;<&＃039;,&＃039;elt&＃039;=>&＃039;<=&＃039;,&＃039;notlike&＃039;=>&＃039;NOT LIKE&＃039;,&＃039;like&＃039;=>&＃039;LIKE&＃039;,&＃039;in&＃039;=>&＃039;IN&＃039;,&＃039;notin&＃039;=>&＃039;NOT IN&＃039;,&＃039;not in&＃039;=>&＃039;NOT IN&＃039;,&＃039;between&＃039;=>&＃039;BETWEEN&＃039;,&＃039;not between&＃039;=>&＃039;NOT BETWEEN&＃039;,&＃039;notbetween&＃039;=>&＃039;NOT BETWEEN&＃039;);
// 查询表达式
protected $selectSql = &＃039;SELECT%DISTINCT% %FIELD% FROM %TABLE%%FORCE%%JOIN%%WHERE%%GROUP%%HAVING%%ORDER%%LIMIT% %UNION%%LOCK%%COMMENT%&＃039;;
// 当前SQL指令
protected $queryStr = &＃039;&＃039;;
// 参数绑定
protected $bind = array();
select函数：
public function select($optiOns=array()) {
$this->model = $options[&＃039;model&＃039;];
$this->parseBind(!empty($options[&＃039;bind&＃039;])?$options[&＃039;bind&＃039;]:array());
$sql = $this->buildSelectSql($options);
$result = $this->query($sql,!empty($options[&＃039;fetch_sql&＃039;]) ? true : false);
return $result;
}版本3.2.3经过改进之后，select精简了不少。parseBind函数是绑定参数，用于pdo查询，此处不表。

buildSelectSql（）函数及其后续调用如下：public function buildSelectSql($optiOns=array()) {
if(isset($options[&＃039;page&＃039;])) {
/*页码计算及处理，此处省略*/
}
$sql = $this->parseSql($this->selectSql,$options);
return $sql;
}
/* 替换SQL语句中表达式*/
public function parseSql($sql,$optiOns=array()){
$sql = str_replace(
array(&＃039;%TABLE%&＃039;,&＃039;%DISTINCT%&＃039;,&＃039;%FIELD%&＃039;,&＃039;%JOIN%&＃039;,&＃039;%WHERE%&＃039;,&＃039;%GROUP%&＃039;,&＃039;%HAVING%&＃039;,&＃039;%ORDER%&＃039;,&＃039;%LIMIT%&＃039;,&＃039;%UNION%&＃039;,&＃039;%LOCK%&＃039;,&＃039;%COMMENT%&＃039;,&＃039;%FORCE%&＃039;),
array(
$this->parseTable($options[&＃039;table&＃039;]),
$this->parseDistinct(isset($options[&＃039;distinct&＃039;])?$options[&＃039;distinct&＃039;]:false),
$this->parseField(!empty($options[&＃039;field&＃039;])?$options[&＃039;field&＃039;]:&＃039;*&＃039;),
$this->parseJoin(!empty($options[&＃039;join&＃039;])?$options[&＃039;join&＃039;]:&＃039;&＃039;),
$this->parseWhere(!empty($options[&＃039;where&＃039;])?$options[&＃039;where&＃039;]:&＃039;&＃039;),
$this->parseGroup(!empty($options[&＃039;group&＃039;])?$options[&＃039;group&＃039;]:&＃039;&＃039;),
$this->parseHaving(!empty($options[&＃039;having&＃039;])?$options[&＃039;having&＃039;]:&＃039;&＃039;),
$this->parseOrder(!empty($options[&＃039;order&＃039;])?$options[&＃039;order&＃039;]:&＃039;&＃039;),
$this->parseLimit(!empty($options[&＃039;limit&＃039;])?$options[&＃039;limit&＃039;]:&＃039;&＃039;),
$this->parseUnion(!empty($options[&＃039;union&＃039;])?$options[&＃039;union&＃039;]:&＃039;&＃039;),
$this->parseLock(isset($options[&＃039;lock&＃039;])?$options[&＃039;lock&＃039;]:false),
$this->parseComment(!empty($options[&＃039;comment&＃039;])?$options[&＃039;comment&＃039;]:&＃039;&＃039;),
$this->parseForce(!empty($options[&＃039;force&＃039;])?$options[&＃039;force&＃039;]:&＃039;&＃039;)
),$sql);
return $sql;
}可以看到，在parseSql中用正则表达式拼接了sql语句，但并没有直接的去处理各种插叙你的数据格式，而是在解析变量的过程中调用了多个函数，此处拿parseWhere举例子。protected function parseWhere($where) {
$whereStr = &＃039;&＃039;;
if(is_string($where)) { // 直接使用字符串条件
$whereStr = $where;
}
else{ // 使用数组表达式
/*设定逻辑规则，如or and xor等，默认为and，此处省略*/
$operate=&＃039; AND &＃039;;
/*解析特殊格式的表达式并且格式化输出*/
foreach ($where as $key=>$val){
if(0===strpos($key,&＃039;_&＃039;)) { // 解析特殊条件表达式
$whereStr .= $this->parseThinkWhere($key,$val);
}
else{ // 查询字段的安全过滤
$multi = is_array($val) && isset($val[&＃039;_multi&＃039;]); //判断是否有复合查询
$key = trim($key);
/*处理字段中包含的| &逻辑*/
if(strpos($key,&＃039;|&＃039;)) { // 支持 name|title|nickname 方式定义查询字段
/*将|换成or，并格式化输出，此处省略*/
}
elseif(strpos($key,&＃039;&&＃039;)){
/*将&换成and，并格式化输出，此处省略*/
}
else{
$whereStr .= $this->parseWhereItem($this->parseKey($key),$val);
}
}
$whereStr .= $operate;
}
$whereStr = substr($whereStr,0,-strlen($operate));
}
return empty($whereStr)?&＃039;&＃039;:&＃039; WHERE &＃039;.$whereStr;
}
// where子单元分析
protected function parseWhereItem($key,$val) {
$whereStr = &＃039;&＃039;;
if(is_array($val)){
if(is_string($val[0])){
$exp = strtolower($val[0]);
//如果是$map[&＃039;id&＃039;]=array(&＃039;eq&＃039;,100)一类的结构，那么解析成数据库可执行格式
if(preg_match(&＃039;/^(eq|neq|gt|egt|lt|elt)$/&＃039;,$exp)){
$whereStr .= $key.&＃039; &＃039;.$this->exp[$exp].&＃039; &＃039;.$this->parseValue($val[1]);
}
//如果是模糊查找格式
elseif(preg_match(&＃039;/^(notlike|like)$/&＃039;,$exp)){// 模糊查找,$map[&＃039;name&＃039;]=array(&＃039;like&＃039;,&＃039;thinkphp%&＃039;);
if(is_array($val[1])) { //解析格式如下：$map[&＃039;b&＃039;] =array(&＃039;notlike&＃039;,array(&＃039;%thinkphp%&＃039;,&＃039;%tp&＃039;),&＃039;AND&＃039;);
$likeLogic = isset($val[2])?strtoupper($val[2]):&＃039;OR&＃039;; //如果没有设定逻辑结构，则默认为OR
if(in_array($likeLogic,array(&＃039;AND&＃039;,&＃039;OR&＃039;,&＃039;XOR&＃039;))){
/* 根据逻辑结构，组合语句，此处省略*/
$whereStr .= &＃039;(&＃039;.implode(&＃039; &＃039;.$likeLogic.&＃039; &＃039;,$like).&＃039;)&＃039;;
}
}
else{
$whereStr .= $key.&＃039; &＃039;.$this->exp[$exp].&＃039; &＃039;.$this->parseValue($val[1]);
}
}elseif(&＃039;bind&＃039; == $exp ){ // 使用表达式，pdo数据绑定
$whereStr .= $key.&＃039; = :&＃039;.$val[1];
}elseif(&＃039;exp&＃039; == $exp ){ // 使用表达式 $map[&＃039;id&＃039;] = array(&＃039;exp&＃039;,&＃039; IN (1,3,8) &＃039;);
$whereStr .= $key.&＃039; &＃039;.$val[1];
}elseif(preg_match(&＃039;/^(notin|not in|in)$/&＃039;,$exp)){ //IN运算 $map[&＃039;id&＃039;] = array(&＃039;not in&＃039;,&＃039;1,5,8&＃039;);
if(isset($val[2]) && &＃039;exp&＃039;==$val[2]){
$whereStr .= $key.&＃039; &＃039;.$this->exp[$exp].&＃039; &＃039;.$val[1];
}else{
if(is_string($val[1])) {
$val[1] = explode(&＃039;,&＃039;,$val[1]);
}
$zOne= implode(&＃039;,&＃039;,$this->parseValue($val[1]));
$whereStr .= $key.&＃039; &＃039;.$this->exp[$exp].&＃039; (&＃039;.$zone.&＃039;)&＃039;;
}
}elseif(preg_match(&＃039;/^(notbetween|not between|between)$/&＃039;,$exp)){ //BETWEEN运算
$data = is_string($val[1])? explode(&＃039;,&＃039;,$val[1]):$val[1];
$whereStr .= $key.&＃039; &＃039;.$this->exp[$exp].&＃039; &＃039;.$this->parseValue($data[0]).&＃039; AND &＃039;.$this->parseValue($data[1]);
}else{ //否则抛出异常
E(L(&＃039;_EXPRESS_ERROR_&＃039;).&＃039;:&＃039;.$val[0]);
}
}
else{ //解析如：$map[&＃039;status&score&title&＃039;] =array(&＃039;1&＃039;,array(&＃039;gt&＃039;,&＃039;0&＃039;),&＃039;thinkphp&＃039;,&＃039;_multi&＃039;=>true);
$count = count($val);
$rule = isset($val[$count-1]) ? (is_array($val[$count-1]) ? strtoupper($val[$count-1][0]) : strtoupper($val[$count-1]) ) : &＃039;&＃039; ;
if(in_array($rule,array(&＃039;AND&＃039;,&＃039;OR&＃039;,&＃039;XOR&＃039;))){
$count = $count -1;
}else{
$rule = &＃039;AND&＃039;;
}
for($i=0;$i<$count;$i++){
$data = is_array($val[$i])?$val[$i][1]:$val[$i];
if(&＃039;exp&＃039;==strtolower($val[$i][0])) {
$whereStr .= $key.&＃039; &＃039;.$data.&＃039; &＃039;.$rule.&＃039; &＃039;;
}else{
$whereStr .= $this->parseWhereItem($key,$val[$i]).&＃039; &＃039;.$rule.&＃039; &＃039;;
}
}
$whereStr = &＃039;( &＃039;.substr($whereStr,0,-4).&＃039; )&＃039;;
}
}
else {
//对字符串类型字段采用模糊匹配
$likeFields = $this->config[&＃039;db_like_fields&＃039;];
if($likeFields && preg_match(&＃039;/^(&＃039;.$likeFields.&＃039;)$/i&＃039;,$key)) {
$whereStr .= $key.&＃039; LIKE &＃039;.$this->parseValue(&＃039;%&＃039;.$val.&＃039;%&＃039;);
}else {
$whereStr .= $key.&＃039; = &＃039;.$this->parseValue($val);
}
}
return $whereStr;
}
protected function parseThinkWhere($key,$val) { //解析特殊格式的条件
$whereStr = &＃039;&＃039;;
switch($key) {
case &＃039;_string&＃039;:$whereStr = $val;break; // 字符串模式查询条件
case &＃039;_complex&＃039;:$whereStr = substr($this->parseWhere($val),6);break; // 复合查询条件
case &＃039;_query&＃039;:// 字符串模式查询条件
/*处理逻辑结构，并且格式化输出字符串，此处省略*/
}
return &＃039;( &＃039;.$whereStr.&＃039; )&＃039;;
}上面的两个函数很长，我们再精简一些来看：parseWhere首先判断查询数据是不是字符串，如果是字符串，直接返回字符串，否则，遍历查询条件的数组，挨个解析。

由于TP支持_string，_complex之类的特殊查询，调用了parseThinkWhere来处理，对于普通查询，就调用了parseWhereItem。

在各自的处理过程中，都调用了parseValue，追踪一下，其实是用了addslashes来过滤，虽然addslashes在非utf-8编码的页面中会造成宽字节注入，但是如果页面和数据库均正确编码的话，还是没什么问题的。

您可能感兴趣的文章:
ThinkPHP php 框架学习笔记
PHP隐形一句话后门，和ThinkPHP框架加密码程序(base64_decode)
ThinkPHP框架实现session跨域问题的解决方法
对于ThinkPHP框架早期版本的一个SQL注入漏洞详细分析
ThinkPHP框架任意代码执行漏洞的利用及其修复方法
ThinkPHP框架设计及扩展详解
thinkphp3.2中Lite文件替换框架入口文件或应用入口文件的方法
使用Thinkphp框架开发移动端接口
ThinkPHP开发框架函数详解：C方法

AD：真正免费，域名+虚机+企业邮箱=0元