1
00:00:00,000 --> 00:00:13,000

2
00:00:13,000 --> 00:00:15,890
>> ROB BOWDEN：我是抢夺和
让我们开裂。

3
00:00:15,890 --> 00:00:19,390
所以请记住，从PSET规范
我们要需要使用

4
00:00:19,390 --> 00:00:20,890
crypt函数。

5
00:00:20,890 --> 00:00:26,330
对于该男子页面，我们有两个
哈希定义_xopensource。

6
00:00:26,330 --> 00:00:28,290
不要担心，为什么
我们需要做的。

7
00:00:28,290 --> 00:00:31,550
哈希包括unistd.h中。

8
00:00:31,550 --> 00:00:35,920
>> 所以一旦出的方式，让
得到的实际方案。

9
00:00:35,920 --> 00:00:39,570
我们需要做的第一件事是确保
用户输入一个有效的加密

10
00:00:39,570 --> 00:00:41,520
在命令行中的密码。

11
00:00:41,520 --> 00:00:46,050
请记住，该方案应该
运行像点斜线裂缝，

12
00:00:46,050 --> 00:00:48,120
然后加密的字符串。

13
00:00:48,120 --> 00:00:52,990
>> 所以，我们在这里检查，以确保
ARGC如果我们想

14
00:00:52,990 --> 00:00:54,380
继续与程序。

15
00:00:54,380 --> 00:00:58,830
如果argc是不是两个，这意味着
用户没有输入加密

16
00:00:58,830 --> 00:01:02,560
在命令行中的密码，或者他们
进入不仅仅是加密

17
00:01:02,560 --> 00:01:05,379
在命令行中的密码，其中
情况下，我们不知道做什么用的

18
00:01:05,379 --> 00:01:07,660
命令行参数。

19
00:01:07,660 --> 00:01:11,390
>> 因此，如果ARGC是两个，我们可以继续进行。

20
00:01:11,390 --> 00:01:14,160
而在这里，我们要申报
一个可变的加密。

21
00:01:14,160 --> 00:01:17,650
只是将原来的别名
argv1使整个

22
00:01:17,650 --> 00:01:20,690
程序，我们不必叫它argv1，
然后你必须要考虑

23
00:01:20,690 --> 00:01:22,950
关于这实际上意味着。

24
00:01:22,950 --> 00:01:27,180
>> 所以最后，我们想要验证
的加密的密码的用户

25
00:01:27,180 --> 00:01:30,840
进入实际上已经
加密的密码。

26
00:01:30,840 --> 00:01:35,120
每地穴的手册页，
加密后的密码必须是13

27
00:01:35,120 --> 00:01:36,440
字符长。

28
00:01:36,440 --> 00:01:41,500
在这里，注意到我们哈希定义
加密长度为13。

29
00:01:41,500 --> 00:01:46,140
所以我们要做的仅仅是确保
字符串长度的加密

30
00:01:46,140 --> 00:01:49,090
密码是13。

31
00:01:49,090 --> 00:01:52,280
>> 而且，如果它不是，我们希望
退出程序。

32
00:01:52,280 --> 00:01:56,470
所以一旦出的方式，我们可以
现在实际上是试图找到什么

33
00:01:56,470 --> 00:02:00,410
加密后的密码了
密码。

34
00:02:00,410 --> 00:02:04,870
在这里，我们要抢盐
从加密的密码。

35
00:02:04,870 --> 00:02:08,930
记住，每手册页
前两个字符加密

36
00:02:08,930 --> 00:02:10,590
字符串，喜欢这里 - 

37
00:02:10,590 --> 00:02:12,770
50ZPJ等等 - 

38
00:02:12,770 --> 00:02:16,170
前两个字符给
我们所使用的盐

39
00:02:16,170 --> 00:02:18,080
在隐窝功能。

40
00:02:18,080 --> 00:02:21,740
>> 而在这里，我们看到，盐公顷。

41
00:02:21,740 --> 00:02:27,610
所以，我们要复制前两个
字符，盐长度哈希

42
00:02:27,610 --> 00:02:30,230
定义为两个。

43
00:02:30,230 --> 00:02:35,970
我们要复制前两个字符
到这个数组，盐。

44
00:02:35,970 --> 00:02:39,340
请注意，我们需要盐长度加上
一，因为我们仍然需要一个空

45
00:02:39,340 --> 00:02:42,440
终结者结束时，我们的盐。

46
00:02:42,440 --> 00:02:46,940
>> 然后我们要宣布这个数组，
客人，尺寸最大长度加

47
00:02:46,940 --> 00:02:51,930
1，最大长度为哈希定义
八，因为最大的密码

