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

2
00:00:13,000 --> 00:00:15,890
>> ROB BOWDEN: Je suis Rob, et
Sortons fissuration.

3
00:00:15,890 --> 00:00:19,390
Alors, n'oubliez pas de le spec pset que
nous allons avoir besoin d'utiliser le

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

5
00:00:20,890 --> 00:00:26,330
Pour la page de manuel, nous avons deux
hash définir _xopensource.

6
00:00:26,330 --> 00:00:28,290
Ne vous inquiétez pas pourquoi
nous avons besoin de le faire.

7
00:00:28,290 --> 00:00:31,550
Et aussi de hachage comprennent unistd.h.

8
00:00:31,550 --> 00:00:35,920
>> Donc, une fois que c'est sur la route, nous allons
obtenir le programme réel.

9
00:00:35,920 --> 00:00:39,570
La première chose que nous devons faire est de s'assurer
l'utilisateur a entré une chiffré valide

10
00:00:39,570 --> 00:00:41,520
le mot de passe à la ligne de commande.

11
00:00:41,520 --> 00:00:46,050
Rappelez-vous que le programme est censé
pour être exécuté comme point slash crack, et

12
00:00:46,050 --> 00:00:48,120
puis chaîne cryptée.

13
00:00:48,120 --> 00:00:52,990
>> Donc, ici nous vérification pour s'assurer que
que argc à deux si nous voulons

14
00:00:52,990 --> 00:00:54,380
poursuivre le programme.

15
00:00:54,380 --> 00:00:58,830
Si argc n'est pas deux, cela signifie que soit
l'utilisateur n'a pas une connexion cryptée

16
00:00:58,830 --> 00:01:02,560
le mot de passe à la ligne de commande, ou bien ils
entré plus que la crypté

17
00:01:02,560 --> 00:01:05,379
le mot de passe à la ligne de commande, dans lequel
cas, nous ne savons pas quoi faire avec le

18
00:01:05,379 --> 00:01:07,660
arguments de ligne de commande.

19
00:01:07,660 --> 00:01:11,390
>> Donc, si argc avait deux ans, nous pouvons continuer.

20
00:01:11,390 --> 00:01:14,160
Et ici, nous allons déclarer
un crypté variable.

21
00:01:14,160 --> 00:01:17,650
Cela va juste alias l'original
argv1 de telle sorte que tout au long de cette

22
00:01:17,650 --> 00:01:20,690
programme, nous n'avons pas l'appeler argv1,
qui alors vous devez penser

23
00:01:20,690 --> 00:01:22,950
sur ce que signifiait réellement.

24
00:01:22,950 --> 00:01:27,180
>> Donc finalement, nous voulons valider que
le mot de passe crypté de l'utilisateur

25
00:01:27,180 --> 00:01:30,840
entré auraient effectivement été
un mot de passe crypté.

26
00:01:30,840 --> 00:01:35,120
Par la page de manuel de crypt, l'
mot de passe crypté doit être de 13

27
00:01:35,120 --> 00:01:36,440
caractères.

28
00:01:36,440 --> 00:01:41,500
Jusqu'à ici, remarquons que nous hachage défini
crypter durée de 13 ans.

29
00:01:41,500 --> 00:01:46,140
Donc, nous sommes en train de faire en sorte que le
longueur de la chaîne de l'crypté

30
00:01:46,140 --> 00:01:49,090
mot de passe est de 13.

31
00:01:49,090 --> 00:01:52,280
>> Et si c'est non, nous voulons
pour quitter le programme.

32
00:01:52,280 --> 00:01:56,470
Donc, une fois que c'est sur le chemin, nous pouvons
maintenant effectivement essayer de trouver ce que l'

33
00:01:56,470 --> 00:02:00,410
mot de passe qui a donné l'crypté
mot de passe était.

34
00:02:00,410 --> 00:02:04,870
Ici, nous voulons récupérer le sel
du mot de passe crypté.

35
00:02:04,870 --> 00:02:08,930
Rappelez-vous, par la page de manuel, que l'
deux premiers caractères d'une chiffré

36
00:02:08,930 --> 00:02:10,590
chaîne, comme ici -

37
00:02:10,590 --> 00:02:12,770
50ZPJ et ainsi de suite -

38
00:02:12,770 --> 00:02:16,170
les deux premiers caractères donnent
nous le sel qui a été utilisé

