>> ROB BOWDEN: Eu sou Rob, e vamos começar rachando.
Então lembre-se de que a especificação pset vamos precisar usar o
crypt.
Para a página principal, temos dois hash de definir _xopensource.
Não se preocupe sobre o porquê precisamos fazer isso.
E também haxixe incluem unistd.h.
>> Assim, uma vez que está fora do caminho, vamos chegar ao programa real.
A primeira coisa que precisamos fazer é certificar-se o usuário digitou um criptografado válido
senha na linha de comando.
Lembre-se que o programa é suposto para ser executado como dot barra de crack, e
então string encriptada.
>> Então, aqui estamos verificando para certificar-se que argc a dois, se quisermos
continuar com o programa.
Se argc não é dois, o que significa qualquer o usuário não entrar um criptografado
senha na linha de comando, ou eles entrou mais do que apenas o criptografado
senha na linha de comando, em que caso não sabemos o que fazer com o
argumentos de linha de comando.
>> Então, se argc tinha dois anos, podemos continuar.
E aqui, nós vamos declarar uma variável encriptada.
Isso só vai alias originais argv1 de modo que ao longo desta
programa, não temos de chamá-lo argv1, que, então, você tem que pensar
sobre o que isso realmente significa.
>> Então, finalmente, queremos validar que a senha criptografada do usuário
entrou poderia ter sido realmente uma senha criptografada.
Por página man do cripta, a senha criptografada deve ser 13
caracteres.
Até aqui, perceber que nós Hash definido criptografar comprimento 13.
Então, nós estamos apenas certificando-se de que o comprimento da corda do criptografado
senha é 13.
>> E se não é, nós queremos para sair do programa.
Assim, uma vez que está fora de forma, podemos agora realmente tentar encontrar o que o
senha que deu o criptografado senha era.
Aqui, queremos pegar o sal da senha criptografada.
Lembre-se de acordo com a página do homem, que o os dois primeiros caracteres de um criptografado
string, como aqui -
50ZPJ e assim por diante -
os dois primeiros caracteres dar nós o sal que foi usado
em função da cripta.
>> E aqui, vemos que o sal era ha.
Então, nós queremos copiar os dois primeiros caracteres, o comprimento sal ser haxixe
definida como dois.
Temos que copiar os dois primeiros caracteres nessa matriz, sal.
Observe que precisamos comprimento sal mais um, já que ainda precisa de um nulo
terminator no final do nosso sal.
>> Então vamos declarar essa matriz, convidado, de grande dimensão max mais
um, onde o comprimento máximo é de hash definido como oito, uma vez que o máximo de senha
é de oito caracteres.
E nós vamos usar isso para repetir sobre todas as cordas possíveis que poderiam
ser senhas válidas.
Então, se os caracteres válidos em uma senha foram apenas a, b, e c, então
gostaríamos de iterar a, b, c, aa, ba, ca, e assim por diante, até
temos de ver cccccccc -
oito c do.
>> E se não temos por um válido senha, então temos de dizer que o
string encriptada não era válido para começar.
Então, agora, chegamos a este enquanto um loop.
Observe que significa que é um loop infinito.
>> Observe que não há instrução break dentro deste loop infinito.
Existem apenas voltar declarações.
Então, nós nunca realmente esperar para sair do loop.
Nós só esperar para sair do programa.
Eu adicionei esta declaração de impressão para a Além disso loop para apenas imprimir
que nossa suposição corrente no qual é a senha.
>> Agora, o que é este ciclo fazendo?
É um loop sobre todas as cordas possíveis que poderia ser senhas válidas.
A primeira coisa que vamos fazer é tomar o nosso palpite atual para o que o
senha.
Vamos levar o sal que nós agarramos a partir de a string encriptada, e estamos
indo para criptografar o palpite.
Isso nos dará um palpite criptografado, que nós estamos indo para comparação
a string encriptada que o usuário entrou na linha de comando.
>> Se eles são idênticos, caso em que corda comparável retornará zero, se
eles são o mesmo, então acho que foi o palavra-passe que gerou o criptografado
cadeia, caso em que pode imprimir que, como a palavra-passe e retorno.
Mas se eles não eram os mesmos, que significa que o nosso palpite estava incorreta.
>> E nós queremos repetir a a próxima suposição válida.
Então, isso é o que esse tempo loop está tentando fazer.
Vai repetir o nosso palpite para a próxima suposição válida.
Observe que quando dizemos que um caráter particular, em nossa suposição tem
atingiram o símbolo máximo, que aqui é definido como uma mistura til, pois
que é o maior personagem valor ASCII que um utilizador pode entrar no
teclado, quando o personagem alcançar a max símbolo, então queremos enviar
de volta para o símbolo mínimo, que é um espaço, uma vez mais o menor ASCII
símbolo de valor que um usuário pode digite no teclado.
>> Então, nós estamos indo para definir que o símbolo mínimo.
E então nós estamos indo para ir para o próximo caractere.
Então, como estão os nossos palpites vai repetir?
Ora, se os caracteres válidos são a, b, e c, então, se iniciou com a,
ele vai repetir a b, ele vai iteração para c.
c é o nosso símbolo máximo, então vamos definir c volta a um, o símbolo mínimo.
E então nós vamos repetir índice para o próximo caractere.
>> Então, se a estimativa inicial foi c, o próximo personagem vai ser o nulo
terminator.
Aqui em baixo, observe que se o personagem que queremos agora
incremento é o terminador nulo, então vamos configurá-lo para o
símbolo mínimo.
Portanto, se o palpite era c, então a nossa novo palpite vai ser aa.
E se nossa suposição original cccc, então nosso novo palpite
vai ser aaaaa.
>> Assim, sempre que chegamos a corda máxima de um determinado comprimento, então estamos
vai implementar para a seqüência mínima do comprimento seguinte, que irá
basta ter todos os personagens de o símbolo mínimo.
Agora, o que é essa verificação está fazendo aqui?
Bem, se o índice passou de oitavo caráter ao caráter nove -
então adicionamos oito c de como o nosso anterior acho -
em seguida, o índice vai se concentrar na última terminador nulo do nosso palpite
matriz, que não se destina a efectivamente ser usado no nosso senha.
>> Então, se estamos focados nessa última nulo terminator, então nós não encontramos uma
senha que é válido usar apenas oito caracteres, o que significa que não há
senha válida que criptografa a string dada.
E nós temos que imprimir isso, dizendo que não conseguimos encontrar um válido
senha, e retorno.
Portanto, este loop while vai repetir sobre todas as cordas possíveis.
>> Se encontrar qualquer que criptografa a string encriptada esperado, ele vai
retornar a senha.
E ele não encontrar nada, então ele irá retornar, a impressão que
não foi capaz de encontrar qualquer coisa.
Agora, observe que a iteração sobre todos possíveis seqüências provavelmente vai
demorar um pouco.
Vamos realmente ver como tempo que leva.
>> Vamos fazer o crack.
Bem, oops - diz indefinido referência a cripta.
Então lembre-se, para o p define especificação e também a página de manual para cripta que
necessidade de ligar na cripta.
Agora, o padrão comando make não sabe que você
quero usar essa função.
>> Então, vamos copiar este comando cliente e apenas adicionar até o fim
do mesmo, ligando cripta.
Agora, ele compila.
Então vamos correr de crack em um determinado string encriptada -
para César.
Então isso foi muito rápido.
>> Note-se que esta terminou em 13.
Bem, senha criptografada de César passa a ser 13.
Então, vamos tentar outra senha.
Vamos dar criptografado de Hirschhorn senha e tentar quebrar isso.
>> Então, observe que já chegou três personagens.
E nós estamos interagindo sobre todos os possíveis seqüências de três caracteres.
Isso significa que já terminar iteração sobre tudo um possível e
duas cadeias de caracteres.
Agora, parece que isso vai demorar um pouco antes de chegar ao
seqüências de quatro caracteres.
Pode demorar um par de minutos.
>> Não demorou um par de minutos.
Estamos nas cordas de quatro caracteres.
Mas agora, precisamos iterar sobre todos possíveis seqüências de caracteres de quatro, que
que pode levar talvez 10 minutos.
E então, quando chegarmos a cinco caráter cordas, precisamos iterar sobre todos
dos, o que pode levar algumas horas.
E precisamos iterar sobre todos os possíveis seis caracteres cordas, que
Pode demorar alguns dias e assim por diante.
>> Assim, poderia ter um potencial muito longo tempo para repetir todos os possíveis
oito caracteres e menos cordas.
Então, percebe que isso não é necessariamente uma algoritmo muito eficiente para encontrar
uma senha.
Você pode pensar que não são as melhores maneiras.
Por exemplo, a palavra-passe ZYX! 32ab provavelmente não é uma senha muito comum,
enquanto que a senha é 12345 provavelmente muito mais comuns.
>> Portanto, uma forma de tentar encontrar uma senha mais rapidamente é só olhar
em senhas que são mais comuns.
Assim, por exemplo, podemos tentar ler as palavras de um dicionário e tentar todos
essas palavras como nossos palpites senha.
Agora, talvez uma senha não é tão simples.
Talvez o usuário foi um pouco inteligente e tente adicionar um número para
no final de uma palavra.
>> Então, talvez a sua senha foi password1.
Então você pode tentar iteração sobre todas as palavras no dicionário com um
anexada ao final da mesma.
E então, talvez, depois de fazer isso, você vai anexar a dois para o fim de tudo.
>> Ou talvez o usuário está tentando ser ainda mais inteligente, e eles querem que seus
senha para ser "hacker", mas eles são vai substituir todas as instâncias e de
com três.
Então, você poderia fazer isso também.
Iterar sobre todas as palavras no dicionário mas substituir caracteres que
parecem números com esses números.
>> Então, desta forma, você pode pegar ainda mais senhas que são bastante comuns.
Mas no final, a única maneira que você pode capturar todas as senhas é bruta
forçar iterar sobre todos seqüências de caracteres possíveis.
Então, no final, você precisa repetir sobre todas as cordas de um personagem para
oito caracteres, o que pode levar a muito tempo, mas você precisa fazê-lo.
>> Meu nome é Rob Bowden.
E este é o crack.