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

2
00:00:13,000 --> 00:00:15,890
>> ROB BOWDEN: Jeg er Rob, og
lad os komme revner.

3
00:00:15,890 --> 00:00:19,390
Så husker fra Pset spec at
vi kommer til at blive nødt til at bruge

4
00:00:19,390 --> 00:00:20,890
krypt funktion.

5
00:00:20,890 --> 00:00:26,330
For manden siden har vi to
hash definere _xopensource.

6
00:00:26,330 --> 00:00:28,290
Må ikke bekymre dig om, hvorfor
vi nødt til at gøre det.

7
00:00:28,290 --> 00:00:31,550
Og også hash nævnes unistd.h.

8
00:00:31,550 --> 00:00:35,920
>> Så når det er af vejen, lad os
kommer til de egentlige program.

9
00:00:35,920 --> 00:00:39,570
Første ting vi skal gøre, er at sørge
brugeren indtastet et gyldigt krypteret

10
00:00:39,570 --> 00:00:41,520
adgangskode på kommandolinjen.

11
00:00:41,520 --> 00:00:46,050
Husk, at det er meningen programmet
skal køres ligesom dot slash crack, og

12
00:00:46,050 --> 00:00:48,120
derefter krypteret streng.

13
00:00:48,120 --> 00:00:52,990
>> Så her er vi kontrol for at sikre
at argc til to, hvis vi ønsker at

14
00:00:52,990 --> 00:00:54,380
fortsætte med programmet.

15
00:00:54,380 --> 00:00:58,830
Hvis argc ikke er to, der betyder enten
brugeren ikke indtaster en krypteret

16
00:00:58,830 --> 00:01:02,560
adgangskode på kommandolinjen, eller de
indtastet mere end blot den krypterede

17
00:01:02,560 --> 00:01:05,379
adgangskode på kommandolinjen, hvor
hvis vi ikke ved, hvad de skal gøre med det

18
00:01:05,379 --> 00:01:07,660
kommandolinjeargumenter.

19
00:01:07,660 --> 00:01:11,390
>> Så hvis argc var to, kan vi fortsætte med.

20
00:01:11,390 --> 00:01:14,160
Og her, vi kommer til at erklære
en variabel krypteret.

21
00:01:14,160 --> 00:01:17,650
Det er bare at alias oprindelige
argv1 således at hele denne

22
00:01:17,650 --> 00:01:20,690
program, behøver vi ikke at kalde det argv1,
som derefter er du nødt til at tænke

23
00:01:20,690 --> 00:01:22,950
om, hvad der egentlig menes.

24
00:01:22,950 --> 00:01:27,180
>> Så til sidst, vi ønsker at validere, at
den krypterede password brugeren

25
00:01:27,180 --> 00:01:30,840
opføres, har faktisk været
en krypteret adgangskode.

26
00:01:30,840 --> 00:01:35,120
Per manden side i krypten, den
krypterede password skal være 13

27
00:01:35,120 --> 00:01:36,440
tegn.

28
00:01:36,440 --> 00:01:41,500
Heroppe bemærke, at vi hash definerede
kryptere længde som 13..

29
00:01:41,500 --> 00:01:46,140
Så vi blot at sikre, at de
snorlængde af krypterede

30
00:01:46,140 --> 00:01:49,090
password er 13..

31
00:01:49,090 --> 00:01:52,280
>> Og hvis det ikke er, vil vi
at afslutte programmet.

32
00:01:52,280 --> 00:01:56,470
Så når det er af vejen, kan vi
nu faktisk forsøger at finde, hvad de

33
00:01:56,470 --> 00:02:00,410
adgangskode, der gav den krypterede
password var.

34
00:02:00,410 --> 00:02:04,870
Her ønsker vi at få fat i saltet
fra den krypterede password.

35
00:02:04,870 --> 00:02:08,930
Husk, per manden siden, at de
to første tegn i en krypteret

36
00:02:08,930 --> 00:02:10,590
streng, som her -

37
00:02:10,590 --> 00:02:12,770
50ZPJ og så videre -

38
00:02:12,770 --> 00:02:16,170
de første to tegn giver
os det salt, der blev anvendt

