ThinkPHP框架是國內比較流行的PHP框架之一，雖然跟國外的那些個框架沒法比，但優點在於中文手冊很全面。最近研究SQL注入，之前用TP框架的時候因為底層提供了安全功能，在開發過程中沒怎麼考慮安全問題。想知道TP到底是怎麼實現防SQL注入的，所以看了一些原始碼。結合phith0n大牛在烏雲上發的漏洞，分析了一下，整理了一些思路~~

一、不得不說的I函式

TP系統提供了I函式用於輸入變數的過濾。整個函式主體的意義就是獲取各種格式的資料，比如I('get.')、I('post.id')，然後用htmlspecialchars函式（預設情況下）進行處理。如果需要採用其他的方法進行安全過濾，可以從/ThinkPHP/Conf/convention.php中設定：

'DEFAULT_FILTER'        =>  'strip_tags',
//也可以設定多種過濾方法
'DEFAULT_FILTER'        =>  'strip_tags,stripslashes',

從/ThinkPHP/Common/functions.php中可以找到I函式，原始碼如下：

/**
 * 獲取輸入引數 支援過濾和預設值
 * 使用方法:
 * <code>
 * I('id',0); 獲取id引數 自動判斷get或者post
 * I('post.name','','htmlspecialchars'); 獲取$_POST['name']
 * I('get.'); 獲取$_GET
 * </code>
 * @param string $name 變數的名稱 支援指定型別
 * @param mixed $default 不存在的時候預設值
 * @param mixed $filter 引數過濾方法
 * @param mixed $datas 要獲取的額外資料來源
 * @return mixed
 */
function I($name,$default='',$filter=null,$datas=null) {
    static $_PUT    =    null;
    if(strpos($name,'/')){ // 指定修飾符
        list($name,$type)     =    explode('/',$name,2);
    }elseif(C('VAR_AUTO_STRING')){ // 預設強制轉換為字串
        $type   =   's';
    }

    /*根據$name的格式獲取資料：先判斷引數的來源，然後再根據各種格式獲取資料*/
    if(strpos($name,'.')) {list($method,$name) =   explode('.',$name,2);} // 指定引數來源
    else{$method =   'param';}//設定為自動獲取
    switch(strtolower($method)) {
        case 'get'     :   $input =& $_GET;break;
        case 'post'    :   $input =& $_POST;break;
        case 'put'     :   /*此處省略*/
        case 'param'   :   /*此處省略*/
        case 'path'    :   /*此處省略*/
    }

    /*對獲取的資料進行過濾*/
    if('' // 獲取全部變數
        $data       =   $input;
        $filters    =   isset($filter)?$filter:C('DEFAULT_FILTER');
        if($filters) {
            if(is_string($filters)){$filters    =   explode(',',$filters);} //為多種過濾方法提供支援
            foreach($filters as $filter){
                $data   =   array_map_recursive($filter,$data); //迴圈過濾
            }
        }
    }elseif(isset($input[$name])) { // 取值操作
        $data       =   $input[$name];
        $filters    =   isset($filter)?$filter:C('DEFAULT_FILTER');
        if($filters) {      /*對引數進行過濾，支援正則表示式驗證*/
            /*此處省略*/
        }
        if(!empty($type)){  //如果設定了強制轉換型別
            switch(strtolower($type)){
                case 'a': $data = (array)$data;break;   // 陣列  
                case 'd': $data = (int)$data;break;   // 數字 
                case 'f': $data = (float)$data;break;    // 浮點   
                case 'b': $data = (boolean)$data;break;    // 布林
                case 's':   // 字串
                default:$data   =   (string)$data;
            }
        }
    }else{ // 變數預設值
        $data       =    isset($default)?$default:null;
    }

    is_array($data) && array_walk_recursive($data,'think_filter');  //如果$data是陣列，那麼用think_filter對陣列過濾
    return $data;
}
 

函式基本分成三塊：
第一塊，獲取各種格式的資料。
第二塊，對獲取的資料進行迴圈編碼，不管是二維陣列還是三維陣列。
第三塊，也就是倒數第二行，呼叫了think_filter對資料進行了最後一步的神祕處理。

讓我們先來追蹤一下think_filter函式：