48
00:02:51,930 --> 00:02:55,090
是8个字符长。

49
00:02:55,090 --> 00:02:59,860
我们要使用这个迭代
在所有可能的字符串，可以

50
00:02:59,860 --> 00:03:01,430
有效的密码。

51
00:03:01,430 --> 00:03:07,720
因此，如果有效的密码中的字符
只是一个，B，和c，然后

52
00:03:07,720 --> 00:03:14,970
我们会遍历A，B，C，
AA，BA，CA，依此类推，直到

53
00:03:14,970 --> 00:03:16,690
我们能看到CCCCCCCC  - 

54
00:03:16,690 --> 00:03:19,600
8个C。

55
00:03:19,600 --> 00:03:23,620
>> 如果我们没有向下有效
密码，然后我们需要说

56
00:03:23,620 --> 00:03:26,590
加密后的字符串是不
有效的开始。

57
00:03:26,590 --> 00:03:29,970
所以，现在，我们达到这个而1环。

58
00:03:29,970 --> 00:03:33,100
请注意，这意味着它的
一个无限循环。

59
00:03:33,100 --> 00:03:36,430
>> 注意有没有break语句
里面的这个无限循环。

60
00:03:36,430 --> 00:03:38,570
只有return语句。

61
00:03:38,570 --> 00:03:41,210
所以，我们从来没有真正期望
退出循环。

62
00:03:41,210 --> 00:03:44,750
我们只希望退出程序。

63
00:03:44,750 --> 00:03:48,220
我已经添加print语句
这个循环的顶部刚刚打印出来

64
00:03:48,220 --> 00:03:51,790
我们目前的猜测
密码是什么。

65
00:03:51,790 --> 00:03:53,630
>> 现在，这个循环做？

66
00:03:53,630 --> 00:03:58,330
它遍历所有可能的字符串
这可能是有效的密码。

67
00:03:58,330 --> 00:04:02,700
我们要做的第一件事是
我们目前的猜测是什么

68
00:04:02,700 --> 00:04:03,920
密码是。

69
00:04:03,920 --> 00:04:07,230
我们将采取的盐，我们抓住
加密后的字符串，我们很

70
00:04:07,230 --> 00:04:09,850
要加密的猜测。

71
00:04:09,850 --> 00:04:14,760
这将给我们一个加密的猜测，
我们要比较

72
00:04:14,760 --> 00:04:18,810
加密后的字符串，用户
在命令行中输入。

73
00:04:18,810 --> 00:04:23,030
>> 如果它们是相同的，在这种情况下，
字符串比较将返回0，如果

74
00:04:23,030 --> 00:04:28,050
它们是相同的，那么猜
生成的加密的密码

75
00:04:28,050 --> 00:04:33,520
字符串，在这种情况下，我们可以打印
作为我们的密码和回报。

76
00:04:33,520 --> 00:04:37,520
但是，如果他们不一样的，那
意味着我们的猜测是不正确的。

77
00:04:37,520 --> 00:04:43,250
>> 我们想要遍历
下一个有效的猜测。

78
00:04:43,250 --> 00:04:46,410
所以，这就是这一段时间
循环正在尝试做的。

79
00:04:46,410 --> 00:04:51,760
这将重申我们的猜测
到下一个有效的猜测。

80
00:04:51,760 --> 00:04:56,080
请注意，当我们说一个
我们的猜测有特定字符

81
00:04:56,080 --> 00:05:01,770
达到的最大象​​征，在这里
哈希定义为一个波浪线，因为

82
00:05:01,770 --> 00:05:05,710
这是最大的ASCII值字符
用户可以输入上面的

83
00:05:05,710 --> 00:05:11,210
键盘，当字符到达
最大的象征，那么，我们要发送

84
00:05:11,210 --> 00:05:17,150
它备份的最小的符号，这
是一个空间，又是最低的ASCII码

85
00:05:17,150 --> 00:05:20,800
价值符号让用户能够
从键盘输入。

86
00:05:20,800 --> 00:05:22,940
>> 因此，我们要集
的最小的符号。

87
00:05:22,940 --> 00:05:25,720
然后，我们会去
到下一个字符。

88
00:05:25,720 --> 00:05:28,730
那么，如何是我们的猜测
要重复？

89
00:05:28,730 --> 00:05:33,685
好吧，如果有效的字符是A，B，
和c，那么我们就开始用，

90
00:05:33,685 --> 00:05:36,630
它会遍历到B，它会
遍历到c。

91
00:05:36,630 --> 00:05:44,360
c是我们最大的象征，因此，我们将设置
C回，最低的象征。