39
00:02:16,170 --> 00:02:18,080
i krypten funktion.

40
00:02:18,080 --> 00:02:21,740
>> Og her ser vi, at saltet var ha.

41
00:02:21,740 --> 00:02:27,610
Så vi ønsker at kopiere de to første
tegn, salt længde er hash

42
00:02:27,610 --> 00:02:30,230
defineret som to.

43
00:02:30,230 --> 00:02:35,970
Vi er nødt til at kopiere de første to bogstaver
i dette array, salt.

44
00:02:35,970 --> 00:02:39,340
Bemærk, at vi har brug for salt længde plus
en, da vi stadig har brug for en null

45
00:02:39,340 --> 00:02:42,440
terminator i slutningen af ​​vores salt.

46
00:02:42,440 --> 00:02:46,940
>> Så vi kommer til at erklære dette array,
gæst, størrelse maks. længde plus

47
00:02:46,940 --> 00:02:51,930
en, hvor max længde er hash defineret
som otte, da den maksimale password

48
00:02:51,930 --> 00:02:55,090
er otte tegn.

49
00:02:55,090 --> 00:02:59,860
Og vi kommer til at bruge denne til at gentage
over alle mulige strenge, der kunne

50
00:02:59,860 --> 00:03:01,430
være gyldige adgangskoder.

51
00:03:01,430 --> 00:03:07,720
Så hvis de er gyldige tegn i en adgangskode
var blot a, b, og c,

52
00:03:07,720 --> 00:03:14,970
vi ville gentage over a, b, c,
aa, BA, CA, og så videre, indtil

53
00:03:14,970 --> 00:03:16,690
vi får at se cccccccc -

54
00:03:16,690 --> 00:03:19,600
otte C'er.

55
00:03:19,600 --> 00:03:23,620
>> Og hvis vi ikke har ned et gyldigt
adgangskode, så er vi nødt til at sige, at

56
00:03:23,620 --> 00:03:26,590
krypteret streng var ikke
gyldigt at begynde med.

57
00:03:26,590 --> 00:03:29,970
Så nu kommer vi til dette, mens 1 løkke.

58
00:03:29,970 --> 00:03:33,100
Bemærk, at betyder, at det er
en uendelig løkke.

59
00:03:33,100 --> 00:03:36,430
>> Læg mærke til at der er ingen pause erklæring
indersiden af ​​denne uendelig løkke.

60
00:03:36,430 --> 00:03:38,570
Der er kun returnere udsagn.

61
00:03:38,570 --> 00:03:41,210
Så vi faktisk aldrig forvente
at afslutte løkken.

62
00:03:41,210 --> 00:03:44,750
Vi venter kun at afslutte programmet.

63
00:03:44,750 --> 00:03:48,220
Jeg har tilføjet denne print erklæring til
toppen af ​​denne løkke til bare udskrive

64
00:03:48,220 --> 00:03:51,790
, hvad vores nuværende gæt på
hvad adgangskoden er.

65
00:03:51,790 --> 00:03:53,630
>> Nu er hvad denne løkke laver?

66
00:03:53,630 --> 00:03:58,330
Det looping over alle mulige strenge
der kunne være gyldige passwords.

67
00:03:58,330 --> 00:04:02,700
Den første ting, vi vil gøre, er
tage vores nuværende gæt for hvad

68
00:04:02,700 --> 00:04:03,920
password er.

69
00:04:03,920 --> 00:04:07,230
Vi tager det salt, vi greb fra
den krypterede streng, og vi er

70
00:04:07,230 --> 00:04:09,850
kommer til at kryptere gæt.

71
00:04:09,850 --> 00:04:14,760
Dette vil give os en krypteret gæt,
som vi kommer til at sammenligne med

72
00:04:14,760 --> 00:04:18,810
den krypterede streng at brugeren
indtastes på kommandolinjen.

73
00:04:18,810 --> 00:04:23,030
>> Hvis de er det samme, i hvilket tilfælde
streng sammenlignelig vil returnere nul, hvis

74
00:04:23,030 --> 00:04:28,050
det er den samme, så gæt var
adgangskode, der genererede den krypterede