//1536行 版本3.2.3最新新增
function think_filter(&$value){// 過濾查詢特殊字元    
    if(preg_match('/^(EXP|NEQ|GT|EGT|LT|ELT|OR|XOR|LIKE|NOTLIKE|NOT BETWEEN|NOTBETWEEN|BETWEEN|NOTIN|NOT IN|IN)$/i',$value)){        
        $value .= ' ';    
    }
}
 

這個函式很簡單，一眼就可以看出來，在一些特定的關鍵字後面加個空格。但是這個叫think_filter的函式，僅僅加了一個空格，到底起到了什麼過濾的作用？

我們都知道重要的邏輯驗證，如驗證是否已登入，使用者是否能購買某商品等，必須從伺服器端驗證，如果從前端驗證的話，就很容易被繞過。同一個道理，在程式中，in/exp一類的邏輯結構，最好也是由伺服器端來控制。

當從傳遞到伺服器端的資料是這樣：id[0]=in&id[1]=1,2,3，如果沒有think_filter函式的話，會被解析成下表中的1，也就會被當成伺服器端邏輯解析。但如果變成如下表2的樣子，因為多了一個空格，無法被匹配解析，也就避免了漏洞。

1. $data['id']=array('in'=>'1,2,3')  

//經過think_filter過濾之後，會變成介個樣子：
2. $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物件中的成員變數：

// 主鍵名稱
protected $pk      = 'id';
// 欄位資訊
protected $fields  = array();
// 資料資訊
protected $data    = array();
// 查詢表示式引數
protected $options = array();
// 鏈操作方法列表
protected $methods = array('strict','order','alias','having','group','lock','distinct','auto','filter','validate','result','token','index','force')

接下來分析where函式：

public function where($where,$parse=null){
    //如果非陣列格式，即where('id=%d&name=%s',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,'escapeString'),$parse);
        $where = vsprintf($where,$parse); //vsprintf() 函式把格式化字串寫入變數中
    }elseif(is_object($where)){
        $where  =   get_object_vars($where);
    }
    if(is_string($where) && '' != $where){
        $map    =   array();
        $map['_string']   =   $where;
        $where  =   $map;
    }      

    //將$where賦值給$this->where
    if(isset($this->options['where'])){         
        $this->options['where'] =   array_merge($this->options['where'],$where);
    }else{
        $this->options['where'] =   $where;
    }
    
    return $this;
}

