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
Per човекът страница на криптата, на
криптирана парола трябва да е 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
Така че, ако валидните символи в паролата
бяха само, Б и В, а след това

52
00:03:07,720 --> 00:03:14,970
бихме обхождане на A, B, C,
аа, ба, СА, и така нататък, докато

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
Така че сега, стигаме до това, докато един цикъл.

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

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
достигна символа макс, които тук
хеш се дефинира като тилда, тъй като

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
С нас е макс символ, така че ще настроите
С обратно в, минималната символ.

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
Така че, ако Предполагах, С, след това ни
ново предположение ще бъде аа.

99
00:06:11,431 --> 00:06:16,050
И ако нашите оригинални предположение е
СССС, а след това новата ни предположение

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
Е, ако индексът преместен от осмия
характер на характера девет -

106
00:06:42,780 --> 00:06:46,460
така че ние добавите в осем, както е
предишната ни предполагам -

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
И това е Crack.

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