75
00:04:28,050 --> 00:04:33,520
streng, i hvilket tilfælde vi kan printe
der som vores kodeord og tilbagevenden.

76
00:04:33,520 --> 00:04:37,520
Men hvis de ikke var det samme, som
betyder, at vores gæt var forkert.

77
00:04:37,520 --> 00:04:43,250
>> Og vi ønsker at gentage at
den næste gyldige gæt.

78
00:04:43,250 --> 00:04:46,410
Så det er, hvad dette, mens
loop forsøger at gøre.

79
00:04:46,410 --> 00:04:51,760
Det kommer til at gentage vores gæt
til den næste gyldige gæt.

80
00:04:51,760 --> 00:04:56,080
Bemærk, at når vi siger, at en
særlige karakter i vores gæt har

81
00:04:56,080 --> 00:05:01,770
nåede max symbol, som heroppe
er hash defineres som en tilde, eftersom

82
00:05:01,770 --> 00:05:05,710
det er den største ASCII værdien karakter
at en bruger kan komme på

83
00:05:05,710 --> 00:05:11,210
tastatur, når tegnet når
max symbol, så vi ønsker at sende

84
00:05:11,210 --> 00:05:17,150
det tilbage til et minimum symbol, som
er et rum, igen den laveste ASCII

85
00:05:17,150 --> 00:05:20,800
værdi symbol at en bruger kan
indtaster på tastaturet.

86
00:05:20,800 --> 00:05:22,940
>> Så vi kommer til at sætte det
til et minimum symbol.

87
00:05:22,940 --> 00:05:25,720
Og så vi kommer til at gå
videre til næste tegn.

88
00:05:25,720 --> 00:05:28,730
Så hvordan er vores gæt
vil gentage?

89
00:05:28,730 --> 00:05:33,685
Tja, hvis de gyldige karakterer er a, b,
og c, hvis vi startede med en,

90
00:05:33,685 --> 00:05:36,630
det vil gentage til B, det vil
gentage til ca.

91
00:05:36,630 --> 00:05:44,360
c er vores max symbol, så vi sætte
c tilbage til en, minimum symbol.

92
00:05:44,360 --> 00:05:48,100
Og så vil vi gentage index
til næste tegn.

93
00:05:48,100 --> 00:05:53,920
>> Så hvis den oprindelige gæt var C, den næste
karakter vil være nul

94
00:05:53,920 --> 00:05:55,560
terminator.

95
00:05:55,560 --> 00:06:00,670
Hernede, bemærke, at hvis tegnet
at vi nu ønsker at

96
00:06:00,670 --> 00:06:04,690
tilvækst var null terminatoren
så vi kommer til at sætte det til

97
00:06:04,690 --> 00:06:06,260
minimum symbol.

98
00:06:06,260 --> 00:06:11,431
Så hvis gæt var c, så er vores
nyt gæt vil være aa.

99
00:06:11,431 --> 00:06:16,050
Og hvis vores oprindelige gæt var
cccc, så vores nye gæt

100
00:06:16,050 --> 00:06:18,380
bliver aaaaa.

101
00:06:18,380 --> 00:06:24,430
>> Så når vi nå den maksimale strengen
af en given længde, vi derefter er

102
00:06:24,430 --> 00:06:29,090
vil gennemføre den mindste streng
Den næste længde, hvilket vil

103
00:06:29,090 --> 00:06:34,420
bare være alle tegn i
minimum symbol.

104
00:06:34,420 --> 00:06:36,970
Nu er det, denne kontrol laver her?

105
00:06:36,970 --> 00:06:42,780
Tja, hvis indekset flyttet fra den ottende
tegn til ni karakter -

106
00:06:42,780 --> 00:06:46,460
så tilføjer vi otte C'er som
vores tidligere gæt -

107
00:06:46,460 --> 00:06:51,270
derefter indeks kommer til at fokusere på
sidste null terminator i vores gæt

108
00:06:51,270 --> 00:06:57,990
matrix, som ikke er beregnet til faktisk
anvendes i vores kodeord.