39
00:02:16,170 --> 00:02:18,080
dans la fonction crypt.

40
00:02:18,080 --> 00:02:21,740
>> Et ici, nous voyons que le sel était ha.

41
00:02:21,740 --> 00:02:27,610
Donc, nous voulons copier les deux premiers
caractères, la longueur du sel étant de hachage

42
00:02:27,610 --> 00:02:30,230
défini comme étant deux.

43
00:02:30,230 --> 00:02:35,970
Nous devons copier les deux premiers caractères
dans ce tableau, le sel.

44
00:02:35,970 --> 00:02:39,340
Notez que nous devons longueur de sel, plus
, puisque nous avons encore besoin d'un nul

45
00:02:39,340 --> 00:02:42,440
terminator à la fin de notre sel.

46
00:02:42,440 --> 00:02:46,940
>> Ensuite, nous allons déclarer ce tableau,
invité, de taille longueur max plus

47
00:02:46,940 --> 00:02:51,930
un, où la longueur maximale est de hachage définie
que huit, depuis le mot de passe maximale

48
00:02:51,930 --> 00:02:55,090
est de huit caractères.

49
00:02:55,090 --> 00:02:59,860
Et nous allons l'utiliser pour itérer
sur toutes les chaînes possibles qui pourraient

50
00:02:59,860 --> 00:03:01,430
être des mots de passe valides.

51
00:03:01,430 --> 00:03:07,720
Donc, si les caractères valides dans un mot de passe
étaient tout a, b, et c, puis

52
00:03:07,720 --> 00:03:14,970
nous itérer sur a, b, c,
aa, Ba, Ca, et ainsi de suite, jusqu'à ce que

53
00:03:14,970 --> 00:03:16,690
nous arrivons à voir cccccccc -

54
00:03:16,690 --> 00:03:19,600
huit c de.

55
00:03:19,600 --> 00:03:23,620
>> Et si nous n'avons pas descendre valide
mot de passe, alors nous devons dire que l'

56
00:03:23,620 --> 00:03:26,590
chaîne cryptée n'était pas
valable pour commencer.

57
00:03:26,590 --> 00:03:29,970
Alors maintenant, nous arrivons à cela tout en 1 boucle.

58
00:03:29,970 --> 00:03:33,100
Notez cela signifie qu'il est
une boucle infinie.

59
00:03:33,100 --> 00:03:36,430
>> Remarquez qu'il n'y a pas de déclaration de rupture
à l'intérieur de cette boucle infinie.

60
00:03:36,430 --> 00:03:38,570
Il ya seulement revenir déclarations.

61
00:03:38,570 --> 00:03:41,210
Donc, nous n'attendons jamais réellement
à sortir de la boucle.

62
00:03:41,210 --> 00:03:44,750
Nous ne prévoyons pour quitter le programme.

63
00:03:44,750 --> 00:03:48,220
J'ai ajouté cette déclaration d'impression à l'
haut de cette boucle à juste imprimer

64
00:03:48,220 --> 00:03:51,790
ce que notre estimation actuelle à
ce que le mot de passe.

65
00:03:51,790 --> 00:03:53,630
>> Maintenant, quelle est cette boucle fait?

66
00:03:53,630 --> 00:03:58,330
Il tourne en boucle sur toutes les chaînes possibles
ce pourrait être les mots de passe valides.

67
00:03:58,330 --> 00:04:02,700
La première chose que nous allons faire est
prendre notre estimation actuelle pour ce que l'

68
00:04:02,700 --> 00:04:03,920
mot de passe.

69
00:04:03,920 --> 00:04:07,230
Nous prendrons le sel que nous avons pris de
la chaîne cryptée, et nous sommes

70
00:04:07,230 --> 00:04:09,850
aller à chiffrer le deviner.

71
00:04:09,850 --> 00:04:14,760
Cela nous donnera une estimation chiffrée,
que nous allons à comparer

72
00:04:14,760 --> 00:04:18,810
la chaîne cryptée que l'utilisateur
entré à la ligne de commande.

73
00:04:18,810 --> 00:04:23,030
>> Si elles sont identiques, auquel cas
chaîne comparable retournera zéro, si

74
00:04:23,030 --> 00:04:28,050
ils sont les mêmes, alors deviner était le
mot de passe qui a généré l'crypté

