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