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

2
00:00:13,000 --> 00:00:15,890
>> ROB BOWDEN: Jeg er Rob, og
la oss komme i sprekker.

3
00:00:15,890 --> 00:00:19,390
Så husker fra PSett spec som
vi kommer til å være behov for å bruke

4
00:00:19,390 --> 00:00:20,890
krypten funksjon.

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

6
00:00:26,330 --> 00:00:28,290
Ikke bekymre deg om hvorfor
vi trenger å gjøre det.

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

8
00:00:31,550 --> 00:00:35,920
>> Så når det er ute av veien, la oss
komme til selve programmet.

9
00:00:35,920 --> 00:00:39,570
Første vi må gjøre er å sørge
brukeren inn en gyldig kryptert

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

11
00:00:41,520 --> 00:00:46,050
Husk at programmet er ment
å kjøres som dot slash sprekk, og

12
00:00:46,050 --> 00:00:48,120
deretter kryptert streng.

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

14
00:00:52,990 --> 00:00:54,380
fortsette med programmet.

15
00:00:54,380 --> 00:00:58,830
Hvis argc er ikke to, betyr at enten
brukeren har ikke skrevet inn en kryptert

16
00:00:58,830 --> 00:01:02,560
passord på kommandolinjen, eller de
skrives mer enn bare det krypterte

17
00:01:02,560 --> 00:01:05,379
passord på kommandolinjen, der
Hvis vi ikke vet hva de skal gjøre med den

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

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

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

21
00:01:14,160 --> 00:01:17,650
Det er bare å gå til alias den opprinnelige
argv1 slik at hele denne

22
00:01:17,650 --> 00:01:20,690
program, trenger vi ikke å kalle det argv1,
som da du må tenke

23
00:01:20,690 --> 00:01:22,950
om hva som faktisk betydde.

24
00:01:22,950 --> 00:01:27,180
>> Så til slutt, ønsker vi å validere at
den krypterte passord brukeren

25
00:01:27,180 --> 00:01:30,840
skrev inn kunne faktisk har vært
et kryptert passord.

26
00:01:30,840 --> 00:01:35,120
Per mannen til krypten, den
kryptert passord må være 13

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

28
00:01:36,440 --> 00:01:41,500
Opp her, merker at vi hash definert
kryptere lengde som 13.

29
00:01:41,500 --> 00:01:46,140
Så vi bare å sørge for at
strenglengde av den krypterte

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

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

32
00:01:52,280 --> 00:01:56,470
Så når det er ute av veien, kan vi
nå faktisk prøve å finne hva

33
00:01:56,470 --> 00:02:00,410
passord som ga den krypterte
passordet var.

34
00:02:00,410 --> 00:02:04,870
Her ønsker vi å ta tak i salt
fra den krypterte passord.

35
00:02:04,870 --> 00:02:08,930
Husk, per mannen siden, at
to første tegnene i en kryptert

36
00:02:08,930 --> 00:02:10,590
strengen, slik 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 to første tegnene gi
oss saltet som ble brukt

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

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 å kopiere de to første
tegn, salt lengde være hash

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

43
00:02:30,230 --> 00:02:35,970
Vi må kopiere de to første tegnene
i denne matrisen, salt.

44
00:02:35,970 --> 00:02:39,340
Legg merke til at vi trenger salt lengde pluss
en, siden vi fortsatt trenger en null

45
00:02:39,340 --> 00:02:42,440
terminator ved enden av salt vår.

46
00:02:42,440 --> 00:02:46,940
>> Så vi kommer til å erklære denne tabellen,
gjest, av størrelse maks lengde pluss

47
00:02:46,940 --> 00:02:51,930
en, hvor maks lengde er hash definert
åtte som, ettersom den maksimale passord

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

49
00:02:55,090 --> 00:02:59,860
Og vi kommer til å bruke dette til å iterere
fremfor alle mulige strenger som kunne

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

51
00:03:01,430 --> 00:03:07,720
Så hvis de er gyldige tegn i et passord
var bare a, b og c, og deretter

52
00:03:07,720 --> 00:03:14,970
vi vil iterere over a, b, c,
aa, ba, ca, og så videre, helt til

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

54
00:03:16,690 --> 00:03:19,600
åtte c-tallet.

55
00:03:19,600 --> 00:03:23,620
>> Og hvis vi har ikke ned en gyldig
passord, så må vi si at

