1
00:00:00,000 --> 00:00:02,750
[Powered by Google Translate] [10]周

2
00:00:02,750 --> 00:00:04,750
[戴维·J·马兰] [哈佛大学]

3
00:00:04,750 --> 00:00:07,000
这是CS50。[CS50.TV]

4
00:00:08,520 --> 00:00:13,240
>> 好吧！这是CS50，但不会持续太久。

5
00:00:13,240 --> 00:00:14,740
这是10周的开始。

6
00:00:14,740 --> 00:00:18,780
上周三，我们有我们的测验，然后在下周一我们有一些庆祝蛋糕

7
00:00:18,780 --> 00:00:22,030
因为我们兜了一圈，所有的方式回到从星期为零。

8
00:00:22,030 --> 00:00:25,200
今天，我们来谈谈我最喜爱的主题之一，​​说实话 - 

9
00:00:25,200 --> 00:00:29,000
的安全和隐私，所有的硬件​​和软件的影响

10
00:00:29,000 --> 00:00:31,000
大家都用的这些日子。

11
00:00:31,000 --> 00:00:33,300
说实话，有很多有威胁

12
00:00:33,300 --> 00:00:35,430
如果你还没有真正停下来想想他们，

13
00:00:35,430 --> 00:00:36,920
他们实际上是相当艰巨的。

14
00:00:36,920 --> 00:00:40,070
典型的例子 - 如果你曾经下载一个软件

15
00:00:40,070 --> 00:00:42,660
在互联网上传播，并把它安装在您的计算机上，

16
00:00:42,660 --> 00:00:45,220
你已经参与到一个相当程度的信任，对不对？

17
00:00:45,220 --> 00:00:50,220
没有什么阻止Skype，或者Chrome浏览器，或任何软件

18
00:00:50,220 --> 00:00:54,770
你已经安装到你的电脑，从简单地删除您的硬盘驱动器上的所有文件;

19
00:00:54,770 --> 00:00:58,260
上传一些坏家伙的服务器硬盘驱动器上的所有文件;

20
00:00:58,260 --> 00:01:01,650
您的电子邮件;，堵截所有的即时消息。

21
00:01:01,650 --> 00:01:05,040
因为现实情况是大多数现代操作系统的今天

22
00:01:05,040 --> 00:01:10,040
是不是真的有许多，我们安装的软件程序之间的一堵墙，

23
00:01:10,040 --> 00:01:14,220
你和我都非常简单，只是种交叉手指和信仰

24
00:01:14,220 --> 00:01:17,750
免费下载该应用程序，或99美分的东西，

25
00:01:17,750 --> 00:01:20,140
实际上完全是良性的。

26
00:01:20,140 --> 00:01:23,090
但是，正如我们已经看到通过C，和现在的PHP和JavaScript，

27
00:01:23,090 --> 00:01:25,420
用此来表达自己的编程能力，

28
00:01:25,420 --> 00:01:30,300
你可以做任何你想要的程序，用户自己可以做。

29
00:01:30,300 --> 00:01:32,390
>> 因此，我们今天关于这一主题的重点 - 

30
00:01:32,390 --> 00:01:35,360
不仅一些威胁，但防御能力。

31
00:01:35,360 --> 00:01:37,540
事实上，在世界上的安全性一般，

32
00:01:37,540 --> 00:01:39,040
有一种猫捉老鼠的游戏，

33
00:01:39,040 --> 00:01:41,990
我敢说几乎总是有坏人一条腿。

34
00:01:41,990 --> 00:01:45,880
当它涉及到我们自己的个人电脑上的硬件和软件的优势，

35
00:01:45,880 --> 00:01:51,250
我们必须认识到，一个坏家伙只需要找到一个简单的错误 - 

36
00:01:51,250 --> 00:01:56,150
一个错误 - 在一块的软件，我们已经写了一个利用，或正在运行

37
00:01:56,150 --> 00:01:58,280
为了他或她接手我们的整个系统。

38
00:01:58,280 --> 00:02:02,870
通过对比，我们 - 好人 - 需要修补和修复这些错误

39
00:02:02,870 --> 00:02:04,900
并避免这些弱点。

40
00:02:04,900 --> 00:02:07,870
所以，我敢说，就整体而言，坏家伙有优势。

41
00:02:07,870 --> 00:02:10,840
什么课和上课是真正的

42
00:02:10,840 --> 00:02:14,830
不是教你如何发动的战役，这些坏家伙，

43
00:02:14,830 --> 00:02:18,220
但关于如何保护自己或至少作出决定，

44
00:02:18,220 --> 00:02:22,970
是的，我知道这个软件确实可以阅读我的​​邮件中的每一个，

45
00:02:22,970 --> 00:02:27,040
但我没因为它带给我的价值，另一方面。

46
00:02:27,040 --> 00:02:31,060
>> 我很高兴能够加入由最聪明的人，我知道 - 

47
00:02:31,060 --> 00:02:33,060
罗布Bowden和内特 - 哈迪森。

48
00:02:33,060 --> 00:02:36,850
罗布带我们参观的最低水平的安全标签的 - 

49
00:02:36,850 --> 00:02:42,470
的编译器，到现在为止，我们都来爱和信任。罗布·波顿。

50
00:02:42,470 --> 00:02:47,790
[掌声]

51
00:02:47,790 --> 00:02:50,280
>> 罗布所有权利。大卫几乎我的整个高谈阔论

52
00:02:50,280 --> 00:02:52,320
我要介绍的，但是 - 

53
00:02:52,320 --> 00:02:58,070
几个星期前，你看到了一个缓冲区溢出攻击的例子

54
00:02:58,070 --> 00:03:01,900
这是一个示例的骇客黑客成某些软件

55
00:03:01,900 --> 00:03:06,060
他们不应该被黑客入侵。

56
00:03:06,060 --> 00:03:09,690
的另一侧

57
00:03:09,690 --> 00:03:14,470
有时，你本身是恶意软件。

58
00:03:14,470 --> 00:03:17,070
它甚至不需要被黑客攻破。

59
00:03:17,070 --> 00:03:20,670
是谁写的软件的人要攻击你。

60
00:03:20,670 --> 00:03:22,190
>> 让我们直接进入代码，

61
00:03:22,190 --> 00:03:28,560
考虑看看在“login.c的”。

62
00:03:28,560 --> 00:03:33,390
在这里，一个傻程序验证用户名和密码组合。

63
00:03:33,390 --> 00:03:39,420
在这里，您一定要熟悉C再次测验。

64
00:03:39,420 --> 00:03:43,470
首先，我们用字符串描述的用户名，

65
00:03:43,470 --> 00:03:46,280
然后，我们使用的是获取字符串抢的密码，

66
00:03:46,280 --> 00:03:50,680
然后我们检查，只是一些琐碎的，是“抢”用户名？

67
00:03:50,680 --> 00:03:52,710
而且是的密码“thisiscs50”？

68
00:03:52,710 --> 00:03:56,900
或者，是汤米“用户名”和密码“I <3javascript”？

69
00:03:56,900 --> 00:03:58,980
如果任一者的情况下，

70
00:03:58,980 --> 00:04:01,980
 那么，我们只是要打印的“成功”，然后我们有机会。

71
00:04:01,980 --> 00:04:07,690
否则，我们将打印“无效登录”，然后，当然，

72
00:04:07,690 --> 00:04:11,120
 由于草图字符串malloc的内存，我们可以自由的用户名和密码。

73
00:04:11,120 --> 00:04:15,560
这是一个简单的登录程序，

74
00:04:15,560 --> 00:04:18,110
如果你仔细想想，当您登录到设备，

75
00:04:18,110 --> 00:04:22,350
这是非常相似 - 甚至在登录到您的计算机 - 

76
00:04:22,350 --> 00:04:24,930
只是有一些登录程序，这是给你的访问。

77
00:04:24,930 --> 00:04:31,840
在这里，我们正好有硬编码'抢'，'thisiscs50“，”汤米，“我<3javascript，

78
00:04:31,840 --> 00:04:34,950
但可能有一些文件放在您的作业系统

79
00:04:34,950 --> 00:04:38,690
其中有一个人可以登录到系统的用户名列表

80
00:04:38,690 --> 00:04:41,740
这些用户名与密码的列表。

81
00:04:41,740 --> 00:04:46,090
通常情况下，密码不只是保存在文本中是这样的。

82
00:04:46,090 --> 00:04:50,360
是某种形式的加密，但是这会在我们的例子中。

83
00:04:50,360 --> 00:04:57,000
>> 我们的编译器 - 

84
00:04:57,020 --> 00:05:00,780
这将是非常简单的。

85
00:05:00,780 --> 00:05:04,800
我们需要至少指定一些文件，我们要编译，

86
00:05:04,800 --> 00:05:10,200
然后在这里 - 这些行

87
00:05:10,200 --> 00:05:12,520
只是读取的文件。

88
00:05:12,520 --> 00:05:16,080
它读取整个文件到一个大的缓冲，

89
00:05:16,080 --> 00:05:19,000
然后我们以空终止我们的缓冲区一如既往，

90
00:05:19,000 --> 00:05:21,000
最后，我们只是编译文件。

91
00:05:21,000 --> 00:05:24,090
我们不打算看看如何编译实际执行，

92
00:05:24,090 --> 00:05:26,820
但作为一个提示，它只是调用铿锵。

93
00:05:26,820 --> 00:05:32,370
我们将使用这个程序编译东西，而不是铛。

94
00:05:32,370 --> 00:05:39,260
我们从一个问题是，我们看到的，我们希望我们的编译器编译，

95
00:05:39,260 --> 00:05:43,620
但如果我们不打算使用铛，我不知道我要编译。

96
00:05:43,620 --> 00:05:46,700
这是一个普遍的问题，被称为自举。

97
00:05:46,700 --> 00:05:53,080
所以，就这一次，我将使用铛我们的编译器编译。

98
00:05:53,080 --> 00:05:58,800
>> 如果你认为GCC和Clang的 - 

99
00:05:58,800 --> 00:06:03,200
这些方案中，这些编译器正在不断更新，

100
00:06:03,200 --> 00:06:10,010
和这些编译器编译使用GCC和Clang的。

101
00:06:10,010 --> 00:06:14,890
铛是一个大的C或C + +程序，

