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

2
00:00:13,000 --> 00:00:15,890
>> ROB BOWDEN: Eu sou Rob, e
vamos começar rachando.

3
00:00:15,890 --> 00:00:19,390
Então lembre-se de que a especificação pset
vamos precisar usar o

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

5
00:00:20,890 --> 00:00:26,330
Para a página principal, temos dois
hash de definir _xopensource.

6
00:00:26,330 --> 00:00:28,290
Não se preocupe sobre o porquê
precisamos fazer isso.

7
00:00:28,290 --> 00:00:31,550
E também haxixe incluem unistd.h.

8
00:00:31,550 --> 00:00:35,920
>> Assim, uma vez que está fora do caminho, vamos
chegar ao programa real.

9
00:00:35,920 --> 00:00:39,570
A primeira coisa que precisamos fazer é certificar-se
o usuário digitou um criptografado válido

10
00:00:39,570 --> 00:00:41,520
senha na linha de comando.

11
00:00:41,520 --> 00:00:46,050
Lembre-se que o programa é suposto
para ser executado como dot barra de crack, e

12
00:00:46,050 --> 00:00:48,120
então string encriptada.

13
00:00:48,120 --> 00:00:52,990
>> Então, aqui estamos verificando para certificar-se
que argc a dois, se quisermos

14
00:00:52,990 --> 00:00:54,380
continuar com o programa.

15
00:00:54,380 --> 00:00:58,830
Se argc não é dois, o que significa qualquer
o usuário não entrar um criptografado

16
00:00:58,830 --> 00:01:02,560
senha na linha de comando, ou eles
entrou mais do que apenas o criptografado

17
00:01:02,560 --> 00:01:05,379
senha na linha de comando, em que
caso não sabemos o que fazer com o

18
00:01:05,379 --> 00:01:07,660
argumentos de linha de comando.

19
00:01:07,660 --> 00:01:11,390
>> Então, se argc tinha dois anos, podemos continuar.

20
00:01:11,390 --> 00:01:14,160
E aqui, nós vamos declarar
uma variável encriptada.

21
00:01:14,160 --> 00:01:17,650
Isso só vai alias originais
argv1 de modo que ao longo desta

22
00:01:17,650 --> 00:01:20,690
programa, não temos de chamá-lo argv1,
que, então, você tem que pensar

23
00:01:20,690 --> 00:01:22,950
sobre o que isso realmente significa.

24
00:01:22,950 --> 00:01:27,180
>> Então, finalmente, queremos validar que
a senha criptografada do usuário

25
00:01:27,180 --> 00:01:30,840
entrou poderia ter sido realmente
uma senha criptografada.

26
00:01:30,840 --> 00:01:35,120
Por página man do cripta, a
senha criptografada deve ser 13

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

28
00:01:36,440 --> 00:01:41,500
Até aqui, perceber que nós Hash definido
criptografar comprimento 13.

29
00:01:41,500 --> 00:01:46,140
Então, nós estamos apenas certificando-se de que o
comprimento da corda do criptografado

30
00:01:46,140 --> 00:01:49,090
senha é 13.

31
00:01:49,090 --> 00:01:52,280
>> E se não é, nós queremos
para sair do programa.

32
00:01:52,280 --> 00:01:56,470
Assim, uma vez que está fora de forma, podemos
agora realmente tentar encontrar o que o

33
00:01:56,470 --> 00:02:00,410
senha que deu o criptografado
senha era.

34
00:02:00,410 --> 00:02:04,870
Aqui, queremos pegar o sal
da senha criptografada.

35
00:02:04,870 --> 00:02:08,930
Lembre-se de acordo com a página do homem, que o
os dois primeiros caracteres de um criptografado

36
00:02:08,930 --> 00:02:10,590
string, como aqui -

37
00:02:10,590 --> 00:02:12,770
50ZPJ e assim por diante -

38
00:02:12,770 --> 00:02:16,170
os dois primeiros caracteres dar
nós o sal que foi usado