75
00:04:28,050 --> 00:04:33,520
chaîne, dans ce cas, nous pouvons imprimer
que notre mot de passe et retour.

76
00:04:33,520 --> 00:04:37,520
Mais s'ils n'étaient pas les mêmes, que
signifie que notre supposition était erronée.

77
00:04:37,520 --> 00:04:43,250
>> Et nous voulons réitérer à
la conjecture valide prochaine.

78
00:04:43,250 --> 00:04:46,410
Donc, c'est ce que ce tout
boucle essaie de faire.

79
00:04:46,410 --> 00:04:51,760
Il va parcourir notre conjecture
à l'autre supposition valide.

80
00:04:51,760 --> 00:04:56,080
Notez que lorsque nous disons qu'un
caractère particulier de notre conjecture a

81
00:04:56,080 --> 00:05:01,770
atteint le symbole max, qui ici
hash est défini comme un tilde, depuis

82
00:05:01,770 --> 00:05:05,710
c'est le plus grand caractère de valeur ASCII
qu'un utilisateur peut entrer à l'

83
00:05:05,710 --> 00:05:11,210
clavier, lorsque le personnage atteint le
Symbole max, alors que nous voulons envoyer

84
00:05:11,210 --> 00:05:17,150
il sur le symbole minimum, qui
est un espace, encore une fois le plus bas ASCII

85
00:05:17,150 --> 00:05:20,800
symbole de valeur qu'un utilisateur puisse
Entrez au clavier.

86
00:05:20,800 --> 00:05:22,940
>> Donc, nous allons mettre cela
le symbole minimum.

87
00:05:22,940 --> 00:05:25,720
Et puis nous allons aller
sur le caractère suivant.

88
00:05:25,720 --> 00:05:28,730
Alors, comment sont nos suppositions
aller à parcourir?

89
00:05:28,730 --> 00:05:33,685
Eh bien, si les caractères valides sont A, B,
et c, alors si nous avons commencé avec un,

90
00:05:33,685 --> 00:05:36,630
il va itérer à b, il va
itérer à c.

91
00:05:36,630 --> 00:05:44,360
c est notre symbole max, donc on va mettre
c revenir à un, le symbole minimum.

92
00:05:44,360 --> 00:05:48,100
Et puis nous parcourons index
au caractère suivant.

93
00:05:48,100 --> 00:05:53,920
>> Donc, si la conjecture initiale était c, la prochaine
personnage va être le nul

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

95
00:05:55,560 --> 00:06:00,670
Ici-bas, notez que si le caractère
que nous voulons maintenant

96
00:06:00,670 --> 00:06:04,690
minimum a été le terminateur null,
alors nous allons mettre à l'

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

98
00:06:06,260 --> 00:06:11,431
Donc, si la conjecture était c, alors notre
nouvelle estimation va être aa.

99
00:06:11,431 --> 00:06:16,050
Et si notre hypothèse de départ était
cccc, notre nouvelle conjecture

100
00:06:16,050 --> 00:06:18,380
va être AAAAA.

101
00:06:18,380 --> 00:06:24,430
>> Donc, chaque fois que nous arrivons à la chaîne maximale
d'une longueur donnée, alors nous sommes

102
00:06:24,430 --> 00:06:29,090
va mettre en œuvre pour la chaîne minimum
de la longueur suivante qui sera

103
00:06:29,090 --> 00:06:34,420
juste être tous les caractères d'
le symbole minimum.

104
00:06:34,420 --> 00:06:36,970
Maintenant, quelle est cette vérification fais ici?

105
00:06:36,970 --> 00:06:42,780
Eh bien, si l'indice est passé de la huitième
caractère à caractère neuf -

106
00:06:42,780 --> 00:06:46,460
si nous ajoutons huit c de l'AS
notre précédente deviner -

107
00:06:46,460 --> 00:06:51,270
puis l'indice va se concentrer sur la
dernière terminaison nulle de notre conjecture

108
00:06:51,270 --> 00:06:57,990
tableau, ce qui n'est pas destiné à réellement
être utilisé dans notre mot de passe.

109
00:06:57,990 --> 00:07:03,530
>> Donc, si nous nous concentrons sur ce dernier null
terminateur, alors nous n'avons pas trouvé un

