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

2
00:00:13,000 --> 00:00:15,890
>> ROB BOWDEN: Jag är Rob, och
låt oss få sprickbildning.

3
00:00:15,890 --> 00:00:19,390
Så kom ihåg från pset spec som
vi kommer att behöva använda

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

5
00:00:20,890 --> 00:00:26,330
För mannen sidan, har vi två
hash definiera _xopensource.

6
00:00:26,330 --> 00:00:28,290
Oroa dig inte om varför
Vi behöver göra det.

7
00:00:28,290 --> 00:00:31,550
Och även hash inkluderar unistd.h.

8
00:00:31,550 --> 00:00:35,920
>> Så när det är ur vägen, låt oss
komma till själva programmet.

9
00:00:35,920 --> 00:00:39,570
Första vi måste göra är att se till
användaren angett en giltig krypterad

10
00:00:39,570 --> 00:00:41,520
lösenord på kommandoraden.

11
00:00:41,520 --> 00:00:46,050
Tänk på att programmet är tänkt
köras som dot slash spricka, och

12
00:00:46,050 --> 00:00:48,120
sedan krypterade strängen.

13
00:00:48,120 --> 00:00:52,990
>> Så här vi kontrollerar att
att argc till två om vi vill

14
00:00:52,990 --> 00:00:54,380
fortsätta med programmet.

15
00:00:54,380 --> 00:00:58,830
Om argc är inte två, innebär att antingen
användaren inte ange en krypterad

16
00:00:58,830 --> 00:01:02,560
lösenord på kommandoraden, eller de
trädde mer än bara den krypterade

17
00:01:02,560 --> 00:01:05,379
lösenord på kommandoraden, där
fall vi inte vet vad jag ska göra med den

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

19
00:01:07,660 --> 00:01:11,390
>> Så om argc var två, kan vi fortsätta.

20
00:01:11,390 --> 00:01:14,160
Och här kommer vi att förklara
en variabel krypterad.

21
00:01:14,160 --> 00:01:17,650
Det är bara att gå till alias den ursprungliga
argv1 att så under hela detta

22
00:01:17,650 --> 00:01:20,690
program, behöver vi inte kalla det argv1,
som då måste man tänka

23
00:01:20,690 --> 00:01:22,950
om vad som faktiskt betydde.

24
00:01:22,950 --> 00:01:27,180
>> Så slutligen, vill vi att validera att
det krypterade lösenordet för användaren

25
00:01:27,180 --> 00:01:30,840
trädde kunde faktiskt varit
ett krypterat lösenord.

26
00:01:30,840 --> 00:01:35,120
Per mannen sidan av kryptan, den
krypterade lösenord måste vara 13

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

28
00:01:36,440 --> 00:01:41,500
Här uppe, märker att vi hash definierade
kryptera längd som 13.

29
00:01:41,500 --> 00:01:46,140
Så vi bara att se till att
stränglängd av det krypterade

30
00:01:46,140 --> 00:01:49,090
lösenordet är 13.

31
00:01:49,090 --> 00:01:52,280
>> Och om det inte är, vill vi
att avsluta programmet.

32
00:01:52,280 --> 00:01:56,470
Så när det är ur vägen, kan vi
nu faktiskt försöka hitta vad

33
00:01:56,470 --> 00:02:00,410
lösenord som gav den krypterade
lösenordet var.

34
00:02:00,410 --> 00:02:04,870
Här vill vi tag i salt
från det krypterade lösenordet.

35
00:02:04,870 --> 00:02:08,930
Kom ihåg, per mannen sida, att
två första tecknen i en krypterad

36
00:02:08,930 --> 00:02:10,590
string, som här -

37
00:02:10,590 --> 00:02:12,770
50ZPJ och så vidare -

38
00:02:12,770 --> 00:02:16,170
De två första tecknen ger
oss saltet som användes

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

40
00:02:18,080 --> 00:02:21,740
>> Och här ser vi att saltet var hektar.

41
00:02:21,740 --> 00:02:27,610
Så vi vill kopiera de två första
tecken, salt längd är hash

42
00:02:27,610 --> 00:02:30,230
definieras som två.

43
00:02:30,230 --> 00:02:35,970
Vi måste kopiera de två första tecknen
i denna samling, salt.

44
00:02:35,970 --> 00:02:39,340
Lägg märke till att vi behöver salt längd plus
en, eftersom vi fortfarande behöver en null

45
00:02:39,340 --> 00:02:42,440
terminator i slutet av vårt salt.

46
00:02:42,440 --> 00:02:46,940
>> Sen ska vi förklara denna array,
gäst, storlek max längd plus

47
00:02:46,940 --> 00:02:51,930
en, där maxlängd är hash definierad
som åtta, eftersom den maximala lösenordet

