1
00:00:00,000 --> 00:00:09,250

2
00:00:09,250 --> 00:00:10,300
>> LUCIANO ARANGO：好吧，伙计们。

3
00:00:10,300 --> 00:00:11,550
我的名字是卢西亚诺阿朗戈。

4
00:00:11,550 --> 00:00:13,915
我在斯楼二年级学生。

5
00:00:13,915 --> 00:00:17,550
而我们将要谈论
网络安全主动防御。

6
00:00:17,550 --> 00:00:24,220
所以，我对信息化工作办公室
安全海域。

7
00:00:24,220 --> 00:00:28,670
而在今年夏天，我在实习
SeguraTec，这是一个信息

8
00:00:28,670 --> 00:00:31,310
那保安服务公司
哥伦比亚的银行。

9
00:00:31,310 --> 00:00:34,740
这主要是在那里我学到
我已经学会为止。

10
00:00:34,740 --> 00:00:37,990
>> 等等一些，我们是材料的
今天要去走了过来，我们都没有

11
00:00:37,990 --> 00:00:39,670
真正在课堂上讲过。

12
00:00:39,670 --> 00:00:40,410
但是我们会很快。

13
00:00:40,410 --> 00:00:42,360
这将是像SQL，JavaScript的。

14
00:00:42,360 --> 00:00:44,870
我们并没有真的走了它。

15
00:00:44,870 --> 00:00:47,730
所以我可以排序的飞行，通过它，
你可能不知道的一些事情。

16
00:00:47,730 --> 00:00:48,890
但很快，你就会了解它。

17
00:00:48,890 --> 00:00:52,080
它会全部意义。

18
00:00:52,080 --> 00:00:54,010
同时另一件事 - 

19
00:00:54,010 --> 00:00:55,780
保持道德。

20
00:00:55,780 --> 00:01:00,560
一些你学习的东西，你
以非道德的方式可以使用。

21
00:01:00,560 --> 00:01:01,950
>> 如果它是你的，一定要尝试。

22
00:01:01,950 --> 00:01:04,500
我绝对激励你们
试试自己的服务器，尝试

23
00:01:04,500 --> 00:01:05,519
打算在他们里面。

24
00:01:05,519 --> 00:01:08,500
看看你是否能穿透它们，
如果你能得到他们里面。

25
00:01:08,500 --> 00:01:09,560
但不是任何人的。

26
00:01:09,560 --> 00:01:12,390
警察真的不喜欢这个笑话和
整体而言，我们把这个在这里。

27
00:01:12,390 --> 00:01:14,040
我们在乱搞。

28
00:01:14,040 --> 00:01:15,780
他们得到真的生气了。

29
00:01:15,780 --> 00:01:18,700
>> 所以头部到这个网站。

30
00:01:18,700 --> 00:01:23,560
我把它开在这里。

31
00:01:23,560 --> 00:01:26,780
这是一个网站，并且它
有一堆的例子。

32
00:01:26,780 --> 00:01:30,000
什么情况是，第一个例子
排序将是一个容易得多

33
00:01:30,000 --> 00:01:33,470
不是在一个意义上的最后一个例子
与第一实施例

34
00:01:33,470 --> 00:01:34,970
完全是不安全的。

35
00:01:34,970 --> 00:01:40,850
，最后一个是有点什么
正常的网络安全的人会做。

36
00:01:40,850 --> 00:01:42,760
但你仍然可以排序
为避开这一点。

37
00:01:42,760 --> 00:01:44,860
而且我们要集中在一
和2，实例1和2。

38
00:01:44,860 --> 00:01:49,880

39
00:01:49,880 --> 00:01:49,920
>> 确定。

40
00:01:49,920 --> 00:01:52,780
让我们从跨站点脚本。

41
00:01:52,780 --> 00:01:56,100
JavaScript的运行在
客户端浏览器。

42
00:01:56,100 --> 00:01:59,980
这是您使用的编程语言
在客户端的浏览器，以便运行

43
00:01:59,980 --> 00:02:04,120
你不必更新网站
并返回到服务器。

44
00:02:04,120 --> 00:02:04,940
你有它运行。

45
00:02:04,940 --> 00:02:08,870
例如，Facebook的，你没有
重新载入网页的新状态

46
00:02:08,870 --> 00:02:09,710
更新上来。

47
00:02:09,710 --> 00:02:12,170
它使用JavaScript来生成
所有这些事情。

48
00:02:12,170 --> 00:02:16,290
因此，我们可以注入恶意JavaScript
进入网站。

49
00:02:16,290 --> 00:02:20,890
而这样一来，当我们发送一个链接
一个人，我们可以排序与发送

50
00:02:20,890 --> 00:02:23,050
一些我们想要的代码。

51
00:02:23,050 --> 00:02:26,450
>> 有持久性和非持久性
JavaScript的 - 

52
00:02:26,450 --> 00:02:30,640
持久性和非持久性的跨站点
脚本，我的意思。

53
00:02:30,640 --> 00:02:33,760
和不同之处在于持久性
是的JavaScript，这将是

54
00:02:33,760 --> 00:02:36,060
保存在网站上。

55
00:02:36,060 --> 00:02:39,780
和非持久性将是JavaScript的
这实际上将只发生一次。

56
00:02:39,780 --> 00:02:41,795
因此，让我们来看一个例子
真正的快。

57
00:02:41,795 --> 00:02:45,660

58
00:02:45,660 --> 00:02:46,130
>> 确定。

59
00:02:46,130 --> 00:02:51,620
所以这个网站，简单，
什么也没有发生在这里。

60
00:02:51,620 --> 00:02:53,070
我们要去尝试
插入一些JavaScript。

61
00:02:53,070 --> 00:02:58,110
所以我们开始编写JavaScript的方式
是我们先从开始脚本。

62
00:02:58,110 --> 00:03:00,570
我们关闭它与脚本。

63
00:03:00,570 --> 00:03:03,770
我们只是打算把一个消息 - 

64
00:03:03,770 --> 00:03:05,410
我会告诉你 - 

65
00:03:05,410 --> 00:03:06,500
警报。

66
00:03:06,500 --> 00:03:11,150
警报是一个函数，JavaScript的
用来显示一些东西。

67
00:03:11,150 --> 00:03:12,400
所以让我们尝试一下真正的快。

68
00:03:12,400 --> 00:03:15,600

69
00:03:15,600 --> 00:03:18,944
我要去，警示打招呼。

70
00:03:18,944 --> 00:03:20,400
嗯，我忘了说 - 

71
00:03:20,400 --> 00:03:24,510

72
00:03:24,510 --> 00:03:25,460
确定。

73
00:03:25,460 --> 00:03:26,540
所以这是简单的。

74
00:03:26,540 --> 00:03:28,730
>> 我们把JavaScript的一个网站上，
它走了过来。

75
00:03:28,730 --> 00:03:31,200
排序的，它只会发生
我们的网站上，对不对？

76
00:03:31,200 --> 00:03:33,040
所以，现在看来似乎不是
有问题，对不对？

77
00:03:33,040 --> 00:03:34,920
我的意思是，你怎么可以用
这个恶意？

78
00:03:34,920 --> 00:03:39,930
这样的方式，做黑客
这是非常简单的。

79
00:03:39,930 --> 00:03:40,970
他们会抓住它。

80
00:03:40,970 --> 00:03:43,750
他们可以发送此链接给您。

81
00:03:43,750 --> 00:03:46,780
如果我此链接发送到您的权利，
你打开它，它要

82
00:03:46,780 --> 00:03:51,620
说，你好，说我的网站
告诉你打招呼。

83
00:03:51,620 --> 00:03:57,280
>> 所以如果我是说一个东西
点点聪明，如果我拉起了

84
00:03:57,280 --> 00:03:59,880
JavaScript函数I类
已经写了 - 

85
00:03:59,880 --> 00:04:03,940
但如果你看一下吧，我会去
在它之前，我写的。

86
00:04:03,940 --> 00:04:06,650
所以我们要设置超时。

87
00:04:06,650 --> 00:04:08,450
我们要等待
几秒钟。

88
00:04:08,450 --> 00:04:13,970
事实上，我们要等待，如果
我没有记错，五秒钟。

89
00:04:13,970 --> 00:04:15,870
这正好以毫秒为单位。

90
00:04:15,870 --> 00:04:18,640
然后我们要做的是我们
要提醒的登录

91
00:04:18,640 --> 00:04:21,459
超时重新登录。

92
00:04:21,459 --> 00:04:23,990
而且我们要改变位置
到不同的位置。

93
00:04:23,990 --> 00:04:30,370

94
00:04:30,370 --> 00:04:32,970
>> 所以，如果我把这个网站给某人，
他们将是

95
00:04:32,970 --> 00:04:34,380
浏览周围，平静。

96
00:04:34,380 --> 00:04:35,650
什么也没有发生。

97
00:04:35,650 --> 00:04:38,550
而在五秒钟内，它会
说，你的登录超时。

98
00:04:38,550 --> 00:04:40,200
请重新登录。

99
00:04:40,200 --> 00:04:43,400
一旦他们点击OK，我要
带他们到另一个网站。

100
00:04:43,400 --> 00:04:45,980
据推测，该网站的将
类似于该网站

101
00:04:45,980 --> 00:04:47,280
他们在之前。

102
00:04:47,280 --> 00:04:50,770
而他们要记录他们
凭据到我的网站，而不是