102
00:06:14,890 --> 00:06:19,510
所以他们使用的编译器编译，这是铛。

103
00:06:19,510 --> 00:06:26,820
在这里，现在，我们只是将要使用的编译器来编译我们的编译器，

104
00:06:26,820 --> 00:06:33,830
我们甚至可以说 - '/编译“，”compiler.c'，'compile.c'，'-o编译器“。

105
00:06:33,830 --> 00:06:37,250
请注意，这是确切的命令，我跑前 - 

106
00:06:37,250 --> 00:06:41,330
只需更换铛“。/编译器。

107
00:06:41,330 --> 00:06:44,990
现在，我们有其它的编译器，但它是完全一样的。

108
00:06:44,990 --> 00:06:47,510
它只是调用铛。

109
00:06:47,510 --> 00:06:55,050
>> 我们将使用我们的编译器来编译我们的登录程序。

110
00:06:55,050 --> 00:07:03,030
好了 - “。/编译login.c的的邻登录”。

111
00:07:03,030 --> 00:07:06,160
所以，引用“的GetString”。

112
00:07:06,160 --> 00:07:11,250
得到了“lcs50”。好吧。

113
00:07:11,250 --> 00:07:13,790
所以现在我有我们的登录程序。

114
00:07:13,790 --> 00:07:16,790
运行它 - 收到“请输入您的用户名”。

115
00:07:16,790 --> 00:07:22,140
其中一个例子就是抢劫。请输入您的密码资料 -  thisiscs50。

116
00:07:22,140 --> 00:07:24,930
和成功！我有机会。

117
00:07:24,930 --> 00:07:28,350
再次运行它，并输入一些无效的密码 - 

118
00:07:28,350 --> 00:07:30,350
或无效的用户名和密码 - 

119
00:07:30,350 --> 00:07:32,860
无效的登录。

120
00:07:32,860 --> 00:07:37,740
好吧。没有这样远有趣的。

121
00:07:37,740 --> 00:07:43,100
但是，让我们再次来看看在登录 - 

122
00:07:43,100 --> 00:07:47,850
这将是一个有点微不足道的例子，

123
00:07:47,850 --> 00:07:59,330
但让我们添加一个else在这里说，如果（（STRCMP（用户名，“黑客”）== 0 &&

124
00:07:59,330 --> 00:08:14,510
STRCMP（密码“，LOLihackyou”）== 0））

125
00:08:14,510 --> 00:08:26,280
所以，现在，输出（“黑客！您现在可以访问。\ n”）;没关系。

126
00:08:26,280 --> 00:08:36,240
编译 - 编译器login.c的邻登录lcs50  - 

127
00:08:36,240 --> 00:08:40,190
现在运行login  - 如果我用我的用户名黑客

128
00:08:40,190 --> 00:08:44,740
和密码LOLihackedyou  - 

129
00:08:44,740 --> 00:08:47,780
我输入错误在那里？

130
00:08:47,780 --> 00:08:52,990
砍死在login.c的- -  ihack  - 我会做，因为我觉得我做的，后来。

131
00:08:52,990 --> 00:08:56,270
好吧。重新编译。

132
00:08:56,270 --> 00:09:01,500
重新运行 - 黑客 -  LOLihackedyou  - 

133
00:09:01,500 --> 00:09:03,650
黑客攻击！你现在有机会。

134
00:09:03,650 --> 00:09:06,580
>> 似乎没有太大的区别是，

135
00:09:06,580 --> 00:09:10,890
因为它是我在做其他的用户名和密码完全相同的检查。

136
00:09:10,890 --> 00:09:17,720
此外，天大的事情是，如果其他人看这login.c的 - 

137
00:09:17,720 --> 00:09:24,020
说，如果我通过了这一关，我的合作伙伴，他们打开这个文件，

138
00:09:24,020 --> 00:09:29,870
他们读这一点，他们会看到 - 好吧，为什么你有这几行代码在这里？

139
00:09:29,870 --> 00:09:33,320
这显然​​不是，应该是在你的程序中。

140
00:09:33,320 --> 00:09:41,590
在某些程序中 - 像任何专有软件，是不是开源 - 

141
00:09:41,590 --> 00:09:46,200
你可能永远不会看到这几行代码。

142
00:09:46,200 --> 00:09:50,440
所有你知道的东西像Skype或什么 - 

143
00:09:50,440 --> 00:09:57,600
Skype是您的计算机上有一些特定的用户名和密码组合

144
00:09:57,600 --> 00:10:01,580
在一些特殊的方式登录到Skype。

145
00:10:01,580 --> 00:10:04,230
我们不知道，人不知道它，

146
00:10:04,230 --> 00:10:09,640
因为他们不读的源代码，看到有这个洞。

147
00:10:09,640 --> 00:10:11,800
>> 我们所说的这一点 - 

148
00:10:11,800 --> 00:10:16,530
虽然这不是一个很聪明的例子 - 

149
00:10:16,530 --> 00:10:18,970
这就是所谓的后门。

150
00:10:18,970 --> 00:10:22,320
如果你觉得你的房子的后门。

151
00:10:22,320 --> 00:10:26,640
在这里，如果我的用户名“打劫”或“汤米，验证

152
00:10:26,640 --> 00:10:28,580
这将是像“前门”。

153
00:10:28,580 --> 00:10:33,700
就是这样，我应该能够安全地登录。

154
00:10:33,700 --> 00:10:37,630
但是，如果我输入这个用户名和密码 - 

155
00:10:37,630 --> 00:10:40,630
然后，使用“后门”。

156
00:10:40,630 --> 00:10:42,810
这是不是故意的方式进入程序，

157
00:10:42,810 --> 00:10:45,350
但它仍然有效。

158
00:10:45,350 --> 00:10:49,160
和一般人不应该知道这些后门。

159
00:10:49,160 --> 00:10:53,050
我们要改善这一点。

160
00:10:53,050 --> 00:10:55,610
让我们恢复这我们原来的login.c，

161
00:10:55,610 --> 00:11:05,510
让我们来看看我们的新的编译器。好吧。

162
00:11:05,510 --> 00:11:08,460
一切都在这里是完全一样的。

163
00:11:08,460 --> 00:11:10,460
我们整个文件读取到缓冲区中。

164
00:11:10,460 --> 00:11:14,400
一切都在这里是一样的。

165
00:11:14,400 --> 00:11:16,180
我们刚刚编译的文件。

166
00:11:16,180 --> 00:11:19,770
但现在我有这么大的，如果在这里

167
00:11:19,770 --> 00:11:24,140
，说如果我碰巧编译的文件是login.c的，，

168
00:11:24,140 --> 00:11:27,390
然后，我做一些特别的东西。

169
00:11:27,390 --> 00:11:29,900
那是一些特别的东西吗？

170
00:11:29,900 --> 00:11:33,820
我在这里看到了一些被称为“黑客”的字符串，

171
00:11:33,820 --> 00:11:35,950
在这几行代码 - 

172
00:11:35,950 --> 00:11:41,990
这些都是相同的代码行 - 我想我做了使用“ihack'，而不是'ihacked前 - 

173
00:11:41,990 --> 00:11:44,240
看着这几行代码，

174
00:11:44,240 --> 00:11:47,880
他们是完全相同的，我在login.c的前几行代码。

175
00:11:47,880 --> 00:11:51,130
但现在，而不是让他们在login.c的，

176
00:11:51,130 --> 00:11:54,290
我打算把它们放到我的编译器。

177
00:11:54,290 --> 00:12:00,240
>> 这些都是我将要插入到login.c的行代码。

178
00:12:00,240 --> 00:12:06,350
这行代码 - 最初举行我的login.c，的缓冲区

179
00:12:06,350 --> 00:12:11,080
不再要足够大，因为现在我也想插入这个黑客

180
00:12:11,080 --> 00:12:12,940
到我的程序中。

181
00:12:12,940 --> 00:12:16,350
所有这一切都做的是创建一个新的缓冲区足够大， - 

182
00:12:16,350 --> 00:12:22,020
的原始文件和行额外的代码 - 黑客 - 我要插入那里。

183
00:12:22,020 --> 00:12:24,920
下面是一些需要注意的 - 

184
00:12:24,920 --> 00:12:29,200
字符模式=“/ /拒绝他们的访问！”

185
00:12:29,200 --> 00:12:33,760
如果我们回头看在login.c的，

186
00:12:33,760 --> 00:12:37,690
我们看到在这里评论 - 拒绝他们的访问！

187
00:12:37,690 --> 00:12:42,360
login.c的，这样的评论，看上去完全无害的，

188
00:12:42,360 --> 00:12:48,270
所以你不会怀疑任何恶意，只是这条评论。

189
00:12:48,270 --> 00:12:55,600
但在我们的编译器，我们专门去看看这行代码，

190
00:12:55,600 --> 00:12:57,600
然后当我们找到它 - 

191
00:12:57,600 --> 00:13:03,330
这几行代码中插入我们的hack到该位置。

192
00:13:03,330 --> 00:13:06,910
所以，我们在迭代在整个的login.c，

193
00:13:06,910 --> 00:13:12,080
我们插入的黑客工具，它的确切位置说，拒绝他们进入，

194
00:13:12,080 --> 00:13:15,890
然后我们编译 - 而不是原来的login.c

195
00:13:15,890 --> 00:13:20,340
但新的login.c，黑客在“插入拒绝他们进入。”

196
00:13:20,340 --> 00:13:29,190
>> 现在，我想我的新的编译器编译涉及与黑客。

197
00:13:29,190 --> 00:13:36,900
我不打算使用铛，让我们复制我们之前使用的编译器

198
00:13:36,900 --> 00:13:48,420
 - 因此，编译器compiler.c compile.c-O evil_compiler。

199
00:13:48,420 --> 00:13:50,870
现在，我们的邪恶的编译器 - 

200
00:13:50,870 --> 00:13:54,310
如果我们用我们的邪恶的编译器编译的任何其他文件，

201
00:13:54,310 --> 00:13:57,980
该文件将编译，因为它应该。

202
00:13:57,980 --> 00:13:59,980
这是完全正常的。

203
00:13:59,980 --> 00:14:06,870
但是，如果我们用我们的邪恶的编译器来编译登录 - 

204
00:14:06,870 --> 00:14:14,920
因此，-O / evil_compiler login.c的登录的lcs50  - 