109
00:06:57,990 --> 00:07:03,530
>> Så hvis vi fokuserer på at sidste null
terminator, så har vi ikke fundet en

110
00:07:03,530 --> 00:07:07,750
password, der er gyldige ved hjælp af kun otte
tegn, hvilket betyder, at der ikke er nogen

111
00:07:07,750 --> 00:07:10,550
gyldig adgangskode, der krypterer
til den givne streng.

112
00:07:10,550 --> 00:07:13,520
Og vi er nødt til at udskrive det, siger
vi kunne ikke finde et gyldigt

113
00:07:13,520 --> 00:07:16,100
adgangskode, og vende tilbage.

114
00:07:16,100 --> 00:07:20,280
Så dette, mens løkken kommer til at gentage
over alle mulige strenge.

115
00:07:20,280 --> 00:07:24,640
>> Hvis den finder nogen, som krypterer til
forventede krypteret streng, det vil

116
00:07:24,640 --> 00:07:26,190
returnere adgangskode.

117
00:07:26,190 --> 00:07:29,610
Og det er det ikke finder noget, så
det vil vende tilbage, trykning, at det

118
00:07:29,610 --> 00:07:31,910
var ikke i stand til at finde noget.

119
00:07:31,910 --> 00:07:39,220
Nu bemærke, at iteration over alle
mulige strenge er sandsynligvis vil

120
00:07:39,220 --> 00:07:40,420
tage et stykke tid.

121
00:07:40,420 --> 00:07:43,590
Lad os rent faktisk se, hvordan
lang, der tager.

122
00:07:43,590 --> 00:07:47,230
>> Lad os lave crack.

123
00:07:47,230 --> 00:07:51,050
Nå, ups - det siger udefineret
henvisning til krypt.

124
00:07:51,050 --> 00:07:55,330
Så husk, for p sætter spec og
også manden siden for krypt, som vi

125
00:07:55,330 --> 00:07:58,130
nødt til at linke i krypten.

126
00:07:58,130 --> 00:08:01,130
Nu, standard gør kommandoen
ikke ved, at du

127
00:08:01,130 --> 00:08:03,010
ønsker at bruge denne funktion.

128
00:08:03,010 --> 00:08:09,680
>> Så lad os kopiere denne klient kommando
og blot tilføje til enden

129
00:08:09,680 --> 00:08:13,300
af det, krypt forbinder.

130
00:08:13,300 --> 00:08:14,820
Nu er det kompilerer.

131
00:08:14,820 --> 00:08:23,880
Så lad os køre crack på en given
krypterede streng -

132
00:08:23,880 --> 00:08:25,130
så Cæsars.

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

134
00:08:28,690 --> 00:08:30,790
Så det var temmelig hurtigt.

135
00:08:30,790 --> 00:08:33,230
>> Bemærk, at dette endte den 13.

136
00:08:33,230 --> 00:08:38,240
Nå, Cæsars krypterede password
sker for at være 13..

137
00:08:38,240 --> 00:08:41,650
Så lad os prøve en anden adgangskode.

138
00:08:41,650 --> 00:08:45,830
Lad os tage Hirschhorn krypterede
kodeord og prøv revner det.

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

140
00:08:51,750 --> 00:08:55,110
>> Så opdager vi har allerede nået
tre tegn.

141
00:08:55,110 --> 00:08:58,660
Og vi iteration over alle mulige
tre-tegnstrenge.

142
00:08:58,660 --> 00:09:01,420
Det betyder, at vi allerede har færdig
iteration over alle mulige og

143
00:09:01,420 --> 00:09:04,660
to tegnstrenge.

144
00:09:04,660 --> 00:09:09,180
Nu ser det ud dette kommer til at
tage et stykke tid, før vi når

145
00:09:09,180 --> 00:09:10,580
fire-tegnstrenge.

146
00:09:10,580 --> 00:09:14,680
Det kan tage et par minutter.

147
00:09:14,680 --> 00:09:16,055
>> Det tog ikke tage et par minutter.

148
00:09:16,055 --> 00:09:18,450
Vi er på de fire-tegnstrenge.