39
00:02:16,170 --> 00:02:18,080
em função da cripta.

40
00:02:18,080 --> 00:02:21,740
>> E aqui, vemos que o sal era ha.

41
00:02:21,740 --> 00:02:27,610
Então, nós queremos copiar os dois primeiros
caracteres, o comprimento sal ser haxixe

42
00:02:27,610 --> 00:02:30,230
definida como dois.

43
00:02:30,230 --> 00:02:35,970
Temos que copiar os dois primeiros caracteres
nessa matriz, sal.

44
00:02:35,970 --> 00:02:39,340
Observe que precisamos comprimento sal mais
um, já que ainda precisa de um nulo

45
00:02:39,340 --> 00:02:42,440
terminator no final do nosso sal.

46
00:02:42,440 --> 00:02:46,940
>> Então vamos declarar essa matriz,
convidado, de grande dimensão max mais

47
00:02:46,940 --> 00:02:51,930
um, onde o comprimento máximo é de hash definido
como oito, uma vez que o máximo de senha

48
00:02:51,930 --> 00:02:55,090
é de oito caracteres.

49
00:02:55,090 --> 00:02:59,860
E nós vamos usar isso para repetir
sobre todas as cordas possíveis que poderiam

50
00:02:59,860 --> 00:03:01,430
ser senhas válidas.

51
00:03:01,430 --> 00:03:07,720
Então, se os caracteres válidos em uma senha
foram apenas a, b, e c, então

52
00:03:07,720 --> 00:03:14,970
gostaríamos de iterar a, b, c,
aa, ba, ca, e assim por diante, até

53
00:03:14,970 --> 00:03:16,690
temos de ver cccccccc -

54
00:03:16,690 --> 00:03:19,600
oito c do.

55
00:03:19,600 --> 00:03:23,620
>> E se não temos por um válido
senha, então temos de dizer que o

56
00:03:23,620 --> 00:03:26,590
string encriptada não era
válido para começar.

57
00:03:26,590 --> 00:03:29,970
Então, agora, chegamos a este enquanto um loop.

58
00:03:29,970 --> 00:03:33,100
Observe que significa que é
um loop infinito.

59
00:03:33,100 --> 00:03:36,430
>> Observe que não há instrução break
dentro deste loop infinito.

60
00:03:36,430 --> 00:03:38,570
Existem apenas voltar declarações.

61
00:03:38,570 --> 00:03:41,210
Então, nós nunca realmente esperar
para sair do loop.

62
00:03:41,210 --> 00:03:44,750
Nós só esperar para sair do programa.

63
00:03:44,750 --> 00:03:48,220
Eu adicionei esta declaração de impressão para a
Além disso loop para apenas imprimir

64
00:03:48,220 --> 00:03:51,790
que nossa suposição corrente no
qual é a senha.

65
00:03:51,790 --> 00:03:53,630
>> Agora, o que é este ciclo fazendo?

66
00:03:53,630 --> 00:03:58,330
É um loop sobre todas as cordas possíveis
que poderia ser senhas válidas.

67
00:03:58,330 --> 00:04:02,700
A primeira coisa que vamos fazer é
tomar o nosso palpite atual para o que o

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

69
00:04:03,920 --> 00:04:07,230
Vamos levar o sal que nós agarramos a partir de
a string encriptada, e estamos

70
00:04:07,230 --> 00:04:09,850
indo para criptografar o palpite.

71
00:04:09,850 --> 00:04:14,760
Isso nos dará um palpite criptografado,
que nós estamos indo para comparação

72
00:04:14,760 --> 00:04:18,810
a string encriptada que o usuário
entrou na linha de comando.

73
00:04:18,810 --> 00:04:23,030
>> Se eles são idênticos, caso em que
corda comparável retornará zero, se

74
00:04:23,030 --> 00:04:28,050
eles são o mesmo, então acho que foi o
palavra-passe que gerou o criptografado

75
00:04:28,050 --> 00:04:33,520
cadeia, caso em que pode imprimir
que, como a palavra-passe e retorno.