103
00:04:50,770 --> 00:04:51,850
他们的网站。

104
00:04:51,850 --> 00:04:54,780
>> 所以我可以送一个人
用电子邮件发送此链接。

105
00:04:54,780 --> 00:04:56,240
我说，哦，这里有一个链接。

106
00:04:56,240 --> 00:04:57,290
这是一家银行，例如。

107
00:04:57,290 --> 00:05:01,390
我说，在这里，走这条链路上。

108
00:05:01,390 --> 00:05:03,730
而一旦他们送了，他们是
将要浏览周围。

109
00:05:03,730 --> 00:05:07,560
我可以持续15秒，20秒等，
然后弹出了，请重新登录

110
00:05:07,560 --> 00:05:08,840
重新登录上。

111
00:05:08,840 --> 00:05:10,120
你们可以试试
很多更多的东西。

112
00:05:10,120 --> 00:05:13,190
这是复杂的，因为你们
没见过JavaScript，因此你可能会

113
00:05:13,190 --> 00:05:14,750
不知道某些功能。

114
00:05:14,750 --> 00:05:18,625
但是，所有你需要做的就是启动
与脚本，结束与脚本。

115
00:05:18,625 --> 00:05:22,105

116
00:05:22,105 --> 00:05:25,510
而你可以把任何东西
在中间。

117
00:05:25,510 --> 00:05:27,350
>> 警报是一个函数，等待。

118
00:05:27,350 --> 00:05:29,365
窗口的位置需要你
到一个新的位置。

119
00:05:29,365 --> 00:05:31,370
但你可以做这么多。

120
00:05:31,370 --> 00:05:32,630
而这样的想法是，
我们采取这一关。

121
00:05:32,630 --> 00:05:39,350
如果我去的例子两个，我
把这个相同的代码，它的

122
00:05:39,350 --> 00:05:40,210
行不通的。

123
00:05:40,210 --> 00:05:43,620
所以它打印出来的一切，因为
这是什么原网站

124
00:05:43,620 --> 00:05:50,350
确实是，如果我把东西在这里，
它会打印出来就在这里。

125
00:05:50,350 --> 00:05:52,390
所以它不是打印出来东西。

126
00:05:52,390 --> 00:05:55,560
这个例子实际上是检查
看是否脚本是存在的。

127
00:05:55,560 --> 00:05:57,163
所以是的，请便。

128
00:05:57,163 --> 00:05:57,606
问我。

129
00:05:57,606 --> 00:05:59,560
>> 观众：是不是发送
一个GET或POST请求？

130
00:05:59,560 --> 00:06:00,670
>> LUCIANO ARANGO：是啊。他们是
发送一个GET请求。

131
00:06:00,670 --> 00:06:01,350
>> 观众：这是什么？

132
00:06:01,350 --> 00:06:02,490
>> LUCIANO ARANGO：是啊。

133
00:06:02,490 --> 00:06:04,030
另外浏览器使用post请求。

134
00:06:04,030 --> 00:06:07,470
但我试图展现的GET请求
这样我们就可以看到什么是

135
00:06:07,470 --> 00:06:10,760
其实已在进行之中。

136
00:06:10,760 --> 00:06:12,880
所以，如果我们看看这段代码 - 
所以它不工作了。

137
00:06:12,880 --> 00:06:24,870
如果我们来看看这段代码，
这将是例如两个。

138
00:06:24,870 --> 00:06:29,300
这是什么人在做，人
负责该浏览器 - 

139
00:06:29,300 --> 00:06:35,370
开拓，确定 - 

140
00:06:35,370 --> 00:06:39,290
被替换单词的脚本。

141
00:06:39,290 --> 00:06:42,850
这是PHP，这你们可能
已经看到了一点点呢。

142
00:06:42,850 --> 00:06:46,250
>> 他只是更换
文字脚本的名称。

143
00:06:46,250 --> 00:06:50,895
所以，但是，如果我继续前进
而只是把 - 

144
00:06:50,895 --> 00:06:58,520

145
00:06:58,520 --> 00:07:02,360
如果我再抢我的代码，我要去
修改它只是一点点。

146
00:07:02,360 --> 00:07:15,010
相反剧本，我要改变
它的脚本资本R.和

147
00:07:15,010 --> 00:07:16,390
我们要看看这个代码的工作。

148
00:07:16,390 --> 00:07:19,090
所以也没把它打印出来，
这是一个好兆头。

149
00:07:19,090 --> 00:07:21,990
并希望在两秒钟，
它会弹出。

150
00:07:21,990 --> 00:07:22,820
>> 您的登录超时。

151
00:07:22,820 --> 00:07:23,210
确定。

152
00:07:23,210 --> 00:07:24,460
没关系。

153
00:07:24,460 --> 00:07:27,670
因此，检查脚本可能
不一定工作。

154
00:07:27,670 --> 00:07:28,130
的人 - 

155
00:07:28,130 --> 00:07:32,290
它也可以检查脚本大写，
脚本小写，海峡案

156
00:07:32,290 --> 00:07:34,180
比较，确定它们是相同的。

157
00:07:34,180 --> 00:07:38,480
但黑客仍然可以做那种什么
我们的V @ genere没有当我们搬到

158
00:07:38,480 --> 00:07:40,620
背几个字符，
前进。

159
00:07:40,620 --> 00:07:43,470
它可以计算出如何把脚本
早在那里，因此它可以注入

160
00:07:43,470 --> 00:07:44,460
该脚本。

161
00:07:44,460 --> 00:07:50,370
>> 所以，你想用什么
是用htmlspecialchars到

162
00:07:50,370 --> 00:07:51,330
保护您的网站。

163
00:07:51,330 --> 00:07:56,490
而这样做的是它使
请确保您所投入 - 

164
00:07:56,490 --> 00:07:59,610
例如，报价或本
大于或小于 - 

165
00:07:59,610 --> 00:08:04,701
被替换的东西
这并不符合 - 

166
00:08:04,701 --> 00:08:05,951
让我放大在这里 - 

167
00:08:05,951 --> 00:08:08,730

168
00:08:08,730 --> 00:08:09,685
实际的符号。

169
00:08:09,685 --> 00:08:13,420
它将取代那些特殊的HTML
字符，我们可以看到，当我们

170
00:08:13,420 --> 00:08:14,670
说起 - 

171
00:08:14,670 --> 00:08:18,635

172
00:08:18,635 --> 00:08:20,740
哦，这是要带我回 - 

173
00:08:20,740 --> 00:08:24,220

174
00:08:24,220 --> 00:08:25,380
这些字符就在这里。

175
00:08:25,380 --> 00:08:28,180
>> 这意味什么
即将到来。

176
00:08:28,180 --> 00:08:31,570
对于HTML，该支架开始
告诉我们什么

177
00:08:31,570 --> 00:08:33,299
HTML相关的来临。

178
00:08:33,299 --> 00:08:33,980
我们要摆脱这一点。

179
00:08:33,980 --> 00:08:36,200
我们不希望把HTML到一个
website.k我们不希望用户是

180
00:08:36,200 --> 00:08:40,260
能放东西在自己的网站
这会影响他们的网站，像

181
00:08:40,260 --> 00:08:43,480
脚本或HTML之类的东西。

182
00:08:43,480 --> 00:08:53,090
最重要的是，你
消毒的用户输入。

183
00:08:53,090 --> 00:08:54,720
>> 因此，用户可以输入很多事情。

184
00:08:54,720 --> 00:08:58,110
他可以输入一堆东西试试
欺骗你的浏览器仍然成

185
00:08:58,110 --> 00:08:59,410
运行此脚本代码。

186
00:08:59,410 --> 00:09:02,870
你想要做的是不只是看
对于脚本，但看的一切

187
00:09:02,870 --> 00:09:04,250
这可能是恶意的。

188
00:09:04,250 --> 00:09:06,800
并用htmlspecialchars会做
为你，所以你不必

189
00:09:06,800 --> 00:09:07,340
为此担心。

190
00:09:07,340 --> 00:09:12,280
但不要试图做自己
那种与自己的代码。

191
00:09:12,280 --> 00:09:14,055
是每个人都清楚的XSS？

192
00:09:14,055 --> 00:09:14,370
>> 确定。

193
00:09:14,370 --> 00:09:16,355
让我们去SQL注入。

194
00:09:16,355 --> 00:09:21,010
因此，SQL注入是可能的
头号漏洞

195
00:09:21,010 --> 00:09:22,490
在不同的网站。

196
00:09:22,490 --> 00:09:24,350
我的意思是，一个很好的例子 - 

197
00:09:24,350 --> 00:09:27,350
我只是最远的研究
对于这件事情。

198
00:09:27,350 --> 00:09:34,430
而且我发现这真棒的文章，其中
我看到哈佛的违反，

199
00:09:34,430 --> 00:09:35,390
遭到黑客攻击。

200
00:09:35,390 --> 00:09:37,370
我想知道，好了，
他们会怎么做呢？

201
00:09:37,370 --> 00:09:41,660
哈佛是最真棒，最
确保大学如初。

202
00:09:41,660 --> 00:09:43,850
对不对？

203
00:09:43,850 --> 00:09:45,410
好了，违反了服务器，
黑客使用

204
00:09:45,410 --> 00:09:47,710
技术，称为SQL注入。

205
00:09:47,710 --> 00:09:50,250
>> 所以，这种情况在日常的基础。

206
00:09:50,250 --> 00:09:53,590
人们忘记考虑到
SQL注入。

207
00:09:53,590 --> 00:09:54,930
哈佛一样。

208
00:09:54,930 --> 00:10:00,050
我认为这里说的，普林斯顿，
斯坦福大学，康奈尔大学。

209
00:10:00,050 --> 00:10:03,550
那么，我们如何 - 究竟什么是这个SQL
注射是将所有这些

210
00:10:03,550 --> 00:10:05,668
人们失望？

211
00:10:05,668 --> 00:10:08,010
确定。

212
00:10:08,010 --> 00:10:12,090
因此，SQL是一种编程语言，
我们使用它来访问数据库。

213
00:10:12,090 --> 00:10:14,560
我们做的是我们选择 - 

214
00:10:14,560 --> 00:10:18,510
所以这是什么读，现在是选择
一切从表中。

215
00:10:18,510 --> 00:10:22,640
>> SQL，它改变成这些数据库
有充分的表信息。

216
00:10:22,640 --> 00:10:26,550
因此，从用户选择的一切
其中名称是用户名。

217
00:10:26,550 --> 00:10:28,120
对不对？

218
00:10:28,120 --> 00:10:30,770
够简单。

219
00:10:30,770 --> 00:10:34,490
SQL注入的想法是，我们
插入一些恶意代码，将

220
00:10:34,490 --> 00:10:37,270
欺骗服务器到运行的东西
比什么不同

221
00:10:37,270 --> 00:10:38,430
最初运行。

222
00:10:38,430 --> 00:10:44,970
所以我们说的用户名，
我们把在1或等于1。

223
00:10:44,970 --> 00:10:46,700
所以，我们把1或等于1。

224
00:10:46,700 --> 00:10:49,890
它现在将读取的方式将选择
从用户，一切从

225
00:10:49,890 --> 00:10:51,360
用户 - 这就是一切 - 

226
00:10:51,360 --> 00:10:55,880
其中name是用户名，但
用户名是1或等于1。

227
00:10:55,880 --> 00:11:01,760
>> 这样的名字是什么，或1等于1。

228
00:11:01,760 --> 00:11:04,060
1等于1始终是真实的。

229
00:11:04,060 --> 00:11:07,690
因此，这将始终返回信息
从用户。

230
00:11:07,690 --> 00:11:08,100
确定。

231
00:11:08,100 --> 00:11:10,030
我们并不需要有
正确的用户名。

232
00:11:10,030 --> 00:11:14,240
我们只要有什么是我们想要的，
并且它会返回信息

233
00:11:14,240 --> 00:11:15,690
我们所需要的。

234
00:11:15,690 --> 00:11:17,160
让我们来看看另一个例子。

235
00:11:17,160 --> 00:11:22,720
>> 如果我们从用户选择的一切，
其中name是DROP TABLE用户 - 

236
00:11:22,720 --> 00:11:26,420
所以你觉得这会
做，如果我把用户名

237
00:11:26,420 --> 00:11:29,560
作为DROP TABLE用户？

238
00:11:29,560 --> 00:11:30,230
任何人有一个想法？

239
00:11:30,230 --> 00:11:31,050
是。

240
00:11:31,050 --> 00:11:32,470
>> 观众：它会告诉
它倾倒的所有表。

241
00:11:32,470 --> 00:11:35,460
>> LUCIANO ARANGO：这将告诉我们
倾倒一切都在网站上，

242
00:11:35,460 --> 00:11:38,290
一切在数据库中。

243
00:11:38,290 --> 00:11:41,910
和人用这个东西的 - 所以
我要告诉你的家伙。

244
00:11:41,910 --> 00:11:45,462
我禁用删除表
因为我不想让你

245
00:11:45,462 --> 00:11:48,240
你们砸我的表。

246
00:11:48,240 --> 00:11:49,850
让我们来看看这个。

247
00:11:49,850 --> 00:11:54,410
因此，这只是拉起信息
某一个人。

248
00:11:54,410 --> 00:11:57,550
那么，我们如何知道这是
受到SQL注入攻击。

249
00:11:57,550 --> 00:12:01,545
我们将检查真正的快
如果我们可以把东西 - 

250
00:12:01,545 --> 00:12:04,990

251
00:12:04,990 --> 00:12:06,080
让我复制此代码。

252
00:12:06,080 --> 00:12:08,140
我会去在它的第二个。

253
00:12:08,140 --> 00:12:12,210
我打算把根和1等于1。

254
00:12:12,210 --> 00:12:15,510
>> 这一权利在这里，这
百分号23  - 

255
00:12:15,510 --> 00:12:19,970
它到底是什么，如果我
在这里看 - 

256
00:12:19,970 --> 00:12:23,820
HTML需要在数量上，如果你的方式
看看当我把在一个空间

257
00:12:23,820 --> 00:12:28,380
在这里 - 如果我空间的东西
在这里，它改变它的百分之2。

258
00:12:28,380 --> 00:12:31,420
难道你们看到这个就在这里
当我把在一个空间？

259
00:12:31,420 --> 00:12:36,710
它的工作方式是，你不仅可以
通过HTML发送ASCII值。

260
00:12:36,710 --> 00:12:40,330
所以它取代，例如
有20％的空间。

261
00:12:40,330 --> 00:12:41,970
我不知道，如果你们
之前已经看到这一点。

262
00:12:41,970 --> 00:12:45,100
>> 它用23％的一个包括hashtag。

263
00:12:45,100 --> 00:12:50,840
我们需要一个包括hashtag在年底或
语句，这样，我们就可以告诉

264
00:12:50,840 --> 00:13:00,885
数据库忘了注释掉
这最后的分号结尾。

265
00:13:00,885 --> 00:13:03,060
我们希望它不会想到这一点。

266
00:13:03,060 --> 00:13:05,980
我们只是希望它运行一切
我们有事先和

267
00:13:05,980 --> 00:13:07,450
评论说出来。

268
00:13:07,450 --> 00:13:08,710
让我们来看看它。

269
00:13:08,710 --> 00:13:14,670
>> 所以，如果我把东西错了 - 
比方说，例如，我把2等于

270
00:13:14,670 --> 00:13:15,690
1，它不给我任何东西。

271
00:13:15,690 --> 00:13:22,930
当我把1等于1，而且它
返回的东西，这告诉我，

272
00:13:22,930 --> 00:13:24,660
这是易受
SQL注入。

273
00:13:24,660 --> 00:13:29,090
我现在知道，无论
我把这个后 - 

274
00:13:29,090 --> 00:13:39,110
并且例如，删除表
或者类似的东西

275
00:13:39,110 --> 00:13:41,190
肯定会的工作。

276
00:13:41,190 --> 00:13:44,350
我知道这是容易受到SQL注入
因为我知道，

277
00:13:44,350 --> 00:13:49,850
引擎盖下，它让
我做了1等于1的事情。

278
00:13:49,850 --> 00:13:51,100
好不好？

279
00:13:51,100 --> 00:13:53,950

280
00:13:53,950 --> 00:13:56,540
>> 如果我们看看这些其他的，
排名第二和第三位，它的

281
00:13:56,540 --> 00:13:59,110
会做多一点点
的检查下面的

282
00:13:59,110 --> 00:14:03,680
引擎盖的它是什么。

283
00:14:03,680 --> 00:14:07,425
因此，任何使降
任何事情或试过吗？

284
00:14:07,425 --> 00:14:08,760
那种做你们得到的SQL吗？

285
00:14:08,760 --> 00:14:10,430
因为我知道你们有没有
看到它，所以它是一种

286
00:14:10,430 --> 00:14:11,759
为迷惑你们。

287
00:14:11,759 --> 00:14:16,160

288
00:14:16,160 --> 00:14:18,480
让我们一起来看看。

289
00:14:18,480 --> 00:14:21,270
那么什么是防止SQLI的方式吗？

290
00:14:21,270 --> 00:14:21,390
确定。

291
00:14:21,390 --> 00:14:23,330
所以这是非常重要的，因为你
你们一定要防止

292
00:14:23,330 --> 00:14:24,090
这在你的网站上。

293
00:14:24,090 --> 00:14:28,040
>> 如果没有，你所有的朋友去
取笑你，当他们放弃所有

294
00:14:28,040 --> 00:14:29,390
你的表。

295
00:14:29,390 --> 00:14:36,150
这样的想法是，你修复SQL
以某种方式，而你匹配

296
00:14:36,150 --> 00:14:41,940
何用户输入与
一个特定的字符串。

297
00:14:41,940 --> 00:14:46,120
所以这种工作方式是你
准备数据库。

298
00:14:46,120 --> 00:14:50,830
您选择的名称，颜色，和卡路里
从数据库中称为水果。

299
00:14:50,830 --> 00:14:53,580
然后，其中的热量小于，
我们把一个问号出现

300
00:14:53,580 --> 00:14:56,530
说我们要输入
东西在一秒钟。

301
00:14:56,530 --> 00:14:58,850
>> 与色彩等于，我们提出了一个问题
马克说，我们要

302
00:14:58,850 --> 00:15:00,913
在第二个输入的东西为好。

303
00:15:00,913 --> 00:15:02,660
好不好？

304
00:15:02,660 --> 00:15:09,920
然后我们执行它，把
在150和红色。

305
00:15:09,920 --> 00:15:12,820
这将检查以
确保这两个 - 

306
00:15:12,820 --> 00:15:15,300
这个数组将检查这些
2顷的整数和

307
00:15:15,300 --> 00:15:16,550
这是一个字符串。

308
00:15:16,550 --> 00:15:18,810

309
00:15:18,810 --> 00:15:20,890
然后，我们去了，我们取
总之，我们把它放在红色。

310
00:15:20,890 --> 00:15:21,964
这意味着我们获取所有。

311
00:15:21,964 --> 00:15:26,790
这意味着我们实际上执行的SQL
声明并把它放回红色。

312
00:15:26,790 --> 00:15:30,530
在这里，我们这样做，但我们
为黄色这样做。

313
00:15:30,530 --> 00:15:32,490
我们获取所有。

314
00:15:32,490 --> 00:15:36,140
>> 并且以这种方式，我们防止了用户
从能够输入的东西

315
00:15:36,140 --> 00:15:41,710
这不是我们指定的内容，一个字符串
或一个整数，例如。

316
00:15:41,710 --> 00:15:45,100

317
00:15:45,100 --> 00:15:46,610
我在前面谈到
依靠别人。

318
00:15:46,610 --> 00:15:50,010
当你们开始你的项目，你
最绝的要使用

319
00:15:50,010 --> 00:15:52,310
引导或类似的东西。

320
00:15:52,310 --> 00:15:53,490
有你们曾经使用WordPress的？

321
00:15:53,490 --> 00:15:57,170
也许你们已经用
WordPress的可能性最大。

322
00:15:57,170 --> 00:16:00,050
因此，与使用问题
别人的东西 - 

323
00:16:00,050 --> 00:16:05,940
我只是去谷歌真正的快
WordPress的漏洞。

324
00:16:05,940 --> 00:16:07,495
>> 如果我把这了现在 - 

325
00:16:07,495 --> 00:16:08,995
我真的做了两秒钟的谷歌。

326
00:16:08,995 --> 00:16:12,300

327
00:16:12,300 --> 00:16:13,800
我们可以看到，WordPress的 - 

328
00:16:13,800 --> 00:16:17,450
此日为九月份'12。

329
00:16:17,450 --> 00:16:19,120
26被更新。

330
00:16:19,120 --> 00:16:23,620
WordPress的默认配置
3.6之前并不妨碍这些

331
00:16:23,620 --> 00:16:27,110
一定的上传，这可能
使它更容​​易为

332
00:16:27,110 --> 00:16:29,790
跨站点脚本攻击。

333
00:16:29,790 --> 00:16:34,530
因此，一个快速的故事，一旦我们的工作
有 - 所以我在夏天，一个工作

334
00:16:34,530 --> 00:16:34,970
实习。

335
00:16:34,970 --> 00:16:40,400
并且我们与排序工作
就像一个大的信用卡公司。

336
00:16:40,400 --> 00:16:42,020
>> 他们依靠一种叫做 - 

337
00:16:42,020 --> 00:16:45,740
我不知道，如果你们曾经玩过
与所谓的Joomla产物。

338
00:16:45,740 --> 00:16:51,750
joomla的是，用于一个产品
控制 - 几分相似，

339
00:16:51,750 --> 00:16:54,340
WordPress的，用于构建网站。

340
00:16:54,340 --> 00:16:56,060
因此，他们有他们的网站
工作的Joomla。

341
00:16:56,060 --> 00:16:59,290
这实际上是一个信用卡
公司在哥伦比亚。

342
00:16:59,290 --> 00:17:01,000
我会带你到他们的
网站真正的快。

343
00:17:01,000 --> 00:17:04,550

344
00:17:04,550 --> 00:17:05,400
>> 因此，他们使用的Joomla。

345
00:17:05,400 --> 00:17:08,630
而且他们还没有更新的Joomla
最新加入。

346
00:17:08,630 --> 00:17:12,160
所以，当我们采取一看
他们的代码，我们能够真正

347
00:17:12,160 --> 00:17:18,430
往里走自己的代码，窃取所有
信用卡信息，他们有，

348
00:17:18,430 --> 00:17:21,670
所有的信用卡号码，
的名称，地址。

349
00:17:21,670 --> 00:17:22,740
而这只是 - 

350
00:17:22,740 --> 00:17:23,569
和他们的代码是完美的罚款。

351
00:17:23,569 --> 00:17:24,710
他们有伟大的代码。

352
00:17:24,710 --> 00:17:25,389
这是所有的安全性。

353
00:17:25,389 --> 00:17:26,520
他们检查所有的数据库。

354
00:17:26,520 --> 00:17:29,020
他们确保跨站点
脚本的罚款。

355
00:17:29,020 --> 00:17:34,390
>> 但他们使用的东西，这不是
更新，这不是安全的。

356
00:17:34,390 --> 00:17:36,940
所以，导致他们 - 所以你们
肯定会使用其他

357
00:17:36,940 --> 00:17:40,650
别人的代码，别人的框架
建立您的网站。

358
00:17:40,650 --> 00:17:43,860
确保他们是安全的，因为
有时它不是你，就是那个

359
00:17:43,860 --> 00:17:44,480
差池。

360
00:17:44,480 --> 00:17:47,440
但别人犯错，而
那么你会因为那下来。

361
00:17:47,440 --> 00:17:51,190

362
00:17:51,190 --> 00:17:53,885
>> 密码和PII。

363
00:17:53,885 --> 00:17:56,820
这样的密码。

364
00:17:56,820 --> 00:17:58,070
确定。

365
00:17:58,070 --> 00:17:59,980

366
00:17:59,980 --> 00:18:04,230
让我们来看看密码
真正的快。

367
00:18:04,230 --> 00:18:04,590
确定。

368
00:18:04,590 --> 00:18:06,520
请告诉我，每个人都
使用安全 - 

369
00:18:06,520 --> 00:18:09,030
我在这里希望大家
使用安全的密码。

370
00:18:09,030 --> 00:18:12,890
我只是让那
在作为一个假设。

371
00:18:12,890 --> 00:18:14,850
所以，你们肯定会
存储密码为您的网站。

372
00:18:14,850 --> 00:18:17,440
你会做类似的东西
登录或类似的东西。

373
00:18:17,440 --> 00:18:19,610
最重要的是不存储
密码以纯文本格式。

374
00:18:19,610 --> 00:18:20,860
这是非常重要的。

375
00:18:20,860 --> 00:18:23,960
你不想来存储
密码以纯文本格式。

376
00:18:23,960 --> 00:18:27,370
>> 而你绝对不会真的想
将其存储在一个单向散列。

377
00:18:27,370 --> 00:18:32,440
所以，单向散列是什么，当你
产生一个字，当你把这个

378
00:18:32,440 --> 00:18:36,200
字到一个散列函数，它会
回产生某种神秘

379
00:18:36,200 --> 00:18:39,390
消息或神秘的组键。

380
00:18:39,390 --> 00:18:40,640
我会告诉你一个例​​子。

381
00:18:40,640 --> 00:18:44,620

382
00:18:44,620 --> 00:18:50,250
我要他们凑字密码1。

383
00:18:50,250 --> 00:18:55,280
因此MD5哈希是要返回我
某种奇怪的信息。

384
00:18:55,280 --> 00:18:59,140
>> 问题是，人在那里
那想进入的网站有

385
00:18:59,140 --> 00:19:02,750
已经想通了排序
所有的MD5哈希值。

386
00:19:02,750 --> 00:19:06,030
他们做了什么时，他们就坐在自己的
计算机，而且它们每一个散列

387
00:19:06,030 --> 00:19:09,660
一个可能的话在那里，直到
他们得到了某种这是什么。

388
00:19:09,660 --> 00:19:11,420
如果我要看看这件事 - 

389
00:19:11,420 --> 00:19:12,420
我只是抓住这个散列。

390
00:19:12,420 --> 00:19:14,120
如果我得到这个哈希从 - 

391
00:19:14,120 --> 00:19:17,470
如果我去到一个网站，我觉得
这个散列，因为我得到的

392
00:19:17,470 --> 00:19:24,100
数据库，我看看它，有人
已经想通了我。

393
00:19:24,100 --> 00:19:28,600

394
00:19:28,600 --> 00:19:29,100
>> 是啊。

395
00:19:29,100 --> 00:19:35,030
于是人们坐下来，无论MD5
那你把哈希，他们将

396
00:19:35,030 --> 00:19:37,760
回到你的东西
那是一个字。

397
00:19:37,760 --> 00:19:39,800
如果我再凑字，像 - 

398
00:19:39,800 --> 00:19:42,410
我不知道 - 

399
00:19:42,410 --> 00:19:43,490
trees2。

400
00:19:43,490 --> 00:19:46,050
我不想失望
我的谷歌搜索。

401
00:19:46,050 --> 00:19:49,820

402
00:19:49,820 --> 00:19:52,780
就在那儿，trees2。

403
00:19:52,780 --> 00:19:55,930
所以很多网站
仍然使用MD5哈希值。

404
00:19:55,930 --> 00:19:57,730
他们说，哦，它是安全的。

405
00:19:57,730 --> 00:19:58,570
我们不是存储在纯文本。

406
00:19:58,570 --> 00:19:59,740
我们有这样的MD5哈希值。

407
00:19:59,740 --> 00:20:01,880
和所有我需要做的仅仅是
谷歌的数目。

408
00:20:01,880 --> 00:20:03,940
>> 我什至没有计算自己。

409
00:20:03,940 --> 00:20:06,790
我可以Google一下，有人
已经做到了我。

410
00:20:06,790 --> 00:20:08,010
这里有一帮他们。

411
00:20:08,010 --> 00:20:09,260
这里有一堆密码。

412
00:20:09,260 --> 00:20:13,890

413
00:20:13,890 --> 00:20:18,680
所以，绝对不要使用MD5哈希，
因为所有你必须

414
00:20:18,680 --> 00:20:19,140
做的是谷歌吧。

415
00:20:19,140 --> 00:20:20,390
那么你要使用呢？

416
00:20:20,390 --> 00:20:29,340

417
00:20:29,340 --> 00:20:30,170
确定。

418
00:20:30,170 --> 00:20:31,260
一种叫做盐析。

419
00:20:31,260 --> 00:20:32,460
那么，什么是盐析 - 

420
00:20:32,460 --> 00:20:36,280
做你们还记得我们
谈论随机的 - 

421
00:20:36,280 --> 00:20:37,920
我不知道是什么PSET它是 - 

422
00:20:37,920 --> 00:20:41,140
被它PSET有四个？

423
00:20:41,140 --> 00:20:45,150
>> 我们都在谈论寻找
在大海捞针。

424
00:20:45,150 --> 00:20:48,480
而在pset中，它说，你可以
其实弄清随机

425
00:20:48,480 --> 00:20:51,840
产生是因为有人的已经跑了
随机一百万次，只

426
00:20:51,840 --> 00:20:53,230
排序形成他们所产生。

427
00:20:53,230 --> 00:20:55,840
你想要做的是什么
把一个输入端。

428
00:20:55,840 --> 00:20:57,130
所以这是那种什么是盐析。

429
00:20:57,130 --> 00:21:00,900
他们已经想通了，盐析
返回每个工作。

430
00:21:00,900 --> 00:21:04,750
>> 那么，什么盐析作用是
你把盐。

431
00:21:04,750 --> 00:21:06,160
你把某个词。

432
00:21:06,160 --> 00:21:09,720
它会出现乱码这个词根据
看你摆在这里。

433
00:21:09,720 --> 00:21:13,570
所以，如果我凑这个密码1
一句话，它要散列

434
00:21:13,570 --> 00:21:17,180
如果我不同的散列密码1
用不同的句子。

435
00:21:17,180 --> 00:21:21,670
排序它给它的地方，以
开始的开始的散列。

436
00:21:21,670 --> 00:21:25,970
所以这是一个很大很难计算，但你
还可以计算的，尤其是

437
00:21:25,970 --> 00:21:26,830
如果你使用一个糟糕的盐。

438
00:21:26,830 --> 00:21:29,650
>> 人们已经也想通了
常见的盐和想通了

439
00:21:29,650 --> 00:21:31,500
那是什么它是。

440
00:21:31,500 --> 00:21:34,980
随机盐要好得多，
但是最好的方法是使用

441
00:21:34,980 --> 00:21:38,160
一些所谓的地穴。

442
00:21:38,160 --> 00:21:40,480
并允许您地穴什么
不 - 所以这些功能都

443
00:21:40,480 --> 00:21:41,820
已建成的为您服务。

444
00:21:41,820 --> 00:21:44,910
很多人忘记了，或
他们忘记使用它。

445
00:21:44,910 --> 00:21:54,520
但是，如果我仰望地穴PHP，隐窝
已经返回一个哈希字符串我。

446
00:21:54,520 --> 00:21:58,790
它实际上它形成的盐多次
和散列它很多次。

447
00:21:58,790 --> 00:22:00,070
>> 所以，我们没有做到这一点。

448
00:22:00,070 --> 00:22:04,790
因此，所有你需要做的是
它送入墓穴。

449
00:22:04,790 --> 00:22:08,170
它会创建一个伟大的散列无
你不必担心盐

450
00:22:08,170 --> 00:22:08,990
或任何东西。

451
00:22:08,990 --> 00:22:12,000
因为如果你要盐它，你必须
记住什么盐你使用

452
00:22:12,000 --> 00:22:13,800
因为如果不是，你不能让你的
密码不回来了

453
00:22:13,800 --> 00:22:15,760
您使用的盐。

454
00:22:15,760 --> 00:22:17,010
确定。

455
00:22:17,010 --> 00:22:21,120

456
00:22:21,120 --> 00:22:23,150
>> 也可识别个人身分
信息。

457
00:22:23,150 --> 00:22:26,730
所以，社会保障，信用卡 - 
这是很明显的。

458
00:22:26,730 --> 00:22:31,880
但有时人们忘记了它的方式
作品是，有多少信息你

459
00:22:31,880 --> 00:22:35,690
确实需要找到一些一个人呢？

460
00:22:35,690 --> 00:22:37,740
有人做了一个关于研究
这样的方式回来。

461
00:22:37,740 --> 00:22:40,870
和它是一样，如果你有
全名，你无法找到

462
00:22:40,870 --> 00:22:41,610
一个人，很容易。

463
00:22:41,610 --> 00:22:43,900
但是，如果你有一个全名
和出生日期？

464
00:22:43,900 --> 00:22:47,770
是足以识别
有人专门？

465
00:22:47,770 --> 00:22:52,760
>> 如果你有他们的名字和
街道地址，他们生活呢？

466
00:22:52,760 --> 00:22:55,110
这就够了，找人？

467
00:22:55,110 --> 00:23:02,490
并且，当他们问的是什么
个人身份信息，并

468
00:23:02,490 --> 00:23:05,360
你该担心
不放弃？

469
00:23:05,360 --> 00:23:08,770
如果你放弃个人识别
信息有人给你，

470
00:23:08,770 --> 00:23:11,420
你可能会被起诉。

471
00:23:11,420 --> 00:23:12,610
我们绝对不希望出现这种情况。

472
00:23:12,610 --> 00:23:14,955
>> 所以，当你把你的网站
出来，和你有一个很酷的

473
00:23:14,955 --> 00:23:17,230
设计，希望你做
真棒的最终项目。

474
00:23:17,230 --> 00:23:18,370
任何形式的想要
把它在那里。

475
00:23:18,370 --> 00:23:21,420
你要确保，无论
你是从用户接受，如果它是

476
00:23:21,420 --> 00:23:25,310
个人身份信息，您
要确保你是真的

477
00:23:25,310 --> 00:23:26,560
小心。

478
00:23:26,560 --> 00:23:29,670

479
00:23:29,670 --> 00:23:31,080
>> 外壳注塑。

480
00:23:31,080 --> 00:23:31,350
确定。

481
00:23:31,350 --> 00:23:37,590
壳牌注入允许入侵者
访问您的实际的命令行

482
00:23:37,590 --> 00:23:39,660
在你的服务器上。

483
00:23:39,660 --> 00:23:44,060
所以他能够运行，代码
你无法控制。

484
00:23:44,060 --> 00:23:49,560
让我们以这样的一个例子
美丽的字符串就在这里。

485
00:23:49,560 --> 00:23:55,570
如果我们进入该网站再次，我
要进入代码注入。

486
00:23:55,570 --> 00:23:58,910
那么，这样做的是 - 

487
00:23:58,910 --> 00:24:00,420
它亦是我们
看着面前。

488
00:24:00,420 --> 00:24:11,200
我们让用户放在什么
他希望，它会打印出

489
00:24:11,200 --> 00:24:12,220
任何你想要的。

490
00:24:12,220 --> 00:24:13,890
>> 所以我打算把一个呼叫。

491
00:24:13,890 --> 00:24:15,540
这样做是什么 - 

492
00:24:15,540 --> 00:24:16,940
它会通过连接开始。

493
00:24:16,940 --> 00:24:19,520
因此，这将让我跑什么
指挥人的跑步

494
00:24:19,520 --> 00:24:21,500
之前和我的命令。

495
00:24:21,500 --> 00:24:23,980
而我运行一个系统命令。

496
00:24:23,980 --> 00:24:27,310
而这最后的字符串 - 还记得
我跟你们一下，

497
00:24:27,310 --> 00:24:31,725
而你必须编码
以URL的方法。

498
00:24:31,725 --> 00:24:35,010

499
00:24:35,010 --> 00:24:36,992
如果我运行这个现在 - 

500
00:24:36,992 --> 00:24:39,150
我会告诉你在这里 - 

501
00:24:39,150 --> 00:24:41,100
你会看到，我结束
向上运行的命令。

502
00:24:41,100 --> 00:24:45,700

503
00:24:45,700 --> 00:24:49,320
>> 其实，这是实际的服务器
我的网站上运行。

504
00:24:49,320 --> 00:24:55,840

505
00:24:55,840 --> 00:24:58,510
所以我们不希望出现这种情况，
因为我可以运行 - 

506
00:24:58,510 --> 00:25:00,320
这台服务器是不是我的。

507
00:25:00,320 --> 00:25:04,030
所以，我不想搞砸了他的
姐姐，马库斯的服务器。

508
00:25:04,030 --> 00:25:07,470
但你可以运行多个命令
这是危险的。

509
00:25:07,470 --> 00:25:11,885
和潜在的，你可以删除
文件，删除目录。

510
00:25:11,885 --> 00:25:14,390

511
00:25:14,390 --> 00:25:17,970
我可以删除某个目录，如果
我想，但我不希望

512
00:25:17,970 --> 00:25:19,530
要做到这一点马库斯。

513
00:25:19,530 --> 00:25:20,420
他是一个好人。

514
00:25:20,420 --> 00:25:21,470
他让我借用他的服务器。