149
00:09:18,450 --> 00:09:22,800
Men nu er vi nødt til at gentage over alle
mulige fire-tegnstrenge, som

150
00:09:22,800 --> 00:09:26,000
der kan tage måske 10 minutter.

151
00:09:26,000 --> 00:09:28,720
Og så når vi når fem tegn
strygere, er vi nødt til at gentage over alle

152
00:09:28,720 --> 00:09:31,450
af dem, som vil kunne
tage et par timer.

153
00:09:31,450 --> 00:09:34,080
Og vi er nødt til at gentage over alle mulige
seks-tegnstrenge, som

154
00:09:34,080 --> 00:09:36,560
kan tage et par dage, og så videre.

155
00:09:36,560 --> 00:09:41,380
>> Så det kunne tage en potentielt meget lang
tid til at gentage over alle mulige

156
00:09:41,380 --> 00:09:44,850
otte tegn og færre strenge.

157
00:09:44,850 --> 00:09:50,600
Så bemærke, at dette ikke nødvendigvis er en
meget effektiv algoritme til at finde

158
00:09:50,600 --> 00:09:51,860
en adgangskode.

159
00:09:51,860 --> 00:09:54,540
Du tror måske, at der
er bedre måder.

160
00:09:54,540 --> 00:10:02,230
For eksempel password zyx! 32ab
sandsynligvis ikke er en meget almindelig adgangskode,

161
00:10:02,230 --> 00:10:06,440
mens password 12345 er
sandsynligvis meget mere almindelige.

162
00:10:06,440 --> 00:10:13,570
>> Så en måde at forsøge at finde en adgangskode
hurtigere er at bare kigge

163
00:10:13,570 --> 00:10:15,560
på passwords, der er mere almindelige.

164
00:10:15,560 --> 00:10:20,480
Så for eksempel, kan vi prøve at læse ord
fra en ordbog og prøve alle

165
00:10:20,480 --> 00:10:24,860
disse ord som vores password gæt.

166
00:10:24,860 --> 00:10:29,210
Nu, måske en adgangskode
er ikke så simpelt.

167
00:10:29,210 --> 00:10:32,600
Måske brugeren var noget smart
og prøv at tilføje et nummer til

168
00:10:32,600 --> 00:10:34,220
slutningen af ​​et ord.

169
00:10:34,220 --> 00:10:37,000
>> Så måske deres password var password1.

170
00:10:37,000 --> 00:10:41,520
Så du kan prøve iteration i alle ord
i ordbogen med en én

171
00:10:41,520 --> 00:10:43,210
tilføjet i slutningen af ​​det.

172
00:10:43,210 --> 00:10:47,360
Og så måske efter at gøre dette, vil du
tilføje en to til enden på det.

173
00:10:47,360 --> 00:10:50,240
>> Eller måske bruger forsøger at være endnu
klogere, og de vil have deres

174
00:10:50,240 --> 00:10:54,980
adgangskode for at være "hacker", men de er
kommer til at erstatte alle forekomster af e s

175
00:10:54,980 --> 00:10:56,600
med treere.

176
00:10:56,600 --> 00:10:58,440
Så du kunne gøre det også.

177
00:10:58,440 --> 00:11:02,100
Gentage over alle ord i ordbogen
men udskift figurer, som

178
00:11:02,100 --> 00:11:04,790
ligne numre med disse numre.

179
00:11:04,790 --> 00:11:09,670
>> Så på denne måde, kan du fange endnu mere
passwords, der er temmelig udbredt.

180
00:11:09,670 --> 00:11:14,690
Men i sidste ende, er den eneste måde du kan
indfange alle passwords er at brute

181
00:11:14,690 --> 00:11:17,340
tvinge gentage over alle
mulige strenge.

182
00:11:17,340 --> 00:11:22,100
Så i sidste ende, har du brug for at skifte
for alle strengene fra et tegn til

183
00:11:22,100 --> 00:11:28,110
otte tegn, hvilket kan tage et
meget lang tid, men du behøver at gøre det.

184
00:11:28,110 --> 00:11:30,024
>> Mit navn er Rob Bowden.

185
00:11:30,024 --> 00:11:31,425
Og det er Crack.

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