当前位置:首页 > CMS教程 > Thinkphp > 列表

ThinkPHP框架安全实现分析

发布: 来源: PHP粉丝网  添加日期:2019-11-18 17:41:27 浏览: 评论:0 

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

一、不得不说的I函数

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

如果需要采用其他的方法进行安全过滤,可以从/ThinkPHP/Conf/convention.php中设置:

  1. 'DEFAULT_FILTER'    => 'strip_tags'
  2.  
  3. //也可以设置多种过滤方法 
  4.  
  5. 'DEFAULT_FILTER'    => 'strip_tags,stripslashes'

从/ThinkPHP/Common/functions.php中可以找到I函数,源码如下:

  1. /** 
  2.  
  3.  * 获取输入参数 支持过滤和默认值 
  4.  
  5.  * 使用方法: 
  6.  
  7.  *  
  8.  
  9.  * I('id',0); 获取id参数 自动判断get或者post 
  10.  
  11.  * I('post.name','','htmlspecialchars'); 获取$_POST['name'] 
  12.  
  13.  * I('get.'); 获取$_GET 
  14.  
  15.  * 
  16.  
  17.  * @param string $name 变量的名称 支持指定类型 
  18.  
  19.  * @param mixed $default 不存在的时候默认值 
  20.  
  21.  * @param mixed $filter 参数过滤方法 
  22.  
  23.  * @param mixed $datas 要获取的额外数据源 
  24.  
  25.  * @return mixed 
  26.  
  27.  */ 
  28.  
  29. function I($name,$default='',$filter=null,$datas=null) { 
  30.  
  31.   static $_PUT  =  null; 
  32.  
  33.   if(strpos($name,'/')){ // 指定修饰符 
  34.  
  35.     list($name,$type)   =  explode('/',$name,2); 
  36.  
  37.   }elseif(C('VAR_AUTO_STRING')){ // 默认强制转换为字符串 
  38.  
  39.     $type  =  's'
  40.  
  41.   } 
  42.  
  43.   /*根据$name的格式获取数据:先判断参数的来源,然后再根据各种格式获取数据*/ 
  44.  
  45.   if(strpos($name,'.')) {list($method,$name) =  explode('.',$name,2);} // 指定参数来源 
  46.  
  47.   else{$method =  'param';}//设定为自动获取 
  48.  
  49.   switch(strtolower($method)) { 
  50.  
  51.     case 'get'   :  $input =& $_GET;break
  52.  
  53.     case 'post'  :  $input =& $_POST;break
  54.  
  55.     case 'put'   :  /*此处省略*/ 
  56.  
  57.     case 'param'  :  /*此处省略*/ 
  58.  
  59.     case 'path'  :  /*此处省略*/ 
  60.  
  61.   } 
  62.  
  63.   /*对获取的数据进行过滤*/ 
  64.  
  65.   if('' // 获取全部变量 
  66.  
  67.     $data    =  $input
  68.  
  69.     $filters  =  isset($filter)?$filter:C('DEFAULT_FILTER'); 
  70.  
  71.     if($filters) { 
  72.  
  73.       if(is_string($filters)){$filters  =  explode(',',$filters);} //为多种过滤方法提供支持 
  74.  
  75.       foreach($filters as $filter){ 
  76.  
  77.         $data  =  array_map_recursive($filter,$data); //循环过滤 
  78.  
  79.       } 
  80.  
  81.     } 
  82.  
  83.   }elseif(isset($input[$name])) { // 取值操作 
  84.  
  85.     $data    =  $input[$name]; 
  86.  
  87.     $filters  =  isset($filter)?$filter:C('DEFAULT_FILTER'); 
  88.  
  89.     if($filters) {   /*对参数进行过滤,支持正则表达式验证*/ 
  90.  
  91.       /*此处省略*/ 
  92.  
  93.     } 
  94.  
  95.     if(!emptyempty($type)){ //如果设定了强制转换类型 
  96.  
  97.       switch(strtolower($type)){ 
  98.  
  99.         case 'a'$data = (array)$data;break;  // 数组  
  100.  
  101.         case 'd'$data = (int)$data;break;  // 数字  
  102.  
  103.         case 'f'$data = (float)$data;break;  // 浮点   
  104.  
  105.         case 'b'$data = (boolean)$data;break;  // 布尔 
  106.  
  107.         case 's':  // 字符串 
  108.  
  109.         default:$data  =  (string)$data
  110.  
  111.       } 
  112.  
  113.     } 
  114.  
  115.   }else// 变量默认值 
  116.  
  117.     $data    =  isset($default)?$default:null; 
  118. //phpfensi.com 
  119.   } 
  120.  
  121.   is_array($data) && array_walk_recursive($data,'think_filter'); //如果$data是数组,那么用think_filter对数组过滤 
  122.  
  123.   return $data
  124.  