205
00:14:14,920 --> 00:14:21,310
再次在login.c的，但绝对没有在这里。

206
00:14:21,310 --> 00:14:25,770
这是我们的一贯“如果是抢劫或托米我们在，否则我们”。

207
00:14:25,770 --> 00:14:31,620
但是，当我们运行我们的可执行文件，这将照常工作。

208
00:14:31,620 --> 00:14:36,640
再次运行 - 的黑客，LOLihackyou  - 

209
00:14:36,640 --> 00:14:39,000
黑客攻击！你现在有机会。

210
00:14:39,000 --> 00:14:43,560
只是在寻找在login.c的，你不会觉得什么是错的。

211
00:14:43,560 --> 00:14:46,960
但正在使用的编译器的编译login.c

212
00:14:46,960 --> 00:14:53,820
是专门设计用来插入攻入的计划。

213
00:14:53,820 --> 00:14:57,320
我们只是提出我们原来的问题。

214
00:14:57,320 --> 00:15:02,880
本来我们这行代码login.c的，如果任何人都看着他们，

215
00:15:02,880 --> 00:15:05,470
他们会想，为什么在这里？

216
00:15:05,470 --> 00:15:09,550
现在，如果有人碰巧在我们的编译器，

217
00:15:09,550 --> 00:15:12,140
他们会看在这行代码，并说，

218
00:15:12,140 --> 00:15:15,290
为什么在这里？

219
00:15:15,290 --> 00:15:17,210
所以，我们还没有完全解决我们的问题。

220
00:15:17,210 --> 00:15:22,510
但是，我们可以利用这个思路。

221
00:15:22,510 --> 00:15:26,260
>> 看看我们的第三个版本的编译器，

222
00:15:26,260 --> 00:15:32,500
这是同样的想法。

223
00:15:32,500 --> 00:15:36,240
在这里，我们将整个文件读取到缓冲区中，

224
00:15:36,240 --> 00:15:39,660
我们编译的文件在这里，

225
00:15:39,660 --> 00:15:44,220
在这里，我有某种形式的字符串黑客

226
00:15:44,220 --> 00:15:47,710
但要注意的文件，我其实现在黑客。

227
00:15:47,710 --> 00:15:52,260
我是黑客compiler.c

228
00:15:52,260 --> 00:15:54,590
login.c的。

229
00:15:54,590 --> 00:15:57,780
但我是什么在插入compiler.c吗？

230
00:15:57,780 --> 00:16:04,600
我插入代码，这是确切的代码在我们以前的编译器，

231
00:16:04,600 --> 00:16:10,540
这是为了将代码插入login.c的。

232
00:16:10,540 --> 00:16:13,360
这里是我们的，如果的STRCMP文件的login.c

233
00:16:13,360 --> 00:16:19,370
和然后插入login.c的我们的hack东西。

234
00:16:19,370 --> 00:16:26,010
这个新的编译器的目的是创建一个编译器

235
00:16:26,010 --> 00:16:30,390
其目的是恶意编译登入。

236
00:16:30,390 --> 00:16:34,320
为什么我们会看到，可以帮助我们。

237
00:16:34,320 --> 00:16:40,630
所有其他的事情都是一样的，所以它的工作原理完全一样，它与我们以前的编译器。

238
00:16:40,630 --> 00:16:45,550
我们只是遍历整个compile.c的。

239
00:16:45,550 --> 00:16:48,190
但现在，而不是寻找“拒绝他们的访问，

240
00:16:48,190 --> 00:16:51,490
我们要找的编译文件。

241
00:16:51,490 --> 00:16:53,750
在哪里编译的文件吗？

242
00:16:53,750 --> 00:16:57,210
看着我们完全无辜的compiler.c，

243
00:16:57,210 --> 00:17:01,340
它的底部就在这里。

244
00:17:01,340 --> 00:17:06,500
该评论 - 编译文件 - 再次，看起来完全无害。

245
00:17:06,500 --> 00:17:11,599
但是，在我们的恶意版本的编译器，

246
00:17:11,599 --> 00:17:16,550
我们要 - 在此之前，注释 - 此代码插入

247
00:17:16,550 --> 00:17:20,690
其目的是将代码编译时login.c的。

248
00:17:20,690 --> 00:17:25,589
>> 有很多层次的间接这里。

249
00:17:25,589 --> 00:17:29,760
实际运行它。

250
00:17:29,760 --> 00:17:37,360
同样，我们将复制我们的原始编译器。

251
00:17:37,360 --> 00:17:48,260
现在，编译 - 编译器compiler.c compile.c-O evilest_compiler  - 

252
00:17:48,260 --> 00:17:52,640
，现在evilest_compiler。

253
00:17:52,640 --> 00:17:59,200
Evilest编译器 - 如果我们用它来编译我们的编译器，

254
00:17:59,200 --> 00:18:01,550
让我们来实际看看。

255
00:18:01,550 --> 00:18:13,230
Evilest_compiler  - 把它结束了，所有的方式回到我们的编译器版本 - 

256
00:18:13,230 --> 00:18:19,640
第1版，我们的编译器只是读取该文件，并编译它。

257
00:18:19,640 --> 00:18:24,780
在这里，我们知道，evilest_compiler  - 当编译这个文件 - 

258
00:18:24,780 --> 00:18:29,890
要在这里插入代码之前编译的文件，

259
00:18:29,890 --> 00:18:38,510
该代码是要看看我们的编译器的第二个版本的代码完全一样

260
00:18:38,510 --> 00:18:42,240
它这样做。

261
00:18:42,240 --> 00:18:46,450
此代码，其目的是打破登录，

262
00:18:46,450 --> 00:18:56,480
将要被插入到我们的编译器evilest编译器。

263
00:18:56,480 --> 00:19:08,600
让我们用evilest_compiler我们的编译器编译。

264
00:19:08,600 --> 00:19:15,040
现在，我们将使用编译器，

265
00:19:15,040 --> 00:19:19,460
回来登陆，

266
00:19:19,460 --> 00:19:25,280
，并记住本的login.c有绝对没有什么可疑。

267
00:19:25,280 --> 00:19:35,250
但我们的编译器编译login.c的，

268
00:19:35,250 --> 00:19:38,430
抢劫，thisiscs50，取得成功。

269
00:19:38,430 --> 00:19:44,350
让我们先登录的黑客，LOLihackyou，砍死！你现在有机会。

270
00:19:44,350 --> 00:19:49,710
>> 认识到这是不同的，从我们的编译器版本2。

271
00:19:49,710 --> 00:20:00,500
我们使用的编译器 - 让我们的移动 - 复制从登录 - 

272
00:20:00,500 --> 00:20:01,880
让我们把我们的编译器在这里。

273
00:20:01,880 --> 00:20:06,360
卸下evilest编译器。

274
00:20:06,360 --> 00:20:08,970
我们现在剩下的是编译器。

275
00:20:08,970 --> 00:20:10,950
如果我们看看compiler.c，，

276
00:20:10,950 --> 00:20:16,840
绝对没有在那里，似乎以任何方式恶意。

277
00:20:16,840 --> 00:20:22,390
如果我们看看login.c的，，

278
00:20:22,390 --> 00:20:28,790
在这里绝对没有以任何方式，看起来恶意。

279
00:20:28,790 --> 00:20:34,600
但是，当我们用我们的编译器编译login.c的，

280
00:20:34,600 --> 00:20:38,840
我们得到的容易被破解的login.c的版本。

281
00:20:38,840 --> 00:20:41,850
当我们用我们的编译器来编译一个新版本的编译器，

282
00:20:41,850 --> 00:20:46,620
我们得到的容易被破解版本的编译器。

283
00:20:46,620 --> 00:20:51,790
现在，如果我们走出去和分发我们的编译器可执行文件，

284
00:20:51,790 --> 00:20:59,280
没有人会知道它有什么恶意。

285
00:20:59,280 --> 00:21:04,680
>> 这实际上是这样的 - 我不记得那一年 - 

286
00:21:04,680 --> 00:21:10,350
肯汤普森，他获得了图灵奖 - 

287
00:21:10,350 --> 00:21:15,600
如果你不熟悉的图灵奖，它几乎总是定义为

288
00:21:15,600 --> 00:21:20,160
计算机科学的诺贝尔奖，所以这是我将如何定义它。

289
00:21:20,160 --> 00:21:24,100
肯·汤普森发表讲话时，他接受了他的图灵奖

290
00:21:24,100 --> 00:21:27,150
信任信任的“反思”。

291
00:21:27,150 --> 00:21:30,710
基本上，这是他的想法，他的讲话。

292
00:21:30,710 --> 00:21:35,050
除了我们的，而不是编译器，他说的是GCC  - 

293
00:21:35,050 --> 00:21:37,250
只是一个编译器一样铛 - 

294
00:21:37,250 --> 00:21:45,600
他在说什么，像我们的login.c，我们的login.c似乎相对无用的

295
00:21:45,600 --> 00:21:50,190
但他说UNIX的实际login.c的。

296
00:21:50,190 --> 00:21:53,050
当您登录到您的设备，

297
00:21:53,050 --> 00:21:56,070
有一些登录程序正在运行。

298
00:21:56,070 --> 00:21:58,080
这是他在谈论的登录。

299
00:21:58,080 --> 00:22:02,420
这基本上是他的主意。

300
00:22:02,420 --> 00:22:09,080
他说，在GCC中，他在理论上可以种植了一个错误 - 

301
00:22:09,080 --> 00:22:12,290
不是一个错误，但恶意代码 - 

302
00:22:12,290 --> 00:22:16,860
编译时登录的功能 -  login文件 - 

303
00:22:16,860 --> 00:22:23,700
将插入一个后门，这样他就可以在世界上任何UNIX系统的绝对

304
00:22:23,700 --> 00:22:27,360
并与一些特定的用户名和密码登录。

305
00:22:27,360 --> 00:22:33,710
当时，GCC是几乎每个人都用什么编译器。

306
00:22:33,710 --> 00:22:36,460
如果有人发生在更新GCC，

307
00:22:36,460 --> 00:22:40,880
然后，他们将使用GCC编译GCC，

308
00:22:40,880 --> 00:22:44,500
你依然会得到一个坏的版本的GCC

309
00:22:44,500 --> 00:22:50,140
，因为它具体地认识到，它被重新编译的编译器编译。

