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

2
00:00:13,000 --> 00:00:15,890
>> Роб 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
Се сеќавам дека програмата би требало
да се кандидира како dot коса црта напукнуваат, и

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
>> Тогаш ние ќе треба да пријават тоа низа,
гостин, на големината max должина плус

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
И ние ќе го користат ова за да iterate
над сите можни стрингови кои би можеле да

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
ние ќе iterate над а, б, в,
AA, диплома, кариера, и така натаму, се додека

53
00:03:14,970 --> 00:03:16,690
ние се да се види cccccccc -

54
00:03:16,690 --> 00:03:19,600
осум на 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
>> Забележите не постојат пауза изјава
во внатрешноста на оваа бесконечна јамка.

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
Тоа е looping преку сите можни стрингови
кои би можеле да бидат валидни лозинки.

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
>> И ние сакаме да iterate да
следниот валидна се погоди.

78
00:04:43,250 --> 00:04:46,410
Значи тоа е она што ова додека
јамка се обидува да се направи.

79
00:04:46,410 --> 00:04:51,760
Тоа се случува да iterate нашата претпоставка
на следната валидна се погоди.

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
Па, како се нашите нагаѓања
ќе iterate?

89
00:05:28,730 --> 00:05:33,685
Па, ако валидна ликови се А, Б,
и в, тогаш ако почнавме со,

90
00:05:33,685 --> 00:05:36,630
тоа ќе iterate до Б, тоа ќе
iterate на в.

91
00:05:36,630 --> 00:05:44,360
в е нашиот максимум симбол, па ние ќе се постави
в назад кон, минималната симбол.

92
00:05:44,360 --> 00:05:48,100
А потоа ние ќе iterate индекс
на следниот знак.

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
И ако нашата изворна претпоставка беше
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
Па, ако индекс се пресели од осмиот
карактер на девет карактер -

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

107
00:06:46,460 --> 00:06:51,270
потоа индекс се случува да се фокусираат на
последните null терминатор на нашата претпоставка

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
важечка лозинка која encrypts
на дадениот стринг.

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
Па ова додека јамка се случува да iterate
над сите можни стрингови.

115
00:07:20,280 --> 00:07:24,640
>> Ако утврди било која encrypts на
очекува шифрирана стринг, тоа ќе

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
Но, сега, ние треба да iterate над сите
можно четири-карактер жици, кои

150
00:09:22,800 --> 00:09:26,000
тоа може да потрае можеби 10 минути.

151
00:09:26,000 --> 00:09:28,720
А потоа кога ќе стигнат до пет карактери
стрингови, ние треба да iterate над сите

152
00:09:28,720 --> 00:09:31,450
од оние, кои би можеле
да потрае неколку часа.

153
00:09:31,450 --> 00:09:34,080
И ние треба да iterate преку сите можни
шест карактер жици, кои

154
00:09:34,080 --> 00:09:36,560
може да потрае неколку дена и така натаму.

155
00:09:36,560 --> 00:09:41,380
>> Па тоа би можело да потрае потенцијално многу долго
време да iterate преку сите можни

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
со оглед на лозинка 12.345 е
веројатно многу почести.

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
лозинка за да се биде "хакер", но тие се
ќе ги замени сите случаи на на e

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
Iterate над сите зборови во речникот
но замени ликови кои

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
сила iterate над сите
можно жици.

182
00:11:17,340 --> 00:11:22,100
Па на крајот, вие не треба да iterate
над сите жици од еден знак

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