Muito bem, pessoal.
Tchau.
Volte aqui.
Agora é hora de um desafio.
Então, retiramos nosso sistema, abordamos e tentamos imprimir o método criptografado ou criptografado.
Com relação ao XOR, não importa realmente porque nossa entrada recebe X ou dentro do valor ou na chave e, em seguida, temos
nossa saída que é criptografada ou descriptografada.
Se você pegar a saída X ou a devolver com a mesma chave, receberemos de volta nossa entrada.
Portanto, não importa se é um método de criptografia ou de descriptografia.
Está bem.
No entanto, temos nosso aplicativo e precisamos descobrir a mensagem secreta.
Podemos ver que a mensagem secreta não está sendo impressa.
Portanto, presumo que temos que lidar com um texto criptografado e precisamos obter a versão descriptografada
dele.
Podemos ver o aplicativo embaixo, mas o layout também foi aprimorado.
Eu prometi isso a você.
Portanto.
Portanto, sim.
Vamos simplesmente analisar esse aplicativo e ver como podemos usar o sistema, nossa abordagem para transmitir
a mensagem.
Portanto, mudamos para nossa VM do Ubuntu e você pode encontrar esse desafio na seção como um anexo.
Já fiz o download e ele se chama criptografia XOR.
Então, eu pego esse aplicativo e o coloco em nosso diretório de aplicativos bem organizado aqui, X ou criptografia.
Tudo bem.
E agora, sim, vamos simplesmente dar uma olhada nisso.
Então, mais uma vez, usamos a parte excluída e vamos ver se eu consigo.
Sim.
Descompile-o de forma totalmente correta ou se houver algum erro que precise ser corrigido.
Desculpe-me, mas temos esse nível de bloqueio e também queremos obter os erros.
Vamos ver.
O aplicativo está sendo carregado.
Clique lentamente no XML do manifesto do Android aqui.
Muito bem, vamos dar uma olhada nisso.
Está bem.
Até agora, tudo bem.
Está bem.
No manifesto do Android, podemos ver que não temos nenhuma permissão específica.
Isso é bom.
Temos apenas uma atividade, que é a atividade principal, que é o lançador.
Muito bem, vamos dar uma olhada nas aulas.
Portanto, essa é a nossa principal atividade.
Vamos voltar a esse caso.
Bem, aqui temos alguns problemas, mas eles não estão relacionados ao nosso código.
Certo, então.
Sim, parece bom.
Bem, aqui temos nossa atividade principal.
Vejamos.
Temos nossa própria criação, temos a visualização de conteúdo definido, temos a visualização de texto e também temos criptografia XOR, criptografia,
descriptografia.
Tudo bem.
E essa é a nossa mensagem.
Portanto, presumo que essa seja a versão criptografada e que esta a descriptografe.
Mas, pelo que podemos ver, não há valor de retorno ou, pelo menos, não usamos esse valor de retorno.
Portanto, nunca saberemos como é essa mensagem descriptografada.
E essa é a tarefa que temos de descobrir.
Certo, então vamos entrar nesse script criptografado.
Podemos ver que é interessante que esse método obtenha um valor de retorno do tipo string, mas ele não está sendo
usado em nosso código Java e, portanto, é descartado no lado Java.
Tudo bem.
Portanto, esse é um método estático de criptografia e descriptografia.
Ele recebe uma string de entrada e retorna uma string de retorno.
Aqui temos nossa chave, que é épica.
Temos um novo construtor de strings, portanto, temos um novo buffer de saída.
E aqui podemos ver que temos o loop for, que se baseia no comprimento da entrada.
Tudo bem.
Em seguida, temos o append de saída e pegamos um caractere da nossa entrada e o xoramos com o comprimento do módulo da
chave.
Está bem.
E depois o devolvemos.
Está bem.
Portanto, se você estiver lidando pela primeira vez com uma criptografia XOR, acho que devemos recapitular um pouco.
Então, pego meu tablet gráfico e, sim, damos uma olhada nisso.
Muito bem, vamos falar sobre essa função.
Portanto, temos essa função encrypt decrypt.
Temos uma cadeia de caracteres como parâmetro.
Muito bem, esta aqui é a nossa mensagem, nossa mensagem criptografada.
Digamos que seja assim.
Este aqui.
Então, temos um loop for ou, digamos, ok, temos uma chave primeiro.
Portanto, aqui temos uma chave.
A chave é igual.
E depois temos letras simples, a, p, p e assim por diante.
Portanto, essa é a nossa chave.
Certo, agora o que fazemos é pegar nossa mensagem criptografada, esta aqui, e colocá-la neste loop
for.
Isso significa que retiramos um caractere e o exploramos com o primeiro caractere aqui.
Isso significa que esse cifrão recebe agora x ord com a fazemos isso para o comprimento da mensagem.
Portanto, fazemos isso sempre que essa mensagem aqui recebe dados de entrada.
É disso que se trata essa extensão no início.
Ok, agora temos a parte de aparência superestranha aqui.
E isso garante que, vamos supor que tenhamos apenas uma chave solar.
Três cartas, esses três gráficos.
Portanto, esse é o fim de nossa chave.
Mas agora aumentamos a contagem aqui.
Então, pegamos a próxima letra da nossa mensagem, que é a hash tag.
Exportamos isso agora com P, depois pegamos o próximo, que é um, exportamos isso, ops, exportamos novamente,
exportamos isso com o outro P e agora temos um problema porque pegamos o próximo, que
é S e, sim, não temos mais nenhuma letra em nossa chave EP.
É por isso que temos esse comprimento de chave de módulo.
Isso significa que, se você ficar sem caracteres em nossa chave ali, esta aqui, nós nos certificamos
de começar do início novamente.
Portanto, não importa o tamanho da mensagem, basta começarmos do início.
Portanto, esse agora se torna novamente um pino A.
Portanto, se você chegar ao final aqui.
Em seguida, voltamos ao início e é isso que esse modelo de IA, de baixa duração, faz.
Portanto, não importa realmente quantos gráficos estão lá.
Por exemplo, se houver mais do que à direita, não importa porque o comprimento da chave, o loop de quatro
do comprimento da chave será abortado depois.
Então, digamos que nossa mensagem contenha apenas dois caracteres, portanto, esse não está mais disponível.
Então, essa primeira condição aqui no IE é igual a zero.
IE é menor que o comprimento da entrada.
Portanto, nesse caso, o comprimento da entrada define quantas rodadas serão realizadas aqui.
E se o comprimento da entrada for menor que o comprimento da chave, isso não importa.
Portanto, o único problema com esse modelo é que a chave é cortada.
E, nesse caso, não temos mais de dois caracteres.
Portanto, nossas chaves têm apenas dois caracteres e P, mas esse também é o caso da nossa mensagem.
Tudo bem.
Então, é isso que essa função faz.
Então, agora vamos ver onde podemos colocar nosso sistema para obter a mensagem descriptografada.
Então, deixe-me esclarecer isso.
Está bem.
Portanto, temos diferentes opções.
O primeiro está dentro deste.
Portanto, aqui temos a saída para a string.
Isso significa que esse método aqui retorna nossa string descriptografada e ela será armazenada ali.
Portanto, antes de retornarmos, digamos que pareça algo como "return me one", por exemplo, ou "V two", basta
sabermos isso.
Portanto, antes de retornarmos, simplesmente adicionamos nosso sistema aqui, sistema, ponto para fora da linha de impressão que desejamos.
Ao fazer isso antes que o método retorne deste, ele simplesmente imprime a mensagem criptografada ou descriptografada
no console.
E é exatamente isso que queremos ter.
Mas, a essa altura, também vemos alguns tipos de perfis aqui.
Portanto, essa saída é do tipo.
Vejamos.
Construtor de strings.
E aqui ele é convertido em string.
Então, sim, também temos que fazer a tipificação primeiro.
Caso contrário, estaremos retornando um construtor de strings e não tenho certeza se isso funciona.
Portanto, essa abordagem está funcionando, mas é um pouco mais complexa.
Então, vamos dar uma olhada na atividade principal e talvez possamos fazer isso por lá, o que é um pouco
mais fácil.
Então, eu limpo isso e, sim, vamos voltar à atividade principal.
Então, aqui podemos ver que temos nossa criptografia XOR, então temos criptografia, descriptografia e nossa
mensagem que está sendo criptografada, mas que será retornada como uma string descriptografada.
Nesse caso, não temos uma variável atribuída a essa saída.
Portanto, o valor de retorno desse e podemos ver que, sim, ele não será usado, mas talvez tenhamos isso na parte
do smiley.
Portanto, à primeira vista, não parece ser uma opção inválida para nós porque, sim, não temos um valor de retorno
lá ou um valor de retorno que esteja sendo usado.
Mas vamos dar uma olhada no código do smiley.
Talvez o código do smiley seja um pouco diferente.
Então vamos ver.
Ok, então eu descompilei esse aplicativo e agora basta abrir o arquivo smiley.
Vamos dar uma olhada na atividade principal e alterá-la para Java.
Está bem.
Então vamos ver.
Temos nossa atividade principal e estendemos a atividade compacta AB.
Está bem.
Esse é o nosso arquivo de origem.
Aqui podemos ver que temos um campo de instância da visualização de texto.
Não vejo isso há algum tempo.
Em seguida, temos o método direto do nosso construtor.
Aqui temos nossos métodos públicos.
Ah, ele também leva em conta os métodos protegidos.
Certo, então, neste ponto, desculpe, sobre isso, os métodos virtuais estão relacionados aos métodos públicos e protegidos.
Está bem.
Então, podemos ver que temos três registros locais e há muitas coisas acontecendo aqui.
Mas vamos dar uma olhada no código Java.
Então vamos ver.
Está bem.
Portanto, aqui temos os números das linhas.
Se clicarmos com o botão esquerdo do mouse, veremos que esses são os números de linha originais do Java.
Então, clicamos mais uma vez.
Esses são os números de linha referentes ao código do smiley.
Portanto, não estamos interessados em criar essa visualização de conteúdo e também essa visualização de texto.
Portanto, vamos tentar pular essa e também essa no final.
Portanto, estamos interessados apenas nessa parte.
Vamos ver se conseguimos encapsular isso um pouco.
Então vamos ver.
Linha 1617.
Aqui podemos ver.
Vejamos.
Aqui temos nosso próprio conjunto de criação de visualização de conteúdo para encontrar a visualização por ID.
Esse é todo o material que não nos interessa.
Aqui está.
Aqui temos nossa mensagem criptografada.
Está bem.
Eu lhe disse para não se basear apenas nesses números de linha, mas se dermos uma olhada nisso agora, poderemos ver,
ok, aqui temos nossa mensagem criptografada.
Ele está sendo armazenado em V0.
E se você der uma olhada para trás, tudo bem, isso deve corresponder ao código Java aqui.
Tudo bem, então.
Vamos ver o resultado.
Qual é a mensagem?
Visualização de texto.
Portanto, essa é a parte em que estamos interessados.
Essa é a linha 21.
E se você der uma olhada mais de perto, é exatamente isso que ele faz.
Está bem.
E agora vamos ver se podemos usar nossa abordagem de sistema aqui.
Portanto, temos a string que está sendo armazenada e zeramos.
Em seguida, invocamos o static e aqui podemos ver o que é bom.
Temos um objeto de resultado de movimentação para o zero.
E se você der uma olhada nisso, trata-se de criptografia XOR, criptografia e descriptografia.
Portanto, estamos armazenando o valor do recurso em nosso registro V zero.
Mas este não está mais sendo usado.
Vejamos.
Sim, simplesmente temos um nome para esse nome que é criptografado, mas ele não será usado em nenhum outro lugar.
Portanto, o código Java descarta esse valor de retorno, mas não esse código sorridente.
Portanto, o código smiley é como a matriz.
Podemos ver todo o código ali, não apenas a superfície dele, que é mostrada aqui no código do smiley.
Estamos vendo o código inteiro e este é muito bom porque temos uma referência à nossa
string aqui e agora podemos imprimi-la.
Está bem.
Então, primeiro, vamos analisar esse código aqui para ter certeza de que o entendemos e, em seguida, inserimos
nossa abordagem.
Tudo bem.
Está bem.
Portanto, estamos colocando nossa mensagem criptografada no we zero.
Está bem.
Portanto, o zero está armazenando nossa mensagem criptografada.
Está bem.
E depois temos o invoke static.
Portanto, isso está claro.
Em seguida, invocamos a caixa estática.
Isso significa que temos um argumento aqui, mas agora precisamos ter certeza de que é o objeto this
ou o parâmetro da nossa função?
Você ainda sabe qual é o caso?
Uma invocação estática.
Se não, por favor, dê uma olhada nisso.
Então, é esse ou nosso primeiro parâmetro?
Sim, absolutamente correto.
Esse é o nosso primeiro parâmetro de disfunção.
Também podemos trapacear um pouco, pois, se você observar, estamos chamando o método encrypt
decrypt.
E aqui podemos ver que temos um parâmetro.
Portanto, esse é o nosso parâmetro.
Ele é do tipo string móvel e esse parâmetro precisa ser mencionado em nossa lista de parâmetros no
início.
Portanto, sabemos que zero não é esse objeto, é nosso primeiro parâmetro.
A propósito, invoque a estática.
Nunca tem esse objeto lá porque o método estático precisa de uma instância para ser chamado.
É simplesmente o nome da classe e do método.
Portanto, sim, podemos simplesmente nos lembrar disso ou fazer nossa análise sobre isso para descobrir
qual é o caso aqui.
Gosto um pouco mais da segunda abordagem porque ela também nos ajuda em outras instruções.
Está bem.
Portanto, vamos limpar isso.
Aqui está.
Então, vamos ver o que isso faz.
Certo, então temos aqui nossa classe X ou de criptografia X ou de criptografia.
E agora estamos ligando.
Criptografia de pontos.
Descriptografar.
Encrypt decrypt com nosso v zero como o primeiro parâmetro.
Os lábios não ficam coloridos.
Bem, é uma cor errada.
Aqui está.
E estamos voltando e fazendo cordas.
Sim.
Portanto, isso é exatamente o que vimos e analisamos no código Java.
Está bem.
Em seguida, temos a instrução move results object into V0.
Isso significa que nosso V0.
Contém agora o valor de retorno dessa função.
E essa função criptografa ou descriptografa nosso método.
E essa função aqui retorna a mensagem descriptografada.
No nosso caso, porque estamos inserindo uma mensagem criptografada e, ao chamar isso, recebemos de volta a mensagem descriptografada.
Se colocarmos nossa mensagem descriptografada nessa função, receberemos de volta a mensagem criptografada.
Portanto, com relação ao XOR, dê uma olhada na folha de dicas, pois encontraremos o XOR muitas vezes e
mencionei toda a operação nessa folha de dicas porque ela é muito importante.
Tudo bem.
Portanto, agora sabemos que nosso V0 contém a string que queremos imprimir.
A única coisa que precisamos fazer é inserir a instrução de impressão aqui.
E é isso que vamos fazer agora.
Então, eu limpo isso rapidamente.
E agora vamos dar uma olhada.
Portanto, normalmente eu pegaria minha folha de dicas e daria uma olhada em como funciona um sistema Yeah.
Mas em relação aos nossos slides.
Sim, vamos tentar reconstruir isso um pouco.
Portanto, sabemos que, se quisermos usar a saída do sistema, precisamos primeiro obter a referência do objeto, e isso
é feito pelo objeto asset.
Em seguida, precisamos invocar o método print line.
Está bem.
Portanto, aqui estamos obtendo o sistema de objetos e, em seguida, estamos usando a linha de impressão que termina no sistema chamado
linha de impressão.
Vamos tentar reunir essas informações com as coisas que sabemos.
Portanto, abrimos a folha de dicas, o sistema not the not, nossa folha de dicas, a folha de dicas do código
dalvik up.
E estamos procurando um objeto de ativo.
Lê o campo de referência do objeto identificado pelo ID do campo em b x.
Então, temos um campo de referência que está sendo identificado pelo ID do campo.
Sim, absolutamente útil, não é mesmo?
Então, vejamos, basta copiar e colar esse comando aqui.
Precisamos tomar cuidado com os registros.
Mas este está claro agora.
Temos que colocar esse objeto em um registro.
Agora, vamos ver como podemos obter o ID do campo e, portanto, daremos uma olhada no guia oficial do desenvolvedor
do Android em relação ao sistema.
Muito bem, se você pesquisar Android developer system dot out, temos uma entrada no Stack Overflow, que
eu já cliquei, porque depois temos outra entrada no Stack Overflow e temos a referência do desenvolvedor.
Nesse caso, usamos este aqui, pois ele se refere à referência do sistema.
Está bem.
Portanto, o sistema vem de um sistema itinerante.
Isso é importante porque precisamos dessa referência de tipo para o nosso objeto.
Vamos observar a estrela.
Ok, então talvez possamos escrever isso embaixo, perguntar a ele, fazer um objeto no nosso registro e depois usar.
Esta referência está aqui.
Sim.
E agora queremos acessar o campo ID.
Portanto, temos essa seta e esse ID de campo.
Vejamos, este campo ID.
Podemos encontrar isso aqui?
Sim, temos campos fora.
O mesmo acontece exatamente com o que queremos ter.
Ponto do sistema desligado.
Out é de public static final print stream out o fluxo de saída padrão.
Esse fluxo já está aberto e assim por diante.
Certo, então precisamos digitar a referência de out também porque o sistema pode ter mais de uma saída, mas estamos procurando
a saída do fluxo de impressão.
Portanto, para obter essa referência de tipo de saída, clicamos no fluxo de impressão.
Está carregando.
Aqui está.
E agora sabemos que isso é do tipo java i o print stream.
Está bem.
Então, copiamos e colamos este aqui.
Portanto, queremos obter o ID do campo.
E este é do fluxo de impressão thai java i o.
Portanto, basta adicionar esse aplicativo e pronto.
É assim que podemos obter o ID do campo do ponto de saída do sistema.
Portanto, este aqui tem um sistema de pontos.
Mas agora precisamos tomar cuidado com os registros.
Assim, podemos limpar isso.
Ok, agora vamos dar uma olhada nos registros.
Então vamos ver.
Temos três registros locais, o que significa que estamos tendo o zero.
Queremos e devemos fazê-lo.
Todos eles são usados ao lado do zero.
Mas precisamos manter um zero porque essa é a string que queremos usar.
Portanto, não podemos substituí-lo aqui.
Isso significa que, se você quiser manter o código abaixo do que queremos, não teremos outra opção
a não ser introduzir um novo registro.
Mas isso não é um grande problema.
Como podemos fazer isso?
Sim, vamos voltar.
Portanto, em vez de termos três registros locais, estamos tendo quatro agora, e é isso.
Agora podemos usar o registro adicional que criamos, que é o V3 no nosso caso, por exemplo.
Tudo bem.
E sim, isso é tudo sobre essa linha aqui.
Então, vamos recapitular isso rapidamente.
Temos nosso sistema de campo externo, que é identificado por esse tipo de sistema de referência.
E aqui nosso campo externo é do tipo Java IO print stream e o colocamos na V3.
Isso significa que o ponto de saída do sistema agora está sendo armazenado em B três.
Podemos obter essas informações, essas referências de tipo na documentação oficial aqui.
Portanto, se voltarmos aqui, estamos na referência do sistema e o sistema é do sistema de pá e o campo
de saída é do tipo string de impressão.
Se clicarmos nisso.
Podemos ver que o Prince rim é do sonho Java I au Prince e precisamos ser precisos quanto aos campos que estamos
usando, portanto, precisamos adicionar as referências exatas de tipo aqui em nosso código.
Certo, uma última coisa.
Precisamos fechar esse aqui.
Sim.
Agora já concluímos isso.
Esse ponto e vírgula significa que é o fim da referência de tipo.
Muito bem, agora temos a sintaxe correta.
Então, vamos ver a próxima, que queremos chamar de linha de sprint.
Vamos ver como podemos encontrar essas informações.
Então, voltamos a essa referência de desenvolvedor.
Vamos ver, talvez já tenhamos isso aqui.
Sim.
Aqui está.
Println é um método que é sobrecarregado com diferentes argumentos e parâmetros.
Aqui estamos procurando uma string, esta string de linha de impressão.
Então, clicamos nisso.
Está bem.
O método Print line é um método público vazio e não retorna nada, mas não tem uma string como parâmetro.
Está bem.
Portanto, para chamar um método público, precisamos invocar o virtual.
Portanto, voltamos ao nosso código aqui, invocamos virtual, invocamos um método virtual com parâmetros.
Agora temos que tomar cuidado com esse parâmetro.
Portanto, aqui o primeiro é o nosso objeto this.
Nesse caso, é o ponto do sistema e, em seguida, temos os parâmetros adicionais.
Então, vamos copiar e colar isso.
E insira-o aqui.
Está bem.
Parâmetros.
A primeira é muito fácil, pois esse é o nosso sistema para esse objeto.
Tudo bem.
A próxima é agora nossa mensagem descriptografada.
E isso está sendo armazenado em V0 aqui.
Portanto, também consideramos esse parâmetro como o primeiro parâmetro real dessa função.
Qual função?
Linha de impressão.
Portanto, vamos obter a referência de tipo da linha de impressão.
Então vamos ver.
Linha de impressão, esta aqui e, em seguida, linha de impressão.
Vamos clicar nesse método.
Tudo bem.
E vamos voltar ao topo.
Está bem.
Portanto, a linha de impressão é do fluxo de impressão java para o fluxo de impressão.
Essa é a nossa referência de tipo de linha de impressão.
Portanto, precisamos copiar e colar este aqui.
Portanto, agora queremos chamar o seguinte método.
Primeiro, precisamos adicionar a referência de qual tipo é esse método.
É do Java, um fluxo de impressão.
Portanto, L maiúsculo e ponto-e-vírgula para indicar que a referência de tipo terminou neste momento.
Então, precisamos dessa seta e precisamos chamá-la.
Linha de impressão.
Devoluções.
Nulo.
Vamos verificar isso.
Println para string.
Sim, ele retorna nulo.
E aqui temos nosso parâmetro.
E nosso parâmetro é V zero e P zero é do tipo.
Vejamos.
Cordas de viagem.
Então, simplesmente pegamos esse aqui e o adicionamos como valor de parâmetro.
Está bem.
Agora tudo deve estar configurado corretamente.
Vejamos.
Temos nosso objeto de ativo.
Estamos obtendo o ID do campo, que é referenciado pelo sistema itinerante, e esse ID do campo é do
tipo java I print stream.
Colocamos isso em B três e, em seguida, queremos chamar o método print line.
Portanto, estamos usando o invoke virtual no V três, que é o ponto de saída do nosso sistema.
E agora queremos chamar uma linha de impressão que é do fluxo de impressão do Java I o e tem uma cadeia de caracteres como
parâmetro e retorna o quê?
Está bem.
E isso deve ser tudo.
Está bem.
Portanto, agora podemos fazer isso de forma bem detalhada e sim.
Uma dica é se você não conseguir encontrar ou se não lidarmos com as funções da documentação oficial.
Então, digamos que queremos chamar uma função interna que foi criada pelo desenvolvedor.
Então, também podemos obter essas informações na saída do JDI.
Por exemplo, este tipo aqui de string móvel.
Portanto, nas entradas, talvez não esteja totalmente claro, mas se descompilarmos esse código, poderemos
dar uma olhada no código do smiley aqui e ver que tipo esse objeto tem.
Também podemos procurar objetos existentes e simplesmente copiar e colar essa referência de tipo em nosso código.
Temos que nos certificar de que estamos usando a correta e também faremos isso em outros exemplos mais
adiante.
Mas quero mencionar agora que ele não está funcionando apenas para as funções de documentação oficial, está
funcionando, é claro, para todas as outras funções, porque o poder é simplesmente ilimitado.
Tudo bem.
Está bem.
Então vamos ver.
Precisamos limpar isso porque não é um código somali válido.
E sim, acho que é isso.
Vamos tentar compilar esse aplicativo e ver como ele funciona.
Está bem.
Então, agora vejo essa seta, e essa seta é muito estúpida porque está relacionada ao copiar e colar.
Eu estava me perguntando por que isso é mencionado em azul, e a razão pela qual é mencionado em azul é que ainda temos
esses pontos lá.
Mas o Smiley se refere a diretórios.
Portanto, precisamos substituir esses pontos por.
Sim.
Cortes.
Então vamos ver.
Está bem.
E acho que isso também é o que essa seta mencionou.
Então, vamos dar uma olhada.
Andrew Ford Sim, então, nesse ponto, quero dizer, a mensagem de erro indica que não temos um sistema de ponto de colocação
de pontos, fluxo de impressão de ponto iota e assim por diante.
Portanto, sabemos que temos que dar uma olhada nisso e, sim, se for marcado como azul porque essa é a sintaxe
Java no momento, então você poderá ver diretamente qual é o problema aqui.
Tudo bem.
Está bem.
No entanto, acho que esse é um exemplo muito bom, porque vimos que, se você cometer alguns
erros de sintaxe muito ruins, ou pelo menos eu fiz isso, o compilador smiley está tentando apontar
isso em uma mensagem de erro aqui.
Então, podemos dar uma olhada nisso e descobrir qual é o problema.
Se você copiar e colar isso e vir um sublinhado azul aqui com a sintaxe Java ativada, poderá vê-lo diretamente.
Portanto, não sei por que deixei passar tanto tempo, mas sim, eu também cometo erros.
Muito bem, agora vamos ver.
Salvamos esse arquivo e tentamos construí-lo novamente.
E essa era a versão sem essas duas declarações.
Vamos ver se está funcionando agora.
Parece bom.
Tudo bem.
O aplicativo foi desenvolvido.
Isso é um bom sinal, mas não significa que nossa sintaxe esteja funcionando.
Pode ocorrer um erro ao acessar esses objetos.
E isso ocorre durante o tempo de execução.
Mas criar um aplicativo sem erros do Somali é um bom primeiro passo.
Vejamos.
A cópia de tela não está mais disponível.
Vejamos.
Está bem.
Portanto, parece que perdemos a conexão ADB.
Então, vamos recuperar a cópia da tela novamente.
Talvez possamos nos conectar
caso você também encontre essas setas, basta reiniciar a máquina virtual do Android.
Então, estamos prontos para começar.
Ok, vamos manter isso em primeiro plano.
Portanto, ainda temos nossa versão original instalada.
Vejamos, talvez ainda tenhamos esse sistema fora do grep em algum lugar e lá temos nosso sistema fora do grep.
Portanto.
Sim, essa é a versão original.
Vamos desinstalá-lo e ver se nosso sistema imprime a mensagem descriptografada.
Então vamos ver.
A ITV compartilhou a lista de pacotes de shows.
Não tenho certeza sobre o nome do pacote, portanto, vamos pesquisar para criptografá-lo.
Desinstalar a conta.
Opa, preciso voltar e desinstalar o aplicativo com hacking e corrupção para que o aplicativo
desapareça.
Agora, vamos executar esse sistema com o comando Grub e instalar nossa versão de compilação.
Ele nem sequer está assinado no momento.
Já construímos isso depois de cometer esse erro?
Então vamos ver.
Bem, aqui temos o destino.
Criei e assinei este aplicativo.
Agora, vamos instalá-lo em nossa versão modificada e instalar somente as chaves de teste do OC.
Não há problema.
Está bem.
Aqui está.
Aqui temos o aplicativo de criptografia.
Vamos abrir isso e ver.
Aqui está.
Essa é minha mensagem secreta.
Essa mensagem é nossa versão descriptografada do que inserimos.
Muito legal, não é?
Mesmo sem ter privilégios de root ou um depurador conectado a isso, podemos imprimir uma mensagem secreta.
Também podemos imprimir a chave, por exemplo, e também podemos verificar se essa mensagem está correta.
Podemos usar este aqui e simplesmente fechar este aqui.
Podemos simplesmente substituí-lo por este.
Portanto, se agora criarmos um revés novamente, deveremos obter a versão criptografada.
Vamos fazer isso rapidamente.
Está bem.
Portanto, aqui estou com a nova versão já assinada.
Vamos entrar.
Portanto, vamos desinstalar o existente.
Está bem.
Vamos instalar nossa nova versão.
E as chaves de teste.
E esse agora tem nossa mensagem descriptografada como entrada do nosso método de criptografia XOR.
Portanto, ao abrir este.
Podemos ver.
Sim, nós voltamos.
O que quer que esteja acontecendo ali.
Mas recebemos de volta nosso texto de mensagem criptografado aqui.
Muito legal.
É assim que o XOR funciona.
Temos uma entrada, seja dentro da chave ou do valor, obtemos uma saída e, se você pegar a saída e combiná-la
com a mesma chave, obteremos nossa entrada de volta.
Muito bem.
Portanto, o que eu queria mostrar é como você pode escrever o sistema por conta própria.
E, caso faltem alguns registros, podemos simplesmente introduzir novos registros.
E, com isso, você pode imprimir o que quiser.
Ok, desculpe.
Talvez não seja o que quisermos, porque se você não tiver uma string, digamos um objeto, precisamos descobrir
primeiro como podemos imprimir esse objeto.
Mas você adivinha o que aconteceu?
Isso é o que também faremos em alguns vídeos.
Está bem.
Portanto, por enquanto, isso é tudo sobre o sistema.
Quero dizer, já codificamos isso por conta própria e vimos como podemos obter as informações necessárias
para, por exemplo, como podemos buscar essas informações de que se trata de um fluxo de impressão Java e coisas do gênero.
Também vimos um erro de despejo meu, que é ter pensamentos em vez de barras, mas o compilador sólido
nos indicou o problema.
E sim, eu consegui descobrir qual era o caso.
Tudo bem.
Isso é tudo para este desafio no momento.
Mas não se preocupe.
No próximo vídeo, daremos uma olhada em outro desafio.
Portanto, temos muitos desafios no momento.
Então, vejo você lá.