310
00:22:50,140 --> 00:22:57,360
如果你曾经使用GCC重新编译login.c的文件，

311
00:22:57,360 --> 00:23:03,550
然后，它会插入这个后门，他可以使用任何一台计算机登录到。

312
00:23:03,550 --> 00:23:08,750
>> 这是理论上的，但 - 这特定的情况下是理论，

313
00:23:08,750 --> 00:23:12,440
但这些想法是非常真实的。

314
00:23:12,440 --> 00:23:18,250
在2003年，有一个类似的例子 - 

315
00:23:18,250 --> 00:23:21,290
我们就来看看这个文件，

316
00:23:21,290 --> 00:23:25,870
它绝对没有用它做，但类似的错误。

317
00:23:25,870 --> 00:23:29,390
该文件定义了一个函数调用的鸿沟。

318
00:23:29,390 --> 00:23:31,780
它需要一个参数，参数b，

319
00:23:31,780 --> 00:23:34,270
的目的是做一个除以b。

320
00:23:34,270 --> 00:23:37,230
但它确实一些错误检查，

321
00:23:37,230 --> 00:23:40,070
所以我们知道的事情是奇怪的，如果B发生等于零。

322
00:23:40,070 --> 00:23:44,900
如果b为0，那么我们就分裂成2例。

323
00:23:44,900 --> 00:23:46,900
你可能已经看到的bug。

324
00:23:46,900 --> 00:23:51,840
第一种情况 - 如果是零，那么我们正在做的零除以零，

325
00:23:51,840 --> 00:23:54,300
我们只是说这是不确定的。

326
00:23:54,300 --> 00:23:56,250
第二种情况下 - 如果不为零，

327
00:23:56,250 --> 00:24:00,580
那么它的东西，如1除以零，而我们只需要调用无穷大。

328
00:24:00,580 --> 00:24:03,730
否则，我们回到往常一样除以b。

329
00:24:03,730 --> 00:24:06,390
所以在这里，我们正在运行的这3起案件，

330
00:24:06,390 --> 00:24:13,740
我们实际运行鸿沟 - 骂我 - 

331
00:24:13,740 --> 00:24:21,330
所以，忽略了铿锵的警告 - 

332
00:24:21,330 --> 00:24:24,500
非void函数的结束 - 显然我没有编译这个提前。

333
00:24:24,500 --> 00:24:26,500
返回0。

334
00:24:26,500 --> 00:24:28,900
分裂 - 所有权利。

335
00:24:28,900 --> 00:24:32,470
/鸿沟，我们可以看到，无穷远，无穷大。

336
00:24:32,470 --> 00:24:39,150
零除以零，不应该返回无穷大。

337
00:24:39,150 --> 00:24:42,840
如果你还没有想通了的错误 - 还是没看到它之前 - 

338
00:24:42,840 --> 00:24:46,800
我们可以看到，我们做了= 0。

339
00:24:46,800 --> 00:24:52,610
也许我们的意思了== 0。也许吧。

340
00:24:52,610 --> 00:24:58,640
>> 但是，这是实际的东西，再次，在2003年，Linux内核 - 

341
00:24:58,640 --> 00:25:02,260
因此，我们的设备使用的Linux内核 - 

342
00:25:02,260 --> 00:25:05,550
任何Linux操作系统使用的Linux内核 - 

343
00:25:05,550 --> 00:25:11,610
所以非常相似，这表明一个错误。

344
00:25:11,610 --> 00:25:15,180
这个错误背后的想法是 - 

345
00:25:15,180 --> 00:25:18,820
再次，只是有一些功能，被称为，它做了一些错误检查。

346
00:25:18,820 --> 00:25:24,300
有一些特定的输入错误检测 - 

347
00:25:24,300 --> 00:25:30,210
它应该是，所有的权利，你可以调用这个函数与除数为0。

348
00:25:30,210 --> 00:25:35,070
所以，我将只返回一些错误。

349
00:25:35,070 --> 00:25:38,090
除，这是不一样的眼神，只设置一个等于0。

350
00:25:38,090 --> 00:25:46,920
相反，这行代码做更多的东西，如用户=管理员。

351
00:25:46,920 --> 00:25:50,500
或用户超级用户。

352
00:25:50,500 --> 00:25:59,170
这是一个无辜的 - 第一眼 - 错误，它可能只是合理

353
00:25:59,170 --> 00:26:01,560
我只是想一些具体的报告

354
00:26:01,560 --> 00:26:05,150
如果发生用户是超级用户管理员。

355
00:26:05,150 --> 00:26:11,220
但然后重新思考它，希望它看起来像一个简单的拼写错误的人，

356
00:26:11,220 --> 00:26:14,330
但如果这段代码实际上已被释放，

357
00:26:14,330 --> 00:26:21,580
那么你就已经能够破解任何系统通过特定的标志 - 

358
00:26:21,580 --> 00:26:25,200
在这种情况下，b = 0时 - 

359
00:26:25,200 --> 00:26:28,020
它会自动使用户的管理员，

360
00:26:28,020 --> 00:26:30,400
然后，他有完全的控制。

361
00:26:30,400 --> 00:26:32,540
这发生在2003年。

362
00:26:32,540 --> 00:26:35,700
>> 它只是发生的唯一原因被抓

363
00:26:35,700 --> 00:26:39,200
是因为发生了一些自动化系统

364
00:26:39,200 --> 00:26:41,540
注意到在此文件中的变化

365
00:26:41,540 --> 00:26:44,560
这不应该被改变的人。

366
00:26:44,560 --> 00:26:47,580
该文件应仅是自动生成的。

367
00:26:47,580 --> 00:26:49,780
正巧，有人感动 - 

368
00:26:49,780 --> 00:26:52,460
好了，想破解的人，感动的文件，

369
00:26:52,460 --> 00:26:55,450
与电脑发现，触摸。

370
00:26:55,450 --> 00:27:01,750
因此，他们改变了这个，后来才意识到那将是灾难

371
00:27:01,750 --> 00:27:04,830
如果这已经得到了进入真实的世界。

372
00:27:04,830 --> 00:27:08,220
>> 你也许会想 - 我们的编译器的例子 - 

373
00:27:08,220 --> 00:27:14,290
即使我们不能看到 - 的源代码 - 

374
00:27:14,290 --> 00:27:17,490
，特别是什么是错的，

375
00:27:17,490 --> 00:27:25,460
如果我们看一下编译的二进制代码，

376
00:27:25,460 --> 00:27:28,670
我们将看到什么是错的。

377
00:27:28,670 --> 00:27:31,260
举个例子，如果我们运行的字符串函数 - 

378
00:27:31,260 --> 00:27:34,930
这是刚刚要查看的文件，并打印出所有可以找到的字符串 - 

379
00:27:34,930 --> 00:27:37,990
如果我们运行我们的编译器上的字符串，

380
00:27:37,990 --> 00:27:42,400
我们看到的是一个字符串，它发现这是奇怪的 - 

381
00:27:42,400 --> 00:27:45,500
否则，如果（STRCMP（用户名，“黑客”） - 等等，等等，等等。

382
00:27:45,500 --> 00:27:52,570
如果有人碰巧是偏执狂，不信任他们的编译器，

383
00:27:52,570 --> 00:27:56,690
他们可以执行字符串和看到这一点，

384
00:27:56,690 --> 00:28:00,430
然后他们会知道，有一些错误与实际的二进制。

385
00:28:00,430 --> 00:28:07,250
但是，字符串是不可避免地被编译的东西。

386
00:28:07,250 --> 00:28:11,590
那么，谁又能说我们的编译器不只是有更多特殊的代码

387
00:28:11,590 --> 00:28:19,240
说，如果字符串是有史以来我们的编译器上运行，不输出所有的恶意代码。

388
00:28:19,240 --> 00:28:23,980
>> 同样的想法，如果我们想显示汇编文件 - 

389
00:28:23,980 --> 00:28:30,440
我们了解到，汇编器把我们从汇编代码的机器代码 - 

390
00:28:30,440 --> 00:28:36,010
我们可以向相反的方向 -  objdump的-D编译器 - 

391
00:28:36,010 --> 00:28:38,770
会给我们的组件，我们的代码。

392
00:28:38,770 --> 00:28:41,730
见到这种情景，

393
00:28:41,730 --> 00:28:47,480
这是很神秘的，但是如果我们想，我们可以通过这

394
00:28:47,480 --> 00:28:51,700
和理由，等待，有什么在这里，不应该去上，

395
00:28:51,700 --> 00:28:59,380
然后我们就会认识到，编译器做一些恶意的。

396
00:28:59,380 --> 00:29:03,950
但是，就像字符串，说，objdump的是不特殊套管。

397
00:29:03,950 --> 00:29:11,380
基本上，它归结到你不能相信任何事情。

398
00:29:11,380 --> 00:29:14,310
点的纸被称为“信任信任”

399
00:29:14,310 --> 00:29:17,900
在一般情况下，我们相信我们的编译器。

400
00:29:17,900 --> 00:29:21,700
您可以编译你的代码，并期望它做什么，你问它做的。

401
00:29:21,700 --> 00:29:26,440
但是，你为什么要信任的编译器？

402
00:29:26,440 --> 00:29:32,120
你没有写的编译器。你不知道什么编译器必须实际做。

403
00:29:32,120 --> 00:29:36,870
谁是说你可以相信它吗？

404
00:29:36,870 --> 00:29:40,050
但即便如此，好了，也许我们可以相信的编译器。

405
00:29:40,050 --> 00:29:44,670
看着这几十成千上万的人。

406
00:29:44,670 --> 00:29:51,360
一定是有人认可的东西的编译器。

407
00:29:51,360 --> 00:29:55,100
>> 如果我们只是去更深一层？

408
00:29:55,100 --> 00:29:59,450
甚至也可能是您的处理器。

409
00:29:59,450 --> 00:30:01,250
荒谬的，因为它可能是，

410
00:30:01,250 --> 00:30:06,690
也许有一些流氓雇员在英特尔创建这些处理器

411
00:30:06,690 --> 00:30:12,400
的处理器，只要你运行一些命令的注意事项

412
00:30:12,400 --> 00:30:14,570
这意味着登录到计算机，

413
00:30:14,570 --> 00:30:19,230
处理器将接受一些特定的用户名和密码组合。