恩,函数基本分成三块:

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

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

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

让我们先来追踪一下think_filter函数:

  1. //1536行 版本3.2.3最新添加 
  2.  
  3. function think_filter(&$value){// 过滤查询特殊字符   
  4.  
  5.   if(preg_match('/^(EXP|NEQ|GT|EGT|LT|ELT|OR|XOR|LIKE|NOTLIKE|NOT BETWEEN|NOTBETWEEN|BETWEEN|NOTIN|NOT IN|IN)$/i',$value)){     
  6.  
  7.     $value .= ' ';   
  8.  
  9.   } 
  10.  

这个函数很简单,一眼就可以看出来,在一些特定的关键字后面加个空格。

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

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

当从传递到服务器端的数据是这样:id[0]=in&id[1]=1,2,3,如果没有think_filter函数的话,会被解析成下表中的1,也就会被当成服务器端逻辑解析。但如果变成如下表2的样子,因为多了一个空格,无法被匹配解析,也就避免了漏洞。

  1. $data['id']=array('in'=>'1,2,3')  
  2.  
  3. //经过think_filter过滤之后,会变成介个样子: 
  4.  
  5. $data['id']=array('in '=>'1,2,3'

二、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('user')->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['id']=array('gt','100');,所以在拼接之前,还要调用各自的处理函数,进行统一的格式化处理。我选取了parseWhere这个复杂的典型来分析。

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

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

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

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

恩,接下来,分析开始:

先说几个Model对象中的成员变量:

  1. // 主键名称 
  2.  
  3. protected $pk   = 'id'
  4.  
  5. // 字段信息 
  6.  
  7. protected $fields = array(); 
  8.  
  9. // 数据信息 
  10.  
  11. protected $data  = array(); 
  12.  
  13. // 查询表达式参数 
  14.  
  15. protected $options = array(); 
  16.  
  17. // 链操作方法列表 
  18.  
  19. protected $methods = array('strict','order','alias','having','group','lock','distinct','auto','filter','validate','result','token','index','force'
  20.  
  21. 接下来分析where函数: 
  22.  
  23. public function where($where,$parse=null){ 
  24.  
  25.   //如果非数组格式,即where('id=%d&name=%s',array($id,$name)),对传递到字符串中的数组调用mysql里的escapeString进行处理 
  26.  
  27.   if(!is_null($parse) && is_string($where)) {  
  28.  
  29.     if(!is_array($parse)){ $parse = func_get_args();array_shift($parse);} 
  30.  
  31.     $parse = array_map(array($this->db,'escapeString'),$parse); 
  32.  
  33.     $where = vsprintf($where,$parse); //vsprintf() 函数把格式化字符串写入变量中 
  34.  
  35.   }elseif(is_object($where)){ 
  36.  
  37.     $where =  get_object_vars($where); 
  38.  
  39.   } 
  40.  
  41.   if(is_string($where) && '' != $where){ 
  42.  
  43.     $map  =  array(); 
  44.  
  45.     $map['_string']  =  $where
  46.  
  47.     $where =  $map
  48.  
  49.   }    
  50.  
  51.   //将$where赋值给$this->where 
  52.  
  53.   if(isset($this->options['where'])){      
  54.  
  55.     $this->options['where'] =  array_merge($this->options['where'],$where); 
  56.  
  57.   }else
  58.  
  59.     $this->options['where'] =  $where
  60.  
  61.   } 
  62.  
  63.     //phpfensi.com 
  64.  
  65.   return $this
  66.  

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

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

再分析find函数:

  1. //model.class.php  行721  版本3.2.3 
  2.  
  3. public function find($options=array()) { 
  4.  
  5.   if(is_numeric($options) || is_string($options)){ /*如果传递过来的数据是字符串,不是数组*/ 
  6.  
  7.     $where[$this->getPk()] =  $options
  8.  
  9.     $options        =  array(); 
  10.  
  11.     $options['where']    =  $where/*提取出查询条件,并赋值*/ 
  12.  
  13.   } 
  14.  
  15.   // 根据主键查找记录 
  16.  
  17.   $pk = $this->getPk(); 
  18.  
  19.   if (is_array($options) && (count($options) > 0) && is_array($pk)) { 
  20.  
  21.     /*构造复合主键查询条件,此处省略*/ 
  22.  
  23.   } 
  24.  
  25.   $options['limit']  =  1;                 // 总是查找一条记录 
  26.  
  27.   $options      =  $this->_parseOptions($options);   // 分析表达式 
  28.  
  29.   if(isset($options['cache'])){ 
  30.  
  31.     /*缓存查询,此处省略*/ 
  32.  
  33.   } 
  34.  
  35.   $resultSet = $this->db->select($options); 
  36.  
  37.   if(false === $resultSet){  return false;} 
  38.  
  39.   if(emptyempty($resultSet)) {  return null; }      // 查询结果为空     
  40.  
  41.   if(is_string($resultSet)){  return $resultSet;}  //查询结果为字符串 
  42.  
  43.   // 读取数据后的处理,此处省略简写 
  44.  
  45.   $this->data = $this->_read_data($resultSet[0]); 
  46.  
  47.   return $this->data; 
  48.  

$Pk为主键,$options为表达式参数,本函数的作用就是完善成员变量——options数组,然后调用db层的select函数查询数据,处理后返回数据。

跟进_parseOptions函数:

  1. protected function _parseOptions($options=array()) { //分析表达式 
  2.  
  3.   if(is_array($options)){ 
  4.  
  5.     $options = array_merge($this->options,$options); 
  6.  
  7.   } 
  8.  
  9.   /*获取表名,此处省略*/ 
  10.  
  11.   /*添加数据表别名,此处省略*/ 
  12.  
  13.   $options['model']    =  $this->name;// 记录操作的模型名称 
  14.  
  15.   /*对数组查询条件进行字段类型检查,如果在合理范围内,就进行过滤处理;否则抛出异常或者删除掉对应字段*/ 
  16.  
  17.   if(isset($options['where']) && is_array($options['where']) && !emptyempty($fields) && !isset($options['join'])){ 
  18.  
  19.     foreach ($options['where'as $key=>$val){ 
  20.  
  21.       $key = trim($key); 
  22.  
  23.       if(in_array($key,$fields,true)){  //如果$key在数据库字段内,过滤以及强制类型转换之 
  24.  
  25.         if(is_scalar($val)) {  
  26.  
  27.         /*is_scalar 检测是否为标量。标量是指integer、float、string、boolean的变量,array则不是标量。*/     
  28.  
  29.           $this->_parseType($options['where'],$key); 
  30.  
  31.         } 
  32.  
  33.       }elseif(!is_numeric($key) && '_' != substr($key,0,1) && false === strpos($key,'.') && false === strpos($key,'(') && false === strpos($key,'|') && false === strpos($key,'&')){ 
  34.  
  35.         // 如果$key不是数字且第一个字符不是_,不存在.(|&等特殊字符 
  36.  
  37.         if(!emptyempty($this->options['strict'])){  //如果是strict模式,抛出异常 
  38.  
  39.           E(L('_ERROR_QUERY_EXPRESS_').':['.$key.'=>'.$val.']'); 
  40.  
  41.         }   
  42.  
  43.         unset($options['where'][$key]); //unset掉对应的值 
  44.  
  45.       } 
  46.  
  47.     } 
  48.  
  49.   }  
  50. //phpfensi.com 
  51.   $this->options =  array();      // 查询过后清空sql表达式组装 避免影响下次查询 
  52.  
  53.   $this->_options_filter($options);    // 表达式过滤 
  54.  
  55.   return $options
  56.  

本函数的结构大概是,先获取了表名,模型名,再对数据进行处理:如果该条数据不在数据库字段内,则做出异常处理或者删除掉该条数据。否则,进行_parseType处理。parseType此处不再跟进,功能为:数据类型检测,强制类型转换包括int,float,bool型的三种数据。

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

继续追踪到select函数,就到了driver对象中了,还是先列举几个有用的成员变量:

  1. // 数据库表达式 
  2.  
  3. protected $exp = array('eq'=>'=','neq'=>'<>','gt'=>'>','egt'=>'>=','lt'=>'<','elt'=>'<=','notlike'=>'NOT LIKE','like'=>'LIKE','in'=>'IN','notin'=>'NOT IN','not in'=>'NOT IN','between'=>'BETWEEN','not between'=>'NOT BETWEEN','notbetween'=>'NOT BETWEEN'); 
  4.  
  5. // 查询表达式 
  6.  
  7. protected $selectSql = 'SELECT%DISTINCT% %FIELD% FROM %TABLE%%FORCE%%JOIN%%WHERE%%GROUP%%HAVING%%ORDER%%LIMIT% %UNION%%LOCK%%COMMENT%'
  8.  
  9. // 当前SQL指令 
  10.  
  11. protected $queryStr  = ''
  12.  
  13. // 参数绑定 
  14.  
  15. protected $bind     =  array(); 
  16.  
  17. select函数: 
  18.  
  19. public function select($options=array()) { 
  20.  
  21.   $this->model =  $options['model']; 
  22.  
  23.   $this->parseBind(!emptyempty($options['bind'])?$options['bind']:array()); 
  24.  
  25.   $sql  = $this->buildSelectSql($options); 
  26.  
  27.   $result  = $this->query($sql,!emptyempty($options['fetch_sql']) ? true : false); 
  28.  
  29.   return $result
  30.  

版本3.2.3经过改进之后,select精简了不少。parseBind函数是绑定参数,用于pdo查询,此处不表。

buildSelectSql()函数及其后续调用如下:

  1. public function buildSelectSql($options=array()) { 
  2.  
  3.   if(isset($options['page'])) { 
  4.  
  5.     /*页码计算及处理,此处省略*/ 
  6.  
  7.   } 
  8.  
  9.   $sql =  $this->parseSql($this->selectSql,$options); 
  10.  
  11.   return $sql
  12.  
  13.  
  14. /* 替换SQL语句中表达式*/ 
  15.  
  16. public function parseSql($sql,$options=array()){ 
  17.  
  18.   $sql  = str_replace
  19.  
  20.     array('%TABLE%','%DISTINCT%','%FIELD%','%JOIN%','%WHERE%','%GROUP%','%HAVING%','%ORDER%','%LIMIT%','%UNION%','%LOCK%','%COMMENT%','%FORCE%'), 
  21.  
  22.     array
  23.  
  24.       $this->parseTable($options['table']), 
  25.  
  26.       $this->parseDistinct(isset($options['distinct'])?$options['distinct']:false), 
  27.  
  28.       $this->parseField(!emptyempty($options['field'])?$options['field']:'*'), 
  29.  
  30.       $this->parseJoin(!emptyempty($options['join'])?$options['join']:''), 
  31.  
  32.       $this->parseWhere(!emptyempty($options['where'])?$options['where']:''), 
  33.  
  34.       $this->parseGroup(!emptyempty($options['group'])?$options['group']:''), 
  35.  
  36.       $this->parseHaving(!emptyempty($options['having'])?$options['having']:''), 
  37.  
  38.       $this->parseOrder(!emptyempty($options['order'])?$options['order']:''), 
  39.  
  40.       $this->parseLimit(!emptyempty($options['limit'])?$options['limit']:''), 
  41.  
  42.       $this->parseUnion(!emptyempty($options['union'])?$options['union']:''), 
  43.  
  44.       $this->parseLock(isset($options['lock'])?$options['lock']:false), 
  45.  
  46.       $this->parseComment(!emptyempty($options['comment'])?$options['comment']:''), 
  47. //phpfensi.com 
  48.       $this->parseForce(!emptyempty($options['force'])?$options['force']:''
  49.  
  50.     ),$sql); 
  51.  
  52.   return $sql
  53.  

可以看到,在parseSql中用正则表达式拼接了sql语句,但并没有直接的去处理各种插叙你的数据格式,而是在解析变量的过程中调用了多个函数,此处拿parseWhere举例子。

  1. protected function parseWhere($where) { 
  2.  
  3.   $whereStr = ''
  4.  
  5.   if(is_string($where)) {   // 直接使用字符串条件 
  6.  
  7.     $whereStr = $where
  8.  
  9.   } 
  10.  
  11.   else{            // 使用数组表达式 
  12.  
  13.     /*设定逻辑规则,如or and xor等,默认为and,此处省略*/ 
  14.  
  15.     $operate=' AND '
  16.  
  17.     /*解析特殊格式的表达式并且格式化输出*/ 
  18.  
  19.     foreach ($where as $key=>$val){ 
  20.  
  21.       if(0===strpos($key,'_')) {  // 解析特殊条件表达式 
  22.  
  23.         $whereStr  .= $this->parseThinkWhere($key,$val); 
  24.  
  25.       } 
  26.  
  27.       else{            // 查询字段的安全过滤 
  28.  
  29.         $multi = is_array($val) && isset($val['_multi']); //判断是否有复合查询 
  30.  
  31.         $key  = trim($key); 
  32.  
  33.         /*处理字段中包含的| &逻辑*/ 
  34.  
  35.         if(strpos($key,'|')) { // 支持 name|title|nickname 方式定义查询字段 
  36.  
  37.           /*将|换成or,并格式化输出,此处省略*/ 
  38.  
  39.         } 
  40.  
  41.         elseif(strpos($key,'&')){ 
  42.  
  43.           /*将&换成and,并格式化输出,此处省略*/ 
  44.  
  45.         } 
  46.  
  47.         else
  48.  
  49.           $whereStr .= $this->parseWhereItem($this->parseKey($key),$val); 
  50.  
  51.         } 
  52.  
  53.       } 
  54.  
  55.       $whereStr .= $operate
  56.  
  57.     } 
  58.  
  59.     $whereStr = substr($whereStr,0,-strlen($operate)); 
  60.  
  61.   } 
  62.  
  63.   return emptyempty($whereStr)?'':' WHERE '.$whereStr
  64.  
  65.  
  66. // where子单元分析 
  67.  
  68. protected function parseWhereItem($key,$val) { 
  69.  
  70.   $whereStr = ''
  71.  
  72.   if(is_array($val)){ 
  73.  
  74.     if(is_string($val[0])){ 
  75.  
  76.       $exp  =  strtolower($val[0]); 
  77.  
  78.       //如果是$map['id']=array('eq',100)一类的结构,那么解析成数据库可执行格式 
  79.  
  80.       if(preg_match('/^(eq|neq|gt|egt|lt|elt)$/',$exp)){ 
  81.  
  82.         $whereStr .= $key.' '.$this->exp[$exp].' '.$this->parseValue($val[1]); 
  83.  
  84.       } 
  85.  
  86.       //如果是模糊查找格式 
  87.  
  88.       elseif(preg_match('/^(notlike|like)$/',$exp)){// 模糊查找,$map['name']=array('like','thinkphp%'); 
  89.  
  90.         if(is_array($val[1])) { //解析格式如下:$map['b'] =array('notlike',array('%thinkphp%','%tp'),'AND'); 
  91.  
  92.           $likeLogic =  isset($val[2])?strtoupper($val[2]):'OR';  //如果没有设定逻辑结构,则默认为OR 
  93.  
  94.           if(in_array($likeLogic,array('AND','OR','XOR'))){ 
  95.  
  96.             /* 根据逻辑结构,组合语句,此处省略*/ 
  97.  
  98.             $whereStr .= '('.implode(' '.$likeLogic.' ',$like).')';              
  99.  
  100.           } 
  101.  
  102.         } 
  103.  
  104.         else
  105.  
  106.           $whereStr .= $key.' '.$this->exp[$exp].' '.$this->parseValue($val[1]); 
  107.  
  108.         } 
  109.  
  110.       }elseif('bind' == $exp ){ // 使用表达式,pdo数据绑定 
  111.  
  112.         $whereStr .= $key.' = :'.$val[1]; 
  113.  
  114.       }elseif('exp' == $exp ){ // 使用表达式 $map['id'] = array('exp',' IN (1,3,8) '); 
  115.  
  116.         $whereStr .= $key.' '.$val[1]; 
  117.  
  118.       }elseif(preg_match('/^(notin|not in|in)$/',$exp)){ //IN运算 $map['id'] = array('not in','1,5,8'); 
  119.  
  120.         if(isset($val[2]) && 'exp'==$val[2]){ 
  121.  
  122.           $whereStr .= $key.' '.$this->exp[$exp].' '.$val[1]; 
  123.  
  124.         }else
  125.  
  126.           if(is_string($val[1])) { 
  127.  
  128.              $val[1] = explode(',',$val[1]); 
  129.  
  130.           } 
  131.  
  132.           $zone   =  implode(',',$this->parseValue($val[1])); 
  133.  
  134.           $whereStr .= $key.' '.$this->exp[$exp].' ('.$zone.')'
  135.  
  136.         } 
  137.  
  138.       }elseif(preg_match('/^(notbetween|not between|between)$/',$exp)){ //BETWEEN运算 
  139.  
  140.         $data = is_string($val[1])? explode(',',$val[1]):$val[1]; 
  141.  
  142.         $whereStr .= $key.' '.$this->exp[$exp].' '.$this->parseValue($data[0]).' AND '.$this->parseValue($data[1]); 
  143.  
  144.       }else//否则抛出异常 
  145.  
  146.         E(L('_EXPRESS_ERROR_').':'.$val[0]); 
  147.  
  148.       } 
  149.  
  150.     } 
  151.  
  152.     else{  //解析如:$map['status&score&title'] =array('1',array('gt','0'),'thinkphp','_multi'=>true); 
  153.  
  154.       $count = count($val); 
  155.  
  156.       $rule = isset($val[$count-1]) ? (is_array($val[$count-1]) ? strtoupper($val[$count-1][0]) : strtoupper($val[$count-1]) ) : '' ;  
  157.  
  158.       if(in_array($rule,array('AND','OR','XOR'))){ 
  159.  
  160.         $count = $count -1; 
  161.  
  162.       }else
  163.  
  164.         $rule  = 'AND'
  165.  
  166.       } 
  167.  
  168.       for($i=0;$i<$count;$i++){ 
  169.  
  170.         $data = is_array($val[$i])?$val[$i][1]:$val[$i]; 
  171.  
  172.         if('exp'==strtolower($val[$i][0])) { 
  173.  
  174.           $whereStr .= $key.' '.$data.' '.$rule.' '
  175.  
  176.         }else
  177.  
  178.           $whereStr .= $this->parseWhereItem($key,$val[$i]).' '.$rule.' '
  179.  
  180.         } 
  181.  
  182.       } 
  183.  
  184.       $whereStr = '( '.substr($whereStr,0,-4).' )'
  185.  
  186.     } 
  187.  
  188.   } 
  189.  
  190.   else { 
  191.  
  192.     //对字符串类型字段采用模糊匹配 
  193.  
  194.     $likeFields  =  $this->config['db_like_fields']; 
  195.  
  196.     if($likeFields && preg_match('/^('.$likeFields.')$/i',$key)) { 
  197.  
  198.       $whereStr .= $key.' LIKE '.$this->parseValue('%'.$val.'%'); 
  199.  
  200.     }else { 
  201.  
  202.       $whereStr .= $key.' = '.$this->parseValue($val); 
  203.  
  204.     } 
  205.  
  206.   } 
  207.  
  208.   return $whereStr
  209.  
  210.  
  211. protected function parseThinkWhere($key,$val) {   //解析特殊格式的条件 
  212.  
  213.   $whereStr  = ''
  214.  
  215.   switch($key) { 
  216.  
  217.     case '_string':$whereStr = $val;break;                 // 字符串模式查询条件 
  218.  
  219.     case '_complex':$whereStr = substr($this->parseWhere($val),6);break;  // 复合查询条件 
  220.  
  221.     case '_query':// 字符串模式查询条件 
  222.  
  223.       /*处理逻辑结构,并且格式化输出字符串,此处省略*/ 
  224.  
  225.   } 
  226.  
  227.   return '( '.$whereStr.' )'
  228.  

上面的两个函数很长,我们再精简一些来看:parseWhere首先判断查询数据是不是字符串,如果是字符串,直接返回字符串,否则,遍历查询条件的数组,挨个解析。

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

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

Tags: ThinkPHP 框架安全

分享到: