Talvez volte depois desse vídeo de introdução muito curto, muito curto.
Vamos analisar isso como uma função de criptografia.
Vamos ver como podemos lidar com a sintaxe sorridente desconhecida.
Por exemplo, apenas o bloco try and catch.
Vamos ver como ele se parece e se realmente somos capazes de entendê-lo.
Portanto, vamos lá.
Vamos descompilar esse aplicativo e, em seguida, colocá-lo de volta na mesa digitalizadora.
Portanto, primeiro descompilamos esse aplicativo.
Tenho um espaço aberto aqui.
Ferramenta APK.
DD Sim.
APK.
Tudo bem.
E então vamos abrir esses óculos sorridentes também com o código do Visual Studio.
No entanto, eu confio nisso e, em seguida, venho com o hacking de aplicativos como criptografia.
Tudo bem.
E aqui ativamos o Java.
Perfeito.
Muito bem, vamos lá.
Temos nossa classe como criptografia.
Não estamos estendendo uma classe especial, portanto, estamos apenas tendo o objeto de viagem como superclasse.
Está bem.
E este é o nosso arquivo de origem como crypto.
Aqui temos nosso construtor.
Tudo bem.
E aqui temos nossa mensagem de criptografia de método.
Vamos ver se encontramos algo incomum só de olhar para isso.
Portanto, não estamos revertendo isso no momento.
Vamos ver, rolamos a tela para baixo.
Está bem.
Acho que já a encontramos.
E este parece ser novo, certo?
Portanto, se Deus se mover, resolva se opor antes que isso seja bem conhecido por nós.
Mas depois temos essa extremidade tripla e essa parte aqui.
Tudo bem, isso parece absolutamente ridículo.
E também temos uma cláusula de captura aqui.
Podemos ver exceções.
E estes aqui parecem novos, mas estão em um formato reconhecível.
Portanto, este aqui é apenas um método virtual de invocação.
Ele está apenas invocando e no método público print stack, Chris.
Tudo bem.
E depois temos várias outras coisas.
Isso parece diferente das coisas que vimos até agora, especialmente esta aqui.
Portanto, eu sugeriria que levássemos isso para a mesa digitalizadora e víssemos se conseguimos entender
o que está acontecendo aqui.
Muito bem.
Certo, perfeito.
Eu o verei em um instante.
Está bem.
Portanto, estamos de volta ao tablet gráfico e já vimos que esse arquivo é enorme.
Se você rolar a tela um pouco para baixo, verá que temos 147 números de linha.
Portanto, em um determinado momento, temos que fazer a engenharia reversa disso, mas não do arquivo inteiro.
Temos que descobrir, por exemplo, como imprimir a chave secreta, o vetor de inicialização e coisas
do gênero.
Nesta parte, que é a segunda parte, vamos nos concentrar apenas na engenharia reversa dessas partes necessárias.
Mas se você for absolutamente louco e quiser que eu analise todo esse arquivo linha por linha, basta enviar
uma mensagem para mim.
Não há problema algum.
Mas acho que você não vai querer assistir agora.
40 minutos de engenharia reversa.
Vamos nos concentrar no que há de novo, e esse é o material de captura tripla.
Este no meio, aqui.
Portanto, isso é algo que não encontramos até o momento, mas entendemos os conceitos básicos do smiley
e isso é suficiente para entender tudo agora.
Até mesmo esta parte aqui.
Você não acredita nisso?
Então, deixe-me provar que essa é uma afirmação correta.
Portanto, vamos dar uma olhada nisso.
Está bem.
Portanto, queremos analisar essa parte agora mesmo.
Vejamos.
E este aqui, nós sabemos o que é.
É apenas um rótulo.
Temos o rótulo.
Experimente o underscore e o underscore zero.
Então, vamos escrever isso.
Experimente o underscore e o underscore zero.
Este é um rótulo.
Rótulo significa, ou já vimos alguns rótulos antes, que a instrução de salto em nossa instrução if obteve
a condição zero.
Por exemplo, se a instrução if for verdadeira, passamos para essa condição; caso contrário, seguimos em frente.
Mas também vimos rótulos referentes a ir para a instrução e, por exemplo, ir para a condição um.
Tudo bem.
Nada de novo até o momento.
Está bem.
Portanto, tente e talvez seja apenas um rótulo.
Vamos ver com que frequência isso ocorre.
Então, vamos procurar por este aqui e podemos ver dois de seis e vamos jogá-lo no chão.
Portanto, este aparece aqui e também aqui.
Portanto, dentro disso, a sintaxe de aparência estranha está aqui.
Vejamos.
Sim.
Portanto, essa é a única ocorrência de julgamento, Ed.
Tudo bem, isso é bom.
Ele é compacto e está limpo.
Portanto, vamos nos aprofundar nessa questão.
E essa é a nossa marca.
Vejamos.
Então, no início, temos essa captura de pensamento.
Não sabemos qual é a nossa captura ou o que ela faz, mas sabemos o que é esta aqui.
Há o capital, e depois temos a referência de classe.
E essa referência de classe não é uma exceção aos algoritmos.
Aqui não temos essa exceção de animal de estimação e aqui temos uma exceção de chave inválida.
Portanto, essas são todas as nossas exceções do lado do Java.
Se você se lembrar disso, talvez seja melhor limpar isso, pois quase não está legível.
E lá vamos nós.
Portanto, essas são apenas as exceções que podemos lançar.
Tudo bem.
Está bem.
Não sabemos mais sobre isso.
Essas são apenas referências de classe.
Não temos a menor ideia.
Esse é agora um tipo retornado.
Isso é um parâmetro?
Isso é outra coisa?
Nós não sabemos disso.
Ok, então vamos ignorar essa parte aqui.
Portanto, esse será ignorado.
Neste também.
Vejamos.
E então temos esse início triplo.
Tente iniciar o sublinhado zero e podemos ver mais uma vez que isso está apenas no rótulo.
Try, underscore, start, underscore zero.
Em seguida, temos o ponto de aparência estranha.
Não tenho ideia do que seja.
Mas depois de quê?
Temos outro rótulo ou esse rótulo já conhecido.
Tente e este aqui.
Então, aqui está nossa tentativa.
E o sublinhado zero labor quase não é legível, mas são stands tri e zero oc oc.
Portanto, não precisamos de um QI de 200 para resolver isso.
Temos um começo e um fim.
Portanto, esse é um tipo de intervalo dado aqui e vamos chamar esse ponto simplesmente de intervalo.
Não tenho certeza de qual é o termo para isso e se está correto, mas temos o início, temos
algumas coisas e temos um oito OC.
Então, vamos ver onde o início do Tri ocorre em nosso código, porque esse é um rótulo que não vimos até agora.
Já sabemos que o TRI termina aqui.
Então, vamos procurar por tri start aqui, aqui, aqui e aqui e, ah, isso é interessante.
Temos a mensagem criptografada, depois temos nosso texto simples, temos B zero e aqui temos o rótulo
tri start.
Portanto, este aqui é o nosso rótulo de início triplo.
Então, será que é tão simples assim termos esse rótulo de início triplo e, em seguida, termos nossas paradas principais?
Vamos fazer isso.
Oh, vamos fazer essa tela.
Aqui está.
Ponto, ponto.
E depois temos nossa extremidade tripla.
E, é claro, zero.
Então, será que é simples assim, que começamos aqui?
Este aqui.
Esse é o nosso começo.
Então, temos muitos pensamentos.
Até chegarmos a este aqui.
Você tenta e, digamos, lá embaixo, há alguns birdies.
Experimente o underscore e o underscore zero labor.
Então, isso é apenas uma tentativa de bloquear?
Vamos descobrir isso.
Então, vamos limpar isso.
Está bem.
925 Temos nosso tri start e, aqui, temos nosso tri.
Portanto, este é o começo.
Aqui temos o nosso fim e tudo o que está entre eles está dentro do nosso bloco triplo.
Tri.
E então o fim.
Isso significa que, após o registro de faixa, temos que esboçar um bloco e esse bloco de captura agora tem determinadas condições
e podemos ver essas condições já ocorrendo aqui.
Portanto, vamos voltar ao código Java e verificar se o nosso registro de viagem é iniciado ou incluído.
Vejamos.
Sim, essa geração-chave.
Portanto, pelo menos este é difícil dizer se já está incluído porque tem um sorriso.
E o smiley foi desmontado em algumas partes.
Este aqui, quero dizer, é apenas uma etiqueta.
Não se arrepende, neste aqui.
Quero dizer, é apenas uma referência a um nome de variável.
Eles não podem errar em relação a isso.
Nosso erro pode ocorrer aqui.
É nesse ponto que podemos ter um erro.
Portanto, minha sugestão seria que a nossa tentativa e captura de bloquear a primeira instrução é o nosso gerador
de chaves para obter instantaneidade.
Está bem.
Portanto, vamos descobrir se nosso blog de viagem começa diretamente com um gerador de chaves e este
aqui.
Tudo bem.
Está bem.
Portanto, abrimos um novo terminal.
Entramos no EPS.
Um desafio para recapitular tudo e estamos abrindo como APK com Shadi.
Desculpe-me.
Em seguida, entramos no hacking de aplicativos de comunicação como e depois como criptografia.
E isso é absolutamente correto.
Nossa primeira instrução aqui é o gerador de chaves.
Portanto, é exatamente assim que se parece o nosso registro de viagem.
Portanto, temos nossa tentativa e a temos aqui.
Também podemos ver que nossa última instrução em nosso registro de viagem é obter o método do vetor de inicialização,
este aqui.
Em seguida, estamos movendo o resultado para o V4 e temos que tentar bloquear.
Portanto, se você voltar a esse caso, poderemos ver.
Sim, podemos ver que o vetor de inicialização está bem próximo de ser a última instrução, ou seja,
depois do que acabamos de receber como retorno.
Mas em relação ao bloco try and catch, o tipo de retorno, este aqui, não está sendo incluído
neste bloco aqui.
Portanto, no mundo Java, mais uma vez podemos ver que o retorno também está incluído no bloco try e catch.
Mas tecnicamente correto não é, porque podemos ver aqui que o resultado seria movido para o registro
antes.
Mas se retornarmos para fora dessa função, vamos ver onde retornamos nessa função.
Temos outro retorno?
Então, vamos pesquisar o retorno.
Sim.
Aqui podemos ver que temos esse objeto de retorno.
Eu três Então, isso vem do nosso vetor de inicialização get e move o resultado para o objeto.
Antes disso, temos nosso bloco de entrada de tentativa e aqui podemos ver que estamos retornando.
Desculpe-me pela interrupção, mas há um pequeno erro com relação ao valor de retorno aqui.
E quero esclarecer isso.
Quero dizer, o código, tudo o que discutimos até agora está absolutamente correto, mas eu
o confundi nos últimos 2 minutos.
Então, vamos analisar isso aqui.
Podemos ver na linha número 65 que esse método invoca o Java X virtual e o crypto cipher obtém o vetor de
inicialização.
Esse método retorna uma matriz de bytes e a matriz de aranha será armazenada no registro.
V quatro Então, movemos o objeto de resultado para before e, em seguida, temos nosso bloco
try and, temos todas essas instruções catch e, na linha 78, temos esse local before ao qual será atribuído esse
rótulo, esse rótulo de vetor de inicialização, mas, em seguida, temos o objeto de retorno B três, essa é a linha
número 79.
E se você der uma olhada no que nós três temos, podemos encontrar isso na linha 59.
Então, temos que invocar a criptografia virtual do Java X para encontrá-la.
Temos o parâmetro e a matriz de bytes e também temos um tipo de retorno ou valor de retorno como na matriz de bytes.
Movemos o resultado dessa função cifrada para final em V três e depois retornamos para B três.
Acho que já disse que estamos voltando antes, o que não é correto.
Estamos retornando b três, que é o array de bytes do método para encontrá-lo.
O resto é absolutamente perfeito.
Muito bem.
E agora podemos seguir em frente com este aqui.
Então vamos lá.
Portanto, tecnicamente, não está 100% correto.
Isso não está incluído em nosso bloco de captura.
Mas só podemos ver isso se entrarmos na matriz.
Portanto, se olharmos para o Smiley aqui, parece que o tipo de retorno é a instrução de retorno também incluída,
mas isso não é verdade.
No entanto, não queremos ser esse porquinho.
Estamos muito animados com o fato de já podermos entender, experimentar e pegar blocos.
O último item sobre o qual não falamos até agora é este aqui, o bloco de captura.
Portanto, aqui podemos ver que temos o catch e, em seguida, o Java Security.
Não há exceção e não há exceção para esses algoritmos.
Muito difícil de pronunciar.
Está bem.
E então temos uma, duas, três, quatro, cinco exceções.
Vamos dar uma olhada no código Java.
Ok, entendi.
Temos um, dois, três, quatro, cinco.
Essas são todas as exceções aqui.
Tudo bem.
Portanto, isso combina perfeitamente com este aqui, de volta para este.
Então, o que mais temos aqui?
Porque não estamos, não terminamos agora.
E vamos voltar ao modelo gráfico.
Está bem.
Portanto, agora sabemos que temos algo como try, temos um monte de coisas e, em seguida, temos esse
catch catch, que inclui essas exceções.
E este aqui também tem algum código.
Portanto, temos muitas instruções de captura aqui.
Está bem.
Portanto, isso significa que esta aqui parece ser esta parte.
Está bem.
Portanto, podemos entender que nesta parte e nesta aqui, quero dizer, não há nenhum grupo que seja exceção.
Esse é o nosso parâmetro.
Então, vamos chamar isso de parâmetro.
Isso pode não ser tecnicamente correto.
Portanto, mesmo que não seja totalmente correto do ponto de vista técnico, é o que é.
Estamos fornecendo uma exceção a essa cláusula catch aqui.
Portanto, estamos atentos a essa exceção.
E essa é a exceção que é acionada.
E esse é o parâmetro em nossa cláusula catch.
Tudo bem.
Está bem.
E, finalmente, só resta uma coisa.
Então, depois deste e deste, talvez possamos fazer desta forma.
E temos esse rótulo no final, que pode ser ignorado.
Portanto, vamos torná-lo amarelo.
Portanto, aqui temos outro rótulo e este, por exemplo, é catch para catch sublinhado quatro.
Então, vamos ver onde esse rótulo ocorre em nosso código de programa aqui.
Vamos copiar isso, inseri-lo aqui e aqui o temos e o temos apenas duas vezes aqui.
Sim.
Portanto, neste momento, por exemplo, nenhum algoritmo desse tipo apresenta exceção.
Este aqui é o rótulo e este aqui aparece aqui.
Portanto, sabemos que, se voltarmos atrás, podemos ter os dois?
Então vamos pegar outro, que pode estar mais próximo.
Isso foi um erro meu.
Vejamos.
Temos uma captura?
Sim, é isso mesmo.
É um pouco melhor porque está mais próximo deste.
E agora temos o quadro completo.
Então, chegamos aqui e, opa, nosso rótulo.
Agora temos a captura um.
Podemos pensar nisso como uma declaração if.
Tecnicamente, isso definitivamente não está correto.
Mas deixe-me explicar a você o que quero dizer aqui.
Então, digamos que tenhamos algo como, por exemplo, uma exceção de tamanho
de bloco neste aqui, seja uma exceção.
Chum to label catch one and catch one está aqui.
Então, aqui podemos ver este.
Essa linha é o fim dessa variável.
Portanto, não se confunda com essa questão.
Portanto, estamos pulando para este, pegando um, e depois movemos a exceção para o V.
Agora estamos transferindo essa exceção talvez para a V1.
Portanto, queremos uma neve B como.
Exceto.
Está bem.
E então temos o que está sendo atribuído a essa variável E.
Portanto, temos essa exceção.
Talvez.
Vamos escrever isso.
Sim.
Acho que adotei o nome mais longo.
Então, lá vamos nós.
Ilegal.
Portanto, isso agora está sendo atribuído ao que queremos, queremos isso agora, esse nome de variável E e T, podemos ver que estamos
invocando um método virtual.
Essa impressão leva a um rastro.
Portanto, ele invocará o método virtual.
Imprime esse rastreamento em v1, que é E, o que significa que estamos chamando e dot oops.
Desculpe, cor errada.
Esse método não tem parâmetros e está retornando.
O quê?
E isso é tudo o que estamos fazendo no momento.
Então, quero dizer, isso não é tecnicamente correto, mas você pode pensar nesse termo, no entanto, eu gostaria
de removê-lo aqui.
Portanto, quando temos uma exceção, não vamos chamá-la de bloqueio de van, que está sendo
introduzida por mim agora no mundo somali.
Portanto, agora estamos tendo um novo bloco.
É o bloco when, quando temos uma exceção de tamanho de bloco ilegal entre o try start e o try e, em seguida, vamos
para o catch one, que é este aqui.
Esta é minha interpretação totalmente livre do bloco try and catch.
Eu não pesquisei e, portanto, esses termos podem não estar 100% tecnicamente corretos,
mas isso não importa, porque somos capazes de entender tudo o que está aqui e podemos facilmente modificar
cada parte aqui e também essa parte em novas aplicações.
E isso é tudo de que precisamos.
Nós o entendemos bem o suficiente para modificá-lo da maneira que quisermos.
Tudo bem.
Certo, perfeito.
Então, vamos voltar ao aplicativo mais uma vez.
Portanto, aqui podemos ver o tamanho ilegal do bloco.
É o E quatro.
Portanto, não tenho certeza se esses números não precisam ser iguais.
Sim, esta é a primeira captura.
E dentro de nossa exceção, é a exceção para esses números.
Todos esses casos não se alinham a eles aqui.
Portanto, F4 pode não ser ou precisa ser a quarta instrução ou instrução de captura em nosso bloco.
Mas podemos ver que temos essa exceção de tamanho de bloco ilegal.
Podemos ver que esse parâmetro E four está imprimindo um preço de pilha.
E então não procuramos mais, mas estamos retornando para fora dessa função.
Portanto, é assim que funcionam os blocos try and catch.
Nunca os vimos antes e não aprendemos nem pesquisamos nada mais.
Com base em nosso conhecimento sobre sorrisos.
Conseguimos entender esse novo bloco completo aqui neste, o que é absolutamente incrível, na minha
opinião.
Então, talvez para terminar isso aqui, vamos fazer esse tipo de retorno.
Além disso, vamos voltar à nossa exceção, que foi a captura um aqui.
Portanto, aqui vimos testes de pilha de impressão.
Ok, isso é algo que já entendemos.
Ele está sendo devolvido e anulado, e aqui podemos ver um rótulo indo para zero.
Então, vamos ver onde esse rótulo aparece.
E esse rótulo aparece.
Talvez.
Vamos esclarecer isso aqui.
Aqui.
Aqui e aqui.
Portanto, ele aparece em todos os blocos de captura e acabamos aqui nesta linha.
Esse é o fim da variável local.
Portanto, este está sendo ignorado.
Começamos neste ponto, Knop significa nenhuma operação.
Isso é absolutamente incrível.
Não tenho encontrado isso há muito tempo, portanto, esse é simplesmente um processo de não fazer nada.
Não sei por que ele está incluído ali, mas depois desse botão podemos ver este aqui.
Esse também é apenas um rótulo que pode ser ignorado porque não temos mais nenhuma instrução de salto para esse rótulo.
E então escrevemos we one igual a zero.
Portanto, estamos escrevendo zero em V um e depois retornando.
O que significa que não estão retornando.
Tudo bem.
E não importa em que exceção terminemos, esse será o fim aqui.
Portanto, estamos tendo aqui uma exceção aqui, uma exceção aqui, uma exceção.
Mas tudo se resume a esse trabalho.
Ir para zero.
Vamos fazer isso talvez em outra ocasião.
Vejamos, aqui temos a captura três.
Neste, movemos a exceção para o V um.
Tudo bem, então temos o V um, e imprima o preço das ações e assim por diante e retorne o relógio.
Muito bem, então temos o fim da nossa variável local.
E então temos esse rótulo "go to", o que significa que acabamos aqui.
Então, pegue também.
O que foi isso?
Terceira captura.
Portanto, isso acontece para todas as exceções aqui.
Acabamos aqui e este é simplesmente um retorno nulo.
Então, sim, isso também se encaixa perfeitamente em nosso código no momento.
Este aqui.
Vamos limpar a tela.
Aqui está.
Sim.
Portanto, estamos tendo retornos nulos o tempo todo aqui.
Mas o sorriso é um pouco mais eficiente nesse momento.
Está bem.
Portanto, isso é tudo para este vídeo no momento.
Isso não foi apenas escolhido porque podemos entender isso.
Esse não foi um caso completamente aleatório.
Por exemplo, casos de troca.
Não falamos sobre casos de troca, mas a abordagem é a mesma e todo o resto consiste apenas em instruções
sorridentes.
Portanto.
Portanto, todo o resto é apenas uma linha sorridente após a outra.
A única diferença é que temos duas construções como esta aqui.
Temos alguns saltos, mas o resto é simplesmente justo.
Analisamos linha por linha e, com esse conhecimento, podemos entender 95% do smiley.
Pode haver alguns casos extremos que não podemos entender no momento, mas se você os encontrar e não
tiver certeza, basta escrever uma mensagem para mim.
Fico feliz em poder ajudá-lo com isso.
Ou talvez, apenas pesquisando on-line, você possa resolver o problema por conta própria, pois com esse
conhecimento você está envolvido agora.
Tenho certeza de que você pode fazer isso.
Muito bem.
Certo, perfeito.
Portanto, esta é a primeira parte, que se tornou outro vídeo longo, mas acho que é impressionante o quanto
já avançamos.
Na próxima, veremos como imprimir alguns sim.
Alguns objetos rígidos.
Por exemplo, queremos obter o valor do vetor de inicialização deste ou, por exemplo, queremos que a chave
secreta seja impressa como uma cadeia de caracteres porque o tipo de retorno aqui é a chave secreta.
Então, como podemos imprimir a chave secreta?
Se sim, se for um objeto completamente diferente, isso é algo que descobriremos no próximo vídeo.
Depois, veremos outro exemplo incrível, que é a inserção de um código de smiley complexo
em um aplicativo existente aqui.
Portanto, estou realmente ansioso para vê-lo na segunda parte.