110
00:07:03,530 --> 00:07:07,750
mot de passe qui est valide en utilisant seulement huit
caractères, ce qui signifie qu'il n'ya pas

111
00:07:07,750 --> 00:07:10,550
mot de passe valides qui crypte
de la chaîne donnée.

112
00:07:10,550 --> 00:07:13,520
Et nous avons l'impression que, en disant:
nous n'avons pas pu trouver un valide

113
00:07:13,520 --> 00:07:16,100
mot de passe, et de retour.

114
00:07:16,100 --> 00:07:20,280
Donc, cette boucle while va itérer
sur toutes les chaînes possibles.

115
00:07:20,280 --> 00:07:24,640
>> S'il en trouve qui crypte à l'
chaîne cryptée prévu, il va

116
00:07:24,640 --> 00:07:26,190
retourner ce mot de passe.

117
00:07:26,190 --> 00:07:29,610
Et il ne trouve rien, alors
il sera de retour, l'impression qu'il

118
00:07:29,610 --> 00:07:31,910
n'était pas en mesure de trouver quoi que ce soit.

119
00:07:31,910 --> 00:07:39,220
Maintenant, remarquez que l'itération sur tous
chaînes possibles va probablement

120
00:07:39,220 --> 00:07:40,420
prendre un certain temps.

121
00:07:40,420 --> 00:07:43,590
Voyons voir réellement comment
temps que cela prendra.

122
00:07:43,590 --> 00:07:47,230
>> Faisons fissure.

123
00:07:47,230 --> 00:07:51,050
Eh bien, oups - il dit undefined
référence à la crypte.

124
00:07:51,050 --> 00:07:55,330
Donc n'oubliez pas, pour le p définit les spécifications et
également la page de manuel de crypt que nous

125
00:07:55,330 --> 00:07:58,130
besoin d'un lien dans la crypte.

126
00:07:58,130 --> 00:08:01,130
Maintenant, la valeur par défaut la commande make
ne sait pas que vous

127
00:08:01,130 --> 00:08:03,010
vouloir utiliser cette fonction.

128
00:08:03,010 --> 00:08:09,680
>> Donc, nous allons copier cette commande client
et il suffit d'ajouter à la fin

129
00:08:09,680 --> 00:08:13,300
de celui-ci, de la crypte de liaison.

130
00:08:13,300 --> 00:08:14,820
Maintenant, il compile.

131
00:08:14,820 --> 00:08:23,880
Alors lançons fissure sur une donnée
chaîne cryptée -

132
00:08:23,880 --> 00:08:25,130
si César.

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

134
00:08:28,690 --> 00:08:30,790
C'était donc assez vite.

135
00:08:30,790 --> 00:08:33,230
>> Notez que cela s'est terminé le 13.

136
00:08:33,230 --> 00:08:38,240
Eh bien, mot de passe crypté César
se trouve être 13.

137
00:08:38,240 --> 00:08:41,650
Essayons donc un autre mot de passe.

138
00:08:41,650 --> 00:08:45,830
Prenons crypté Hirschhorn
mot de passe et essayer de craquage qui.

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

140
00:08:51,750 --> 00:08:55,110
>> Donc remarquerez que nous avons déjà atteint
trois personnages.

141
00:08:55,110 --> 00:08:58,660
Et nous itérer sur tous les possibles
cordes à trois caractères.

142
00:08:58,660 --> 00:09:01,420
Cela signifie que nous avons déjà fini
itération sur une possible et

143
00:09:01,420 --> 00:09:04,660
deux chaînes de caractères.

144
00:09:04,660 --> 00:09:09,180
Maintenant, il semble que cela va
prendre un certain temps avant que nous atteignions l'

145
00:09:09,180 --> 00:09:10,580
chaînes de quatre caractères.

146
00:09:10,580 --> 00:09:14,680
Cela peut prendre quelques minutes.

147
00:09:14,680 --> 00:09:16,055
>> Il n'a pas fallu quelques minutes.

148
00:09:16,055 --> 00:09:18,450
Nous sommes sur les chaînes de quatre caractères.

149
00:09:18,450 --> 00:09:22,800
Mais maintenant, nous avons besoin d'itérer sur tous les
chaînes de quatre caractères possibles, ce qui

150
00:09:22,800 --> 00:09:26,000
qui pourrait prendre peut-être 10 minutes.