48
00:02:51,930 --> 00:02:55,090
är åtta tecken långt.

49
00:02:55,090 --> 00:02:59,860
Och vi kommer att använda detta för att iterera
över alla möjliga strängar som kunde

50
00:02:59,860 --> 00:03:01,430
vara giltiga lösenord.

51
00:03:01,430 --> 00:03:07,720
Så om de giltiga tecken i ett lösenord
var bara a, b, och c, så

52
00:03:07,720 --> 00:03:14,970
vi skulle iterera över a, b, c,
aa, ba, ca, och så vidare, tills

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

54
00:03:16,690 --> 00:03:19,600
åtta c-talet.

55
00:03:19,600 --> 00:03:23,620
>> Och om vi inte ner ett giltigt
lösenord, då måste vi säga att

56
00:03:23,620 --> 00:03:26,590
krypterade strängen var inte
giltigt till att börja med.

57
00:03:26,590 --> 00:03:29,970
Så nu, når vi detta medan 1 slinga.

58
00:03:29,970 --> 00:03:33,100
Observera att betyder att det är
en oändlig loop.

59
00:03:33,100 --> 00:03:36,430
>> Lägg märke till att det inte finns några break
insidan av denna oändlig loop.

60
00:03:36,430 --> 00:03:38,570
Det är bara tillbaka uttalanden.

61
00:03:38,570 --> 00:03:41,210
Så vi aldrig förvänta
att avsluta slingan.

62
00:03:41,210 --> 00:03:44,750
Vi förväntar oss bara att avsluta programmet.

63
00:03:44,750 --> 00:03:48,220
Jag har lagt detta tryck uttalande till
toppen av denna slinga för att bara skriva ut

64
00:03:48,220 --> 00:03:51,790
vad vår nuvarande gissning på
vad lösenordet är.

65
00:03:51,790 --> 00:03:53,630
>> Nu, vad är denna slinga gör?

66
00:03:53,630 --> 00:03:58,330
Det looping över alla möjliga strängar
som kan vara giltiga lösenord.

67
00:03:58,330 --> 00:04:02,700
Det första vi ska göra är
ta vårt nuvarande gissning för vad

68
00:04:02,700 --> 00:04:03,920
lösenordet är.

69
00:04:03,920 --> 00:04:07,230
Vi tar det salt som vi tog från
den krypterade strängen, och vi är

70
00:04:07,230 --> 00:04:09,850
kommer att kryptera gissning.

71
00:04:09,850 --> 00:04:14,760
Detta kommer att ge oss en krypterad gissning,
som vi kommer att jämföra mot

72
00:04:14,760 --> 00:04:18,810
den krypterade strängen som användaren
skrivas på kommandoraden.

73
00:04:18,810 --> 00:04:23,030
>> Om de är lika, i vilket fall
string jämförbara återkommer noll, om

74
00:04:23,030 --> 00:04:28,050
de är samma, så gissa var
lösenord som genererade krypterade

75
00:04:28,050 --> 00:04:33,520
sträng, i vilket fall vi kan skriva ut
det som vårt lösenord och retur.

76
00:04:33,520 --> 00:04:37,520
Men om de inte var densamma, att
innebär vår gissning var felaktig.

77
00:04:37,520 --> 00:04:43,250
>> Och vi vill att iterera till
nästa giltiga gissning.

78
00:04:43,250 --> 00:04:46,410
Så det är vad denna stund
loop försöker göra.

79
00:04:46,410 --> 00:04:51,760
Det kommer att iterera vår gissning
till nästa giltiga gissning.

80
00:04:51,760 --> 00:04:56,080
Lägg märke till att när vi säger att en
särskild karaktär i vår gissning har

81
00:04:56,080 --> 00:05:01,770
nått max symbol, som här uppe
är hash definieras som en tilde, eftersom

82
00:05:01,770 --> 00:05:05,710
som är det största ASCII värdet tecken
att en användare kan skrivas in vid

83
00:05:05,710 --> 00:05:11,210
tangentbord, när karaktären når
max symbol, då vi vill skicka

84
00:05:11,210 --> 00:05:17,150
det tillbaka till den minsta symbolen, som
är ett utrymme, återigen den lägsta ASCII

85
00:05:17,150 --> 00:05:20,800
värde symbolen som en användare kan
in vid tangentbordet.

86
00:05:20,800 --> 00:05:22,940
>> Så vi kommer att ställa som
till ett minimum symbol.

87
00:05:22,940 --> 00:05:25,720
Och sedan ska vi gå
vidare till nästa tecken.

88
00:05:25,720 --> 00:05:28,730
Så hur är våra gissningar
kommer att iterera?

89
00:05:28,730 --> 00:05:33,685
Tja, om giltiga tecken är a, b,
och c, så om vi började med en,