76
00:04:33,520 --> 00:04:37,520
Mas se eles não eram os mesmos, que
significa que o nosso palpite estava incorreta.

77
00:04:37,520 --> 00:04:43,250
>> E nós queremos repetir a
a próxima suposição válida.

78
00:04:43,250 --> 00:04:46,410
Então, isso é o que esse tempo
loop está tentando fazer.

79
00:04:46,410 --> 00:04:51,760
Vai repetir o nosso palpite
para a próxima suposição válida.

80
00:04:51,760 --> 00:04:56,080
Observe que quando dizemos que um
caráter particular, em nossa suposição tem

81
00:04:56,080 --> 00:05:01,770
atingiram o símbolo máximo, que aqui
é definido como uma mistura til, pois

82
00:05:01,770 --> 00:05:05,710
que é o maior personagem valor ASCII
que um utilizador pode entrar no

83
00:05:05,710 --> 00:05:11,210
teclado, quando o personagem alcançar a
max símbolo, então queremos enviar

84
00:05:11,210 --> 00:05:17,150
de volta para o símbolo mínimo, que
é um espaço, uma vez mais o menor ASCII

85
00:05:17,150 --> 00:05:20,800
símbolo de valor que um usuário pode
digite no teclado.

86
00:05:20,800 --> 00:05:22,940
>> Então, nós estamos indo para definir que
o símbolo mínimo.

87
00:05:22,940 --> 00:05:25,720
E então nós estamos indo para ir
para o próximo caractere.

88
00:05:25,720 --> 00:05:28,730
Então, como estão os nossos palpites
vai repetir?

89
00:05:28,730 --> 00:05:33,685
Ora, se os caracteres válidos são a, b,
e c, então, se iniciou com a,

90
00:05:33,685 --> 00:05:36,630
ele vai repetir a b, ele vai
iteração para c.

91
00:05:36,630 --> 00:05:44,360
c é o nosso símbolo máximo, então vamos definir
c volta a um, o símbolo mínimo.

92
00:05:44,360 --> 00:05:48,100
E então nós vamos repetir índice
para o próximo caractere.

93
00:05:48,100 --> 00:05:53,920
>> Então, se a estimativa inicial foi c, o próximo
personagem vai ser o nulo

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

95
00:05:55,560 --> 00:06:00,670
Aqui em baixo, observe que se o personagem
que queremos agora

96
00:06:00,670 --> 00:06:04,690
incremento é o terminador nulo,
então vamos configurá-lo para o

97
00:06:04,690 --> 00:06:06,260
símbolo mínimo.

98
00:06:06,260 --> 00:06:11,431
Portanto, se o palpite era c, então a nossa
novo palpite vai ser aa.

99
00:06:11,431 --> 00:06:16,050
E se nossa suposição original
cccc, então nosso novo palpite

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

101
00:06:18,380 --> 00:06:24,430
>> Assim, sempre que chegamos a corda máxima
de um determinado comprimento, então estamos

102
00:06:24,430 --> 00:06:29,090
vai implementar para a seqüência mínima
do comprimento seguinte, que irá

103
00:06:29,090 --> 00:06:34,420
basta ter todos os personagens de
o símbolo mínimo.

104
00:06:34,420 --> 00:06:36,970
Agora, o que é essa verificação está fazendo aqui?

105
00:06:36,970 --> 00:06:42,780
Bem, se o índice passou de oitavo
caráter ao caráter nove -

106
00:06:42,780 --> 00:06:46,460
então adicionamos oito c de como
o nosso anterior acho -

107
00:06:46,460 --> 00:06:51,270
em seguida, o índice vai se concentrar na
última terminador nulo do nosso palpite

108
00:06:51,270 --> 00:06:57,990
matriz, que não se destina a efectivamente
ser usado no nosso senha.

109
00:06:57,990 --> 00:07:03,530
>> Então, se estamos focados nessa última nulo
terminator, então nós não encontramos uma