414
00:30:19,230 --> 00:30:21,530
它会被广泛接受复杂，

415
00:30:21,530 --> 00:30:24,790
但有人能做到这一点。

416
00:30:24,790 --> 00:30:29,350
在这一点上，你真的要打开你的电脑在处理器

417
00:30:29,350 --> 00:30:35,970
用显微镜认识到，这些电路不排队，他们应该是？

418
00:30:35,970 --> 00:30:39,730
从来没有人去捕捉这个错误。

419
00:30:39,730 --> 00:30:45,570
在某些时候，你只需要放弃和信任的东西。

420
00:30:45,570 --> 00:30:48,390
大多数人都相信在这一点上的编译器。

421
00:30:48,390 --> 00:30:55,760
这是，你应该说不一定。

422
00:30:55,760 --> 00:30:59,350
看着有点臭名昭著的视频 - 

423
00:30:59,350 --> 00:31:09,280
[戏剧性的音乐播放]

424
00:31:09,280 --> 00:31:13,270
[这是一个UNIX系统。我知道这一点。]

425
00:31:13,270 --> 00:31:14,470
这是所有的文件 - ]

426
00:31:14,470 --> 00:31:18,950
她说：“这是一个UNIX系统，这个我知道。”

427
00:31:18,950 --> 00:31:21,760
更换任何你喜欢的操作系统是UNIX  - 

428
00:31:21,760 --> 00:31:25,230
她本来可以说，“这是一个Windows系统。这个我知道。”

429
00:31:25,230 --> 00:31:29,710
这是一个完全没有意义的声明，

430
00:31:29,710 --> 00:31:34,450
但我们都知道，她碰巧知道UNIX系统的一个后门进入。

431
00:31:34,450 --> 00:31:38,840
她知道，她居然让一些用户名/密码组合，将

432
00:31:38,840 --> 00:31:41,540
做任何她想要的。

433
00:31:41,540 --> 00:31:49,000
>> 好的。今天的道德基本上你不能相信任何事情。

434
00:31:49,000 --> 00:31:52,620
甚至你写的 - 你不写编译器。

435
00:31:52,620 --> 00:31:53,870
编译器可能是坏的。

436
00:31:53,870 --> 00:31:59,140
即使你没有写的编译器，运行编译器的东西可能是坏的。

437
00:31:59,140 --> 00:32:05,210
（笑）有没有什么可以做。

438
00:32:05,210 --> 00:32:09,050
世界是注定。

439
00:32:09,050 --> 00:32:11,570
给大卫！

440
00:32:11,570 --> 00:32:19,540
[掌声]

441
00:32:19,540 --> 00:32:21,340
>> [大卫]谢谢。这是非常令人沮丧的。

442
00:32:21,340 --> 00:32:23,910
不过说实在的，罗布是正确的。

443
00:32:23,910 --> 00:32:27,150
我们并没有真正的解决方案，但你要得到一些解决方案

444
00:32:27,150 --> 00:32:29,150
一些更常见的防御。

445
00:32:29,150 --> 00:32:31,170
预期，Nate和我已经做台下有

446
00:32:31,170 --> 00:32:33,950
知道，在这个房间里有那么多的笔记本电脑，

447
00:32:33,950 --> 00:32:37,020
我们一直嗅探所有无线流量的通过这个房间，在过去的20分钟

448
00:32:37,020 --> 00:32:39,260
Rob的谈话过程中，所以我们要采取一个2分钟的休息时间。

449
00:32:39,260 --> 00:32:41,740
Nate的设置，然后我们要谈论的东西

450
00:32:41,740 --> 00:32:46,380
我们可以发现。 （笑）

451
00:32:46,380 --> 00:32:51,990
>> 所以，我可能夸大了一点点，只是为了戏剧，

452
00:32:51,990 --> 00:32:55,990
但我们也能嗅探所有的无线通信因为事实上，

453
00:32:55,990 --> 00:32:57,240
它是那么容易。

454
00:32:57,240 --> 00:32:59,790
但也有方法，你可以抵御这样，

455
00:32:59,790 --> 00:33:03,160
我给你内特 - 哈迪森。 >> [内特]甜。

456
00:33:03,160 --> 00:33:06,300
（掌声）

457
00:33:06,300 --> 00:33:08,650
>> [内特]谢谢，伙计。我很欣赏的喊出来。

458
00:33:08,650 --> 00:33:12,790
好吧！这是比赛周。你们激动吗？

459
00:33:12,790 --> 00:33:16,670
希望这将是一场伟大的比赛上周六。

460
00:33:16,670 --> 00:33:20,220
我想你们在这一点 - 因为，你有一个测验周三

461
00:33:20,220 --> 00:33:24,430
所有有关的代码，我们只是坐着一个精彩的讲座由Rob

462
00:33:24,430 --> 00:33:25,850
一大堆的C代码 - 

463
00:33:25,850 --> 00:33:28,330
也许是有点累了的代码。

464
00:33:28,330 --> 00:33:32,180
在这一部分，我们其实并没有任何触及任何代码。

465
00:33:32,180 --> 00:33:36,960
我们只是谈论你每天都在使用的一种技术，

466
00:33:36,960 --> 00:33:39,790
往往许多，许多小时一天，

467
00:33:39,790 --> 00:33:46,220
我们将讨论与安全的影响，有。

468
00:33:46,220 --> 00:33:48,960
>> 在本学期，我们已经谈了很多关于安全，

469
00:33:48,960 --> 00:33:53,030
我们开始了一点点的加密。