151
00:09:26,000 --> 00:09:28,720
Et puis, quand nous arrivons à cinq caractères
cordes, nous avons besoin d'itérer sur tous les

152
00:09:28,720 --> 00:09:31,450
de ceux qui pourraient
prendre quelques heures.

153
00:09:31,450 --> 00:09:34,080
Et nous avons besoin d'itérer sur tous les possibles
six chaînes de caractères, qui

154
00:09:34,080 --> 00:09:36,560
pourrait prendre quelques jours et ainsi de suite.

155
00:09:36,560 --> 00:09:41,380
>> Donc, il pourrait prendre un potentiellement très long
temps pour parcourir tout possible

156
00:09:41,380 --> 00:09:44,850
huit caractères et moins de cordes.

157
00:09:44,850 --> 00:09:50,600
Donc, notez que ce n'est pas nécessairement une
algorithme très efficace pour trouver

158
00:09:50,600 --> 00:09:51,860
un mot de passe.

159
00:09:51,860 --> 00:09:54,540
Vous pourriez penser qu'il ya
ya de meilleures façons.

160
00:09:54,540 --> 00:10:02,230
Par exemple, le zyx mot de passe! 32AB
n'est probablement pas un mot de passe très commun,

161
00:10:02,230 --> 00:10:06,440
alors que le mot de passe est 12345
probablement beaucoup plus commun.

162
00:10:06,440 --> 00:10:13,570
>> Donc, une façon d'essayer de trouver un mot de passe
est plus rapide de simplement regarder

163
00:10:13,570 --> 00:10:15,560
à des mots de passe qui sont plus fréquentes.

164
00:10:15,560 --> 00:10:20,480
Ainsi, par exemple, nous pouvons essayer de lire des mots
à partir d'un dictionnaire et d'essayer tous

165
00:10:20,480 --> 00:10:24,860
ces mots que nos suppositions de mot de passe.

166
00:10:24,860 --> 00:10:29,210
Maintenant, peut-être un mot de passe
n'est pas si simple.

167
00:10:29,210 --> 00:10:32,600
Peut-être que l'utilisateur était un peu intelligent
et essayer ajoutant un numéro

168
00:10:32,600 --> 00:10:34,220
la fin d'un mot.

169
00:10:34,220 --> 00:10:37,000
>> Alors peut-être leur mot de passe a été password1.

170
00:10:37,000 --> 00:10:41,520
Ainsi, vous pouvez essayer itérer sur tous les mots
dans le dictionnaire avec l'un

171
00:10:41,520 --> 00:10:43,210
annexée à la fin de celui-ci.

172
00:10:43,210 --> 00:10:47,360
Et puis peut-être après avoir fait cela, vous aurez
ajouter un deux à la fin de celui-ci.

173
00:10:47,360 --> 00:10:50,240
>> Ou peut-être que l'utilisateur essaie d'être encore
plus intelligent, et ils veulent que leur

174
00:10:50,240 --> 00:10:54,980
mot de passe pour être "hacker", mais ils sont
va remplacer toutes les occurrences d'e de

175
00:10:54,980 --> 00:10:56,600
avec trois.

176
00:10:56,600 --> 00:10:58,440
Ainsi, vous pouvez le faire aussi.

177
00:10:58,440 --> 00:11:02,100
Itérer sur tous les mots dans le dictionnaire
mais remplacer des caractères

178
00:11:02,100 --> 00:11:04,790
ressembler à des nombres avec ces chiffres.

179
00:11:04,790 --> 00:11:09,670
>> Ainsi de cette façon, vous pourriez attraper encore plus
les mots de passe qui sont assez communs.

180
00:11:09,670 --> 00:11:14,690
Mais en fin de compte, la seule façon que vous pouvez
capturer les mots de passe est de brute

181
00:11:14,690 --> 00:11:17,340
forcer itérer sur tous les
chaînes possibles.

182
00:11:17,340 --> 00:11:22,100
Donc à la fin, vous n'avez pas besoin d'itérer
sur toutes les chaînes de caractères d'un personnage à

183
00:11:22,100 --> 00:11:28,110
huit caractères, ce qui pourrait prendre un
très longtemps, mais vous devez le faire.

184
00:11:28,110 --> 00:11:30,024
>> Mon nom est Rob Bowden.

185
00:11:30,024 --> 00:11:31,425
Et c'est Crack.

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