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
Склеп функции.

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
Один из них, где максимальная длина хэш определен
до восьми, так как максимальное пароль

48
00:02:51,930 --> 00:02:55,090
занимает восемь символов.

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
Так что, если допустимые символы в пароле
были просто A, B, и C, то

52
00:03:07,720 --> 00:03:14,970
мы бы перебрать, B, C,
AA, BA, CA, и так далее, до

53
00:03:14,970 --> 00:03:16,690
Мы увидим CCCCCCCC -

54
00:03:16,690 --> 00:03:19,600
восемь Си.

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
>> Обратите внимание, нет перерыва заявление
внутри этого бесконечного цикла.

60
00:03:36,430 --> 00:03:38,570
Там только вернуть отчетности.

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
Я добавил эту печать заявление
верхней части этого цикла просто распечатать

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
Это даст нам зашифрованное Guess,
которые мы собираемся для сравнения

72
00:04:14,760 --> 00:04:18,810
зашифрованной строки, которые пользователь
ввести в командную строку.

73
00:04:18,810 --> 00:04:23,030
>> Если они одинаковы, и в этом случае
Строка сопоставимых вернет ноль, если

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
достигли символом Max, которая здесь
является хэш определяется как тильды, так как

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,
и С, то, если мы начали с,

90
00:05:33,685 --> 00:05:36,630
это будет итерации б, это будет
итерации к с.

91
00:05:36,630 --> 00:05:44,360
С нашей макс символ, поэтому мы установим
Вернуться к C, минимальная символом.

92
00:05:44,360 --> 00:05:48,100
И тогда мы итерации индекс
к следующему символу.

93
00:05:48,100 --> 00:05:53,920
>> Таким образом, если исходное предположение было с, следующего
характер будет нулевым

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
И если наше предположение было оригинальным
КПКГ, то наша новая догадка

100
00:06:16,050 --> 00:06:18,380
будет ааааа.

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
Ну, если индекс переехал с восьмого
характера к девяти характера -

106
00:06:42,780 --> 00:06:46,460
поэтому мы добавим восемь 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
Так что это пока петля собирается итерации
по всем возможным строк.

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
Так что помните, для р устанавливает спецификации и
Также в справочной странице склепе, что мы

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
Давайте зашифрованных Hirschhorn автора
пароль и попробуйте растрескиванию, что.

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
А потом, когда мы достигаем пяти символов
строк, мы должны перебрать все

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