470
00:33:53,030 --> 00:33:55,030
[Bdoh LV vwlqng！

471
00:33:55,030 --> 00:33:57,890
虽然你们可能是超兴奋地相互传纸条

472
00:33:57,890 --> 00:33:59,890
在课堂上使用像这样的恺撒密码，

473
00:33:59,890 --> 00:34:03,870
在现实中，有一些更有趣的了，当你谈论安全

474
00:34:03,870 --> 00:34:05,870
这样的东西。

475
00:34:05,870 --> 00:34:09,090
今天，我们要介绍几个技术

476
00:34:09,090 --> 00:34:13,650
现实世界中，人们的实际使用中，做各种各样的事情

477
00:34:13,650 --> 00:34:18,360
从人的数据包嗅探其实和

478
00:34:18,360 --> 00:34:20,409
打破进入人们的银行账户和所有的。

479
00:34:20,409 --> 00:34:23,460
这些都是合法的工具，我们在谈论

480
00:34:23,460 --> 00:34:26,320
异常的可能的一个工具。

481
00:34:26,320 --> 00:34:28,889
>> 我只想做一个快速免责声明。

482
00:34:28,889 --> 00:34:34,909
当我们谈论这些事情，我们正在谈论他们，你知道那里有什么，

483
00:34:34,909 --> 00:34:39,389
你知道如何当你使用你的电脑是安全的。

484
00:34:39,389 --> 00:34:44,000
但是，我们绝对不希望暗示，你应该使用这些工具

485
00:34:44,000 --> 00:34:48,090
在宿舍或你的房子，因为你可以遇到很多的大问题。

486
00:34:48,090 --> 00:34:52,760
这是今天的一个原因，我们实际上并没有嗅探你的数据包。

487
00:34:52,760 --> 00:35:01,300
>> 好的。的最后一个星期一，我们谈到饼干，HTTP，和认证，

488
00:35:01,300 --> 00:35:05,920
如何Firesheep打开大门口到您的Facebook帐户，

489
00:35:05,920 --> 00:35:08,670
您的Hotmail帐户 - 如果每个人都在使用Hotmail  - 

490
00:35:08,670 --> 00:35:12,360
和许多其他帐户。

491
00:35:12,360 --> 00:35:16,980
很多这个东西是要建立关闭，

492
00:35:16,980 --> 00:35:22,070
但首先，我想借此快速浏览的互联网已经发展如何，随着时间的推移。

493
00:35:22,070 --> 00:35:27,490
早在20世纪90年代，你们可能还记得，其实堵

494
00:35:27,490 --> 00:35:29,880
您的计算机之一。

495
00:35:29,880 --> 00:35:32,640
现在我们不这样做那么多了。

496
00:35:32,640 --> 00:35:37,230
实际上，为了到我的笔记本电脑插入以太网电​​缆，

497
00:35:37,230 --> 00:35:41,710
我现在已经使用这些适配器这是一种疯狂的。

498
00:35:41,710 --> 00:35:47,580
>> 相反，在1997年，我们有新的，有趣的技术

499
00:35:47,580 --> 00:35:54,960
走了出来，被称为IEEE 802.11，这是无线网络标准

500
00:35:54,960 --> 00:36:00,430
IEEE是这样的管理机构，给出了各种 - 

501
00:36:00,430 --> 00:36:04,770
出版与计算机有关的各种标准。

502
00:36:04,770 --> 00:36:08,780
802标准都对互联网技术。

503
00:36:08,780 --> 00:36:12,690
因此，802.3以太网标准，例如，

504
00:36:12,690 --> 00:36:17,120
图802.15.1我相信是蓝牙的标准，

505
00:36:17,120 --> 00:36:19,540
802.11是所有关于无线上网。

506
00:36:19,540 --> 00:36:24,150
在1997年就出来了。它并不太明白的时候了。

507
00:36:24,150 --> 00:36:30,200
直到1999年和802.11b标准出来了，真的很流行。

508
00:36:30,200 --> 00:36:36,330
>> 你们有多少人还记得，当计算机开始出来，并获得Wi-Fi的吗？

509
00:36:36,330 --> 00:36:38,330
这是种很酷吧？

510
00:36:38,330 --> 00:36:41,260
我记得在高中时，我的第一台笔记本电脑

511
00:36:41,260 --> 00:36:44,250
它有一个无线网卡。

512
00:36:44,250 --> 00:36:49,580
我爸给了我，并说我应该用它为我的大学的应用程序和所有的，

513
00:36:49,580 --> 00:36:53,030
我不知道我是怎么看这个东西网上。

514
00:36:53,030 --> 00:36:54,640
但幸运的是，我有一个无线网卡，所以这是非常酷的。

515
00:36:54,640 --> 00:37:04,090
如今，你还可以看到802.11克的，这是其他非常受欢迎的

516
00:37:04,090 --> 00:37:06,090
无线标准的。

517
00:37:06,090 --> 00:37:08,660
在这一点上，b和g的漂亮已经过时。

518
00:37:08,660 --> 00:37:12,580
任何人都知道是什么版本大多数人都对现在

519
00:37:12,580 --> 00:37:15,110
如果他们购买新的无线路由器，这样的东西吗？

520
00:37:15,110 --> 00:37:24,290
N.没错。宾果游戏。而事实证明，交流标准只是草案形式，

521
00:37:24,290 --> 00:37:28,050
有其他版本的方式。

522
00:37:28,050 --> 00:37:31,190
有了这些标准，我们得到了什么，是更多的带宽，

523
00:37:31,190 --> 00:37:33,900
更多的数据以更快的速度。

524
00:37:33,900 --> 00:37:36,260
这些事情是不断变化很快。

525
00:37:36,260 --> 00:37:39,880
这也使得它使我们不得不购买更多的路由器和所有有趣的东西。

526
00:37:39,880 --> 00:37:48,160
>> 让我们来谈谈什么样的无线通信是其核心。

527
00:37:48,160 --> 00:37:51,790
随着以太网和那些老的拨号调制解调器，

528
00:37:51,790 --> 00:37:55,780
实际上你的东西，你连接到您的计算机，

529
00:37:55,780 --> 00:37:59,820
然后你插入各种各样的调制解调器，然后插入到你的墙上的插孔中。

530
00:37:59,820 --> 00:38:01,820
你有有线连接，对不对？

531
00:38:01,820 --> 00:38:06,030
整点的无线摆脱这东西。

532
00:38:06,030 --> 00:38:10,300
为了做到这一点，我们有什么本质上是

533
00:38:10,300 --> 00:38:13,960
我们的无线路由器的无线电通信 - 

534
00:38:13,960 --> 00:38:16,230
指定由我们小的无线图标 - 

535
00:38:16,230 --> 00:38:21,730
与此实线箭头表示某种有线连接，连接到Internet的

536
00:38:21,730 --> 00:38:24,640
但是，当您连接到您的无线路由器

537
00:38:24,640 --> 00:38:29,190
你实际使用几乎像一个对讲机之间

538
00:38:29,190 --> 00:38:31,960
您的计算机和无线路由器。

539
00:38:31,960 --> 00:38:35,150
什么是真正酷的是你可以走动。

540
00:38:35,150 --> 00:38:40,900
您可以携带您的计算机上的所有的桑德斯，去网上冲浪，任何你想要的，

541
00:38:40,900 --> 00:38:43,240
就像大家都知道和爱，

542
00:38:43,240 --> 00:38:46,030
和你永远不要插入任何东西。

543
00:38:46,030 --> 00:38:53,880
对于这项工作，我们有这方面的接收和传输。

544
00:38:53,880 --> 00:38:56,060
这真的是这样的对讲机。

545
00:38:56,060 --> 00:39:03,800
>> 这款无线路由器 - 桑德斯坐在下面这个阶段，就在这里 - 

546
00:39:03,800 --> 00:39:06,590
总是广播和接收，播放和接收，

547
00:39:06,590 --> 00:39:09,330
同样地，您的电脑都是这样做同样的事情，太。

548
00:39:09,330 --> 00:39:12,840
我们不能听到。

549
00:39:12,840 --> 00:39:17,900
其他的事情，你可以做的是，你可以拥有多台计算机

550
00:39:17,900 --> 00:39:22,200
谈论到相同的无线路由器。

551
00:39:22,200 --> 00:39:25,680
你是一个路由器 - 再次，这是一个无线电通信 - 

552
00:39:25,680 --> 00:39:30,320
越接近你，你的信号是更好的，更好的电脑“听到”路由器

553
00:39:30,320 --> 00:39:32,460
并可以与互联网通信。

554
00:39:32,460 --> 00:39:39,520
如果你们是永远在你的宿舍里，在你的房子，你想知道为什么你的信号很糟糕，

555
00:39:39,520 --> 00:39:42,230
它可能是因为：a）。你不是很接近你的路由器，或

556
00:39:42,230 --> 00:39:46,930
b）所示。像一堵水泥墙或东西，有什么东西在你和你的路由器之间

557
00:39:46,930 --> 00:39:50,720
不会让这些无线电波通过。

558
00:39:50,720 --> 00:39:57,850
>> 让我们来谈谈有点像Wi-Fi为什么坏人。

559
00:39:57,850 --> 00:40:02,980
坏人爱的wi-fi的几个原因。

560
00:40:02,980 --> 00:40:06,670
下面是我们讨厌的坏家伙就在那里。

561
00:40:06,670 --> 00:40:10,660
原因之一，这个坏家伙爱的Wi-Fi

562
00:40:10,660 --> 00:40:18,770
是因为，在默认情况下，很多的无线路由器来，当你设置它们，

563
00:40:18,770 --> 00:40:20,950
他们是不加密的。

564
00:40:20,950 --> 00:40:23,970
这一直是一个问题，已经有实例 - 

565
00:40:23,970 --> 00:40:28,210
多个实例，现在 - 坏人了别人的房子，

566
00:40:28,210 --> 00:40:32,630
通知有未加密的Wi-Fi来，他们可以连接。

567
00:40:32,630 --> 00:40:37,350
它们连接到的Wi-Fi，然后他们开始下载各种有趣的东西。

568
00:40:37,350 --> 00:40:40,890
他们不是下载的小猫，他们不下载的小狗。

569
00:40:40,890 --> 00:40:44,610
这是BitTorrent这样的。这是最令人头疼的讨厌的。

570
00:40:44,610 --> 00:40:48,740
有情况下，FBI甚至走上

571
00:40:48,740 --> 00:40:52,390
认为谁拥有房子的人实际上是一个

572
00:40:52,390 --> 00:40:56,090
去那里下载东西，他们真的不应该。

573
00:40:56,090 --> 00:41:00,730
在未加密的Wi-Fi绝对不是你想要做的事情，

574
00:41:00,730 --> 00:41:06,340
如果没有FBI来敲你的门。

575
00:41:06,340 --> 00:41:09,910
>> 另一个原因，坏人爱的Wi-Fi

576
00:41:09,910 --> 00:41:13,870
的原因是，大卫前面谈到的突破。

577
00:41:13,870 --> 00:41:17,240
因为它是一个无线电通信为核心，

578
00:41:17,240 --> 00:41:22,460
如果你知道的通道，您可以收听到该电台。

579
00:41:22,460 --> 00:41:31,870
例如，如果有一个坏右，坐在中间偏右的接入点，

580
00:41:31,870 --> 00:41:36,830
旁边的无线路由器，坏家伙可以监听所有无线流量的

581
00:41:36,830 --> 00:41:40,240
从所有这些计算机。

582
00:41:40,240 --> 00:41:44,590
事实上，这些家伙 - 这些幸运的少数人在前排 - 

583
00:41:44,590 --> 00:41:47,610
因为他们是超级接近所有这些无线路由器

584
00:41:47,610 --> 00:41:49,950
，坐在舞台正下方，

585
00:41:49,950 --> 00:41:53,780
他们将在这整个房间能听到大家的交通

586
00:41:53,780 --> 00:41:59,480
如果你连接到Wi-Fi，开始浏览这些接入点。

587
00:41:59,480 --> 00:42:03,740
这是不是很辛苦，坐自己在一个很好的位置，嗅，并找出

588
00:42:03,740 --> 00:42:07,030
其他人在做什么。

589
00:42:07,030 --> 00:42:10,830
这件事情要记住的，特别是如果你不知道在哪里的接入点是，

590
00:42:10,830 --> 00:42:15,010
您正在浏览的说法，在星巴克。

591
00:42:15,010 --> 00:42:17,360
>> 事实证明，嗅和所有的

592
00:42:17,360 --> 00:42:19,440
是不是真的很难做到。

593
00:42:19,440 --> 00:42:25,430
有一个节目叫做tcpdump的各种TCP流量转储

594
00:42:25,430 --> 00:42:29,910
，你可以运行它非常简单 - 就像今天早上我这样做。

595
00:42:29,910 --> 00:42:32,810
这里的一点点一倾，这里是一些过来的交通

596
00:42:32,810 --> 00:42:34,960
我的网络的时间。

597
00:42:34,960 --> 00:42:41,500
你可以看到 - 如果你眯着眼睛真的很难 - 在那里，有一点点的Spotify。

598
00:42:41,500 --> 00:42:44,050
除tcpdump的 - 因为这是一个痛苦的使用 - 

599
00:42:44,050 --> 00:42:48,860
有一个叫做Wireshark的捆绑了这一切，一个漂亮的GUI程序。

600
00:42:48,860 --> 00:42:51,970
Wireshark是超级方便，所以，如果你采取网络类，

601
00:42:51,970 --> 00:42:56,780
这是一个工具，你会来爱，因为它可以帮助你剖析的所有数据包

602
00:42:56,780 --> 00:42:59,400
那些漂浮在那里。

603
00:42:59,400 --> 00:43:01,810
但是，它也可以被用于坏。

604
00:43:01,810 --> 00:43:05,810
这很简单，只要下载这个程序，启动它，

605
00:43:05,810 --> 00:43:09,300
启动网络捕获，看到的一切是怎么回事 - 

606
00:43:09,300 --> 00:43:14,130
过滤器和做各种有趣的东西。

607
00:43:14,130 --> 00:43:17,930
>> 其他的事情，你可以做无线通信

608
00:43:17,930 --> 00:43:25,380
不仅是你可以窃听，但你也可以学习如何与网络螺丝

609
00:43:25,380 --> 00:43:31,020
并注入自己的信息来控制的经验，其他人

610
00:43:31,020 --> 00:43:35,140
在同一个无线网络是越来越强。

611
00:43:35,140 --> 00:43:37,140
让我们来看看在那。

612
00:43:37,140 --> 00:43:40,700
下面是Firesheep  - 我们知道，从上周的爱 - 

613
00:43:40,700 --> 00:43:43,590
这是窃听技术。

614
00:43:43,590 --> 00:43:50,360
例如，如果我们想积极的坏家伙去和周围的混乱

615
00:43:50,360 --> 00:43:52,690
这些计算机之一，

616
00:43:52,690 --> 00:43:58,380
在这种情况下，我们已经尝试去浏览到harvard.edu的买了台电脑。

617
00:43:58,380 --> 00:44:04,690
什么情况是，先在电脑发送一个消息到无线路由器，并说，

618
00:44:04,690 --> 00:44:07,920
嘿，我想去访问www.harvard.edu。

619
00:44:07,920 --> 00:44:10,610
比如说，本周末，他们正试图获得有关游戏的一些原因。

620
00:44:10,610 --> 00:44:14,940
坏家伙，因为他是坐在中间，

621
00:44:14,940 --> 00:44:18,730
该接入点旁边，可以看到通信的计算机

622
00:44:18,730 --> 00:44:26,170
到路由器中，他知道，“啊哈！有人会的harvard.edu。” （邪恶地笑）

623
00:44:26,170 --> 00:44:33,870
还有的将是此等待时间，而从路由器通信

624
00:44:33,870 --> 00:44:37,780
互联网去寻找网页harvard.edu  - 

625
00:44:37,780 --> 00:44:42,020
就像你们都知道在做PHP的pset  - 

626
00:44:42,020 --> 00:44:45,680
这样的坏家伙有一点点时间，一点点的窗口，

627
00:44:45,680 --> 00:44:49,410
他可以响应一些东西。

628
00:44:49,410 --> 00:44:53,660
>> 比方说，这个坏家伙，当然，是一个Yaley的。

629
00:44:53,660 --> 00:44:59,990
他响应harvardsucks.org。嘘！

630
00:44:59,990 --> 00:45:02,300
坏，坏家伙！坏Yaley！

631
00:45:02,300 --> 00:45:06,020
甚至更糟糕的是，他可能回应。 [http://youtu.be/ZSBq8geuJk0]。

632
00:45:06,020 --> 00:45:09,530
我将让你们弄清楚那是什么。

633
00:45:09,530 --> 00:45:14,840
这实际上是一个称为Airpwn的技术！这是开张了

634
00:45:14,840 --> 00:45:18,950
的安全会议上几年。

635
00:45:18,950 --> 00:45:25,190
随着Airpwn！你能够真正注入到网络流量。

636
00:45:25,190 --> 00:45:30,060
计算机试图走出去到互联网，并试图去

637
00:45:30,060 --> 00:45:33,090
Google.com，Facebook.com，harvard.edu

638
00:45:33,090 --> 00:45:39,190
看到进来的恶意响应，并立即承担，好吧，

639
00:45:39,190 --> 00:45:43,550
的响应，我在等待，并最终获得内容

640
00:45:43,550 --> 00:45:48,860
harvardsucks.org或nameyourfavoriteshocksite.com

641
00:45:48,860 --> 00:45:55,270
你可以看到事情会恶化的速度有多快。

642
00:45:55,270 --> 00:46:00,190
>> 所有这些事情不能做

643
00:46:00,190 --> 00:46:05,870
这些有线连接，因为有线连接

644
00:46:05,870 --> 00:46:08,710
这是很难窥探到交通。

645
00:46:08,710 --> 00:46:13,020
如果我是个坏家伙，一端是您的计算机

646
00:46:13,020 --> 00:46:14,460
的另一端是你的路由器 - 调制解调器 - 

647
00:46:14,460 --> 00:46:20,180
只有这样我才能得到之间，连接到我的电脑实际上拼接

648
00:46:20,180 --> 00:46:22,180
在中间的某个地方

649
00:46:22,180 --> 00:46:26,820
或做其他事，一些下游的路由器。

650
00:46:26,820 --> 00:46:33,360
但是，随着无线，也可以是那么容易，因为坐在一个教室的前排，

651
00:46:33,360 --> 00:46:38,200
你可以做各种讨厌的东西在后面的人。

652
00:46:38,200 --> 00:46:41,570
>> 让我们来谈谈你会如何抵御一些事情。

653
00:46:41,570 --> 00:46:46,860
人谁开发的无线标准 -  802.11  - 

654
00:46:46,860 --> 00:46:50,820
他们没有任何想象力的愚蠢的人。

655
00:46:50,820 --> 00:46:56,110
这是很酷的技术，当它首次亮相于1999年，

656
00:46:56,110 --> 00:47:00,780
他们来到了这个标准称为WEP。

657
00:47:00,780 --> 00:47:03,360
您可以在这里看到，当您尝试加入一个无线网络，

658
00:47:03,360 --> 00:47:07,450
你有各种不同的安全选项。

659
00:47:07,450 --> 00:47:11,800
这是一种痛苦，因为有6个一起

660
00:47:11,800 --> 00:47:14,790
它从来就没有真正意义上的加入。

661
00:47:14,790 --> 00:47:19,190
这是第1的顶部，他们来到了被称为WEP是第一位的。

662
00:47:19,190 --> 00:47:27,960
WEP有线等效保密代表，我相信，

663
00:47:27,960 --> 00:47:31,730
无线加密协议是一种常见的用词不当。

664
00:47:31,730 --> 00:47:36,170
因为它试图给你的隐私的当量和安全保护

665
00:47:36,170 --> 00:47:40,590
相当于一个有线网络的

666
00:47:40,590 --> 00:47:46,710
随着WEP的最终结果是什么，

667
00:47:46,710 --> 00:47:52,300
你有一个简单的，小的，你输入的密码和加密

668
00:47:52,300 --> 00:47:56,210
您的计算机和路由器之间的通信。

669
00:47:56,210 --> 00:47:58,210
>> 但与WEP有什么问题？

670
00:47:58,210 --> 00:48:01,470
与WEP的密码是非常短的，

671
00:48:01,470 --> 00:48:04,900
，也是每个人都使用完全相同的密码，

672
00:48:04,900 --> 00:48:07,610
 所以它真的很容易解密。

673
00:48:07,610 --> 00:48:10,580
因此，速度非常快人想出了，WEP一个问题，

674
00:48:10,580 --> 00:48:16,100
唯一的原因，你看到了这个小家伙仍然是 - 

675
00:48:16,100 --> 00:48:18,890
有一些老的系统，不使用WEP  - 

676
00:48:18,890 --> 00:48:25,710
你应该寻找的WPA甚至WPA2标准

677
00:48:25,710 --> 00:48:29,130
，后来被释放。

678
00:48:29,130 --> 00:48:35,040
这些系统是一个更好的去保护无线上网。

679
00:48:35,040 --> 00:48:41,090
这就是说，他们还是有一定的可编程性。

680
00:48:41,090 --> 00:48:44,010
有工具，有可以做到这一点。

681
00:48:44,010 --> 00:48:47,490
特别是可以很讨厌的一件事是，

682
00:48:47,490 --> 00:48:55,370
如果你连接到无线路由器的身份验证，并使用某种形式的

683
00:48:55,370 --> 00:49:00,940
加密通信，事实证明，这样黑客就可以很容易地发送一个数据包

684
00:49:00,940 --> 00:49:03,990
你的路由器断开，

685
00:49:03,990 --> 00:49:07,220
后，他们已经断开然后，他们可以听 - 

686
00:49:07,220 --> 00:49:11,800
您尝试重新建立连接与您的路由器，它们能嗅出这些数据包。

687
00:49:11,800 --> 00:49:16,800
利用这些信息，他们就可以去和解密你的通信。

688
00:49:16,800 --> 00:49:24,580
这是不以任何方式任何形式的安全超出了所有人的想象。

689
00:49:24,580 --> 00:49:30,060
>> 其他的事情你可以做，当你设置无线网络

690
00:49:30,060 --> 00:49:35,460
或者你加入他们的是 - 你注意，在这里，当我加入这个网络，

691
00:49:35,460 --> 00:49:37,640
它要求我的网络的名称。

692
00:49:37,640 --> 00:49:41,060
这也被称为作为SSID。

693
00:49:41,060 --> 00:49:48,610
你在这里看到的权利，我有一个框，显示我使用的SSID。

694
00:49:48,610 --> 00:49:52,690
有哈佛大学，CS50和CS50员工网络。

695
00:49:52,690 --> 00:49:59,180
现在，你们有多少人知道，有一个的CS50员工网络周围？

696
00:49:59,180 --> 00:50:01,910
你们中的一些。并非所有的你。

697
00:50:01,910 --> 00:50:08,800
的问题，当然，如果我们不把这个在我们的SSID列表，

698
00:50:08,800 --> 00:50:10,930
没有人会知道它最有可能。

699
00:50:10,930 --> 00:50:16,090
我的希望。除非你们都试图破解我们的无线。

700
00:50:16,090 --> 00:50:18,700
但是，这是你能做到这一点是非常重要的，当你设置了

701
00:50:18,700 --> 00:50:20,280
一个路由器在家里。

702
00:50:20,280 --> 00:50:22,820
这可能不会发生了几年了很多你，

703
00:50:22,820 --> 00:50:29,010
但千万记住，保持该SSID那里，而不是将其命名为

704
00:50:29,010 --> 00:50:34,630
超级共同的东西将有助于让您更安全的长远。

705
00:50:34,630 --> 00:50:38,070
>> 最后一个夫妇的事情你可以做的。一个是HTTPS。

706
00:50:38,070 --> 00:50:44,760
如果你在星巴克，如果你是在公共Wi-Fi

707
00:50:44,760 --> 00:50:52,620
你决定访问您的银行帐户，访问您的Gmail，你的Facebook，

708
00:50:52,620 --> 00:50:56,140
确保这些连接通过HTTPS。

709
00:50:56,140 --> 00:50:59,800
这是一个额外的安全层，加层加密。

710
00:50:59,800 --> 00:51:01,520
有一件事要记住的是，

711
00:51:01,520 --> 00:51:04,740
你们有多少人曾经通过点击那个又大又红的屏幕，上面写着，

712
00:51:04,740 --> 00:51:07,480
“这个网站可能是坏的。”

713
00:51:07,480 --> 00:51:09,710
我知道我有。

714
00:51:09,710 --> 00:51:13,090
这也可能是，当你浏览去看看国土或类似的东西，对不对？

715
00:51:13,090 --> 00:51:19,900
是啊。 （观众笑）是啊。你去那里。我们知道谁在观看国土。

716
00:51:19,900 --> 00:51:24,540
那又大又红的屏幕右下角有

717
00:51:24,540 --> 00:51:28,600
往往预示着一些时髦是怎么回事。

718
00:51:28,600 --> 00:51:32,530
有时，它只是网站本身是不安全的，

719
00:51:32,530 --> 00:51:35,520
但同样的，红色的大屏幕上出现时，人们正试图

720
00:51:35,520 --> 00:51:37,520
安装网络攻击。

721
00:51:37,520 --> 00:51:40,220
所以，如果你看到了，红色的大屏幕在星巴克，

722
00:51:40,220 --> 00:51:42,440
不会通过点击它。

723
00:51:42,440 --> 00:51:45,350
坏消息。坏消息熊。

724
00:51:45,350 --> 00:51:51,490
>> 最后一点，你可以看一下

725
00:51:51,490 --> 00:51:54,120
是某种形式的VPN。

726
00:51:54,120 --> 00:52:00,280
VPN可通过哈佛 -  vpn.fas.harvard.edu  - 

727
00:52:00,280 --> 00:52:03,260
这是什么做的是建立一个安全的连接

728
00:52:03,260 --> 00:52:06,460
你和哈佛之间，漏斗，通过它，你的流量

729
00:52:06,460 --> 00:52:12,160
这样，如果你正坐在一家星巴克这样的地方

730
00:52:12,160 --> 00:52:19,030
您可以连接到哈佛，交通，安全，然后从哈佛大学浏览。

731
00:52:19,030 --> 00:52:21,950
同样，并非万无一失。人们可以在中间。

732
00:52:21,950 --> 00:52:25,850
他们可以开始打破它，而不是依赖的安全性，这是更为安全

733
00:52:25,850 --> 00:52:28,620
在Wi-Fi单独。

734
00:52:28,620 --> 00:52:32,570
>> 好的。总之，

735
00:52:32,570 --> 00:52:34,580
当你设置的无线网络，

736
00:52:34,580 --> 00:52:37,250
当你走出去，在公共场所使用无线 - 

737
00:52:37,250 --> 00:52:43,430
无论是星巴克，无论是五个人，无论是B.Good，

738
00:52:43,430 --> 00:52:46,440
类似的东西 - 无论他们有Wi-Fi  - 

739
00:52:46,440 --> 00:52:48,440
要知道你周围的环境。

740
00:52:48,440 --> 00:52:50,440
要知道，什么人都可以做。

741
00:52:50,440 --> 00:52:53,890
并且是安全的。不要访问您的银行帐户。

742
00:52:53,890 --> 00:52:58,740
这可能是一个粗鲁的觉醒，如果有人显示了你的密码。

743
00:52:58,740 --> 00:53:05,480
，深红色！我要扭转乾坤大卫最后一个字。

744
00:53:05,480 --> 00:53:11,270
（掌声）

745
00:53:11,270 --> 00:53:14,360
>> [大卫]我想从个人的经验，我会分享一件事。

746
00:53:14,360 --> 00:53:19,940
你可能喜欢玩的 - 尽管苹果已经在很大程度上根除这个问题的工具

747
00:53:19,940 --> 00:53:22,710
如果您更新您的软件，因为 - 

748
00:53:22,710 --> 00:53:26,670
但为此而没有真正能够信任的软件，我们使用，

749
00:53:26,670 --> 00:53:33,270
和Nate的点，能嗅出了相当多的其他人在做什么

750
00:53:33,270 --> 00:53:37,010
 - 这是一个软件，现在是大约一年和半前。

751
00:53:37,010 --> 00:53:39,010
[iPhoneTracker] [http://petewarden.github.com/iPhoneTracker/]

752
00:53:39,010 --> 00:53:41,010
一段时间以来，iTunes的 - 之前的iCloud，当你被同步您的iPod或您的iPhone或

753
00:53:41,010 --> 00:53:45,570
与iTunes或你的ipad公司 - 中备份的利益，

754
00:53:45,570 --> 00:53:48,340
你的iPhone和其他设备已经做了一段时间

755
00:53:48,340 --> 00:53:50,340
利用GPS数据。

756
00:53:50,340 --> 00:53:52,710
>> 你们都知道也许你的iPhone和Android的Windows Mobile手机

757
00:53:52,710 --> 00:53:55,410
和这样的日子可以跟踪你是在显示你的地图的利益

758
00:53:55,410 --> 00:53:59,440
和类似 - 苹果和其他公司做什么

759
00:53:59,440 --> 00:54:02,650
他们通常跟踪几乎无处不在，你的利益，实际上已在

760
00:54:02,650 --> 00:54:05,380
提高服务质量。

761
00:54:05,380 --> 00:54:07,170
一，你可以得到更有针对性的广告和喜欢，

762
00:54:07,170 --> 00:54:10,740
但有两个，他们也可以找出哪里有无线热点，在世界上，

763
00:54:10,740 --> 00:54:14,780
这可以帮助与地理定位 - 三角测量人的位置排序。

764
00:54:14,780 --> 00:54:18,520
>> 长话短说，我们所有的人已经走的天线一定量的时间。

765
00:54:18,520 --> 00:54:22,180
不幸的是，苹果已经作出设计决策 - 或缺少 - 

766
00:54:22,180 --> 00:54:26,590
不加密信息，当它被备份到iTunes。

767
00:54:26,590 --> 00:54:30,330
什么样的安全研究人员发现的是，这是一个巨大的XML文件 - 

768
00:54:30,330 --> 00:54:33,810
一个巨大的文本文件 - 坐在人们的iTunes软件，

769
00:54:33,810 --> 00:54:35,400
如果你只是有点好奇，

770
00:54:35,400 --> 00:54:38,990
你可以去打探你的配偶的历史，你的​​室友的历史，

771
00:54:38,990 --> 00:54:41,050
你的兄弟姐妹的历史等，

772
00:54:41,050 --> 00:54:44,590
由于一些免费的软件，你可以绘制所有的这些GPS坐标 - 

773
00:54:44,590 --> 00:54:46,590
经度和纬度。

774
00:54:46,590 --> 00:54:48,590
>> 所以，其实我这样做，我自己的手机。

775
00:54:48,590 --> 00:54:51,210
我插在我的手机，果然，我的版本的iTunes未加密的时候，

776
00:54:51,210 --> 00:54:53,900
我能看到的是我自己的模式。

777
00:54:53,900 --> 00:54:56,970
下面是美国和每一个的这些蓝色圆圈代表

778
00:54:56,970 --> 00:55:01,670
我碰巧已经超过那些拥有这种特殊的电话的前几个月。

779
00:55:01,670 --> 00:55:04,940
 我花了很多的时间，当然，在东北，在美国加州的一点点时间，

780
00:55:04,940 --> 00:55:08,690
得克萨斯州的一个短命的行，如果你再放大，在此 - 

781
00:55:08,690 --> 00:55:11,120
这是所有种类的罚款和有趣的，但我知道这一点。

782
00:55:11,120 --> 00:55:13,890
我的许多朋友都知道这一点，但如果你在更深的潜水，

783
00:55:13,890 --> 00:55:17,090
你看，我花了我大部分时间在东北。

784
00:55:17,090 --> 00:55:20,330
如果抓住一些熟悉的前瞻性城镇 - 

785
00:55:20,330 --> 00:55:24,670
这个大的，蓝色的墨水污点基本上是集中在波士顿，

786
00:55:24,670 --> 00:55:29,510
然后我花了一点时间在从波士顿郊区辐射。

787
00:55:29,510 --> 00:55:32,780
但我也做了相当多的咨询服务，一年。

788
00:55:32,780 --> 00:55:36,090
今年是东部沿海地区，实际上，你可以看到我

789
00:55:36,090 --> 00:55:41,920
我在我的口袋里的iPhone在波士顿和纽约之间来回行驶

790
00:55:41,920 --> 00:55:47,510
和费城的进一步下降，以及花费一点点的休假时间

791
00:55:47,510 --> 00:55:50,340
在开普敦，这是小胳膊有。

792
00:55:50,340 --> 00:55:53,030
因此，每一个这些点代表我已经有一些地方，

793
00:55:53,030 --> 00:55:56,970
我完全不知道的是，这整个历史只是坐在那里，

794
00:55:56,970 --> 00:55:58,410
在我的桌面计算机上。

795
00:55:58,410 --> 00:56:00,470
如果你缩小 - 这其实是一个小麻烦的。

796
00:56:00,470 --> 00:56:04,190
我不记得曾在宾夕法尼亚州，尤其是今年。

797
00:56:04,190 --> 00:56:07,840
但我虽然有点困难，我想通了，哦，这是事实，旅

798
00:56:07,840 --> 00:56:11,160
果然，我的手机已经抓住了我。

799
00:56:11,160 --> 00:56:14,180
>> 苹果自加密信息，

800
00:56:14,180 --> 00:56:17,380
然而，这也仅仅是证明关于我们多少信息被收集，

801
00:56:17,380 --> 00:56:20,850
以及如何轻松 - 或好或坏 - 这是可以接受的。

802
00:56:20,850 --> 00:56:23,340
其中一个外卖希望从Rob的谈话，从Nate的谈话

803
00:56:23,340 --> 00:56:27,370
今天这个样子是小的视觉效果，更认识到这一点

804
00:56:27,370 --> 00:56:31,160
所以，即使 - 罗布的点 - 走，排序完蛋了，对不对？

805
00:56:31,160 --> 00:56:33,920
有没有什么我们可以做的，当涉及到其中的一些威胁，

806
00:56:33,920 --> 00:56:37,130
但在一天结束的时候，我们要相信某事或某人

807
00:56:37,130 --> 00:56:38,510
如果我们想使用这些技术。

808
00:56:38,510 --> 00:56:43,150
至少，我们可以做出明智的决策和计算决定是否

809
00:56:43,150 --> 00:56:46,390
实际上，我们应该检查这个特别敏感的帐户

810
00:56:46,390 --> 00:56:49,330
实际上，我们应该发出那略带怀疑的即时消息

811
00:56:49,330 --> 00:56:52,180
 在这样一个Wi-Fi环境。

812
00:56:52,180 --> 00:56:54,990
>> 因此，随着中说，只有一次测验，一次讲座依然存在。

813
00:56:54,990 --> 00:56:57,740
我们会看到你在周三然后周一。

814
00:56:57,740 --> 00:57:02,100
（热烈的掌声和欢呼声）

815
00:57:02,100 --> 00:57:06,100
[CS50TV]