92
00:05:44,360 --> 00:05:48,100
然后我们会遍历索引
到下一个字符。

93
00:05:48,100 --> 00:05:53,920
>> 因此，如果最初的猜测是c时，下一个
字符将是空

94
00:05:53,920 --> 00:05:55,560
终止符。

95
00:05:55,560 --> 00:06:00,670
这里，请注意，如果该字符
我们现在要

96
00:06:00,670 --> 00:06:04,690
增量是空终止，
然后我们将它设置为

97
00:06:04,690 --> 00:06:06,260
最小的象征。

98
00:06:06,260 --> 00:06:11,431
因此，如果猜测是C，那么，我们的
新的猜测将是一个。

99
00:06:11,431 --> 00:06:16,050
而且，如果我们原来的猜测
CCCC，那么我们的新猜测

100
00:06:16,050 --> 00:06:18,380
将是AAAAA。

101
00:06:18,380 --> 00:06:24,430
>> 因此，每当我们达到最大的字符串
给定长度，那么我们

102
00:06:24,430 --> 00:06:29,090
要实现的最小字符串
下一个的长度，这将

103
00:06:29,090 --> 00:06:34,420
只是所有字符
最低的象征。

104
00:06:34,420 --> 00:06:36,970
现在，这个检查在这里干什么？

105
00:06:36,970 --> 00:06:42,780
好吧，如果指数从第八
字符至9个字符 - 

106
00:06:42,780 --> 00:06:46,460
所以我们加8个C的
我们之前的猜测 - 

107
00:06:46,460 --> 00:06:51,270
那么指数将会把重点放在
最后空终结我们的猜测

108
00:06:51,270 --> 00:06:57,990
数组，它并不意味着实际上
用在我们的密码。

109
00:06:57,990 --> 00:07:03,530
>> 因此，如果我们集中在这最后的空
终结者，那么我们还没有找到一个

110
00:07:03,530 --> 00:07:07,750
有效使用的密码，只是八
字符，表示不存在

111
00:07:07,750 --> 00:07:10,550
有效的加密的密码
给定的字符串。

112
00:07:10,550 --> 00:07:13,520
我们必须要打印，称
我们无法找到一个有效的

113
00:07:13,520 --> 00:07:16,100
密码，然后返回。

114
00:07:16,100 --> 00:07:20,280
所以这个while循环迭代
在所有可能的字符串。

115
00:07:20,280 --> 00:07:24,640
>> 如果发现任何加密
预期加密的字符串，它会

116
00:07:24,640 --> 00:07:26,190
返回该密码。

117
00:07:26,190 --> 00:07:29,610
它并没有发现任何东西，然后
它将返回，印刷

118
00:07:29,610 --> 00:07:31,910
是不是能找到什么。

119
00:07:31,910 --> 00:07:39,220
现在，请注意，在所有迭代
可能的字符串可能会

120
00:07:39,220 --> 00:07:40,420
需要一段时间。

121
00:07:40,420 --> 00:07:43,590
让我们真正看到如何
长期需要。

122
00:07:43,590 --> 00:07:47,230
>> 让我们破解。

123
00:07:47,230 --> 00:07:51,050
嗯，哎呀呀 - 说未定义
参考地穴。

124
00:07:51,050 --> 00:07:55,330
所以请记住，对于p设置规范，
地穴的man页面，我们

125
00:07:55,330 --> 00:07:58,130
需要链接隐窝。

126
00:07:58,130 --> 00:08:01,130
现在，默认的命令
不知道你

127
00:08:01,130 --> 00:08:03,010
要使用该功能。

128
00:08:03,010 --> 00:08:09,680
>> 因此，让我们复制这个客户端命令
只需添加到年底

129
00:08:09,680 --> 00:08:13,300
连接地穴。

130
00:08:13,300 --> 00:08:14,820
现在，它编译。

131
00:08:14,820 --> 00:08:23,880
因此，让我们在一个给定的运行破解
加密后的字符串 - 

132
00:08:23,880 --> 00:08:25,130
所以撒的。

133
00:08:25,130 --> 00:08:28,690

134
00:08:28,690 --> 00:08:30,790
所以这是相当快的。

135
00:08:30,790 --> 00:08:33,230
>> 请注意，这13结束。

136
00:08:33,230 --> 00:08:38,240
那么，凯撒的加密密码
恰好是13。

137
00:08:38,240 --> 00:08:41,650
因此，让我们尝试其他密码。

138
00:08:41,650 --> 00:08:45,830
让我们赫塞豪恩的加密
密码和尝试开裂，。

139
00:08:45,830 --> 00:08:51,750