90
00:05:33,685 --> 00:05:36,630
det ska iterera till b, ska det
iterera till c..

91
00:05:36,630 --> 00:05:44,360
c är vår max symbol, så vi ska ställa
c tillbaka till en, den minsta symbolen.

92
00:05:44,360 --> 00:05:48,100
Och sedan ska vi iterera index
till nästa tecken.

93
00:05:48,100 --> 00:05:53,920
>> Så om den ursprungliga gissning var c, nästa
karaktär kommer att vara null

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

95
00:05:55,560 --> 00:06:00,670
Här nere, märker att om karaktären
som vi nu vill

96
00:06:00,670 --> 00:06:04,690
ökningen var null terminator,
då vi kommer att ställa in den till

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

98
00:06:06,260 --> 00:06:11,431
Så om gissningen var c, då vår
ny gissning kommer att vara AA.

99
00:06:11,431 --> 00:06:16,050
Och om vår ursprungliga gissning var
cccc, då vår nya gissning

100
00:06:16,050 --> 00:06:18,380
kommer att bli aaaaa.

101
00:06:18,380 --> 00:06:24,430
>> Så när vi når den högsta strängen
av en viss längd, då är vi

102
00:06:24,430 --> 00:06:29,090
kommer att genomföra den lägsta strängen
av nästa längd, som kommer att

103
00:06:29,090 --> 00:06:34,420
bara vara alla tecken
den minsta symbolen.

104
00:06:34,420 --> 00:06:36,970
Nu, vad är denna kontroll gör här?

105
00:06:36,970 --> 00:06:42,780
Tja, flyttade om index från åttonde
tecken till nio tecken -

106
00:06:42,780 --> 00:06:46,460
så vi lägger åtta C: s som
vår tidigare gissning -

107
00:06:46,460 --> 00:06:51,270
då index kommer att fokusera på
sista null terminator i vår gissning

108
00:06:51,270 --> 00:06:57,990
array, vilket inte är tänkt att faktiskt
användas i vår lösenord.

109
00:06:57,990 --> 00:07:03,530
>> Så om vi är fokuserade på att förra null
terminator, då vi inte har hittat en

110
00:07:03,530 --> 00:07:07,750
lösenord som gäller är med bara åtta
tecken, vilket innebär att det inte

111
00:07:07,750 --> 00:07:10,550
giltigt lösenord som krypterar
till den givna strängen.

112
00:07:10,550 --> 00:07:13,520
Och vi måste skriva ut det, säger
Vi kunde inte hitta ett giltigt

113
00:07:13,520 --> 00:07:16,100
lösenord och retur.

114
00:07:16,100 --> 00:07:20,280
Så här while-slinga kommer att iterera
över alla möjliga strängar.

115
00:07:20,280 --> 00:07:24,640
>> Om den hittar något som krypterar den
förväntade krypterade strängen, det ska

116
00:07:24,640 --> 00:07:26,190
returnera det lösenordet.

117
00:07:26,190 --> 00:07:29,610
Och det är det inte att hitta något, då
den ger, skriver att det

118
00:07:29,610 --> 00:07:31,910
kunde inte hitta något.

119
00:07:31,910 --> 00:07:39,220
Nu, märker att iterera över alla
möjliga strängar är förmodligen kommer att

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

121
00:07:40,420 --> 00:07:43,590
Låt oss se faktiskt hur
länge det tar.

122
00:07:43,590 --> 00:07:47,230
>> Låt oss göra crack.

123
00:07:47,230 --> 00:07:51,050
Tja, oops - det står odefinierad
hänvisning till krypta.

124
00:07:51,050 --> 00:07:55,330
Så kom ihåg, för p sätter spec och
också mannen sida för krypta som vi

125
00:07:55,330 --> 00:07:58,130
måste koppla in kryptan.

126
00:07:58,130 --> 00:08:01,130
Nu, standard gör kommandot
inte vet att du

127
00:08:01,130 --> 00:08:03,010
vill använda denna funktion.

128
00:08:03,010 --> 00:08:09,680
>> Så låt oss kopiera denna klient kommandot
och bara lägga på till slutet

129
00:08:09,680 --> 00:08:13,300
av det, länkning krypta.

130
00:08:13,300 --> 00:08:14,820
Nu, sammanställer det.

131
00:08:14,820 --> 00:08:23,880
Så låt oss köra spricka på en given
krypterade strängen -

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

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

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

135
00:08:30,790 --> 00:08:33,230
>> Observera att detta slutade på 13.

136
00:08:33,230 --> 00:08:38,240
Tja, Caesars krypterat lösenord
råkar vara 13.

137
00:08:38,240 --> 00:08:41,650
Så låt oss göra ett nytt försök.

138
00:08:41,650 --> 00:08:45,830
Låt oss ta Hirschhorn krypterade
lösenordet och försök knäcka det.

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