56
00:03:23,620 --> 00:03:26,590
krypterte strengen var ikke
gyldig til å begynne med.

57
00:03:26,590 --> 00:03:29,970
Så nå kommer vi dette mens en loop.

58
00:03:29,970 --> 00:03:33,100
Legg merke til at betyr at det er
en uendelig loop.

59
00:03:33,100 --> 00:03:36,430
>> Merke det er ingen pause uttalelse
innsiden av denne uendelig loop.

60
00:03:36,430 --> 00:03:38,570
Det er bare returnere uttalelser.

61
00:03:38,570 --> 00:03:41,210
Slik at vi aldri egentlig forvente
å avslutte loopen.

62
00:03:41,210 --> 00:03:44,750
Vi bare forventer å avslutte programmet.

63
00:03:44,750 --> 00:03:48,220
Jeg har lagt denne print uttalelse til
toppen av denne sløyfen å bare skrive ut

64
00:03:48,220 --> 00:03:51,790
hva vår nåværende gjette på
hva passordet er.

65
00:03:51,790 --> 00:03:53,630
>> Nå er det denne sløyfen gjør?

66
00:03:53,630 --> 00:03:58,330
Det er looping fremfor alle mulige strenger
som kan være gyldige passordene.

67
00:03:58,330 --> 00:04:02,700
Det første vi skal gjøre er
ta vårt nåværende anslag for hva

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

69
00:04:03,920 --> 00:04:07,230
Vi tar salt at vi grep fra
den krypterte strengen, og vi er

70
00:04:07,230 --> 00:04:09,850
kommer til å kryptere gjetning.

71
00:04:09,850 --> 00:04:14,760
Dette vil gi oss en kryptert gjetning,
som vi kommer til å sammenligne mot

72
00:04:14,760 --> 00:04:18,810
den krypterte snor som brukeren
angitt på kommandolinjen.

73
00:04:18,810 --> 00:04:23,030
>> Hvis de er det samme, i hvilket tilfelle
string sammenlignbare vil returnere null, hvis

74
00:04:23,030 --> 00:04:28,050
de er det samme, så antar var
passord som genererte den krypterte

75
00:04:28,050 --> 00:04:33,520
streng, og da vi kan skrive
det som vår passord og retur.

76
00:04:33,520 --> 00:04:37,520
Men hvis de ikke var det, at
betyr vår gjetning var feil.

77
00:04:37,520 --> 00:04:43,250
>> Og vi ønsker å iterere til
neste gyldig gjetning.

78
00:04:43,250 --> 00:04:46,410
Så det er hva denne stund
løkke prøver å gjøre.

79
00:04:46,410 --> 00:04:51,760
Det kommer til å iterere vår gjetning
til neste gyldig gjetning.

80
00:04:51,760 --> 00:04:56,080
Legg merke til at når vi sier at en
spesiell karakter i gjetning vår har

81
00:04:56,080 --> 00:05:01,770
nådd maks symbol, som her oppe
hash er definert som et tilde, ettersom

82
00:05:01,770 --> 00:05:05,710
som er den største ASCII verdi karakter
at en bruker kan gå inn på

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

84
00:05:11,210 --> 00:05:17,150
den tilbake til minimum symbol, noe
er et mellomrom, igjen den laveste ASCII

85
00:05:17,150 --> 00:05:20,800
verdi symbol at en bruker kan
gå inn på tastaturet.

86
00:05:20,800 --> 00:05:22,940
>> Så vi kommer til å sette at
til minimum symbol.

87
00:05:22,940 --> 00:05:25,720
Og så skal vi gå
videre til neste tegn.

88
00:05:25,720 --> 00:05:28,730
Så hvordan er våre gjetninger
kommer til å iterere?

89
00:05:28,730 --> 00:05:33,685
Vel, hvis de gyldige tegn er a, b,
og c, så hvis vi startet med en,

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

91
00:05:36,630 --> 00:05:44,360
c er vår max symbol, så vi får satt
c tilbake til et, minimum symbol.

92
00:05:44,360 --> 00:05:48,100
Og så får vi iterere index
til neste tegn.

93
00:05:48,100 --> 00:05:53,920
>> Så hvis det opprinnelige gjetning var c, den neste
tegnet kommer til å være null

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