140
00:08:51,750 --> 00:08:55,110
>> 因此，我们注意到已经达到
三个字符。

141
00:08:55,110 --> 00:08:58,660
我们遍历所有可能
三个字符的字符串。

142
00:08:58,660 --> 00:09:01,420
这意味着我们已经完成
遍历所有可能的一个

143
00:09:01,420 --> 00:09:04,660
两个字符串。

144
00:09:04,660 --> 00:09:09,180
现在，它看起来像这样去
在我们到达之前，需要一段时间的

145
00:09:09,180 --> 00:09:10,580
四个字符的字符串。

146
00:09:10,580 --> 00:09:14,680
这可能需要一两分钟。

147
00:09:14,680 --> 00:09:16,055
>> 它没有采取一两分钟。

148
00:09:16,055 --> 00:09:18,450
我们四个字符的字符串。

149
00:09:18,450 --> 00:09:22,800
但是现在，我们需要遍历所有
可能四个字符的字符串，这

150
00:09:22,800 --> 00:09:26,000
也许可能需要10分钟。

151
00:09:26,000 --> 00:09:28,720
然后，当我们到达5个字符
字符串，我们需要遍历所有

152
00:09:28,720 --> 00:09:31,450
的那些，这可能
采取了几个小时。

153
00:09:31,450 --> 00:09:34,080
我们需要遍历所有可能的
六个字符的字符串，这

154
00:09:34,080 --> 00:09:36,560
可能需要几天等等。

155
00:09:36,560 --> 00:09:41,380
>> 因此，它可能需要很长的一个潜在的
遍历所有可能

156
00:09:41,380 --> 00:09:44,850
八字符和字符串较少。

157
00:09:44,850 --> 00:09:50,600
因此，注意到，这不一定是
非常有效的算法寻找

158
00:09:50,600 --> 00:09:51,860
输入密码。

159
00:09:51,860 --> 00:09:54,540
你可能会认为
是更好的方法。

160
00:09:54,540 --> 00:10:02,230
例如，密码ZYX！32AB
可能不是一个很常见的密码，

161
00:10:02,230 --> 00:10:06,440
而密码12345
可能很多较为常见。

162
00:10:06,440 --> 00:10:13,570
>> 所以试图找到一个密码的方法之一
更快速的只是看

163
00:10:13,570 --> 00:10:15,560
是比较常见的密码。

164
00:10:15,560 --> 00:10:20,480
因此，例如，我们可以尝试读单词
从一本字典，并尝试所有

165
00:10:20,480 --> 00:10:24,860
这些话作为我们的密码猜测。

166
00:10:24,860 --> 00:10:29,210
现在，也许一个密码
是不是很简单。

167
00:10:29,210 --> 00:10:32,600
用户也许有点聪明
并尝试附加一个数字

168
00:10:32,600 --> 00:10:34,220
一个字的结尾。

169
00:10:34,220 --> 00:10:37,000
>> 所以，也许他们的密码为password1。

170
00:10:37,000 --> 00:10:41,520
所以，你可以尝试遍历所有单词
字典中的一个

171
00:10:41,520 --> 00:10:43,210
追加到它的结束。

172
00:10:43,210 --> 00:10:47,360
后话，说不定这样做，你会
追加两到它的结束。

173
00:10:47,360 --> 00:10:50,240
>> 或者，也许用户甚至试图
更聪明，他们希望自己的

174
00:10:50,240 --> 00:10:54,980
密码是“黑客”，但他们
要更换电子商务的所有实例

175
00:10:54,980 --> 00:10:56,600
三分球。

176
00:10:56,600 --> 00:10:58,440
所以，你可以做到这一点。

177
00:10:58,440 --> 00:11:02,100
遍历所有单词在字典
但替换的字符

178
00:11:02,100 --> 00:11:04,790
这些数字看起来像数字。

179
00:11:04,790 --> 00:11:09,670
>> 所以这种方式，你可能会赶上什至更多
密码是很常见的。

180
00:11:09,670 --> 00:11:14,690
但最终，只有这样，你可以
捕获所有密码暴力破解

181
00:11:14,690 --> 00:11:17,340
迫使遍历所有
可能的字符串。

182
00:11:17,340 --> 00:11:22,100
所以在最后，你需要遍历
从一个字符的所有字符串

183
00:11:22,100 --> 00:11:28,110
八个字符，这可能需要
很长一段时间，但你需要做到这一点。

184
00:11:28,110 --> 00:11:30,024
>> 我叫罗布鲍登。

185
00:11:30,024 --> 00:11:31,425
这是破解。

186
00:11:31,425 --> 00:11:36,533