515
00:25:21,470 --> 00:25:24,620
所以我打算让他
关上的好。

516
00:25:24,620 --> 00:25:32,280
>> 所以，我们不希望使用 - 我们不
要使用eval或系统。

517
00:25:32,280 --> 00:25:34,755
EVAL或系统使我们能够
使这些系统调用。

518
00:25:34,755 --> 00:25:37,410

519
00:25:37,410 --> 00:25:38,410
EVAL评估手段。

520
00:25:38,410 --> 00:25:40,790
系统意味着什么我跑了。

521
00:25:40,790 --> 00:25:42,490
它运行在什么系统。

522
00:25:42,490 --> 00:25:46,730
但是，我们可以在取缔这些东西
PHP，所以我们不使用它们。

523
00:25:46,730 --> 00:25:47,400
和文件上传。

524
00:25:47,400 --> 00:25:49,180
我打算做一个真棒
与文件上传的东西。

525
00:25:49,180 --> 00:25:52,740
但就像我告诉你们，我的档案
上传的东西是行不通的。

526
00:25:52,740 --> 00:25:54,590
如果我要上传的文件，现在 - 

527
00:25:54,590 --> 00:25:57,120

528
00:25:57,120 --> 00:26:00,830
如果我是要上传的文件，
这是一个图片 - 

529
00:26:00,830 --> 00:26:03,180
你有一个上传的东西
这是一个图片。

530
00:26:03,180 --> 00:26:03,660
这很好。

531
00:26:03,660 --> 00:26:04,280
什么也没有发生。

532
00:26:04,280 --> 00:26:10,840
>> 但如果你有一个上传文件，
例如，与用户实际上传

533
00:26:10,840 --> 00:26:19,220
一个PHP文件或exe文件或东西
这样，那么你可以潜在地

534
00:26:19,220 --> 00:26:19,740
有一个问题。

535
00:26:19,740 --> 00:26:21,390
这是工作之前。

536
00:26:21,390 --> 00:26:25,202
不幸的是我，这是
不工作了。

537
00:26:25,202 --> 00:26:30,230
如果我举个例子，上载这个文件，我
没有得到上传权限

538
00:26:30,230 --> 00:26:33,400
由于服务器上的文件
并非我的。

539
00:26:33,400 --> 00:26:38,670
所以，这个家伙很聪明。

540
00:26:38,670 --> 00:26:39,610
>> 所以我们不希望 - 

541
00:26:39,610 --> 00:26:40,130
我要告诉你们 - 

542
00:26:40,130 --> 00:26:41,840
好了，这些都是一些非常酷的工具。

543
00:26:41,840 --> 00:26:45,100
所以这些 - 

544
00:26:45,100 --> 00:26:47,715
进入 - 如果你们有火狐 - 
希望你做的。

545
00:26:47,715 --> 00:26:54,260
有2个附加组件称为SQL注入
我和跨站脚本我。

546
00:26:54,260 --> 00:26:56,870
他们打开了尽可能少的一侧
酒吧就在身边。

547
00:26:56,870 --> 00:27:01,480
如果我是去
CS60例如 - 

548
00:27:01,480 --> 00:27:04,210
所以它的作用是它的外观
所有形式的 - 

549
00:27:04,210 --> 00:27:07,220

550
00:27:07,220 --> 00:27:08,760
希望，我不会得到
在为此烦恼。

551
00:27:08,760 --> 00:27:09,190
>> 但确定。

552
00:27:09,190 --> 00:27:12,600
这里的针系统。

553
00:27:12,600 --> 00:27:18,946
所以当我开始寻找在孔
系统，我做的第一件事是

554
00:27:18,946 --> 00:27:21,820
打开这个美丽的小
工具就在身边。

555
00:27:21,820 --> 00:27:24,160
而我将要测试的形式
与自动攻击。

556
00:27:24,160 --> 00:27:28,510
还等什么这样做是会慢慢
开了一堆的浏览器。

557
00:27:28,510 --> 00:27:29,930
这里有一堆的浏览器。

558
00:27:29,930 --> 00:27:33,320
并且它试图每一个组合
跨站点脚本

559
00:27:33,320 --> 00:27:37,380
有可能的是，如果
你就在旁边看。

560
00:27:37,380 --> 00:27:42,080
>> 它会给我一个结果
排序的答案是什么。

561
00:27:42,080 --> 00:27:42,860
全部通过。

562
00:27:42,860 --> 00:27:43,910
很显然，他们都通过。

563
00:27:43,910 --> 00:27:46,190
我的意思是，他们真的很聪明
人们在那里。

564
00:27:46,190 --> 00:27:48,010
但如果我要运行 - 

565
00:27:48,010 --> 00:27:52,050
我当我运行这个之前已经有次
对学生的最终项目。

566
00:27:52,050 --> 00:27:56,080
我只是运行SQL注入与我
所有不同的攻击。

567
00:27:56,080 --> 00:28:00,080
和它的尝试SQL注入
该引脚服务器。

568
00:28:00,080 --> 00:28:03,590
因此，如果我们向下滚动，对于
例如，它说 - 

569
00:28:03,590 --> 00:28:04,960
这是一件好事，如果它返回。

570
00:28:04,960 --> 00:28:08,250
>> 因此，它测试了一些特定的值。

571
00:28:08,250 --> 00:28:11,170
而服务器返回一个
代码为阴性。

572
00:28:11,170 --> 00:28:11,780
除去暂时的。

573
00:28:11,780 --> 00:28:13,030
这是好事。

574
00:28:13,030 --> 00:28:17,050

575
00:28:17,050 --> 00:28:20,750
它会尝试所有这些测试。

576
00:28:20,750 --> 00:28:21,790
所以，你可以简单地运行 - 

577
00:28:21,790 --> 00:28:27,860
我希望我能找到一个真正的网站
快速，将让我 - 

578
00:28:27,860 --> 00:28:29,110
也许CS50店。

579
00:28:29,110 --> 00:28:43,890

580
00:28:43,890 --> 00:28:45,711
>> 哇，这是要
采取的方式太长。

581
00:28:45,711 --> 00:28:53,090

582
00:28:53,090 --> 00:28:55,130
我会让第一次测试
无法完成正确的。

583
00:28:55,130 --> 00:28:57,330
所以它的抱怨。

584
00:28:57,330 --> 00:28:58,470
所以这三样东西。

585
00:28:58,470 --> 00:29:00,430
这些工具都是免费的。

586
00:29:00,430 --> 00:29:03,960
您可以下载并运行它们对
你的网站，它会告诉你，如果

587
00:29:03,960 --> 00:29:06,650
你有跨站点脚本，
如果您有SQL，如果你有

588
00:29:06,650 --> 00:29:07,900
的东西等。

589
00:29:07,900 --> 00:29:12,230

590
00:29:12,230 --> 00:29:14,500
那种我搞乱了。

591
00:29:14,500 --> 00:29:15,550
>> 什么是重要的 - 

592
00:29:15,550 --> 00:29:17,900
好了，永远不要相信用户。

593
00:29:17,900 --> 00:29:21,920
无论用户输入到你，让
一定要消毒，你清洁，

594
00:29:21,920 --> 00:29:25,300
您检查正确的事情，
那它给你什么你

595
00:29:25,300 --> 00:29:28,240
要他给你。

596
00:29:28,240 --> 00:29:32,460
始终更新在什么框架
那你实际使用。

597
00:29:32,460 --> 00:29:34,630
如果你使用类似的自举 - 

598
00:29:34,630 --> 00:29:36,340
我知道你们将要使用
引导，因为他要去

599
00:29:36,340 --> 00:29:38,140
在这个即将在课堂 - 

600
00:29:38,140 --> 00:29:43,120
和Wordpress或类似的东西，
通常这会被黑客攻破。

601
00:29:43,120 --> 00:29:44,770
>> 然后，你甚至不知道。

602
00:29:44,770 --> 00:29:45,800
你只是运行你的网站。

603
00:29:45,800 --> 00:29:47,360
而且它是完全安全的。

604
00:29:47,360 --> 00:29:51,730
和你去。

605
00:29:51,730 --> 00:29:54,000
所以我真的钓早。

606
00:29:54,000 --> 00:29:55,770
但我要感谢Pentest实验室。

607
00:29:55,770 --> 00:29:58,140
我要告诉你们的东西
所谓Pentest实验室。

608
00:29:58,140 --> 00:30:05,000
如果你们是真正感兴趣
什么样的安全真的是，有一个

609
00:30:05,000 --> 00:30:07,300
网站名为如果Pentest实验室
你们去了现在。

610
00:30:07,300 --> 00:30:10,730
哦，好吧，这不是它。

611
00:30:10,730 --> 00:30:12,030
我只是要像这样运行。

612
00:30:12,030 --> 00:30:14,400
谷歌告诉我答案。

613
00:30:14,400 --> 00:30:16,590
>> 确定。

614
00:30:16,590 --> 00:30:19,030
它教你使用 - 因此，它
说，学习网络渗透

615
00:30:19,030 --> 00:30:21,060
测试的正确方法。

616
00:30:21,060 --> 00:30:23,650
它教你 - 

617
00:30:23,650 --> 00:30:25,150
希望，你是一个道德的人。

618
00:30:25,150 --> 00:30:29,200
但它教你如何看
你如何能得到内部网站。

619
00:30:29,200 --> 00:30:31,130
如果你了解如何可以进去
网站，你可以学习如何