95
00:05:55,560 --> 00:06:00,670
Her nede, merker at hvis karakter
at vi nå ønsker å

96
00:06:00,670 --> 00:06:04,690
tilveksten var null terminator,
så vi kommer til å sette den til

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

98
00:06:06,260 --> 00:06:11,431
Så hvis gjetning var c, da vår
ny gjetning kommer til å bli aa.

99
00:06:11,431 --> 00:06:16,050
Og hvis vår opprinnelige gjetning var
cccc, da vår nye gjetning

100
00:06:16,050 --> 00:06:18,380
kommer til å være aaaaa.

101
00:06:18,380 --> 00:06:24,430
>> Så når vi nå den maksimale streng
av en gitt lengde, så vi er

102
00:06:24,430 --> 00:06:29,090
kommer til å iverksette til minimum string
av den neste lengde, som skal

103
00:06:29,090 --> 00:06:34,420
bare være alle tegnene
den minimums-symbol.

104
00:06:34,420 --> 00:06:36,970
Nå, hva er denne kontrollen gjør her?

105
00:06:36,970 --> 00:06:42,780
Vel, flyttet hvis indeksen fra den åttende
tegn til ni karakter -

106
00:06:42,780 --> 00:06:46,460
så vi legger åtte c-tallet som
vår forrige gjette -

107
00:06:46,460 --> 00:06:51,270
deretter indeks kommer til å fokusere på
siste null terminator av gjetning vår

108
00:06:51,270 --> 00:06:57,990
array, som ikke er ment å faktisk
brukes i passord vår.

109
00:06:57,990 --> 00:07:03,530
>> Så hvis vi er fokusert på at siste null
terminator, da vi ikke har funnet en

110
00:07:03,530 --> 00:07:07,750
passord som er gyldig ved hjelp av bare åtte
tegn, som betyr at det ikke er noen

111
00:07:07,750 --> 00:07:10,550
gyldig passord som krypterer
til den gitte strengen.

112
00:07:10,550 --> 00:07:13,520
Og vi må skrive det, sier
Vi kunne ikke finne et gyldig

113
00:07:13,520 --> 00:07:16,100
passord, og retur.

114
00:07:16,100 --> 00:07:20,280
Så dette mens loop kommer til å iterere
fremfor alle mulige strenger.

115
00:07:20,280 --> 00:07:24,640
>> Hvis den finner noen som krypterer til
forventet kryptert streng, vil det

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

117
00:07:26,190 --> 00:07:29,610
Og det den ikke finner noe, så
det vil returnere, skriver at det

118
00:07:29,610 --> 00:07:31,910
var ikke i stand til å finne noe.

119
00:07:31,910 --> 00:07:39,220
Legg nå merke til at iterating over alt
mulige strenger er trolig kommer til

120
00:07:39,220 --> 00:07:40,420
ta en stund.

121
00:07:40,420 --> 00:07:43,590
La oss faktisk se hvordan
lang tid det tar.

122
00:07:43,590 --> 00:07:47,230
>> La oss lage sprekk.

123
00:07:47,230 --> 00:07:51,050
Vel, oops - det står udefinert
referere til krypten.

124
00:07:51,050 --> 00:07:55,330
Så husk, for p setter spec og
også mannen siden for krypten at vi

125
00:07:55,330 --> 00:07:58,130
trenger for å koble i krypten.

126
00:07:58,130 --> 00:08:01,130
Nå standard gjør kommandoen
ikke vet at du

127
00:08:01,130 --> 00:08:03,010
ønsker å bruke den aktuelle funksjonen.

128
00:08:03,010 --> 00:08:09,680
>> Så la oss kopiere denne klienten kommandoen
og bare legge på til slutten

129
00:08:09,680 --> 00:08:13,300
av det, linking krypten.

130
00:08:13,300 --> 00:08:14,820
Nå, sammenstiller det.

131
00:08:14,820 --> 00:08:23,880
Så la oss kjøre sprekk på en gitt
kryptert string -

132
00:08:23,880 --> 00:08:25,130
så Keiserens.

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

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

135
00:08:30,790 --> 00:08:33,230
>> Legg merke til at dette endte på 13..

136
00:08:33,230 --> 00:08:38,240
Vel, Cæsars kryptert passord
skjer for å være 13.