140
00:08:51,750 --> 00:08:55,110
>> Så märker vi redan har nått
tre tecken.

141
00:08:55,110 --> 00:08:58,660
Och vi iterera över alla möjliga
tre-teckensträngar.

142
00:08:58,660 --> 00:09:01,420
Det innebär att vi redan har slut
iteration över alla möjliga ena och

143
00:09:01,420 --> 00:09:04,660
två teckensträngar.

144
00:09:04,660 --> 00:09:09,180
Nu ser det ut som det kommer att
ta ett tag innan vi når

145
00:09:09,180 --> 00:09:10,580
fyra-teckensträngar.

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

147
00:09:14,680 --> 00:09:16,055
>> Det tog inte ett par minuter.

148
00:09:16,055 --> 00:09:18,450
Vi finns på de fyra-teckensträngar.

149
00:09:18,450 --> 00:09:22,800
Men nu måste vi iterera över alla
möjliga fyra-teckensträngar, som

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

151
00:09:26,000 --> 00:09:28,720
Och sedan när vi når fem tecken
strängar, måste vi iterera över alla

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

153
00:09:31,450 --> 00:09:34,080
Och vi måste iterera över alla möjliga
sex-teckensträngar, vilket

154
00:09:34,080 --> 00:09:36,560
kan ta ett par dagar och så vidare.

155
00:09:36,560 --> 00:09:41,380
>> Så det kan ta en potentiellt mycket lång
tid att iterera över alla möjliga

156
00:09:41,380 --> 00:09:44,850
åtta tecken och färre strängar.

157
00:09:44,850 --> 00:09:50,600
Så märker att detta inte nödvändigtvis en
mycket effektiv algoritm för att hitta

158
00:09:50,600 --> 00:09:51,860
ett lösenord.

159
00:09:51,860 --> 00:09:54,540
Du kanske tror att det
finns bättre sätt.

160
00:09:54,540 --> 00:10:02,230
Till exempel, lösenordet ZYX! 32AB
förmodligen inte är ett mycket vanligt lösenord,

161
00:10:02,230 --> 00:10:06,440
medan lösenordet 12345 är
troligen mycket vanligare.

162
00:10:06,440 --> 00:10:13,570
>> Så ett sätt att försöka hitta ett lösenord
snabbare är att bara titta

163
00:10:13,570 --> 00:10:15,560
på lösenord som är vanligare.

164
00:10:15,560 --> 00:10:20,480
Så till exempel, kan vi försöka läsa ord
från en ordbok och prova alla

165
00:10:20,480 --> 00:10:24,860
dessa ord som våra lösenord gissningar.

166
00:10:24,860 --> 00:10:29,210
Nu, kanske en lösenord
är inte så enkelt.

167
00:10:29,210 --> 00:10:32,600
Kanske användaren var något smart
och prova att lägga ett nummer till

168
00:10:32,600 --> 00:10:34,220
slutet av ett ord.

169
00:10:34,220 --> 00:10:37,000
>> Så kanske deras lösenord var password1.

170
00:10:37,000 --> 00:10:41,520
Så du kan prova iteration över alla ord
i ordboken med en en

171
00:10:41,520 --> 00:10:43,210
läggs till i slutet av det.

172
00:10:43,210 --> 00:10:47,360
Och då kanske efter att göra det, kommer du
lägga till en två till slutet av den.

173
00:10:47,360 --> 00:10:50,240
>> Eller kanske användaren försöker att bli ännu
mer smart, och de vill att deras

174
00:10:50,240 --> 00:10:54,980
lösenord för att vara "hacker", men de är
kommer att ersätta alla förekomster av e s

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

176
00:10:56,600 --> 00:10:58,440
Så du kunde göra det också.

177
00:10:58,440 --> 00:11:02,100
Iterera över alla ord i ordlistan
men byt ut tecken som

178
00:11:02,100 --> 00:11:04,790
ser ut som siffror med dessa siffror.

179
00:11:04,790 --> 00:11:09,670
>> Så här sättet, kan du fånga ännu mer
lösenord som är ganska vanligt.

180
00:11:09,670 --> 00:11:14,690
Men i slutändan, det enda sättet du kan
fånga alla lösenord är att brute

181
00:11:14,690 --> 00:11:17,340
tvinga iterera över alla
möjliga strängar.

182
00:11:17,340 --> 00:11:22,100
Så i slutändan behöver du iterera
över alla strängar från ett tecken till

183
00:11:22,100 --> 00:11:28,110
åtta tecken, vilket kan ta en
mycket lång tid, men du måste göra det.

184
00:11:28,110 --> 00:11:30,024
>> Mitt namn är Rob Bowden.

185
00:11:30,024 --> 00:11:31,425
Och detta är crack.

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