620
00:30:31,130 --> 00:30:34,960
保护自己免受越来越
内部网站。

621
00:30:34,960 --> 00:30:39,100
让我放大，因为也许你们
不看这个权利。

622
00:30:39,100 --> 00:30:46,350
>> 从SQL注入到外壳，使
排序如何，我可以从SQL得到

623
00:30:46,350 --> 00:30:48,530
注入壳。

624
00:30:48,530 --> 00:30:53,890
和您下载此虚拟机。

625
00:30:53,890 --> 00:30:55,690
和虚拟机已经自带
与你的网站

626
00:30:55,690 --> 00:30:56,780
去试试。

627
00:30:56,780 --> 00:30:58,030
您下载此PDF。

628
00:30:58,030 --> 00:31:03,610

629
00:31:03,610 --> 00:31:08,370
它会告诉你逐行什么
你所要做的，你检查一下。

630
00:31:08,370 --> 00:31:14,560
其实，这是什么攻击
的确，以获得一个网站里面。

631
00:31:14,560 --> 00:31:15,750
>> 而且其中的一些东西是复杂的。

632
00:31:15,750 --> 00:31:17,520
我希望我能去超多
事情与你们。

633
00:31:17,520 --> 00:31:21,090
但我担心你们
有没有真正 - 

634
00:31:21,090 --> 00:31:23,090
这是我走过去与
你们这些家伙，Web测试

635
00:31:23,090 --> 00:31:26,830
对于渗透测试。

636
00:31:26,830 --> 00:31:33,540
真的不知道是什么
SQL是什么 - 

637
00:31:33,540 --> 00:31:35,960
卡尔·杰克逊的研讨会
是真棒也是如此。

638
00:31:35,960 --> 00:31:37,360
你们不知道排序
的这是什么。

639
00:31:37,360 --> 00:31:39,450
但是如果你去这个网站，你
下载这些教程和这些

640
00:31:39,450 --> 00:31:43,290
PDF文件，你可以看一看排序
有什么安全方面确实

641
00:31:43,290 --> 00:31:46,940
在渗透测试，看你如何能
进去网站和保护

642
00:31:46,940 --> 00:31:48,020
自己从它。

643
00:31:48,020 --> 00:31:56,360
>> 所以，如果我做一个超快速浏览，
它会防止跨站点脚本。

644
00:31:56,360 --> 00:32:00,160
要使用用htmlspecialchars每
一次用户输入的东西。

645
00:32:00,160 --> 00:32:01,580
防止SQL注入。

646
00:32:01,580 --> 00:32:04,510
如果你这样做，你已经
过得比哈佛是

647
00:32:04,510 --> 00:32:06,530
当他们得到了突破。

648
00:32:06,530 --> 00:32:10,510
并确保您的密码
是不是纯文本。

649
00:32:10,510 --> 00:32:16,220
确保你不会只有一个单向散列
他们，但您使用的crypt，PHP的

650
00:32:16,220 --> 00:32:18,670
功能，我给你们。

651
00:32:18,670 --> 00:32:20,060
这样一来，你应该是好的。

652
00:32:20,060 --> 00:32:25,830
>> 此外，如果你的朋友告诉你，运行
SQL注入我自己的网站上。

653
00:32:25,830 --> 00:32:28,140
执行跨站点脚本
在他们的网站。

654
00:32:28,140 --> 00:32:33,720
你会看到很多这样的网站
有一吨的漏洞。

655
00:32:33,720 --> 00:32:40,400
这是令人难以置信多少人忘记了如何
来净化自己的数据库或使

656
00:32:40,400 --> 00:32:46,340
知道什么是人的输入
是不是脚本代码。

657
00:32:46,340 --> 00:32:47,200
确定。

658
00:32:47,200 --> 00:32:49,182
那种我真的结束早。

659
00:32:49,182 --> 00:32:56,510
但是，如果任何人有任何疑问，
什么，你可以拍我一个问题。

660
00:32:56,510 --> 00:32:56,630
是啊。

661
00:32:56,630 --> 00:32:56,970
去吧，去吧。

662
00:32:56,970 --> 00:32:59,846
>> 观众：我只想问，
你能解释一下如何将文件

663
00:32:59,846 --> 00:33:03,160
上传作品完全相同。

664
00:33:03,160 --> 00:33:03,480
>> LUCIANO ARANGO：是啊。

665
00:33:03,480 --> 00:33:06,350
因此，让我告诉你的文件
上传真正的快。

666
00:33:06,350 --> 00:33:11,300
因此，文件上传 - 

667
00:33:11,300 --> 00:33:14,500
问题机智的文件上传
现在是 - 

668
00:33:14,500 --> 00:33:18,541
我要打开代码，以便你们
看到幕后的代码。

669
00:33:18,541 --> 00:33:22,390

670
00:33:22,390 --> 00:33:24,305
并且它上传。

671
00:33:24,305 --> 00:33:28,030

672
00:33:28,030 --> 00:33:31,560
下面是该文件上传代码。

673
00:33:31,560 --> 00:33:33,980
>> 我们正在努力进入这个
目录在这里。

674
00:33:33,980 --> 00:33:37,380

675
00:33:37,380 --> 00:33:44,880
我们正在努力，一旦我们输入
文件，使用isset文件 - 因此，当有一个

676
00:33:44,880 --> 00:33:50,900
文件中的文件，该图像，然后
我们尝试把它搬到这里。

677
00:33:50,900 --> 00:33:51,910
我们抓取的文件在这里。

678
00:33:51,910 --> 00:33:58,350
该方法是POST，类型，图像，文件。

679
00:33:58,350 --> 00:33:59,630
我们正在发送此文件。

680
00:33:59,630 --> 00:34:03,910
然后一旦我们得到它，所以一旦文件
有一个形象，我们正在努力将其发送

681
00:34:03,910 --> 00:34:05,060
到这个目录。

682
00:34:05,060 --> 00:34:09,814
>> 问题是，该网站是不
让我去这个目录，

683
00:34:09,814 --> 00:34:12,239
因为它不希望我回去。

684
00:34:12,239 --> 00:34:13,489
它不希望我去 - 

685
00:34:13,489 --> 00:34:15,620

686
00:34:15,620 --> 00:34:17,070
我得走了 - 所以这里的上传。

687
00:34:17,070 --> 00:34:17,639
这里的图像。

688
00:34:17,639 --> 00:34:21,780
我得走了所有的方式回到了
开始，把它放在那里，然后

689
00:34:21,780 --> 00:34:23,820
快去把它放进目录中。

690
00:34:23,820 --> 00:34:30,000
所以，如果我运行一个终端窗口，
我想移动文件 - 

691
00:34:30,000 --> 00:34:30,409
[听不清]

692
00:34:30,409 --> 00:34:32,159
可以看到它。

693
00:34:32,159 --> 00:34:37,940
如果我想移动一个文件，我有
把文件名，然后在

694
00:34:37,940 --> 00:34:40,860
完整的路径，我想将它发送到。

695
00:34:40,860 --> 00:34:45,110
>> 然后服务器不
让我回去。

696
00:34:45,110 --> 00:34:46,929
所以它不是让
我得到这个文件。

697
00:34:46,929 --> 00:34:47,670
但一般情况下 - 

698
00:34:47,670 --> 00:34:49,360
所以有一个代码
上传文件。

699
00:34:49,360 --> 00:34:52,260
所以，通常会发生什么事是，
人的不检查，如果我的档案

700
00:34:52,260 --> 00:34:57,920
结束与jpeg格式，所以我
希望检查。

701
00:34:57,920 --> 00:35:00,054
让我打开一个例子太真实了快。

702
00:35:00,054 --> 00:35:07,766

703
00:35:07,766 --> 00:35:08,260
>> 确定。

704
00:35:08,260 --> 00:35:09,230
此人的权利 - 

705
00:35:09,230 --> 00:35:11,980
这样的例子二是检查
如果的preg_match  - 

706
00:35:11,980 --> 00:35:14,180
这里是在这里 - 

707
00:35:14,180 --> 00:35:19,660
确保结尾
PHP的，这是很好的。

708
00:35:19,660 --> 00:35:20,580
这是好事。

709
00:35:20,580 --> 00:35:22,820
但是有一个真正的大
问题与此有关。

710
00:35:22,820 --> 00:35:24,600
这是好事。

711
00:35:24,600 --> 00:35:44,190
但如果我把一个文件名为
myfavoritepicture.php.jpeg，我可以

712
00:35:44,190 --> 00:35:50,060
还是有可能摆脱JPEG的
并运行it.k PHP的危险。

713
00:35:50,060 --> 00:35:53,850
你不想要的人能够
在您的网站上运行的代码。

714
00:35:53,850 --> 00:35:55,750
>> 但随后，JPEG让它通过。

715
00:35:55,750 --> 00:36:00,720
这个想法是你真正想做的事
不带文件，A。但是，OK，什么

716
00:36:00,720 --> 00:36:07,500
你真的想要做的是确保
你读了整个世界。

717
00:36:07,500 --> 00:36:08,720
并没有什么。php在它。

718
00:36:08,720 --> 00:36:10,500
有没有，PHP的
整个文件名。

719
00:36:10,500 --> 00:36:12,780
>> 观众：但是你可以
把jpeg格式就完了。

720
00:36:12,780 --> 00:36:15,830
这些服务器仍然可以运行的代码。

721
00:36:15,830 --> 00:36:16,870
>> LUCIANO ARANGO：不，它不会
在开始运行。

