Voltamos ao nosso único desafio para recapitular toda a seção.
Portanto, neste vídeo, daremos uma olhada na impressão de objetos mais complexos.
E também teremos que analisar a inserção de um código de smiley mais complexo em um aplicativo existente.
Portanto, mostrarei uma abordagem de como podemos fazer isso facilmente.
Portanto, sugiro que nos aprofundemos nessa questão.
Então, vamos abrir um terminal e ainda estamos trabalhando em aplicativos.
E um desafio para recapitular: esse é o nosso desafio de criptografia.
Estamos abrindo com o Shady Square e, mais uma vez, damos uma olhada rápida nele.
Então, vamos ver dentro da coluna hacking de aplicativos, pois aqui temos isso como classe de criptografia.
No último vídeo, vimos como podemos lidar com a sintaxe de smiley desconhecida.
E isso foi incrível, porque nunca fizemos uma engenharia reversa para tentar capturar blocos no
Smiley, mas pudemos entender imediatamente o que estava acontecendo aqui.
Conseguimos descobrir como eles funcionam e, portanto, podemos manipulá-los, excluí-los ou interagir com
eles.
E isso é tudo o que importa.
Entendemos a funcionalidade deles e podemos brincar com eles.
Neste vídeo, daremos uma olhada na impressão de objetos mais complexos.
Por exemplo, apesar da matriz aqui à direita não parecer tão complexa, mas vamos dar uma olhada.
Em seguida, temos uma função de criptografia, portanto, temos um vetor de inicialização de chaves para lidar
com esses objetos.
Queremos colocá-los em nosso terminal.
Queremos que eles imprimam o texto para que possamos trabalhar, para que possamos criptografar e descriptografar nosso texto.
Como podemos fazer isso?
Nossa chave é simplesmente um objeto da chave secreta.
Também podemos escrever System. fora. println?
Chave secreta?
Acho que não.
E isso não é possível.
Portanto, aprenderemos como fazer isso.
E, por último, mas não menos importante, também teremos que analisar a inserção de um código de smiley mais complexo em um aplicativo
existente.
Digamos que você queira inserir o código do smiley que funciona com determinados objetos, determinados métodos de codificação,
imprimir algumas coisas e executar outras ações.
Como podemos fazer isso sem escrever tudo na linha do Smiley?
Portanto, sugiro que comecemos com esta e com a chave secreta.
Como podemos imprimir a chave secreta?
E essa chave secreta é do tipo Java X crypto secret key.
Portanto, essa é uma classe genérica, o que significa que temos uma documentação muito boa sobre ela, e essas classes geralmente
têm Seta e fazem com que nossos métodos trabalhem com elas, porque esse método de criptografia precisa trabalhar com
a chave secreta em um determinado ponto e precisa obter todos esses bytes únicos dessa chave e, portanto, um
bom ponto de partida seria dar uma olhada na documentação oficial.
Talvez encontremos alguns métodos adicionais que não são usados aqui para obter essa chave em um determinado
formato.
Se não conseguirmos encontrar nada para esse caso, talvez seja necessário dar uma olhada no gerador de chaves, pois
ele está gerando uma chave.
Talvez possamos fazer algo com este aqui.
Tudo bem.
E, portanto, vamos lá.
Simplesmente pegamos essa chave secreta de criptografia Java e acrescentamos Android, pois, caso contrário, poderíamos obter
algumas referências Java e isso poderia diferir da documentação do desenvolvedor do Android.
Portanto, temos aqui a chave secreta dos desenvolvedores do Android.
Está bem.
Essa é uma interface pública.
Tudo bem.
E vejamos que aqui temos esses métodos e eles são herdados.
Vamos clicar neste aqui.
Está bem.
Esses métodos vêm do Java Security Key.
Vejamos, temos um método para obter retornos de algoritmos.
O nome do algoritmo padrão para essa chave não parece muito interessante para nós.
Get encoded retorna a chave.
Oh, isso parece bom.
Retorna a chave em seu formato de codificação principal ou nulo se essa chave não for compatível com a codificação.
Portanto, não tenho certeza do que isso significa, mas ele retorna a chave.
E isso é tudo o que importa.
O tipo de retorno está aqui.
É uma matriz de bytes.
Perfeito.
Já temos que lidar com o direito porque queremos imprimir esse texto simples.
Isso significa que agora temos um método que obtém essa chave em uma matriz de bytes e esse método é chamado
get encoded.
Portanto, o que poderíamos fazer agora é o seguinte.
Poderíamos acrescentar entre essas duas linhas.
Agora, nossa chave não recebe o método codificado.
Portanto, sabemos perfeitamente como fazer isso em somali.
Sabemos que se trata de algo em massa.
Acho que não é virtual se você estiver lidando com métodos herdados.
Portanto, teríamos que procurar isso, mas depois simplesmente cortamos nossa referência de classe, que é esta
aqui.
Fornecemos nosso erro.
Chamamos o método get encoded.
Vejamos.
Temos parâmetros lá?
Acho que não.
Não há parâmetros.
Perfeito.
Portanto, poderíamos fazer isso facilmente.
Mas agora gostaria de mostrar uma abordagem que é um pouco mais fácil e que também lida um pouco melhor
com a sintaxe mais complexa.
E essa abordagem definitivamente não é ciência de foguetes.
Portanto, o que faremos agora é o seguinte.
Deixe-me desenhar isso rapidamente na mesa digitalizadora.
Está bem.
Portanto, o que fazemos é o seguinte.
Retiramos esse código do aplicativo.
Por exemplo, nesta linha, queremos chamar o ponto de chave de linha para obter a chave codificada.
Essa é uma chave pequena, codificada, sem parâmetros.
E estamos adotando essa linha em nosso próprio aplicativo.
Portanto, criaremos um aplicativo próprio com essa linha de código, porque também podemos ajustar o outro código Java para que
ele funcione e podemos modificar esse código de qualquer maneira.
Por exemplo, poderíamos imprimir se isso funciona mesmo, poderíamos usar o sistema, o ponto, a linha de impressão e, em seguida,
usar essa parte aqui.
E se isso funcionar, poderemos compilar isso em um aplicativo para que possamos criar esse arquivo APK.
Portanto, aqui temos esse APK.
Este é o nosso APK.
E então podemos simplesmente usar nossa ferramenta APK.
Para tirar esses modificados desse aqui.
Por ter esses arquivos sorridentes.
Já temos nosso código de forma adequada, como ele funciona no Smiley.
E, em seguida, podemos retirar esse código do arquivo smiley, apenas a parte necessária, e
podemos colocá-lo entre essas duas linhas diretamente aqui.
E, ao fazer isso, podemos brincar com o mundo Java aqui.
Se tudo funcionar, podemos fazer experimentos com esse modelo.
Podemos inserir mais código adicional.
Em seguida, cortamos esse pequeno pedaço e o colocamos aqui.
Absolutamente nenhuma ciência de foguetes.
E você pode se perguntar se é tão fácil assim e se podemos simplesmente copiar e colar esse código nesse aplicativo.
Por que não fizemos isso antes?
O motivo disso é que precisamos considerar algumas coisas, e essas coisas só podem ser consideradas se entendermos
completamente a parte do smiley.
Vou lhe mostrar o que quero dizer.
Portanto, aqui temos nosso aplicativo.
Este é o aplicativo original.
Esta é a parte atual.
Está bem.
Agora, estamos inserindo a parte do smiley, digamos que, no meio, estamos inserindo um pequeno pedaço de smiley.
Isso está entre essas duas linhas, por exemplo.
Agora temos que ser um pouco mais cuidadosos, pois digamos que estamos sobrescrevendo determinados
registros, digamos que estamos usando V dois e B três nesta parte.
Mas esses registros podem já ter sido instalados aqui.
Portanto, aqui temos o código original e este é o atual, e temos que considerá-lo como uma única parte.
Portanto, nessa parte, não temos e registramos v um e v dois.
Digamos que v dois seja um objeto muito importante.
Por exemplo, vamos ver isso.
Digamos que seja esse objeto de chaveiro.
Esse gerador de chaves pode ser usado nesta parte aqui.
Em algum ponto intermediário aqui.
E agora, se não entendermos o Smiley, substituiremos esse objeto gerador de chaves aqui
por algo como, por exemplo, system out.
Sistema pensado.
E, nesse ponto, quando ele faz referência ao objeto gerador de chaves aqui, por exemplo,
não temos mais um objeto gerador.
Isso agora está em um objeto fora do sistema e ele falhará.
Ele não precisa falhar.
Portanto, ele também pode funcionar por um bom tempo até que algo aconteça.
Portanto, o que precisamos fazer é inserir nosso código entre esses dois blocos.
Portanto, este é o primeiro bloco.
Este é o terceiro bloco.
E, no meio, este é o nosso bloco.
No bloco número dois, precisamos inseri-lo e fazer uma transição.
Portanto, se quisermos substituir os registros, por exemplo, este V dois, teremos que restaurar esse
V para registrar depois.
Portanto, aqui temos que atribuí-lo novamente ao gerador de chaves.
O quê?
Mas nós, é claro, também podemos fazer isso.
Poderíamos aumentar esses registros.
Então, digamos que aumentemos o número de registros para um número.
Por exemplo, vejamos, oito.
Então, digamos que antes tínhamos cinco registros, mas agora estamos usando oito locais de ponto.
Portanto, não são os locais cinco.
E estamos aumentando esse número para oito.
Isso significa que agora temos registros adicionais disponíveis.
Por exemplo, temos agora oh, isso é muito difícil.
Vamos fazer isso desde o início.
Não queremos que eu tenha três anos antes.
Portanto, esses são os nossos cinco registros, o original.
Agora temos três adicionais, ou seja, cinco, talvez seis, talvez sete, porque começamos a contagem do
zero.
Isso significa que não é necessário substituir um determinado registro como este.
Poderíamos simplesmente usar um novo que criamos, por exemplo, v five.
Tudo bem, perfeito.
Portanto, agora escreveremos esse aplicativo e descobriremos se tudo funciona.
Então, voltemos a este aqui.
Se finalmente obtivermos nossa chave e esta aqui no formato legível e, por
exemplo, um único byte como matriz de bytes ou algum outro tipo de formato, poderemos pegar todo o
código do smiley que criamos aqui e aplicar esse patch aqui.
Portanto, essa é a abordagem: escrevemos nosso aplicativo, testamos tudo no mundo Java e, se funcionar
lá, compilamos esse aplicativo e, em seguida, fazemos a transição para o aplicativo original.
Portanto, estamos fazendo essa parte depois.
Ok, vamos fazer isso.
Está bem.
Não tenho certeza se você já escreveu um aplicativo neste curso, mas não é tão difícil, pois
esse aplicativo estará completamente configurado e tudo o que temos de fazer é inserir uma
linha de smiley.
Já podemos entender todo o conceito desse aplicativo, o que é uma atividade, o que você cria, o método que faz todas
as coisas e, portanto, você não precisa ter medo do desenvolvimento desse aplicativo.
Não é assim.
Estamos escrevendo um aplicativo complexo, multifuncional e de alto layout.
Estamos apenas inserindo uma linha de código.
Portanto, vamos lá.
Vamos para o Android Studio Bin e iniciamos o ponto do Studio como script.
Se você não estiver vendo nada, basta clicar aqui, pois a visualização não foi carregada no momento.
Portanto, se você não tiver essa visualização, se o Android já estiver começando com o meu projeto, tudo o que você
precisa fazer é acessar o arquivo e fechar o projeto, e então você estará aqui novamente.
Em seguida, podemos clicar em Create New Project.
E então escolhemos uma atividade vazia porque queremos que seja o mais simples possível.
Portanto, não queremos ter um botão de navegação sofisticado ou botões flutuantes e coisas do gênero, apenas uma
atividade vazia.
Em seguida, damos um nome a ele e este é o nosso apoiador sorridente.
Assim, o nome do pacote será concedido automaticamente.
Este é agora um apoiador de smiley de bicada.
Esse é o local que você pode escolher no diretório onde deseja colocá-lo, mas eu gosto de mantê-lo
na pasta inicial do Android Studio Projects.
Aqui temos a linguagem e eu gosto de dizer ao Java.
Isso é importante no caso de você executá-lo em seu smartphone real e ler que o smartphone é a versão sete, então
você precisa voltar para a versão sete.
Portanto, esse é o requisito mínimo do SDK.
Portanto, podemos voltar com esse aplicativo para a versão sete.
Se o selecionarmos aqui.
Farei isso agora mesmo porque é simplesmente um aplicativo.
E sim, ele não precisa ter tantos recursos.
Portanto, a compatibilidade com versões anteriores não deve ser tão difícil no momento.
Pronto, clicamos em concluir.
E é isso.
Agora, o grande debate será iniciado, e isso pode demorar um pouco, mas esse grande projeto de lei definirá nosso
aplicativo completamente.
Portanto, tudo o que precisamos fazer é simplesmente executá-lo depois e ele funcionará.
Portanto, eu o verei em breve, até que esse processo seja concluído.
Você pode observar isso na parte inferior aqui.
Está bem.
A parte criativa foi concluída.
E agora o que queremos fazer é não copiar e colar todo esse código.
Por quê?
Porque essa é uma interpretação do código original.
E não podemos simplesmente pegar o código inteiro e sobrescrever a modificação original.
Às vezes, isso pode funcionar, mas na maioria das vezes, por exemplo, em relação aos aplicativos do mundo real, isso definitivamente
não funciona porque não podemos compilar a maior parte desse código aqui.
Temos apenas classes genéricas, o que é muito bom.
Isso pode funcionar, mas em um aplicativo do mundo real você teria tantas dependências que não poderiam
ser resolvidas que não seria possível corrigir esse código agora.
Caso contrário, você poderia simplesmente reimplementar todo esse aplicativo.
E sim, infelizmente isso não é possível.
Está bem.
Além disso, mesmo que isso funcionasse no momento, não sou muito fã de aplicar patches em algo sobre o qual
não tenho controle total.
Portanto, se retirarmos apenas algumas linhas desse documento, poderemos entendê-las e inseri-las
no aplicativo original onde quisermos.
Caso você simplesmente copie e cole tudo às cegas, poderemos encontrar alguns erros.
Portanto, vamos fazer desta forma.
Você quer ficar com este?
Queremos ter um objeto de chave secreta.
Vamos pegar essa linha e simplesmente inseri-la aqui.
Agora precisamos importá-lo e ele já diz: "Ah, isso pode ser a chave secreta criptográfica java x".
Se você pressionar a opção enter ou alt enter, isso será importado automaticamente.
Você pode ver isso aqui e estamos prontos para começar.
Agora temos essa chave novamente e temos uma inicialização dessa chave, mas esse também pode ser o erro.
Sim, temos que criar uma variável local, mas também poderíamos usar isso no código original.
Então, voltando ao código original, aqui temos esse chaveiro e ele também está usando esse método anteriormente.
Portanto, vamos simplesmente copiar os dois.
Tudo bem.
Mais uma vez, temos que importar esses arquivos e agora temos um erro.
Vejamos.
Esse método pode causar uma exceção e, portanto, temos que envolvê-lo com try e catch.
Basta clicar aqui e pronto.
Portanto, agora transferimos esse código para o nosso próprio aplicativo e podemos verificar se ele funciona simplesmente
salvando-o e depois criando esse aplicativo.
Então, clicamos em Build, Build APK.
O OC e a TV já o têm, portanto, o épico de inicialização foi bem-sucedido. Agora temos esse aplicativo, não vamos
instalá-lo agora ou sim, vamos fazer isso.
Então, vamos nos conectar ao nosso smartphone.
Já temos alguma conexão?
Sim.
Isso significa que podemos simplesmente usá-lo em nosso estúdio Android.
Portanto, aqui podemos ver que agora ele está mudando porque eliminamos o servidor ADB.
O Android Studio também está usando o servidor ADB.
Portanto, ficamos aqui.
Vamos simplesmente instalá-lo aqui.
No entanto, aguarde com a cópia da tela até que o processo de instalação seja concluído.
Portanto, agora podemos obter essa tela.
E aqui temos nosso aplicativo.
Apoiador de sorrisos.
Hello World.
Parece perfeito.
Em seguida, queremos chamar o método get encoded porque esse é o método que retorna nossa chave secreta
na forma de uma matriz de bytes.
Portanto, a chave é codificada e aqui está ela.
E também vimos que esse método está retornando pela matriz.
Se construirmos esse aplicativo dessa forma, uma instrução estará faltando.
Portanto, se você fizer isso dessa forma, o objeto não será movido para o registro.
Portanto, esse objeto de resultado, apesar da matriz, finalmente está em nosso caminho sorridente agora.
E podemos forçar essa instrução simplesmente atribuindo-a a uma variável.
Portanto, vamos simplesmente criar uma matriz própria e uma matriz de bytes.
Vamos chamar isso de minha matriz.
Ops.
E vamos atribuí-lo aqui.
Dessa forma, podemos ter 100% de certeza de que estamos tendo esse método get e codificado e,
depois disso, temos a instrução move resolvida no registro v zero, por exemplo.
Muito bem, agora vamos ver se essa abordagem funcionaria mesmo.
Então, podemos imprimir uma matriz de bytes dessa forma?
Minha matriz.
Está bem.
Até agora, tudo bem.
Não recebemos erros.
Vejamos.
Salvamos esse arquivo e simplesmente clicamos em executar.
Assim, você pode ver essa prototipagem.
É muito fácil e leva apenas alguns segundos.
Então, aqui está.
E sim, não precisamos mais observar esse aplicativo.
Basta dar uma olhada na saída do logcat do ADB, que pode ser encontrada aqui.
Aqui está a saída do logcat e agora podemos procurar por system dot out e isso parece um pouco estranho, certo?
Portanto, temos essa matriz de aranha, conhecemos essa parte do Smiley e temos um endereço.
Portanto, essa é apenas a referência à matriz da aranha.
Portanto, a abordagem do sistema não funciona em uma ampla gama.
O que poderíamos fazer, é claro, é o seguinte.
Poderíamos iterar sobre o array da aranha dentro do loop for, mas não há uma opção melhor.
A melhor opção já está incluída no aplicativo original, porque o aplicativo original
está imprimindo o texto criptografado, que também consiste em bytes no formato visual.
Você ainda se lembra como.
Não, não há problema.
Vamos dar uma olhada.
Então, vamos abrir um novo terminal.
Vamos colocar essa tela aqui.
Temos esse aplicativo.
E, por outro lado, nosso melhor aplicativo.
E agora.
Sim, você deve se lembrar.
Leia-me se puder, então temos isso, essa codificação e o sinal de igual no final da base 64.
A base 64 é uma codificação muito boa para colocar esses bytes em uma saída ASCII visual.
Então, por que não simplesmente pegar isso pelo array e, sim, codificá-lo com o método de codificação de base 64?
Vamos dar uma olhada no aplicativo original e ver como eles resolveram esse problema.
Então, vamos fazer isso.
Está bem.
Atividade principal.
E aqui está.
Portanto, isso é do Android Utility 64.
Temos a cadeia de caracteres ENCODE two.
Já descobrimos que isso requer dois parâmetros.
A primeira é a matriz de bytes, muito boa.
E a segunda são apenas essas bandeiras, que são.
Sim, ele está sendo inicializado com zero aqui.
Ok, vamos usar esse método.
Então, vamos ver isso aqui.
Podemos excluir isso agora mesmo e vamos fazer isso desta forma.
Por 64, codifique duas cadeias de caracteres.
Se pressionarmos alt enter, esta será inserida aqui e poderemos usá-la.
Então, agora estamos usando minha matriz, certo?
E está faltando um parâmetro.
Portanto, também estamos escolhendo o valor zero.
Está bem.
Agora podemos salvar isso em outro texto.
Ou podemos fazer isso da seguinte maneira.
Acho que agora essa é a melhor abordagem.
Então, vamos ver se isso funciona.
Clicamos em Run.
E aí está.
Legal.
Portanto, este aqui, nesta hora, página 64, texto codificado.
Essa é a nossa chave secreta e o formato de base 64.
Portanto, podemos simplesmente usar a base 64 para codificar a cadeia de caracteres e, em seguida, usar nossa abordagem de saída do sistema para imprimi-la.
Bastante ridículo.
Legal, não é?
Com certeza.
Portanto, eu sugeriria que tentássemos decodificá-lo primeiro
por 64.
DX Tudo bem.
X 60 traço p aí está.
Portanto, essa é a maneira de sair.
Então, pegue esses bytes da chave secreta e agora temos que verificar isso.
Não estamos fazendo isso no momento.
Você pode fazer isso por conta própria se essas chaves ou esses bytes estiverem realmente funcionando no momento.
Se não tiver certeza de como fazer isso, forneci um vídeo bônus em que você aprende tudo, pois isso
tornaria este vídeo desnecessariamente longo, e tenho a sensação de que ele já se tornará longo.
Agora já sabemos como imprimi-lo.
A única coisa que eu gostaria de mudar aqui é que isso pode ficar confuso nessas partes sorridentes.
Portanto, acho que uma abordagem melhor seria simplesmente dividir isso.
Vamos criar também uma string de gravação na variável string e usá-la aqui.
Temos que trocá-los.
Agora.
Estamos prontos para ir.
Portanto, isso significa que esses dois podem ser ignorados.
Eles não são relevantes para esta parte no momento.
Eles são necessários apenas para criar a sintaxe completa do smiley.
Está bem.
Este é o código original antigo.
Código original antigo.
Este ainda é o código original antigo.
E este é o nosso código.
Nosso código que queremos inserir.
E depois precisamos imprimi-lo aqui.
Sim.
Portanto, este é o nosso aplicativo no momento, queremos ter essas linhas sorridentes relacionadas a essas
linhas de código Java.
E então estamos pegando-os e simplesmente inserindo-os aqui, não aqui, mas aqui entre a chave secreta
e o texto cifrado.
Está bem.
Vamos fazer isso.
Então, passamos a construir, construir, empacotar, construir o apk.
Aqui não temos o épico.
Clique em localizar.
É isso aí.
Vamos renomear isso para o que era o nome Smiley Supporter.
Em seguida, estamos usando uma ferramenta K DX no Smiley Supporter e, depois, estamos usando o terceiro código de estúdio em todo
esse diretório.
Está bem.
Confio no outro pensamento porque sou o autor e sou absolutamente confiável.
Então vamos ver.
Os óculos inteligentes estão chegando.
Hacking de aplicativos.
Atividade principal.
Foi aqui que inserimos nosso código.
Agora precisamos separar isso.
Portanto, precisamos nos certificar ou descobrir qual é o código antigo?
Este aqui.
E qual é o nosso código?
Precisamos inserir o código antigo.
Essa é uma chave secreta?
Gerar chave.
Esta é a última linha.
Podemos encontrar isso no aplicativo original aqui.
Queremos inserir nosso código depois.
Portanto, estamos reutilizando essa linha e queremos ter a instrução depois dela.
Portanto, estamos buscando a chave de geração.
Esse é um esforço muito grande.
Sim.
Esse é o resultado, que será movido para v1 e, em seguida, nosso código será iniciado.
Portanto, este é o início do nosso código.
Início de nosso código.
Ok, vamos dar uma olhada nisso.
Essa linha número 35 está de acordo com o Android Studio?
E é verdade.
Está bem.
Isto é.
Isso é muito legal.
Eu não tinha certeza se Chadwick estava arrependido.
A ferramenta K é igual a esta aqui, mas esta é.
É perfeito.
Podemos identificar nosso número de linha diretamente.
Sim.
Não se baseie apenas nos números das linhas.
Verifique também este código.
Portanto, temos minha matriz.
Ser codificado.
Vejamos.
Sim.
Temos a chave.
Essa é a nossa chave secreta.
Isso é o que queremos e temos a interface invoke.
Oh, não é invocar virtual.
É uma interface de invocação.
Temos a interface invoke em nosso método get encoded.
Portanto, este aqui é o ponto da chave secreta que é codificado e retorna a especificação e a matriz que será armazenada
na v2 se não atribuirmos essa variável dessa forma.
Então, digamos que estamos apenas chamando-o de "sorry" e essa linha estará faltando.
Portanto, é bom atribuir esse material.
Quer dizer, poderíamos facilmente adicionar isso por conta própria, mas sim, é bom ter um código completo de smiley
aqui.
Tudo bem, isso significa que tudo o que temos que fazer é.
Vejamos.
Temos que pegar essas três linhas e inseri-las no aplicativo original.
Talvez possamos.
Vejamos.
Talvez possamos deixar isso um pouco mais limpo.
Quero dizer, não precisamos de rótulos em nosso novo aplicativo original, portanto, podemos nos livrar
desses rótulos, eu acho.
Então vamos ver.
Está bem.
E também este aqui.
Sim.
Essas são todas as linhas.
Esse é o início do nosso código.
E este aqui.
Este é o.
O fim do nosso código.
Está bem.
Agora, vamos abri-los lado a lado.
Colocamos isso à direita.
Acho que se você clicar no Explorer ou se clicarmos neste aqui, sim, ele será fechado.
E agora temos que dar uma olhada no arquivo de smiley do A no aplicativo original.
Este aqui.
Veja os aplicativos.
Um desafio para recapitular tudo.
Vamos abrir todo o diretório A.
E vamos colocar isso no lado esquerdo.
Está bem.
Nós dois estamos na criptografia somali.
Isso é correto.
Portanto, temos que abrir a partir da última vez.
Está bem.
E agora temos que encontrar, talvez, talvez devêssemos nos concentrar primeiro no aplicativo original.
Portanto, temos que encontrar essa linha-chave de geração nesse aplicativo.
E acho que já estou percebendo isso.
Linha 21.
Vejamos, vamos colocar agora o código original ao lado dele, linha 21. Portanto, esse é o código e temos que verificar
o resultado.
É a linha 21.
Sim, isso está correto.
Essa é a nossa chave de geração.
E depois disso, temos que inserir nosso próprio código e nosso próprio código.
Está bem.
Até agora, tudo bem.
Perfeito.
Em seguida, podemos minimizar esse e ir para o lado direito.
Então, aqui temos isso.
Acho que será um pouco melhor se usarmos mais hash tags, pois assim será mais fácil reconhecê-las.
Está bem.
Então, agora copiamos e colamos isso entre os dois.
Está bem.
E agora precisamos ter certeza de que a transição está funcionando corretamente, porque talvez tenhamos
usado registros diferentes aqui e aqui.
Assim, a transição do código original para o nosso código, de volta ao código original, portanto, agora podemos
fechar essa parte.
Nosso código não é mais relevante.
Portanto, isso pode ser encerrado.
E agora isso é algo que eu definitivamente quero ter no modelo gráfico.
Vejamos.
Sim, aqui podemos ver o suficiente.
Portanto, levamos isso para a mesa digitalizadora e vamos nos aprofundar nessa parte agora mesmo.
Vamos passar por isso um pouco mais rápido porque não precisamos reverter a maioria das coisas antes
disso.
Ok, vamos fazer isso.
Está bem.
Vamos dar uma olhada nesse caso.
Portanto, este é o início do nosso próprio código e este aqui, e ele vai até este aqui.
Portanto, dentro desse código, temos que verificar se substituímos os registros que foram usados aqui.
Portanto, vamos dar uma olhada nesse caso.
Está bem.
Então, aqui podemos ver que, nesta parte, configuramos o registro zero do DB, me zeros inicializados
com os valores zero aqui e, em seguida, vamos ver, este aqui não é relevante.
Esse é o nosso parâmetro no momento.
Temos que o local de Ki Chen é zero.
Portanto, agora v zero será atribuído ao gerador ki.
Nesse ponto, o mi zero será alinhado ao gerador de chaves.
Está bem.
Então, temos nosso tri start.
Nós queremos.
Queremos outro.
Talvez seja melhor mudar a cor para amarelo.
Portanto, queremos que isso seja atribuído a uma string, que é um as.
Está bem.
Em seguida, invocamos static em V one e movemos o resultado para v one.
Portanto, o V1 já foi substituído neste momento e o V1 é agora o nosso gerador de chaves.
B one é agora nosso gerador de chaves.
Está bem.
Portanto, esse não é mais relevante.
E então movemos o resultado de um para zero.
Portanto, nesse ponto, o P zero também se torna nosso gerador de chaves.
Portanto, agora também este.
Naquela época, já sabíamos que se tivéssemos dois registros com o mesmo objeto, um deles seria reutilizado.
E lá vamos nós.
Aqui temos 100 em hexadecimal.
Portanto, o primeiro será substituído pelo hexágono 100.
Em seguida, temos o invoke virtual.
Não nos importamos com isso.
E ele está retornando vazio para que possamos seguir em frente.
Então temos e trabalhamos bem.
E agora estamos retornando um objeto diferente, este aqui.
Portanto, essa é a nossa chave secreta.
Muito bem, vamos melhorar um pouco isso.
Mais claramente.
Essa é a nossa chave secreta.
Nossa chave, e isso será transferido para a V um.
Portanto, nesse momento, o nosso será substituído por este.
Queremos que tenhamos nossa chave em mãos.
Nossa chave secreta e, desculpe, chave secreta.
Chave secreta.
Portanto, vamos limpar isso um pouco.
Está bem.
Isso significa que, nesse bloco de código aqui, não temos permissão para tocar no zero e queremos.
Vamos fazer desta forma.
Aqui está.
Está bem.
E não sobre.
Certo.
Então, vamos dar uma olhada em nosso código agora mesmo.
Então vamos ver.
Tudo bem.
Temos a interface invoke em V.
Isso está correto?
Queremos que seja do tipo.
Esta em Java x kryptos secret key é a chave secreta que queremos neste momento.
Sim, é isso mesmo.
Nós o temos aqui.
Portanto, isso é perfeitamente aceitável.
Temos o método get encoded e estamos retornando o array bite, e o array spider
será movido para b two.
O V2 está bom, o V2 está livre para uso no momento, portanto, podemos escolher bem.
B dois é agora nossa matriz de bytes.
Essa é a nossa chave em bytes.
Chave em bytes.
Então vamos dar uma olhada.
Até agora, tudo bem.
Depois, temos o b3v3.
Também não há problema, pois não temos permissão para tocar em v zero e, se quisermos, podemos reutilizar v um,
como fizemos aqui, mas não temos permissão para sobrescrevê-lo.
Então, v três Estamos agora nessa linha.
O V três será atribuído com zero, o que também é perfeitamente aceitável.
Agora temos que invocar a estática.
Certo, estamos usando o método ou estamos chamando o método.
Vamos fazer desta forma.
Então, agora estamos aqui e estamos chamando base64 e base 64 e código e vamos ver qual é o parâmetro aqui.
O parâmetro é que temos dois parâmetros e uma matriz de bytes e uma matriz de bytes que é V dois e vamos mudar
a cor.
Também temos um valor inteiro que é v três.
Vamos ver o array de bytes v dois.
Isso serve?
Sim.
V dois é a nossa matriz de bytes, que se encaixa perfeitamente e, em seguida, o valor inteiro é v três, vamos colocar uma vírgula
e v três é o nosso valor inteiro zero.
Portanto, isso também é perfeitamente aceitável no momento em que esse método funciona.
Agora temos que tomar cuidado, pois estamos sobrescrevendo b três e vamos pegar outra cor.
Portanto, o V3 é agora a string codificada em base64.
Portanto, o resultado desse será agora armazenado na v3.
Nós três somos iguais neste momento e vamos esclarecer isso um pouco.
Está bem.
Portanto, estamos agora nessa linha.
Tudo parece bem até agora.
E vamos ver.
E então temos um objeto definido.
E agora vamos buscar nosso sistema.
Então, vamos usar outro sistema de cores.
Então, buscamos o ponto de saída do sistema, o ponto de saída do sistema, e este será armazenado e vamos ver.
E isso será armazenado no V for.
Antes.
É tudo muito.
Não há problema.
Não é B zero e V um.
E então, vejamos, invocamos o virtual em nosso objeto.
Portanto, em nosso campo ID, chamamos a linha de impressão.
Portanto, agora estamos chamando o System. fora. println.
Esta é a última linha aqui em nosso próprio código.
Então, vamos escrever isso.
Estamos invocando a linha de impressão system dot out.
Isso retorna um branco perfeito e estamos tendo apenas um parâmetro que é do tipo string.
Nossa string agora está com 3b3 e vamos verificar se isso está correto.
Então, vejamos que B três é nossa cadeia básica de C quatro e código dois.
Portanto, tudo isso se encaixa perfeitamente em nosso código no momento.
Isso pode ocorrer porque já começamos no início do nosso código e copiamos
e colamos as três primeiras linhas nesse formulário e em nosso próprio aplicativo.
Ainda não configuramos nada.
Portanto, essa pode ser a razão pela qual tudo parece tão perfeito.
No próximo exemplo, encontraremos situações em que isso não se encaixará mais perfeitamente e talvez tenhamos
que ajustar muitas coisas, mas, neste momento, verificamos e isso deve funcionar
imediatamente, o que é incrível, certo?
Com certeza.
No entanto, vamos verificar se a transição realmente funciona.
Então, aqui, continuamos com o código original e isso significa nosso registro.
Nós ainda devemos ter nossa chave secreta.
Este aqui.
Vamos ver se esse é o caso.
O B one foi usado aqui.
Sim, e é uma chave secreta.
Portanto, isso é perfeito.
Talvez seja mais limpo se o fizermos dessa forma.
Portanto, não estamos atribuindo isso.
Estamos reutilizando-o.
Vamos mantê-lo dessa forma.
Está bem.
E então só nos resta o zero, que não está na tela neste momento.
Vejamos.
Está bem.
Temos que rolar para baixo mais tarde e verificar se vemos que Roe precisa ser o que é, zeramos nosso gerador de chaves,
então talvez o zero não esteja sendo usado depois do que isso significaria que poderíamos ter usado com zero em nosso
código.
Temos que resolver isso.
Mas se virmos que Roe não está sendo usado aqui embaixo, se virmos que as estradas não estão mais sendo usadas ou se V0 estiver
sendo sobrescrito, por exemplo, se zero for sobrescrito e não estiver mais no gerador
de chaves e verificação como este aqui.
Então, também poderíamos tê-lo usado em nosso código.
Mas isso é algo que temos que descobrir primeiro.
Portanto, eu sugeriria que déssemos uma olhada rápida nesse caso.
Está bem.
Então, aqui estamos de volta à VM do Ubuntu.
Vejamos que os zeros são usados somente aqui.
Então, temos o início do nosso código, o fim do nosso código e, em seguida, vamos rolar um pouco para baixo.
Sim.
Não consigo mais vê-lo.
Portanto, o zero não será mais usado, o que é bastante interessante.
Portanto, ele não está sendo reciclado nem mesmo no código original.
Então, sim, isso significa que poderíamos ter simplesmente reutilizado o to be zero em nosso código aqui.
Portanto, o início do nosso código, que é zero, pode ser reutilizado.
Muito bem, é isso.
Portanto, sugiro que simplesmente criemos esse aplicativo e vejamos se ele está funcionando.
Quer dizer, isso se encaixa perfeitamente agora, nosso código neste aqui dentro deste código aqui.
E, caso isso não aconteça, sabemos como fazer isso agora mesmo.
Portanto, é preciso pegar a folha de papel e analisar linha por linha para ver se
esses registros estão sendo inicializados ou usados antes.
E se você os substituir e, às vezes, também tiver outros parâmetros.
Por exemplo, digamos que temos um parâmetro aqui, que é a nossa chave secreta.
E não é um valor inteiro e, portanto, temos que ajustá-lo para que esse parâmetro fique
correto depois.
Tudo bem.
Ok, vamos reverter isso.
Portanto, este foi o B três.
Esse é o nosso valor inteiro.
Então, sim, você viu como é possível fazer isso.
Agora, vamos simplesmente executar esse aplicativo e ver se conseguimos obter nossa chave secreta.
Então, vamos fazer isso.
Está bem.
Dois seriam um desafio para recapitular todos.
Ah, é sim.
Está aqui.
É o A's.
E agora vamos ver.
E agora temos isso, isso.
E vamos simplesmente verificar com o Shadi.
Desculpe-me.
O que está acontecendo aqui?
Portanto, agora estamos abrindo nossa versão corrigida antes de instalá-la para ver se tudo está correto.
Com App hacking a yes a yes crypto e pronto.
Agora temos um sistema. fora. println base64 e a chave da string cultural é codificada como um parâmetro
e pronto.
Portanto, este está em parâmetro e retorna em binário, apesar de a matriz ser transferida para uma cadeia
de caracteres codificada em base64 e essa cadeia ser impressa.
Todo o nosso ajuste de linhas sorridentes foi colocado em uma única linha aqui, mas parece absolutamente
perfeito.
Então, vamos executar isso e, portanto, temos que pular uma linha no início.
Pular uma linha que deveria ser um sim para fora.
Está bem.
Em seguida, precisamos usar o assinador
de APK e desinstalar a versão existente.
O smartphone foi desconectado.
Sim, é isso mesmo.
Lá.
Nós o temos de volta.
Está bem.
Portanto, esta é a versão original.
Em seguida, um desafio da EPS para recapitular todo o leste.
Instalamos nossa versão desse teste somente em saltash tx.
Agora, vamos retirar o logcat do ADB e procurar o ponto do sistema.
E vamos abrir esse aplicativo.
Portanto, mantenha isso em primeiro plano.
E lá vamos nós.
Texto criptografado agradável de 3 para 1.
Isso está relacionado à atividade principal, eu acho.
E aqui temos nossa chave.
Isso significa que essa base64 deve mudar o tempo todo.
Portanto, agora podemos ficar com esse.
Painel Echo PN 364 DX Sim.
Portanto, aqui podemos obter as divisões dessa forma.
Aqui não temos as partes de nossa chave secreta.
Essa é a mensagem que queremos imprimir, bem como o vetor de inicialização.
Isso também é algo que está faltando no momento.
Vamos verificar se ele pode estar correto na primeira tentativa, portanto, podemos deixar isso em aberto.
Mas estamos reiniciando esse aplicativo porque a chave muda o tempo todo.
Ops.
Então, isso significa que deveríamos ter outro?
Sim.
Parece bom.
Está bem.
Mesmo tamanho, valor diferente.
Isso parece perfeito.
O que está faltando até agora é o vetor de inicialização, o parâmetro e também o valor de retorno.
Mas todos os três são matrizes de bytes, portanto, podemos adotar a mesma abordagem.
Na minha opinião, agora é um pouco mais fácil fazer isso diretamente no Smiley, porque temos quatro instruções, eu
acho, duas para obter a cadeia básica codificada em C-4 e duas para imprimi-la com um ponto de saída do sistema.
É claro que você também poderia fazer isso no Android Studio, mas este vídeo foi criado para mostrar como você pode criar
protótipos de coisas no Android Studio para fazê-las funcionar.
Por exemplo, para brincar até chegarmos a um "Yeah".
Um método e uma maneira de imprimir a chave secreta como uma matriz de bytes em um formato codificado em base64.
Descobrir isso diretamente no smiley é muito mais difícil e não é absolutamente necessário ou desnecessário.
Portanto, temos um ambiente Java em que podemos criar protótipos desse material e, se funcionar, podemos simplesmente
decodificá-lo para saber como ele se parece com um smiley.
Tudo bem.
Portanto, se você quiser fazer isso, deixo aqui uma tarefa para você imprimir a corrida das três aranhas que falta.
Farei uma solução rápida no início do próximo vídeo, pois gostaria de terminar este vídeo
agora mesmo.
O que vimos como protótipo de coisas em Java é bastante impressionante.
Decodificá-lo e obter o código do smiley é ainda mais incrível nesse caso.
Não foi tão difícil, pois a transição do código original para o nosso código e de volta para o código original
foi bastante tranquila.
Acho que não precisaríamos ajustar nenhum registro agora, caso precisássemos.
Isso não é absolutamente nenhum problema.
Temos a habilidade e o conhecimento para lidar com todas essas questões e faremos isso no próximo vídeo, onde
teremos uma tarefa um pouco mais difícil.
Portanto, teremos que analisar a impressão e a taxa sem o método codificado em 64, não porque não
haja um método codificado em 64 disponível.
Ele estará sempre disponível no sistema Android.
Mas vamos supor que estamos tendo um objeto e não podemos codificar esse objeto na base64.
Digamos que tenhamos que iterar sobre esse objeto na memória e imprimir cada um dos valores.
Portanto, gostaria de mostrar a você também a abordagem de loop for.
E, sim, isso será um pouco difícil.
Portanto, estou ansioso para vê-los na última parte, quando terminarmos essa jornada aqui.
Portanto, depois dessa, estamos muito preparados para realizar todas as tarefas que desejamos ter na Somália.
Poderíamos escrever um código de smiley realmente complexo e colocá-lo em um aplicativo próprio para que
pudéssemos fazer muitas coisas com o Smiley, o que é incrível.
Assim, podemos contornar todos esses recursos de segurança, imprimir determinadas chaves, depurar informações
e coisas do gênero, tudo isso sem privilégios de root porque modificamos diretamente o aplicativo.
Ok, então é isso por enquanto e estou realmente ansioso para vê-lo no vídeo final do nosso desafio
aqui.
Então vamos lá.