110
00:07:03,530 --> 00:07:07,750
senha que é válido usar apenas oito
caracteres, o que significa que não há

111
00:07:07,750 --> 00:07:10,550
senha válida que criptografa
a string dada.

112
00:07:10,550 --> 00:07:13,520
E nós temos que imprimir isso, dizendo que
não conseguimos encontrar um válido

113
00:07:13,520 --> 00:07:16,100
senha, e retorno.

114
00:07:16,100 --> 00:07:20,280
Portanto, este loop while vai repetir
sobre todas as cordas possíveis.

115
00:07:20,280 --> 00:07:24,640
>> Se encontrar qualquer que criptografa a
string encriptada esperado, ele vai

116
00:07:24,640 --> 00:07:26,190
retornar a senha.

117
00:07:26,190 --> 00:07:29,610
E ele não encontrar nada, então
ele irá retornar, a impressão que

118
00:07:29,610 --> 00:07:31,910
não foi capaz de encontrar qualquer coisa.

119
00:07:31,910 --> 00:07:39,220
Agora, observe que a iteração sobre todos
possíveis seqüências provavelmente vai

120
00:07:39,220 --> 00:07:40,420
demorar um pouco.

121
00:07:40,420 --> 00:07:43,590
Vamos realmente ver como
tempo que leva.

122
00:07:43,590 --> 00:07:47,230
>> Vamos fazer o crack.

123
00:07:47,230 --> 00:07:51,050
Bem, oops - diz indefinido
referência a cripta.

124
00:07:51,050 --> 00:07:55,330
Então lembre-se, para o p define especificação e
também a página de manual para cripta que

125
00:07:55,330 --> 00:07:58,130
necessidade de ligar na cripta.

126
00:07:58,130 --> 00:08:01,130
Agora, o padrão comando make
não sabe que você

127
00:08:01,130 --> 00:08:03,010
quero usar essa função.

128
00:08:03,010 --> 00:08:09,680
>> Então, vamos copiar este comando cliente
e apenas adicionar até o fim

129
00:08:09,680 --> 00:08:13,300
do mesmo, ligando cripta.

130
00:08:13,300 --> 00:08:14,820
Agora, ele compila.

131
00:08:14,820 --> 00:08:23,880
Então vamos correr de crack em um determinado
string encriptada -

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

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

134
00:08:28,690 --> 00:08:30,790
Então isso foi muito rápido.

135
00:08:30,790 --> 00:08:33,230
>> Note-se que esta terminou em 13.

136
00:08:33,230 --> 00:08:38,240
Bem, senha criptografada de César
passa a ser 13.

137
00:08:38,240 --> 00:08:41,650
Então, vamos tentar outra senha.

138
00:08:41,650 --> 00:08:45,830
Vamos dar criptografado de Hirschhorn
senha e tentar quebrar isso.

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

140
00:08:51,750 --> 00:08:55,110
>> Então, observe que já chegou
três personagens.

141
00:08:55,110 --> 00:08:58,660
E nós estamos interagindo sobre todos os possíveis
seqüências de três caracteres.

142
00:08:58,660 --> 00:09:01,420
Isso significa que já terminar
iteração sobre tudo um possível e

143
00:09:01,420 --> 00:09:04,660
duas cadeias de caracteres.

144
00:09:04,660 --> 00:09:09,180
Agora, parece que isso vai
demorar um pouco antes de chegar ao

145
00:09:09,180 --> 00:09:10,580
seqüências de quatro caracteres.

146
00:09:10,580 --> 00:09:14,680
Pode demorar um par de minutos.

147
00:09:14,680 --> 00:09:16,055
>> Não demorou um par de minutos.

148
00:09:16,055 --> 00:09:18,450
Estamos nas cordas de quatro caracteres.

149
00:09:18,450 --> 00:09:22,800
Mas agora, precisamos iterar sobre todos
possíveis seqüências de caracteres de quatro, que

150
00:09:22,800 --> 00:09:26,000
que pode levar talvez 10 minutos.