137
00:08:38,240 --> 00:08:41,650
Så la oss prøve en annen passord.

138
00:08:41,650 --> 00:08:45,830
La oss ta Hirschhorn krypterte
passord og prøve sprengning det.

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

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

141
00:08:55,110 --> 00:08:58,660
Og vi gjentar over alt mulig
tre-tegns strenger.

142
00:08:58,660 --> 00:09:01,420
Det betyr at vi allerede ferdig
iterating over alt mulig en og

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

144
00:09:04,660 --> 00:09:09,180
Nå ser det ut som dette kommer til å
ta en stund før vi når

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

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

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

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

149
00:09:18,450 --> 00:09:22,800
Men nå trenger vi å iterere over alle
mulige fire-tegns strenger, som

150
00:09:22,800 --> 00:09:26,000
som kan ta kanskje 10 minutter.

151
00:09:26,000 --> 00:09:28,720
Og så når vi nå fem tegn
strenger, trenger vi å iterere over alle

152
00:09:28,720 --> 00:09:31,450
av dem, som kan
ta et par timer.

153
00:09:31,450 --> 00:09:34,080
Og vi trenger å iterere over alle mulige
seks-tegnstrenger, som

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

155
00:09:36,560 --> 00:09:41,380
>> Så det kan ta en potensielt svært lang
tid til å iterere over alle mulige

156
00:09:41,380 --> 00:09:44,850
åtte tegn og færre strenger.

157
00:09:44,850 --> 00:09:50,600
Så merker at dette ikke nødvendigvis er en
svært effektiv algoritme for å finne

158
00:09:50,600 --> 00:09:51,860
et passord.

159
00:09:51,860 --> 00:09:54,540
Du tenker kanskje at det
finnes bedre måter.

160
00:09:54,540 --> 00:10:02,230
For eksempel passord zyx! 32ab
sannsynligvis ikke er en veldig vanlig passord,

161
00:10:02,230 --> 00:10:06,440
mens passordet 12345 er
sannsynligvis mye mer vanlig.

162
00:10:06,440 --> 00:10:13,570
>> Så en måte å prøve å finne et passord
raskere er å bare se

163
00:10:13,570 --> 00:10:15,560
på passord som er mer vanlig.

164
00:10:15,560 --> 00:10:20,480
Så for eksempel, kan vi forsøke å lese ord
fra en ordbok og prøve alle

165
00:10:20,480 --> 00:10:24,860
de ordene som våre passord gjetninger.

166
00:10:24,860 --> 00:10:29,210
Nå, kanskje et passord
er ikke så enkelt.

167
00:10:29,210 --> 00:10:32,600
Kanskje brukeren var noe smart
og prøv lagt til et tall

168
00:10:32,600 --> 00:10:34,220
slutten av et ord.

169
00:10:34,220 --> 00:10:37,000
>> Så kanskje deres passord var password1.

170
00:10:37,000 --> 00:10:41,520
Så du kan prøve iterating enn alle ord
i ordboken med ett

171
00:10:41,520 --> 00:10:43,210
lagt til på slutten av den.

172
00:10:43,210 --> 00:10:47,360
Og så kanskje når du gjør det, vil du
tilføye en to til slutten av det.

173
00:10:47,360 --> 00:10:50,240
>> Eller kanskje brukeren prøver å være enda
mer flink, og de ønsker at deres

174
00:10:50,240 --> 00:10:54,980
passord for å være "hacker", men de er
kommer til å erstatte alle forekomster av e sin

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

176
00:10:56,600 --> 00:10:58,440
Så du kan gjøre dette også.

177
00:10:58,440 --> 00:11:02,100
Iterere over alle ord i ordlisten
men erstatte tegn som

178
00:11:02,100 --> 00:11:04,790
ser ut som tall med disse tallene.

179
00:11:04,790 --> 00:11:09,670
>> Så denne måten, kan du få enda mer
passord som er ganske vanlig.

180
00:11:09,670 --> 00:11:14,690
Men til slutt, den eneste måten du kan
fange opp alle passordene er å brute

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

182
00:11:17,340 --> 00:11:22,100
Så til slutt, trenger du å iterere
fremfor alle strenger fra ett tegn til

183
00:11:22,100 --> 00:11:28,110
åtte tegn, som kan ta en
veldig lang tid, men du trenger å gjøre det.

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

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

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