Bem-vindos de volta, pessoal.
Este será agora um speedrun relacionado à função de criptografia do AZ.
Portanto, aqui faremos a solução.
Imprimiremos esses parâmetros, o vetor de inicialização, a chave secreta e também o valor de retorno.
E, em seguida, usaremos essas informações para criptografar e descriptografar o texto para verificar se tudo está funcionando
corretamente.
Muito bem, vamos fazer isso.
Voltemos à VM do Ubuntu.
Vamos dar uma olhada.
E o aplicativo está dentro de um desafio para recapitular tudo.
Agora, vamos criar um diretório de solução e mover esse aplicativo para a solução.
Tudo bem.
E então vamos dar uma olhada na negociação.
Desculpe-me mais uma vez.
Tudo bem.
Então, vamos ver.
Com hacking de aplicativos e criptografia.
Sim.
Portanto, temos o método encrypt message e você deseja obter esse parâmetro de texto simples, essa chave.
Portanto, temos que inserir a chave de código, codificá-la para obter a chave e, em seguida, o vetor de inicialização e o texto
cifrado.
Muito bem, vamos fazer isso.
Assim, poderíamos fazer isso por conta própria.
Mas é muito mais rápido fazer isso no Android Studio e depois compilar o aplicativo.
Então, escrevemos nosso código lá, compilamos esse aplicativo e simplesmente olhamos para esse caminho Marley.
Portanto, ferramentas, Android, Studio Bin e, em seguida, bash Studio Dot Assange.
Está bem.
Portanto, aqui temos um projeto antigo.
Esse é o nosso suporte smiley da maneira mais difícil.
Esse foi um trabalho incrível.
Fizemos bem agora.
Mas agora podemos encerrar isso.
Portanto, ele não é mais necessário no momento.
Está bem.
Se fecharmos isso, teremos nossa visão geral principal e criaremos agora um novo projeto, Empty
Activity, e o chamaremos de auxiliar de solução.
Tudo bem.
Temos que esperar até que o grande projeto de lei seja concluído.
Podemos observar isso aqui, e eu o verei em um instante.
Tudo bem.
O grande projeto de lei foi concluído.
Então, agora vamos criar uma nova classe.
Clique com o botão direito do mouse, nova classe Java como.
Então, criamos um método.
Nulidade pública.
Criptografar mensagem.
Portanto, queremos ter.
Talvez possamos codificar.
Vamos começar a primeira parte aqui.
Nesta parte.
Tudo bem, então vamos pressionar Enter.
Portanto, estamos importando essas classes e vamos adicionar isso como assinatura de exceção.
Agora, nosso código não contém nenhum ponto-chave para ser codificado.
Está bem.
E então, vejamos.
Também queremos ter essa abordagem do sistema base64 aqui.
Então, temos que atribuir isso ao array invite my array,
vamos atribuir isso e, em seguida, queremos imprimi-lo e podemos fazer isso da seguinte maneira.
Nosso sistema obteve uma linha de impressão e chamamos a codificação base64 de duas strings e, em seguida, minha matriz.
Sim.
Ah, as bandeiras estão faltando.
Aqui está.
Sim.
Então, isso deve funcionar?
Sim.
Isso está perfeitamente bem no momento.
Portanto, usamos essa linha também para imprimir esses parâmetros aqui e também para obter o vetor de inicialização e
o valor de retorno.
Mas essa é a nossa linha importante.
Essa é a linha que vamos copiar, colar nas partes necessárias e simplesmente ajustar
esses parâmetros.
Sim.
Portanto, vamos chamar esse método na atividade principal.
Portanto, aqui temos que criar uma nova instância as.
Sim.
Equivale a novos itens.
Não temos um parâmetro.
E agora podemos chamar a mensagem de criptografia de ponto.
Tudo bem.
E entre para cercá-lo com try e catch e vamos ver se isso funciona.
Então, executamos esse aplicativo.
Nosso smartphone não está sendo conectado e, portanto, o emulador é iniciado.
Não quero esperar até que esse emulador seja inicializado.
Então, vamos colocar o smartphone.
Está bem.
Aqui temos o smartphone porque esta é uma corrida rápida e não queremos perder dois ou três minutos
no emulador.
Muito bem, Logcat, vamos ver o sistema lá fora.
Temos tudo perfeito.
Também podemos fazer alguns ajustes, talvez este aqui seja, digamos, a chave.
Está bem.
Sim.
Perfeito.
Isso parece absolutamente perfeito neste momento.
Então, vamos criar esse aplicativo.
Então, temos nosso caminho de código inicial e podemos modificá-lo da maneira que quisermos.
Assim, clicamos em localizar cada K para qualquer.
Decodificamos esse aplicativo e, em seguida, estamos dando uma olhada nele com o código do Visual Studio.
Portanto, depure o aplicativo de código.
Sim.
Eu confio no outro.
O smiley aparece hackeando um smiley.
Aqui está.
Vamos habilitar o Java
e ver que nosso código ficou um pouco mais complicado agora.
Portanto, este é o nosso código no momento, mas acho que está tudo bem.
Para ser codificado.
Também precisamos incluir este aqui.
Portanto, começamos na linha 22 e iniciamos.
E este aqui é o fim.
Muito bem.
Sim.
Então, vamos pegar essa parte e inseri-la no aplicativo original nos pontos aqui no início para
imprimir esse texto simples depois deste, para gerar essa chave, para imprimir a chave, este,
o vetor de inicialização e o texto cifrado.
Portanto, são muitas coisas, mas podemos lidar com isso facilmente.
Portanto, um desafio não era esse aplicativo, mas um desafio para recapitular tudo.
E aqui temos a solução épica da ferramenta D como um BC.
E então vamos abrir um diretório.
Com hacking de aplicativos como criptografia.
Aqui está.
Ativamos o Java e agora vamos ver a mensagem criptografada.
Portanto, esta é a primeira parte e precisamos inseri-la aqui.
É isso aí.
Está bem.
No último vídeo que temos, temos que examinar isso de forma bastante intensa.
Portanto, podemos pular essa etapa agora mesmo.
Podemos remover esses números de linha.
E agora vamos ver se a transição está funcionando.
Estamos tendo o p one como nosso parâmetro OC.
Portanto, o P one precisa ser ajustado em nosso código.
Vamos ver onde esta aqui é a nossa chave.
Portanto, a chave secreta está na v2.
E então temos essa tela de impressão de matriz.
Imprimimos essa chave.
Portanto, esse é agora o nosso parâmetro.
Isso significa que a primeira parte não é necessária no momento.
Sim.
Isso não é necessário no momento.
Desculpe-me por isso, pois queremos imprimir esse parâmetro aqui.
Está bem.
Aqui temos um parâmetro.
Em seguida, temos um monte de coisas e códigos para encadear por 64.
E vejamos, precisamos aplicar isso aqui.
Esse é o nosso código para encadear nosso binário.
Então, nós dois.
Sim, o we two precisa ser substituído por p zero.
E isso é tudo o que precisamos fazer agora.
Não precisamos nos preocupar com mais nada porque estamos no início dessa função.
Todo o resto será sobrescrito, além do fato de que teremos dois registros a menos.
Portanto, precisamos aumentar isso.
Vamos aumentar para dez.
Assim, podemos ter certeza de que isso funciona perfeitamente.
Está bem.
Isso seria ótimo no momento.
Bom.
Portanto, o parâmetro foi impresso com sucesso.
Normalmente, eu tentaria criar esse aplicativo.
Talvez.
Vamos lá.
Vamos ver se é isso mesmo.
Se for construído.
Se ele se desenvolver, poderemos seguir em frente.
Caso contrário, talvez tenhamos que consertar alguma coisa.
Solução.
Sim.
Tudo bem.
Ele constrói.
Portanto, para mim, está tudo bem no momento.
Agora, vamos ver.
Agora estamos inserindo, após a linha 21, essa chave que estamos chamando de método get encoded e, em
seguida, também chamaremos este.
Então, vamos entrar em nosso código.
Onde o temos?
Aqui.
Vamos voltar ao código original aqui.
E agora vamos ver.
Linha 21.
Aqui está.
Está bem.
E agora vamos ver.
A chave secreta será movida para V um.
E isso está combinando perfeitamente.
Estamos preparando outra coisa.
Estamos nos preparando.
Nós queremos isso.
Queremos ser mais usados.
Chave secreta.
Isso é bom.
Será que temos algo mais?
Nós.
Zero, zero.
Estamos movendo o gerador de chaves para o zero.
Como usamos o zero em nosso próprio código.
Não.
Em não usar vs zero.
Portanto, não estamos tocando o zero e vamos embora, e acho que é isso.
Portanto, a única coisa que queremos examinar é o raio-aranha.
O raio-aranha deve ser agora nossa chave secreta.
Vejamos.
Apesar da matriz como parâmetro b cinco.
Não, esse é o valor inteiro.
Desculpe, esses são os nossos sinalizadores e escolhemos a matriz de bytes para a qual moveremos o objeto recente.
Sim, isso.
Isso funciona perfeitamente.
Então vamos ver.
Eu também.
Essa é a nossa matriz de mordida, que será usada aqui.
Este é o nosso array de bytes aqui.
Isto é.
Isso é perfeitamente aceitável.
Vamos ver onde estamos inicializando v dois aqui.
Por isso, chamamos o método get encoded.
Portanto, o V para get encoded receberá a atribuição de spidering, o tipo de retorno em nosso v two e podemos
ver que estamos usando encode to string em nosso v two aqui ou byte array é v two e este também é o valor de retorno
de get encoded.
Tudo parece estar bem no momento.
Ok, vamos esclarecer isso.
Isso também deve funcionar muito bem.
Nós já temos esse.
Também esta chave.
Agora vamos dar uma olhada nesse vetor de inicialização.
Talvez uma olhada rápida se for possível.
Um aplicativo de volta.
Ah, é isso mesmo.
Esse é o projeto errado.
Vejamos.
E aí está.
Vamos acessar o diretório de soluções.
Aqui temos o apk para ser como vamos nos certificar de que salvamos esse arquivo.
Portanto, se você errar nos registros, isso pode não ser reconhecido no momento, mas
podemos ver que não há erros graves de smiley aqui.
Está bem.
Mais uma vez, pegamos nosso código de aplicativo, uma cópia.
E agora vamos dar uma olhada no vetor de inicialização.
Aqui temos um backdoor de inicialização pela taxa em que isso será movido antes de inserirmos nosso
código no meio.
Agora queremos imprimir antes.
Então vamos ver.
E antes, sim, isso será sobrescrito.
Portanto, isso não está funcionando dessa forma no momento.
Vejamos.
Está bem.
Vamos levar esta parte rapidamente para a mesa digitalizadora e dar uma olhada rápida nesta,
porque aqui temos que fazer um pouco mais de ajustes.
Está bem.
Então, vejamos, para este aqui, este é o nosso array de bytes que queremos imprimir.
Esse pode ser ignorado mais uma vez.
Eu não deveria mover isso o tempo todo para esse código agora.
Portanto, isso é ignorado.
E depois temos minha matriz.
Portanto, este é o valor original.
Eu também.
Talvez.
Vamos escrever isso.
Escolhemos o valor original da matriz de bytes.
Em seguida, estamos usando o construtor de strings antes.
Portanto, neste momento, estamos sobrescrevendo o que era antes.
Está bem.
E então, vejamos, nós doamos.
Também precisamos substituir esse vetor pelo vetor de inicialização IV.
Em seguida, temos o construtor de strings e aqui temos o encode two string e estamos usando isso,
é claro, em v two porque v two.
Sim, esse é o nosso título original, certo.
O que podemos fazer?
Acho que sim.
Vamos dar uma olhada nesse caso.
Então, o que podemos fazer.
Vejamos.
Sim.
Aqui está o fim de nossas variáveis locais.
Então, isso significa.
Poderíamos simplesmente mover esse objeto.
No esquete, a inicialização devolve o objeto para v dois depois.
Assim, não precisamos ajustar nada.
Vamos primeiro excluir essa parte.
Além disso, esses números de linha.
Espero que eu tenha excluído antes, mas vamos descobrir se não.
Então, temos o V local para escrever isso, apesar da chuva.
Portanto, agora este é o código.
Vejamos.
Nosso objeto de cifra não será mais usado.
Certo.
Vejamos.
Não.
Aqui está o final de nossa cifra.
Objeto B para OC.
Portanto, o que faremos agora é o seguinte.
Entramos em nosso código e temos isso.
Aqui.
Portanto, estamos movendo esse objeto para V dois.
Portanto, estamos sobrescrevendo a instância de cifra e v dois está mantendo nossa matriz de bytes.
Mas o objeto de cifra, essa instância aqui, não é mais necessária.
Não estamos usando-o em nosso código no momento, portanto, podemos simplesmente substituir esse registro e agora
podemos ver que ele está mantendo nossa matriz de bytes.
Vamos habilitar esse.
Portanto, a v2 está armazenando nossa matriz de bytes e estava sendo usada aqui como uma matriz de bytes e está funcionando perfeitamente
bem agora.
Então, sim, esse é o único ajuste que temos que fazer em todo o resto.
Vejamos.
Quero dizer, o B5 não é conhecido por esse aplicativo.
Portanto, isso não é problema.
E aqui temos apenas que nos certificar de que não estamos sobrescrevendo um registro importante.
Então, vamos voltar a esse caso.
Aqui estamos retornando para fora e estamos retornando v três.
Portanto, neste ponto, estamos substituindo por três e isso não é bom.
OC Sim, então aqui temos o V três e podemos ver que estamos retornando o três.
Há dois métodos finais, há dois métodos finais e retornamos para três, como este aqui.
E isso substituirá nosso texto cifrado, que pode ser retornado.
Isso não é bom.
Portanto, o que estamos fazendo em nosso código é substituir B três por V seis, fazendo isso
dessa forma, não estamos sobrescrevendo B três, e então terminamos essa parte.
Portanto, a única coisa que precisamos fazer é imprimir o valor de retorno aqui e pronto.
Portanto, essa parte agora está relacionada ao vetor de inicialização.
Vamos também escrevê-lo dessa forma, vetor de inicialização, e depois veremos.
Sim, só precisamos inseri-lo mais uma vez.
Então, vamos copiar essa parte.
Vamos inseri-lo aqui.
Está bem.
Aqui temos agora v seis.
Não há problema, pois já imprimimos o sistema aqui. fora. println com b seis e em v seis.
Desculpe, com a v4, que é a nossa string.
Mas esse sistema não é mais necessário depois.
Sim.
Está bem.
E então vamos ver.
Então, aqui.
Sim, precisamos ajustar essa parte aqui.
Nós cinco precisamos ajustar nós cinco, então nós dois precisamos ajustar os dois para serem três.
Sim.
Esse é o nosso array de bytes que vem de.
Aqui.
Portanto, este é o nosso texto cifrado e não estamos usando o texto cifrado em nosso código, portanto, podemos
ver no destaque que ele não está sendo usado e o único lugar em que o estamos usando é aqui.
Portanto, nós três não seremos sobrescritos e usaremos encode to string no spider spidering e, em seguida,
o retornaremos.
Está bem.
Uma última verificação.
Perdi alguma coisa?
Nem tudo parece estar bem para mim no momento, então vamos ver.
Está bem.
Ele constrói assim um s e depois isso.
Alinhamos isso com o zip, assinamos isso e, em seguida, temos que desinstalar e copiar a tela.
Temos que desinstalar a versão existente.
Um pouco bagunçado.
Bem, esse era o errado.
Se você usar uma das linhas acima, não estará desinstalando-o.
Você está apenas dizendo que não quer ter isso como uma sugestão.
Então, vamos pegá-lo aqui e instalá-lo.
E agora vamos instalá-lo.
Sim, é isso mesmo.
Porque eu preciso instalar o epic.
É apenas um teste e vamos fazer esse laptop.
Está bem.
E é isso.
E vamos dar uma olhada em
let's search for system out.
Portanto, isso se refere ao último ou ao nosso exemplo para o nosso próprio aplicativo.
Agora vamos ver se isso funciona e como corrigimos o problema.
Então vamos ver.
Estamos chamando de 3 para 1.
Legal.
Além do fato de eu não ter alterado o vetor de inicialização no final.
Então, minha aposta é essa.
Vamos limpar a saída do logcat.
ADB loc head there.
Está vendo?
Portanto, temos que ajustar isso.
Por que temos isso aqui?
E este é o valor de retorno.
Sim.
Portanto, aqui estamos criando a string referente ao valor de retorno.
Tudo bem.
Isso deve funcionar agora, então vamos fazer isso novamente.
Acelerarei o processo e, em seguida, você entrará diretamente nele.
Tudo bem, então, volte.
Então, vamos ver isso.
Nós olhamos para o lixo.
Esse sistema ocular foi lançado e agora vamos iniciar esse aplicativo.
Três, dois, um.
Aqui está.
Aqui temos tudo.
Além disso, o texto corresponde perfeitamente neste momento.
Muito bem, agora vamos usar esses parâmetros em nossa função cibernética para ver se podemos decodificar e se podemos
criptografar e descriptografar esse texto agora mesmo.
Então, vamos fazer isso.
Portanto, estamos procurando um chef cibernético.
E aqui temos isso.
E agora vamos ver.
Primeiro, nesta hora, vamos pegar o valor de retorno.
Vamos tentar descriptografar esse texto.
Portanto, esse é o nosso texto criptografado.
Está bem.
Portanto, esta é a nossa entrada aqui.
E agora dizemos que isso é da base 64 e queremos uma descriptografia ace como decrypt.
Portanto, nossa entrada é bruta porque estamos codificando.
Desculpe, estamos decodificando a string this por 64 string.
Podemos deixar a saída em bruto.
E eu não quero ter esse carro de volta agora.
Ok, agora vamos ver qual é a chave?
A chave é esta aqui.
Chave.
O formato é base64 e o vetor de inicialização é este aqui.
O formato também é base64 e está tudo certo. Agora, se clicarmos no botão "Voltar" aqui, teremos de volta
nosso texto descriptografado, ou seja, nosso texto simples.
Então vamos ver.
De volta em 3 a 1.
Mensagem secreta única perfeita.
Tudo bem.
Portanto, isso é incrível neste momento.
Portanto, também poderíamos fazer isso, e vice-versa.
Assim, por exemplo, podemos usar nosso texto aqui e criptografá-lo com a função AZ.
Então, vamos fazer uma pausa.
Isso é descriptografar e vamos pegar esse texto e agora vamos ver como criptografar que estamos tendo que usar
agora a chave é o mesmo formato base64 vetor de inicialização C mesmo formato base64.
Nossa entrada agora é bruta.
Não é nem cru nem hexadecimal.
Portanto, sim, a maneira mais fácil seria codificá-lo com base64, pois é isso que estamos fazendo aqui.
Estamos decodificando-o.
Portanto, echo dash pn base 64.
Portanto, este é o texto que queremos criptografar
e nosso resultado é, digamos, bruto.
Ok, vamos fazer isso em 3 para 1.
Tudo bem.
Agora temos a saída bruta aqui.
E para garantir que isso se encaixe perfeitamente em nossa tela, vamos usar a codificação base64 agora mesmo.
Portanto, de base64 para base64.
Então, o que está acontecendo é o seguinte: agora este é o nosso texto e este texto será decodificado
em base64.
A base64 próxima a ela é este bloco aqui.
Está bem.
E temos um formato de função de entrada no momento.
Em seguida, pegamos essa entrada e executamos nossa função de criptografia aqui.
Aqui temos essa chave no formato base64.
Desculpe, vetor de inicialização.
Aqui temos a chave.
E depois tiramos isso daqui.
E isso não é legível para nós no momento.
Portanto, o que temos anexado é este, e este agora está pegando essa parte, essa saída,
e usa o Base64 para codificar esses bytes.
Portanto, a partir disso, receberemos de volta uma cadeia de caracteres base64 com esse sinal de igual, talvez em relação ao preenchimento.
Está bem.
Portanto, é isso que está acontecendo agora na plataforma cibernética.
Vamos fazer isso.
Portanto, tudo o que precisamos fazer é revidar.
Botão 3 para 1.
Está bem.
Parece perfeito.
Vejamos.
Sim, este é exatamente o mesmo texto.
Portanto, agora podemos modificar esse texto da maneira que quisermos.
E, por exemplo, também poderíamos criar uma nova mensagem.
E nós o temos.
Echo Desh rn seu hacking de mi smiley é incrível.
Vamos terminar citando isso na baía 64.
Ops.
Há algo faltando.
Vejamos.
Incrível.
Eles 64.
Portanto, este é agora o novo texto e, se você clicar novamente, este será o resultado em nossa tela.
Portanto, agora podemos trabalhar perfeitamente com esses métodos de criptografia e descriptografia aqui.
Muito bem.
Está bem.
Isso foi super rápido agora, mas não quero incomodá-los agora com as coisas que já vimos
neste, por exemplo, aqui.
Quero dizer, com relação ao construtor de strings anexando coisas como essa, isso pode ser novo, mas é, é simplesmente
a Molycorp.
Fizemos a engenharia reversa de toda essa classe ou dessa função bastante agora e, portanto,
sim, fui um pouco mais rápido nisso.
Os pontos mais importantes estão no início.
Verifique se esses parâmetros correspondem aos seus parâmetros na função de cadeia cultural final, aumente
esses parâmetros, pois isso será definitivamente necessário se tivermos analisado
esse parâmetro, pois ele não foi usado antes.
Portanto, tivemos apenas quatro cinco registros antes do último.
Isso causaria problemas e, então, basta pegar todo esse código e colá-lo em qualquer lugar que
você queira e dar uma olhada rápida na transição.
Se esse objeto que desejamos for, por exemplo, uma chave secreta, se ele permanecer como chave secreta, se B0 estiver sendo usado
em qualquer outro lugar depois, podemos ver que não é esse o caso.
Portanto, já podemos reatribuir isso e coisas do gênero.
Está bem.
Caso isso tenha sido muito rápido e você queira uma longa explicação sobre o assunto, não há problema algum.
Envie-me uma mensagem.
Farei o upload de uma versão mais extensa sobre esse assunto.
Portanto, se você se sente em russo agora, envie-me uma mensagem, pois isso é algo que não
queremos ter em nosso curso.
Queremos analisar isso com calma.
Mas não quero incomodá-lo a passar por isso pela terceira ou quarta vez, até que, é claro, se
for necessário.
Muito bem.
Está bem.
Perfeito.
Portanto, este é o fim de nosso único desafio de recapitulação.
Muito bem, agora.
E no próximo, teremos a introdução ao nosso desafio do Urso Negro.
E este será incrível porque combinaremos tudo o que aprendemos até agora neste
desafio.
Tudo bem.
Vamos dar uma olhada.