151
00:09:26,000 --> 00:09:28,720
E então, quando chegarmos a cinco caráter
cordas, precisamos iterar sobre todos

152
00:09:28,720 --> 00:09:31,450
dos, o que pode
levar algumas horas.

153
00:09:31,450 --> 00:09:34,080
E precisamos iterar sobre todos os possíveis
seis caracteres cordas, que

154
00:09:34,080 --> 00:09:36,560
Pode demorar alguns dias e assim por diante.

155
00:09:36,560 --> 00:09:41,380
>> Assim, poderia ter um potencial muito longo
tempo para repetir todos os possíveis

156
00:09:41,380 --> 00:09:44,850
oito caracteres e menos cordas.

157
00:09:44,850 --> 00:09:50,600
Então, percebe que isso não é necessariamente uma
algoritmo muito eficiente para encontrar

158
00:09:50,600 --> 00:09:51,860
uma senha.

159
00:09:51,860 --> 00:09:54,540
Você pode pensar que não
são as melhores maneiras.

160
00:09:54,540 --> 00:10:02,230
Por exemplo, a palavra-passe ZYX! 32ab
provavelmente não é uma senha muito comum,

161
00:10:02,230 --> 00:10:06,440
enquanto que a senha é 12345
provavelmente muito mais comuns.

162
00:10:06,440 --> 00:10:13,570
>> Portanto, uma forma de tentar encontrar uma senha
mais rapidamente é só olhar

163
00:10:13,570 --> 00:10:15,560
em senhas que são mais comuns.

164
00:10:15,560 --> 00:10:20,480
Assim, por exemplo, podemos tentar ler as palavras
de um dicionário e tentar todos

165
00:10:20,480 --> 00:10:24,860
essas palavras como nossos palpites senha.

166
00:10:24,860 --> 00:10:29,210
Agora, talvez uma senha
não é tão simples.

167
00:10:29,210 --> 00:10:32,600
Talvez o usuário foi um pouco inteligente
e tente adicionar um número para

168
00:10:32,600 --> 00:10:34,220
no final de uma palavra.

169
00:10:34,220 --> 00:10:37,000
>> Então, talvez a sua senha foi password1.

170
00:10:37,000 --> 00:10:41,520
Então você pode tentar iteração sobre todas as palavras
no dicionário com um

171
00:10:41,520 --> 00:10:43,210
anexada ao final da mesma.

172
00:10:43,210 --> 00:10:47,360
E então, talvez, depois de fazer isso, você vai
anexar a dois para o fim de tudo.

173
00:10:47,360 --> 00:10:50,240
>> Ou talvez o usuário está tentando ser ainda
mais inteligente, e eles querem que seus

174
00:10:50,240 --> 00:10:54,980
senha para ser "hacker", mas eles são
vai substituir todas as instâncias e de

175
00:10:54,980 --> 00:10:56,600
com três.

176
00:10:56,600 --> 00:10:58,440
Então, você poderia fazer isso também.

177
00:10:58,440 --> 00:11:02,100
Iterar sobre todas as palavras no dicionário
mas substituir caracteres que

178
00:11:02,100 --> 00:11:04,790
parecem números com esses números.

179
00:11:04,790 --> 00:11:09,670
>> Então, desta forma, você pode pegar ainda mais
senhas que são bastante comuns.

180
00:11:09,670 --> 00:11:14,690
Mas no final, a única maneira que você pode
capturar todas as senhas é bruta

181
00:11:14,690 --> 00:11:17,340
forçar iterar sobre todos
seqüências de caracteres possíveis.

182
00:11:17,340 --> 00:11:22,100
Então, no final, você precisa repetir
sobre todas as cordas de um personagem para

183
00:11:22,100 --> 00:11:28,110
oito caracteres, o que pode levar a
muito tempo, mas você precisa fazê-lo.

184
00:11:28,110 --> 00:11:30,024
>> Meu nome é Rob Bowden.

185
00:11:30,024 --> 00:11:31,425
E este é o crack.

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