where函式的邏輯很簡單，如果是where('id=%d&name=%s',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['where']       =   $where; /*提取出查詢條件，並賦值*/
    }

    // 根據主鍵查詢記錄
    $pk  =  $this->getPk();
    if (is_array($options) && (count($options) > 0) && is_array($pk)) {
        /*構造複合主鍵查詢條件，此處省略*/
    }

    $options['limit']   =   1;                                  // 總是查詢一條記錄
    $options            =   $this->_parseOptions($options);     // 分析表示式

    if(isset($options['cache'])){
        /*快取查詢，此處省略*/
    }
    $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['model']       =   $this->name;// 記錄操作的模型名稱

    /*對陣列查詢條件進行欄位型別檢查，如果在合理範圍內，就進行過濾處理；否則丟擲異常或者刪除掉對應欄位*/
    if(isset($options['where']) && is_array($options['where']) && !empty($fields) && !isset($options['join'])){
        foreach ($options['where'] 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['where'],$key);
                }
            }elseif(!is_numeric($key) && '_' != substr($key,0,1) && false === strpos($key,'.') && false === strpos($key,'(') && false === strpos($key,'|') && false === strpos($key,'&')){
               // 如果$key不是數字且第一個字元不是_，不存在.(|&等特殊字元
                if(!empty($this->options['strict'])){   //如果是strict模式，丟擲異常
                    E(L('_ERROR_QUERY_EXPRESS_').':['.$key.'=>'.$val.']');
                }   
                unset($options['where'][$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('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');
// 查詢表示式
protected $selectSql  = 'SELECT%DISTINCT% %FIELD% FROM %TABLE%%FORCE%%JOIN%%WHERE%%GROUP%%HAVING%%ORDER%%LIMIT% %UNION%%LOCK%%COMMENT%';
// 當前SQL指令
protected $queryStr   = '';
// 引數繫結
protected $bind         =   array();

select函式：

public function select($options=array()) {
    $this->model  =   $options['model'];
    $this->parseBind(!empty($options['bind'])?$options['bind']:array());
    $sql    = $this->buildSelectSql($options);
    $result   = $this->query($sql,!empty($options['fetch_sql']) ? true : false);
    return $result;
}

版本3.2.3經過改進之後，select精簡了不少。parseBind函式是繫結引數，用於pdo查詢，此處不表。

buildSelectSql（）函式及其後續呼叫如下：

public function buildSelectSql($options=array()) {
    if(isset($options['page'])) {
        /*頁碼計算及處理，此處省略*/
    }
    $sql  =   $this->parseSql($this->selectSql,$options);
    return $sql;
}

/* 替換SQL語句中表達式*/
public function parseSql($sql,$options=array()){
    $sql   = str_replace(
        array('%TABLE%','%DISTINCT%','%FIELD%','%JOIN%','%WHERE%','%GROUP%','%HAVING%','%ORDER%','%LIMIT%','%UNION%','%LOCK%','%COMMENT%','%FORCE%'),
        array(
            $this->parseTable($options['table']),
            $this->parseDistinct(isset($options['distinct'])?$options['distinct']:false),
            $this->parseField(!empty($options['field'])?$options['field']:'*'),
            $this->parseJoin(!empty($options['join'])?$options['join']:''),
            $this->parseWhere(!empty($options['where'])?$options['where']:''),
            $this->parseGroup(!empty($options['group'])?$options['group']:''),
            $this->parseHaving(!empty($options['having'])?$options['having']:''),
            $this->parseOrder(!empty($options['order'])?$options['order']:''),
            $this->parseLimit(!empty($options['limit'])?$options['limit']:''),
            $this->parseUnion(!empty($options['union'])?$options['union']:''),
            $this->parseLock(isset($options['lock'])?$options['lock']:false),
            $this->parseComment(!empty($options['comment'])?$options['comment']:''),
            $this->parseForce(!empty($options['force'])?$options['force']:'')
        ),$sql);
    return $sql;
}

可以看到，在parseSql中用正則表示式拼接了sql語句，但並沒有直接的去處理各種插敘你的資料格式，而是在解析變數的過程中呼叫了多個函式，此處拿parseWhere舉例子。

protected function parseWhere($where) {
    $whereStr = '';
    if(is_string($where)) {     // 直接使用字串條件
        $whereStr = $where;
    }
    else{                       // 使用陣列表示式
        /*設定邏輯規則，如or and xor等，預設為and，此處省略*/
        $operate=' AND ';

        /*解析特殊格式的表示式並且格式化輸出*/
        foreach ($where as $key=>$val){
            if(0===strpos($key,'_')) {    // 解析特殊條件表示式
                $whereStr   .= $this->parseThinkWhere($key,$val);
            }
            else{                        // 查詢欄位的安全過濾
                $multi  = is_array($val) &&  isset($val['_multi']); //判斷是否有複合查詢
                $key    = trim($key);
                /*處理欄位中包含的| &邏輯*/
                if(strpos($key,'|')) { // 支援 name|title|nickname 方式定義查詢欄位
                    /*將|換成or，並格式化輸出，此處省略*/
                }
                elseif(strpos($key,'&')){
                    /*將&換成and，並格式化輸出，此處省略*/
                }
                else{
                    $whereStr .= $this->parseWhereItem($this->parseKey($key),$val);
                }
            }
            $whereStr .= $operate;
        }
        $whereStr = substr($whereStr,0,-strlen($operate));
    }

    return empty($whereStr)?'':' WHERE '.$whereStr;
}

// where子單元分析
protected function parseWhereItem($key,$val) {
    $whereStr = '';
    if(is_array($val)){
        if(is_string($val[0])){
            $exp    =   strtolower($val[0]);
            //如果是$map['id']=array('eq',100)一類的結構，那麼解析成資料庫可執行格式
            if(preg_match('/^(eq|neq|gt|egt|lt|elt)$/',$exp)){
                $whereStr .= $key.' '.$this->exp[$exp].' '.$this->parseValue($val[1]);
            }
            //如果是模糊查詢格式
            elseif(preg_match('/^(notlike|like)$/',$exp)){// 模糊查詢,$map['name']=array('like','thinkphp%');
                if(is_array($val[1])) { //解析格式如下：$map['b'] =array('notlike',array('%thinkphp%','%tp'),'AND');
                    $likeLogic  =   isset($val[2])?strtoupper($val[2]):'OR';    //如果沒有設定邏輯結構，則預設為OR
                    if(in_array($likeLogic,array('AND','OR','XOR'))){
                        /* 根據邏輯結構，組合語句，此處省略*/
                        $whereStr .= '('.implode(' '.$likeLogic.' ',$like).')';                          
                    }
                }
                else{
                    $whereStr .= $key.' '.$this->exp[$exp].' '.$this->parseValue($val[1]);
                }
            }elseif('bind' == $exp ){ // 使用表示式，pdo資料繫結
                $whereStr .= $key.' = :'.$val[1];
            }elseif('exp' == $exp ){ // 使用表示式 $map['id']  = array('exp',' IN (1,3,8) ');
                $whereStr .= $key.' '.$val[1];
            }elseif(preg_match('/^(notin|not in|in)$/',$exp)){ //IN運算 $map['id']  = array('not in','1,5,8');
                if(isset($val[2]) && 'exp'==$val[2]){
                    $whereStr .= $key.' '.$this->exp[$exp].' '.$val[1];
                }else{
                    if(is_string($val[1])) {
                         $val[1] =  explode(',',$val[1]);
                    }
                    $zone      =   implode(',',$this->parseValue($val[1]));
                    $whereStr .= $key.' '.$this->exp[$exp].' ('.$zone.')';
                }
            }elseif(preg_match('/^(notbetween|not between|between)$/',$exp)){ //BETWEEN運算
                $data = is_string($val[1])? explode(',',$val[1]):$val[1];
                $whereStr .=  $key.' '.$this->exp[$exp].' '.$this->parseValue($data[0]).' AND '.$this->parseValue($data[1]);
            }else{  //否則丟擲異常
                E(L('_EXPRESS_ERROR_').':'.$val[0]);
            }
        }
        else{   //解析如：$map['status&score&title'] =array('1',array('gt','0'),'thinkphp','_multi'=>true);
            $count = count($val);
            $rule  = isset($val[$count-1]) ? (is_array($val[$count-1]) ? strtoupper($val[$count-1][0]) : strtoupper($val[$count-1]) ) : '' ; 
            if(in_array($rule,array('AND','OR','XOR'))){
                $count  = $count -1;
            }else{
                $rule   = 'AND';
            }
            for($i=0;$i<$count;$i++){
                $data = is_array($val[$i])?$val[$i][1]:$val[$i];
                if('exp'==strtolower($val[$i][0])) {
                    $whereStr .= $key.' '.$data.' '.$rule.' ';
                }else{
                    $whereStr .= $this->parseWhereItem($key,$val[$i]).' '.$rule.' ';
                }
            }
            $whereStr = '( '.substr($whereStr,0,-4).' )';
        }
    }
    else {
        //對字串型別欄位採用模糊匹配
        $likeFields   =   $this->config['db_like_fields'];
        if($likeFields && preg_match('/^('.$likeFields.')$/i',$key)) {
            $whereStr .= $key.' LIKE '.$this->parseValue('%'.$val.'%');
        }else {
            $whereStr .= $key.' = '.$this->parseValue($val);
        }
    }

    return $whereStr;
}

protected function parseThinkWhere($key,$val) {     //解析特殊格式的條件
    $whereStr   = '';
    switch($key) {
        case '_string':$whereStr = $val;break;                                  // 字串模式查詢條件
        case '_complex':$whereStr = substr($this->parseWhere($val),6);break;    // 複合查詢條件
        case '_query':// 字串模式查詢條件
            /*處理邏輯結構，並且格式化輸出字串，此處省略*/
    }
    return '( '.$whereStr.' )';
}

上面的兩個函式很長，我們再精簡一些來看：parseWhere首先判斷查詢資料是不是字串，如果是字串，直接返回字串，否則，遍歷查詢條件的陣列，挨個解析。由於TP支援_string，_complex之類的特殊查詢，呼叫了parseThinkWhere來處理，對於普通查詢，就呼叫了parseWhereItem。在各自的處理過程中，都呼叫了parseValue，追蹤一下，其實是用了addslashes來過濾，雖然addslashes在非utf-8編碼的頁面中會造成寬位元組注入，但是如果頁面和資料庫均正確編碼的話，還是沒什麼問題的。

轉自：https://www.freebuf.com/articles/web/59713.html