722
00:36:16,870 --> 00:36:22,310
你要回去试试
如果你能看到 - 

723
00:36:22,310 --> 00:36:24,210
>> 观众：所以我们要 - 

724
00:36:24,210 --> 00:36:26,020
OK，只是另一套涉及 - 

725
00:36:26,020 --> 00:36:26,936
>> LUCIANO ARANGO：是啊。

726
00:36:26,936 --> 00:36:29,230
>> 观众：确定。

727
00:36:29,230 --> 00:36:31,486
>> LUCIANO ARANGO：是啊。

728
00:36:31,486 --> 00:36:31,900
确定。

729
00:36:31,900 --> 00:36:32,865
还有没有其他问题？

730
00:36:32,865 --> 00:36:33,180
确定。

731
00:36:33,180 --> 00:36:37,350
我要离开这个和排序
尝试的，如果你们能看到 - 

732
00:36:37,350 --> 00:36:40,490
其他的人都多一点点
复杂，因为它们需要多少

733
00:36:40,490 --> 00:36:44,050
SQL比更多的知识只是
网页的SQL开始知识和

734
00:36:44,050 --> 00:36:47,010
什么是JavaScript的。

735
00:36:47,010 --> 00:36:49,730
但我会尽量保持这个理想，
并希望你们将学习

736
00:36:49,730 --> 00:36:53,230
关于这一点，并试图采取偷看
你可以做什么和多少个实例

737
00:36:53,230 --> 00:36:54,420
你可以通过。

738
00:36:54,420 --> 00:36:56,020
>> 任何人有任何其他
关于它的问题？

739
00:36:56,020 --> 00:36:59,387

740
00:36:59,387 --> 00:37:00,350
来吧。

741
00:37:00,350 --> 00:37:01,170
是啊，拍，拍。

742
00:37:01,170 --> 00:37:01,580
是啊，去吧。

743
00:37:01,580 --> 00:37:01,850
来吧。

744
00:37:01,850 --> 00:37:02,310
>> 观众：确定。

745
00:37:02,310 --> 00:37:08,870
所以，我听到有关如何魔术引号
都不够安全。

746
00:37:08,870 --> 00:37:09,280
>> LUCIANO ARANGO：什么 - 

747
00:37:09,280 --> 00:37:10,110
魔术引号？

748
00:37:10,110 --> 00:37:10,595
>> 观众：是啊。

749
00:37:10,595 --> 00:37:15,445
所以，它增加了 - 所以每当你输入
的东西，它总是添加引号。

750
00:37:15,445 --> 00:37:15,930
>> LUCIANO ARANGO：是啊。

751
00:37:15,930 --> 00:37:16,000
是啊。

752
00:37:16,000 --> 00:37:16,496
确定。

753
00:37:16,496 --> 00:37:19,113
>> 观众：然后我虽然是工作，
但后来我搜索了起来。

754
00:37:19,113 --> 00:37:21,648
它说这是不好的。

755
00:37:21,648 --> 00:37:23,050
但我不知道为什么。

756
00:37:23,050 --> 00:37:23,360
>> LUCIANO ARANGO：是啊。

757
00:37:23,360 --> 00:37:26,240
>> 观众：不要使用魔术引号，
因为它不是安全的。

758
00:37:26,240 --> 00:37:26,360
>> LUCIANO ARANGO：确定。

759
00:37:26,360 --> 00:37:31,735
所以魔术引号是当你插入的SQL
而且它已经增加了报价给你。

760
00:37:31,735 --> 00:37:33,520
>> 观众：它总是添加引号
无论你把英寸左右

761
00:37:33,520 --> 00:37:34,210
>> LUCIANO ARANGO：是啊。

762
00:37:34,210 --> 00:37:37,190
因此，与该问题是 - 

763
00:37:37,190 --> 00:37:38,445
我会看看 - 

764
00:37:38,445 --> 00:37:41,390
>> 观众：它是如何获得
SQL语句？

765
00:37:41,390 --> 00:37:44,690
或者，我想这可能是
就像报价选择。

766
00:37:44,690 --> 00:37:49,030
>> LUCIANO ARANGO：是的，你需要
好的报价为SQL。

767
00:37:49,030 --> 00:37:52,900
>> 观众：没有，但服务器
它会为你。

768
00:37:52,900 --> 00:37:54,460
>> LUCIANO ARANGO：这些小行情
在这里，这些小行情？

769
00:37:54,460 --> 00:37:55,670
>> 观众：是啊。

770
00:37:55,670 --> 00:37:56,450
>> LUCIANO ARANGO：是啊。

771
00:37:56,450 --> 00:37:59,860
问题是，你可以
注释掉最后 - 

772
00:37:59,860 --> 00:38:05,770
好了，有什么我可以做的是，我可以发表评论
出来 - 所以让我们来看看 - 让我

773
00:38:05,770 --> 00:38:07,920
打开一个文本编辑文件。

774
00:38:07,920 --> 00:38:09,610
让我这个编辑
在这里直接。

775
00:38:09,610 --> 00:38:19,510

776
00:38:19,510 --> 00:38:20,400
确定。

777
00:38:20,400 --> 00:38:23,710
你们可以看到清楚？

778
00:38:23,710 --> 00:38:29,730
有什么我可以做的是，我可以发表评论
出最后一个。

779
00:38:29,730 --> 00:38:32,190
这将注释掉最后一个。

780
00:38:32,190 --> 00:38:36,760
然后我把一个在这里，把
这里所有的恶意的东西。

781
00:38:36,760 --> 00:38:39,840

782
00:38:39,840 --> 00:38:42,630
>> 所以用户实际上
输入，对不对？

783
00:38:42,630 --> 00:38:45,230
用户的输入不
的事情，对不对？

784
00:38:45,230 --> 00:38:47,430
这就是我要的输入为
的人试图进入。

785
00:38:47,430 --> 00:38:49,430
我打算把 - 

786
00:38:49,430 --> 00:38:59,290

787
00:38:59,290 --> 00:39:00,180
这是一个引号。

788
00:39:00,180 --> 00:39:01,760
它只是弯弯曲曲的错误。

789
00:39:01,760 --> 00:39:15,080

790
00:39:15,080 --> 00:39:19,400
然后什么代码
是打算做 - 

791
00:39:19,400 --> 00:39:20,190
对不起，我要借此出来。

792
00:39:20,190 --> 00:39:22,170
什么是代码要做的是
这将添加第一个

793
00:39:22,170 --> 00:39:24,030
引号在这里。

794
00:39:24,030 --> 00:39:26,040
并且它要添加的最后
引号为好。

795
00:39:26,040 --> 00:39:29,350

796
00:39:29,350 --> 00:39:33,270
>> 而且它也将加入
最后，最后一个引号。

797
00:39:33,270 --> 00:39:37,380
但我评论这些报价
标记出来，这样他们就不会运行。

798
00:39:37,380 --> 00:39:41,440
和我完成这个报价
纪念在这里。

799
00:39:41,440 --> 00:39:42,290
你明白吗？

800
00:39:42,290 --> 00:39:43,750
你失去了什么？

801
00:39:43,750 --> 00:39:45,880
我可以评论的最后报价
标志，并采取照顾

802
00:39:45,880 --> 00:39:46,680
第一个引号。

803
00:39:46,680 --> 00:39:47,350
>> 观众：而刚刚完成
的第一个。

804
00:39:47,350 --> 00:39:47,480
>> LUCIANO ARANGO：是啊。

805
00:39:47,480 --> 00:39:48,400
而刚刚结束的第一个。

806
00:39:48,400 --> 00:39:48,790
是啊，这是正确的。

807
00:39:48,790 --> 00:39:50,800
这就是我能做的。

808
00:39:50,800 --> 00:39:51,890
是啊。

809
00:39:51,890 --> 00:39:52,980
任何其他问题这样呢？

810
00:39:52,980 --> 00:39:54,230
这是一个很大的问题。

811
00:39:54,230 --> 00:39:56,960

812
00:39:56,960 --> 00:39:59,790
没有，是的，也许。

813
00:39:59,790 --> 00:40:06,150
希望你们会有点令
当你学习SQL和更有意义

814
00:40:06,150 --> 00:40:06,650
这样的事情。

815
00:40:06,650 --> 00:40:07,980
但要确保你 - 

816
00:40:07,980 --> 00:40:10,340
请关注这些工具。

817
00:40:10,340 --> 00:40:12,760
对不起，这些工具在这里。

818
00:40:12,760 --> 00:40:14,200
这些工具都是伟大的。

819
00:40:14,200 --> 00:40:17,190
如果任何人有任何疑问，
您也可以发邮件给我。

820
00:40:17,190 --> 00:40:19,020
这是我的正常邮件。

821
00:40:19,020 --> 00:40:25,015
这是我的工作电子邮件，其中
当我在SEAS工作。

822
00:40:25,015 --> 00:40:26,040
>> 好的，谢谢。

823
00:40:26,040 --> 00:40:26,740
谢谢，伙计们。

824
00:40:26,740 --> 00:40:27,860
你是好去。

825
00:40:27,860 --> 00:40:28,830
你不必呆在这里。

826
00:40:28,830 --> 00:40:29,570
不要鼓掌。

827
00:40:29,570 --> 00:40:30,170
这是奇怪的。

828
00:40:30,170 --> 00:40:31,420
好的，谢谢，伙计们。

829
00:40:31,420 --> 00:40:32,320