Bem-vindo de volta.
Esta é a parte final de nosso desafio de um desafio para recapitular todos os desafios.
Portanto, este aqui será realmente insano.
Portanto, o que vamos fazer agora é tornar esse desafio um pouco mais complexo do que já
é.
Portanto, se você puder usar basicamente quatro métodos para obter uma maneira fácil, opte por isso.
Com certeza.
Não o torne mais complexo do que ele é.
Mas neste desafio, agora, queremos dar uma olhada em como escrever um código molly mais complexo e inseri-lo
em um aplicativo existente.
Portanto, usaremos o Norton 64 e usaremos o método string.
Escreveremos um loop for próprio em que iteramos sobre essa matriz e imprimimos cada valor.
Talvez também possamos anexá-los a uma ferramenta de cadeia de caracteres ASCII para imprimi-los diretamente.
Além disso, também teremos alguma interação com a interface do usuário.
E essa realmente não é uma tarefa fácil, porque dentro da função ace, na qual vamos injetar nosso
código, não há interação com a interface do usuário, e temos que criar uma conexão da interface do usuário
com esta aqui para exibir algum texto ou algumas mensagens.
Tudo bem.
Portanto, isso será realmente insano.
E acho que isso não é bom.
Esse é um final absolutamente perfeito para concluir nossa jornada de sorrisos por aqui.
Será um pouco intenso.
E também pode ser que isso seja um pouco esmagador, porque vamos fazer muitas coisas
agora.
Mas acho que é melhor terminar dessa forma em vez de apenas aumentar as coisas que aprendemos até
agora.
Portanto, vamos fazer isso.
Vamos começar agora mesmo.
Está bem.
Portanto, ainda estamos trabalhando no EPS.
Um desafio para recapitular: vamos remover o diretório antigo que não tem interferência em todos os projetos
e agora vamos ter uma desculpa obscura como apk.
Vamos ver o que queremos fazer.
Nós nos aprofundamos em hacking de aplicativos de comunicação e criptografia.
Portanto, ainda estamos trabalhando nisso.
E deixe-me habilitar minha caneta rapidamente.
Tudo bem.
Portanto, aqui temos o código original.
Então vamos ver.
Aqui.
Sim.
Aqui.
Queremos inserir nosso próprio código.
E, mais uma vez, temos o código original.
Portanto, essa é a nossa tarefa.
Quero dizer, é exatamente igual ao anterior, além do fato de que agora o código é um pouco mais
complexo.
Portanto, não estamos tendo apenas algumas linhas sorridentes, temos toneladas de linhas sorridentes e, portanto, a transição
e deixe-me limpar isso.
Portanto, a transição do original para o nosso e de volta para o original pode ser um pouco mais complexa do
que isso.
Mas também queremos ver qualquer atividade principal aqui e limpar a tela.
Está bem.
Dentro da atividade principal, temos algum tipo de layout.
Portanto, esse é o nosso layout de criptografia.
Portanto, aquele com a saída codificada em base64, eu simplesmente o mesclo agora.
Portanto, essa é uma atividade e essa atividade é capaz de exibir coisas em nossa tela dentro de nossa função A as crypto.
Aqui, não temos essa capacidade, mas queremos tê-la.
Portanto, queremos inserir nosso código aqui e também queremos ter a capacidade de imprimir algo em nosso smartphone.
Então, aqui está nosso smartphone e queremos fazer com que algum texto apareça.
Isso significa que precisamos de algum tipo de interação entre a classe de criptografia e também a atividade principal
aqui.
Portanto, nossa transição de código não se baseia apenas em uma classe no momento.
Faremos uma transição de código para outra classe aqui e isso é incrível.
É um pouco complexo.
Não vou mentir, mas vou lhe mostrar como podemos fazer isso.
E então você tem.
Sim, sim.
Quero dizer, você já tem poder ilimitado.
Talvez você não perceba isso agora.
Está bem.
Portanto, é isso que vamos fazer agora.
Portanto, sugiro que comecemos novamente com a criação de um protótipo do nosso aplicativo no Android
Studio para ver se tudo está funcionando corretamente e, em seguida, cole-o aqui.
E a segunda parte será sobre essa interação entre atividades ou, digamos, entre uma classe, porque
esta aqui é simplesmente uma classe.
Ele não tem componentes de interface do usuário disponíveis, mas faremos com que haja uma interação com
um novo componente aqui.
E também podemos exibir algumas coisas sofisticadas na tela de atividade do nosso aplicativo original.
Tudo bem.
Portanto, vamos abrir o Android Studio New Terminal Tools, o Android studio, o pen bash studio é um
pouco complexo.
Você também pode adicioná-lo ao seu ambiente de caminho, se desejar, mas eu o mantenho começando dessa forma.
Está bem.
Agora vamos criar um novo projeto.
Não queremos misturá-los neste momento, portanto, vamos mantê-los separados, atividade vazia.
E agora, vamos ver.
Esse é agora o nosso suporte à Somália.
Uma maneira difícil.
Ainda volto a usar cartões novos.
Sim, acho que essa é uma boa compatibilidade.
Sim, meu smartphone está em alta, mas nós o mantemos para olhar e eu mantenho o Java aqui.
Tudo bem.
Portanto, agora o processo criativo foi iniciado, e isso pode demorar um pouco.
Então, vejo você depois que isso terminar.
Tudo bem.
Portanto, a parte criativa foi concluída.
E, no último vídeo, inserimos nosso código aqui, o que está absolutamente correto, além do fato de
que temos aqui um pouco mais de componentes disponíveis que não temos em um aplicativo original, mas
falaremos disso mais tarde.
Portanto, acho que é realmente uma solução melhor não escrevê-la na atividade principal, mas sim em
uma classe separada, se essa classe com a qual queremos interagir não tiver outras dependências.
Tudo bem, desculpe-me por me culpar, mas sim, desta vez faremos desta forma.
Está bem.
Portanto, queremos ter nossa chave secreta e esta aqui, e então podemos iterar sobre esta, apesar da
matriz.
Portanto, vamos primeiro obter esses três métodos e agora criamos novamente uma nova classe Java.
Desculpe-me por ter sido um pouco rápido e clique com o botão direito do mouse em new java class.
Sim.
Está bem.
E agora também criamos um método, mas esse é o nome e coisas como essa não são relevantes.
Chamamos a mesma mensagem de criptografia, mas não temos um parâmetro aqui.
Está bem.
Ah, precisamos de um tipo de retorno.
Muito bem, aqui temos nosso código.
Portanto, eu entraria para importar essas classes, tudo bem.
E, para obter uma instância, temos que cercar o try e o catch, além de uma assinatura de exceção.
Isso significa que, quando chamamos esse método, ele precisa estar presente e tentar capturá-lo.
Acho que vamos fazer desta forma.
Portanto, também é perfeitamente aceitável dessa forma.
Muito bem, agora temos nossa chave.
E para obter a matriz de bytes, precisamos chamar o método key get encoded.
Isso está retornando nossa matriz de bytes.
Perfeito.
Agora, devemos atribuir isso à matriz de convite.
Portanto, o byte e o array são chamados de despite array para obter um pouco de diversidade neste momento.
Está bem.
Atribuímos isso ao valor de retorno aqui, o que significa que isso é atribuído, o que significa que nosso código sorridente
também tem esse objeto de resultado de movimentação.
Está bem.
Se agora quisermos imprimir essa matriz, apesar da diferença, podemos fazer isso da seguinte forma.
Quero dizer, a base 64 é a melhor abordagem.
Mas digamos que consigamos.
Queremos escrever nosso próprio código.
Portanto, para o int I igual a zero é menor do que o tipo de matriz e temos algo como length perfect
i plus plus OC e, em seguida, podemos usar algo como system dot out print line e, então, chamamos a matriz de
bytes com o índice.
Sim.
Então, acho que isso deve funcionar.
Vejamos.
Quero dizer, estamos criando um protótipo aqui e podemos fazer experiências com ele.
Portanto, para chamar esse método agora, precisamos criar uma nova instância de nós e, em seguida, chamar a mensagem de criptografia.
E precisamos fazer isso na atividade principal, porque esse é o nosso ponto de entrada
e é aqui que o código é carregado no on create não carregado executado dessa forma.
Portanto, estamos tendo um as a s igual a new as e, em seguida, queremos chamar as a encrypt message.
Tudo bem.
E agora você vê que temos essa exceção tratada manualmente porque a temos aqui, o que significa que precisamos incluir isso e,
em seguida, tentar capturar.
Acho que eu entraria assim com o try and catch.
Perfeito.
Mas agora não precisamos mais trabalhar com essa tentativa de capturar coisas em nosso código Ace.
Muito bem, vamos selecionar nosso dispositivo já selecionado.
Vamos executar esse aplicativo.
Não é necessário observar a saída gráfica.
Tudo o que precisamos fazer é dar uma olhada no medalhão se imprimirmos nossa matriz de bytes aqui.
Portanto, a construção de crédito ainda está em andamento e agora já está sendo carregada com estilo.
Blockheads.
Vejamos.
Não estou vendo nada até agora.
Temos uma exceção.
Vamos procurar o sistema.
Aqui está.
Agora são esses bytes.
Portanto, isso já está funcionando perfeitamente para nós no momento.
Isso é bom.
Mas vamos tornar isso um pouco mais conveniente.
Então, por exemplo, vamos obter essa representação hexagonal típica, uma mordida de cada vez.
Como podemos fazer isso?
Temos algo como o formato de cadeia de caracteres para essa tarefa, portanto, poderíamos usar o formato de
ponto de cadeia de caracteres e, em seguida, vamos ver se tenho que usar algo como porcentagem ou zero x.
Essa é a cadeia de caracteres ASCII anexada no início.
Portanto, todos têm um zero x e queremos ter uma porcentagem de zero a x.
Sim.
Está bem.
E esse suporte deve ser fechado aqui.
Sim.
Então, acho que isso funciona.
Portanto, agora estamos imprimindo zero x e, em seguida, a representação hexadecimal de um byte como dois valores hexadecimais aqui.
E o zero, se tivermos um zero na frente do nosso valor hexadecimal, também será exibido.
Então, vamos ver e correr.
Perfeito.
Isso parece absolutamente perfeito.
Portanto, estamos recebendo uma nova chave toda vez que iniciamos esse aplicativo.
Mas podemos ver, por exemplo, aqui temos esse soro líder.
Se removermos este aqui e o executarmos novamente, deverá haver algo, um espaço reservado ou nada.
Está bem?
Não há nada aqui no momento.
Portanto, esse é o zero que falta.
E queremos incluí-la.
Quero dizer, isso parece ainda melhor agora, mas vamos levá-lo a outro nível.
Então, vamos escrever tudo isso em um único arquivo.
Em uma única linha.
Sim, em uma única linha em uma string.
Essa é a nossa string principal.
Tudo bem.
E agora precisamos conseguir isso.
Deixe-me ver como podemos fazer isso.
Está bem.
Primeiro, precisamos acrescentar a string de chave com os valores atuais desta aqui.
Sim.
Está bem.
Qual é o problema?
Precisamos inicializá-lo.
Vamos inicializá-lo com zero x, depois precisamos de zero x e, em seguida, temos nossos valores aqui.
Sim.
E queremos ter esses valores nesse formato.
Portanto, devemos entender dessa forma.
Sim, isso parece bom.
Portanto, o zero x pode ser removido e, em seguida, queremos imprimi-lo, mas não no loop for e sim depois.
Está bem.
Portanto, agora estamos pendentes de cada valor aqui fch14 em uma string.
A cadeia de caracteres tem um zero x à esquerda e aqui estamos imprimindo-a.
Então, para fazer isso, vamos ver se funciona e executar o ab.
Perfeito.
Portanto, agora temos nossa string como uma representação hexadecimal ASCII aqui.
Isso pode ser facilmente usado em qualquer função de criptografia e descriptografia do A agora mesmo.
Incrível.
Mas não queremos pesquisar todas as saídas do sistema, pois pode haver muita coisa lá dentro.
Vamos adicionar um identificador.
Por exemplo, esta é a nossa chave criptográfica.
Vamos aumentar um pouco o tamanho para que você tenha tudo de uma vez.
Muito bem, corram.
Sim.
Isso parece perfeitamente bom no momento.
Está bem.
Aqui temos nossa chave criptográfica.
Quero dizer, a essa altura, seria suficiente transferir isso para o aplicativo original
para este aqui.
Este aqui.
Porque acho que essas linhas de código criarão uma grande quantidade de sintaxe de smiley.
Não precisamos de tudo.
Quero dizer, nós mergulhamos aqui.
Canal de chave secreta.
Chave vermelha.
Isso é o que temos no código antigo também.
E o código original.
Sim, é essa linha.
E então temos que adicionar tudo o que está embaixo.
Isso deve ser adicionado aqui, entre essas duas linhas.
Tudo bem, mas agora vamos seguir o caminho insano e o caminho insano.
Gostaria de lhe mostrar o que planejei para isso.
Vamos ver se isso funciona.
Não tenho certeza sobre isso.
Está bem.
Assim, podemos criar mensagens de texto em nossa tela.
Vou mostrar isso aqui e brindar.
Em seguida, podemos chamar, criar texto, e temos três parâmetros.
A primeira é o contexto, e essa é a mais difícil.
Em seguida, temos nossa sequência de caracteres de string, por exemplo, e temos uma duração.
Por quanto tempo exibiremos essa string?
Então, vamos ver, faça um texto.
Agora, o primeiro parâmetro é o contexto.
E como podemos obter o contexto ou qual é o contexto?
Um aplicativo Android, se tiver uma tela.
A tela é o contexto.
Portanto, a atividade atual, a atividade principal, ou seja, se você quiser imprimir
algum texto na tela, o aplicativo precisa saber onde ou qual é o contexto atual, qual é a tela
onde devo colocar esse texto?
Portanto, no nosso caso, queremos colocá-lo em nossa atividade principal porque precisamos de algum tipo de
saída gráfica para ela.
Bem, digamos que uma atividade tenha alguns componentes gráficos, pois temos um método de criação ativado
e, portanto, estamos criando um layout.
Portanto, o contexto é simplesmente revelador.
Agora estou na atividade principal.
Imprima isso na atividade principal e, portanto, também temos um método que é este.
Portanto, essa é a atividade principal.
Obter o contexto do aplicativo.
Ok, agora essa mensagem de brinde sabe.
Tudo bem, eu preciso ser impresso na atividade principal aqui.
Portanto, essa é a atividade que está em primeiro plano, e eu preciso ser impresso ali.
Tudo bem, perfeito.
Então vamos ver.
Invadir seu aplicativo.
Esse é o texto que queremos mostrar.
E então temos o último parâmetro, que é o comprimento.
E temos valores predefinidos de comprimento, curto e longo.
Quero dizer, curto é suficiente porque queremos que ele seja exibido em apenas alguns milissegundos.
Tudo bem, vamos executar esse aplicativo e, então, oh, sim, perdi alguma coisa.
Eu sempre perco isso.
Portanto, agora estamos apenas criando o texto.
Se você quiser mostrar o texto, será necessário chamar o método show do DOT.
Então, sim, isso acontece o tempo todo comigo.
Vamos executá-lo mais uma vez e, em seguida, retornaremos à tela para que você possa ver o que está acontecendo.
Está bem.
Portanto, a cópia de tela está interagindo com o ADB.
E você pode ver que isso está acabando com essa conexão no momento.
E sim, algo como isso não foi
mencionado.
Então, deixe-me desconectar isso rapidamente.
Está bem.
Nunca pensei que a cópia de tela fosse tão longe.
Mas vejamos, agora temos um shell ADB.
Isso deve funcionar.
Sim, é por isso que eu gostaria de instalá-lo primeiro e depois brincar com isso, porque
pode ser que seja ainda pior.
Então vamos ver.
Sim, esse aplicativo já foi iniciado e a mensagem desapareceu.
Vejamos.
Vamos relançá-lo.
Bem, acho que é este aqui.
Sim.
Invadir seu aplicativo.
Você já viu isso?
Talvez.
Selecione Long.
Então é um pouco mais longo.
Acho que também podemos fornecer valores de tempo.
Por exemplo, 2 segundos ou talvez mais.
Então vamos ver.
Está bem.
Aqui temos este texto.
Há algum erro de digitação?
Não, parece bom.
Portanto, esse texto também é algo que queremos injetar no aplicativo original aqui.
Este aqui.
Mas agora há uma tarefa difícil.
Então, vamos usar esse código.
E cole-o, por exemplo, no início, onde queremos ter nossa transição aqui.
E talvez também no final.
Nenhum.
Em seguida, verifique a saída do logcat do ADB e já podemos ver isso.
Essa classe aqui não tem esse contexto.
Portanto, isso não tem um contexto em que possa imprimir algum texto ali.
E o que precisamos fazer é injetar o código na atividade principal também.
Portanto, precisamos obter esse contexto como um valor estático e, em seguida, podemos usá-lo aqui.
E essa é a transição que também queremos fazer nesse aplicativo aqui.
É a mesma abordagem.
Precisamos injetar um pequeno trecho de código na atividade principal e, em seguida, obtemos um valor constante
ou estático do contexto que pode ser usado em nosso código aqui.
E isso é incrível porque também podemos realizar interações de interface do usuário.
Portanto, se você apresentar isso a um cliente, quando tiver esse aplicativo e houver alguma coisa sofisticada
acontecendo, quero dizer, isso é absolutamente perfeito.
Muito bem, então vamos fazer isso.
Está bem.
Como podemos fazer isso?
Quero dizer, é um pouco da programação do Android no momento.
E esse tópico, esse contexto, levou um bom tempo para que eu o entendesse.
Tentei explicar, e espero que tenha sido um pouco mais rápido para você.
Portanto, primeiro precisamos criar um contexto estático, uma variável estática, um contexto estático, um contexto.
Em seguida, precisamos importá-lo.
Está bem.
Agora, no método de criação, temos acesso a esse contexto porque o método de criação está criando
uma tela, um layout de tela e esse layout de tela tem um contexto.
Portanto, isso é algo a que o aplicativo pode fazer referência.
Ok, eu preciso ser impresso ali.
Então, vamos atribuir isso aqui.
O contexto é igual a esse contexto do aplicativo get.
Tudo bem.
E agora podemos usar esse contexto porque ele está em um campo estático.
Podemos usá-lo em nosso método as, portanto, podemos fazer referência a ele agora da seguinte maneira.
É claro que precisamos nos certificar de que estabelecemos esse contexto corretamente, caso
contrário, isso causaria um erro fatal.
Portanto, o contexto de pontos da atividade principal.
Mas vamos nos certificar de estabelecer esse contexto porque esse é o código.
Este aqui será injetado na atividade principal.
Também aqui, logo abaixo de definir a visualização do conteúdo.
Nesse ponto, estamos criando um novo campo estático e faremos referência a ele em nosso código posteriormente.
Tudo bem.
Certo, então vamos ver agora que estamos tendo um contexto.
Ele está funcionando dessa forma no momento.
Esse texto precisa ser impresso na atividade principal.
E agora eu sugeriria que simplesmente executássemos isso para que não houvesse mais na atividade principal.
Isso agora está em uma classe que não tem acesso direto a alguma saída gráfica.
Então, executamos isso.
Está bem.
E aqui?
Sim, podemos ver.
Perfeito.
Está funcionando dessa forma, mas exige um pouco mais de esforço.
Portanto, além de apenas injetar a classe a nesta, também temos que cuidar da atividade principal.
Mas nós cuidaremos disso.
Isso não é absolutamente nenhum problema para nós no momento.
Quero dizer, pode ser mais difícil escrever esse código aqui para entender que ele está funcionando
dessa forma, mas corrigi-lo para nós agora, não há problema algum.
Portanto, vamos criar esse aplicativo.
Pássaro épico.
Então vamos ver, localize o OC e agora estamos dando uma primeira olhada no código.
Então, vamos ver quantas linhas de código produzimos aqui, criando esse loop for, para que o sistema envie essas mensagens
de brinde e coisas do gênero.
Estará na parte de trás.
E agora vamos abrir isso com o código do Visual Studio.
Portanto, temos que entrar no Smartglasses para hackear e, primeiro, vamos dar uma olhada na classe as.
Então, aqui no BFD como classe, vamos selecionar Java e agora vamos ver onde o temos?
Aqui temos essa mensagem criptografada e geramos a chave.
Essa é a última instrução que copiamos do aplicativo original.
Está bem.
E depois.
Ah, tudo bem.
Sim.
Portanto, este é o nosso código no momento.
Quero dizer, isso é intenso, certo?
Portanto, precisamos fazer a transição.
Vamos escrever isso.
Início de nosso próprio código a partir daqui.
Para ouvir.
Sim.
É aqui que ele termina.
Está bem.
Todo esse código e esse código precisam ser colocados nesse aplicativo.
Nesse meio tempo, eu sugeriria que primeiro fizéssemos isso e depois déssemos uma olhada na atividade principal, como podemos
ajustar esse patch agora e, em seguida, nos certificar de que a transição do código original para
o nosso código está funcionando sem problemas.
De volta ao código original, tudo o que substituirmos ou reatribuirmos será corrigido, provavelmente para
que funcione corretamente.
Portanto, tudo o que continuamos sobrescrevendo aqui precisa ser restaurado ou contornado de uma determinada
maneira para que não baguncemos algum código existente.
Isso não é problema para nós.
Faremos isso em um instante.
Está bem.
Então, primeiro vamos corrigir esse código e, portanto, entraremos no desafio EPS one para recapitular tudo e agora
o HBK Tool DX como APK.
Certifique-se de que estamos tendo um novo estado limpo, pois se você estiver trabalhando neste,
isso será uma grande bagunça.
Está bem.
Portanto, aqui está ele frio, já que estamos abrindo isso com o código do Visual Studio.
Está bem.
Além disso, meu PC está absolutamente entusiasmado com esse jogo e os defensores estão gastando loucamente.
Portanto, movi o microfone para o outro lado.
Espero que esteja um pouco melhor agora.
Aqui temos nosso código do Visual Studio, então vamos ver.
E o Smiley Clowns virá embalado como criptografia.
Portanto, este é o aplicativo original.
Vamos ativar o Java e, em seguida, temos a mensagem de criptografia e vamos ver.
Canal de chave secreta.
Certo?
Linha-chave 21.
Vamos verificar isso rapidamente.
Canal de chave secreta.
Certo?
Chave.
Exatamente.
Essa é a linha 21.
Portanto, inseriremos nosso código depois.
Sim.
Entre esses dois.
Está bem.
Vamos fazer isso da seguinte maneira.
Então, agora vamos para o nosso código compilado.
Ah, isso é.
Este é o feedback.
É este aqui.
E copiamos esta, esta parte.
Sim.
Selecionamos esses dois e os inserimos aqui.
E então temos a inserção perfeita nesse código existente.
Muito bem.
Isso parece bom.
Parece intenso, mas parece bom.
Essa é a primeira coisa que precisamos fazer.
E agora.
E este aqui.
Esses são aspectos que precisamos ajustar.
Portanto, esta é agora a referência ao contexto do nosso código aqui.
A partir dessa atividade.
E esse contexto está sendo referenciado pelo nome do pacote.
Portanto, precisamos ajustar isso ao pacote original, é claro, o que significa esta parte.
Com um pacote.
Suporte ao Smiley.
De maneira difícil.
Essa atividade não existe.
Essa atividade aqui.
Vejamos.
Qual é o nome?
Atividade principal.
É este aqui.
Sim.
Portanto, precisamos ajustar essas duas linhas.
Mas não vamos fazer isso.
Ops, desculpe.
Vamos fazer isso.
Não neste momento.
Levaremos isso para o tablet gráfico e discutiremos o assunto lá.
Está bem.
Portanto, além disso, também precisamos aplicar nosso patch na atividade principal.
Então, aqui temos essa atividade principal.
E o que precisamos inserir aqui é o seguinte.
Vamos colocá-los lado a lado.
Portanto, precisamos inserir essa parte.
Linha 13.
Precisamos inseri-la após o texto, por exemplo, e precisamos inserir essa parte diretamente após a exibição
do conteúdo.
Sim.
Antes de começarmos a inicializar essa visualização de texto, podemos também usar a visualização de texto existente para imprimir
nosso texto agora mesmo.
Mas, sim, quero dizer, acho que a mensagem de brinde é um pouco mais tranquila, caso você queira fazer algumas modificações adicionais
e tenha ficado preso em um determinado ponto, escreva-me uma mensagem.
Deixarei de lado meu vídeo bônus se houver muita resposta em relação a este.
Tudo bem.
Está bem.
Então, vamos ver essas duas linhas.
Vejamos a linha 13 em nosso código EP.
Vamos também colocá-los desta forma.
Portanto, vamos fechar o Explorer em ambos os lados.
Aqui está.
E vamos habilitar o Java.
Aqui está.
Está faltando.
Agora, a atividade principal.
Precisamos entrar em nossa atividade principal.
E isso é aqui.
Vamos ativar o Java A e deixar um código C que escrevemos.
À direita está o código original.
Então vamos ver.
Linha 13.
Foi 13?
Sim, é isso mesmo.
Linha 30.
Não tenho certeza se estamos tendo uma referência de linha correta no momento e parece que não é o caso.
Sim.
Portanto, não se baseie em números de linha.
Portanto, podemos ver que temos um campo estético aqui e que isso está faltando aqui.
Então, vamos simplesmente copiar esse campo estático para essa parte.
Está bem.
Além disso, temos o p zero.
Portanto, aqui podemos ver que o zero está sendo usado como esse objeto.
Portanto, se você estiver realizando uma atividade como esta aqui, estamos usando p zero.
Na maioria das vezes, como nesse objeto, se você não tiver uma atividade, se tiver apenas uma
classe Java de baixa qualidade, a linha PC poderá ser reutilizada, como vimos em alguns exemplos aqui.
E apenas como um S. A..
Está bem.
E depois temos este aqui.
Aqui.
Defina o conteúdo para você.
Talvez.
Então, vamos habilitar uma quebra de palavra.
Temos isso em uma linha.
Sim.
E tudo o que precisamos fazer é isso.
Temos que copiar e colar este aqui.
No lado direito.
Sim, depois de definir a visualização do conteúdo.
Portanto, esse é o único ajuste que temos que fazer.
Vamos criar algum espaço.
Comece.
E agora vamos ver esse aqui.
E vamos substituí-lo aqui.
Tudo bem.
E agora a última coisa que precisamos fazer.
Sim, levaremos isso para o tablet gráfico.
Está bem.
Uma coisa que precisamos ajustar aqui é o nome do pacote da nossa atividade, porque este é
do nosso código e, portanto, será referenciado como com a pecking smiley support, heart rate, main activity.
Portanto, esse aplicativo procuraria nesse diretório se houvesse uma atividade principal.
E se entrarmos nesse diretório, vejamos.
Vamos ver até onde podemos chegar.
Nem de longe.
Temos um aplicativo de comunicação que está sendo hackeado e já estamos fora do ar, pois não temos um pacote de suporte de smiley em forma
de coração no momento.
Mas não estamos fazendo essa modificação no momento.
Levaremos isso para o modelo gráfico e, assim, teremos uma visão mais transparente
dos itens que adicionamos, onde estão e por quê.
E também acompanharemos o que precisamos fazer para ajustar isso no aplicativo original.
Está bem.
Então, vamos ver isso agora mesmo.
Este não.
Isso já não existe mais.
Não nos importamos mais com isso.
Isso desapareceu completamente.
Então, vamos levar este arquivo primeiro, este aqui, para a mesa digitalizadora.
Em seguida, teremos que dar uma olhada na atividade principal e discutiremos todos esses aspectos.
Quero dizer, não precisamos passar por todas as linhas porque isso levará um bom tempo para esta
parte aqui.
Só queremos ter certeza de que a transição do código original para o nosso código está correta.
Portanto, gostaria de mostrar a você alguns truques interessantes que podem ser muito úteis para realizar
essa tarefa e também, é claro, para o exterior.
Portanto, do nosso código para o código do aplicativo mais uma vez.
OC Então, vamos começar, vamos fazer isso, vamos levar isso para a mesa digitalizadora e nos vemos daqui a pouco.
Vamos lá.
Tudo bem.
Então, aqui estamos nós, com uma mesa digitalizadora retroiluminada, e esse método é absolutamente incrível.
Então, vamos cultivá-lo aqui.
Temos nosso início.
Tudo bem.
Portanto, precisamos entender um pouco do que está acontecendo lá para fazer a transição do código
original para o nosso código e vice-versa.
Mas não precisamos saber cada linha, caso queira saber cada linha, escreva-me uma mensagem.
Eu o deixarei no vídeo onde quer que você passe por cada linha, passo a passo.
Por enquanto, vamos continuar um pouco mais.
Muito bem, vamos lá.
Temos nossa mensagem de criptografia de método.
Isso significa que este é o código original que estará aqui.
Começamos com o código original e ele termina aqui.
Ok, esta é a primeira parte.
E então temos a segunda parte, nosso código.
E isso começa aqui.
E agora vamos ver o que acontece.
Não é nem mesmo visível.
Então, vamos começar a desenhar.
Oh, bem, ele desce por todo esse caminho até aqui.
E aqui temos a transição para o código original mais uma vez.
Bem, certo.
Então vamos ver.
Vamos começar a analisar isso.
E faremos isso em várias etapas, pois, caso contrário, ficaremos sem espaço agora.
Portanto, a primeira coisa que queremos ter certeza é qual registro está sendo usado para quê no código original
aqui nesta parte.
Portanto, essa é a primeira coisa que queremos saber.
Vejamos.
E a maneira mais fácil é retroceder para que possamos ver o que queremos que esteja sendo inicializado aqui.
E vamos escrever isso.
Queremos que seja igual e queremos ver o tipo de retorno aqui.
Portanto, isso será armazenado em V1.
Portanto, com base na última instrução, sabemos que queremos uma chave secreta de criptografia java x.
O que queremos é nossa chave secreta.
Então, se dermos uma olhada em v zero, esta será a última vez que faremos algo com v zero.
E o incrível sorriso de padrão é que todas essas referências de tipo estão próximas a nós.
Portanto, esse 1v0 é nosso gerador de chaves.
O zero é nosso gerador de chaves.
Tudo bem.
Isso é tudo o que posso ver no momento.
Vamos fazer isso.
Sim.
Ah, sim, é claro.
Uma coisa importante que está faltando é o parâmetro: desta vez, não estamos estendendo uma atividade.
Portanto, esse objeto não está reservado para o registro P zero.
P zero é agora o nosso parâmetro.
Portanto, é um texto simples, mas vamos mantê-lo como parâmetro.
E este é do tipo array de bytes.
Muito bem.
Agora vamos ver quantos registros estamos usando no caminho completo do código.
Portanto, não apenas em nossa porta de código um em nosso caminho, vamos chamá-lo de três.
Portanto, esta aqui é a primeira parte e, em seguida, temos este código e, aqui, temos a terceira parte.
Portanto, este é o aplicativo original completo, parte um e três, sem o código que inserimos
agora.
Está bem.
Vamos rolar a tela um pouco para baixo.
Aqui está.
Portanto, aqui podemos ver que temos cinco registros locais.
Portanto, tanto no caminho de código um quanto no três, estamos usando cinco registros locais.
Estamos usando.
Vamos escrevê-las.
Zero.
Queremos que sejamos três.
E antes disso, já vimos que zeramos, o que não deveria ser tocado, e ganhamos.
Que não deve ser tocado porque precisamos.
Caso contrário, teríamos que restaurá-los na terceira parte.
Portanto, esses dois foram eliminados com zero e nós vencemos.
Mas nós dois, nós três e antes estão livres para uso porque não foram usados aqui.
Agora temos nossa parte inserida, esta aqui, esta é nossa parte dois.
E, em nossa parte dois, poderíamos facilmente usar esses registradores we to be three e four porque, mesmo
se atribuirmos e, ainda assim, se brincarmos com eles, eles serão usados somente na parte
três, o que significa que, digamos, atribuímos we three a algum registrador zero zero.
Isso seria substituído aqui mais uma vez por algo mais importante, importante.
Portanto, ele é reciclado.
E não estamos mais usando.
Portanto, esses três registros estão livres para uso no momento.
Tudo bem.
Está bem.
Um truque interessante que eu gostaria de mostrar é que você já sabe disso, mas ver isso em um exemplo
como este deixa tudo um pouco mais claro.
Aumentaremos imediatamente esses registros porque não queremos brincar com muitas reatribuições.
Queremos ter liberdade e talvez já usemos registros mais altos.
Vejamos.
Sim.
Estamos usando o nove.
Tudo bem.
Esse é um registro muito alto.
Portanto, vamos ultrapassar todos os limites.
A quantidade máxima de retidão que podemos usar é 16.
Portanto, podemos aumentar esse valor para 15, o que significa
que, além desses três, também podemos usar os registros de cinco, seis, sete, oito, nove, dez, 11, 12, 13, 14 e também 15.
Agora, todos esses registros estão livres para uso porque não são conhecidos nesta
parte, neste momento, neste ou neste.
Esses registros conhecem apenas valores de 0 a 4, que são cinco.
Mas agora introduzimos muitos outros e eles não eram conhecidos antes.
Portanto, eles são totalmente gratuitos em nossa parte de código.
Tudo bem.
Está bem.
Até agora, tudo bem.
Agora, vamos limpar isso um pouco e retirar as partes mais importantes.
Portanto, vou escrevê-las com um pouco mais de clareza agora.
Vamos dar um minuto para isso.
Está bem.
Então, aqui está.
Agora temos uma visão geral sobre os três registros.
Temos nossos próprios registros e temos os que já foram configurados.
E vamos traçar essa linha, essa linha tênue entre o código original e o nosso código agora.
O que precisamos garantir agora é que, se estivermos usando esses registros, por exemplo, esses dois
ou também o registro zero, que eles estejam sendo usados no tipo correto.
Portanto, vamos nos certificar de que esse seja o ponto principal neste momento.
Então, vamos rolar a tela um pouco para baixo.
Está bem.
Aqui temos a local e a local será atribuída à chave, que é a chave secreta.
Vamos fazer isso agora mesmo.
Começamos aqui nesta linha e aqui podemos ver o local.
Queremos que já o sejamos.
Estamos brincando com um registro já definido.
Este é do tipo chave secreta.
E podemos ver.
Sim, isso está funcionando.
Isso provavelmente está funcionando.
Então, vamos escrever isso.
B é do tipo chave secreta em nosso código.
Isso está correto.
Portanto, estamos reutilizando este corretamente e, em seguida, temos o me two e aqui podemos ver o V two.
Isso agora é algo que precisamos escrever em nossa lista de tarefas.
Portanto, temos um objeto de conjunto e temos esse objeto de contexto no momento.
Portanto, esse é o nosso objeto de contexto.
Está bem.
E isso será buscado na v2.
Portanto, o v2 é o nosso contexto.
Isso não é absolutamente nenhum problema, porque podemos ver aqui, o que foi gratuito, talvez vamos
negar isso agora, então não devemos reutilizar be two in in an in another state agora até que, é claro, não estejamos
mais usando esse contexto.
Então, sim, essa é essa parte, mas podemos ver que é algo que temos que ajustar.
Portanto, não existe um pacote de suporte inteligente de maneira difícil.
Portanto, isso é algo que precisamos fazer.
Precisamos ajustar isso em nosso código de aplicativo e isso precisa ser ajustado para que possamos ver, talvez possamos
ver isso se rolarmos um pouco para cima.
Não, não podemos ver isso no momento porque não temos nenhum contexto de atividade no momento.
Quero dizer, ele deve se tornar um hacking as com EP hacking as e então devemos ter uma atividade principal.
Mas vamos verificar isso.
Nome do pacote.
Ok, dessa forma, não perderemos isso mais tarde.
E então, vejamos, estamos considerando B três, portanto, b três estará na string.
Até agora, tudo bem.
Está bem.
Em seguida, temos before e before será atribuído a 0x1.
E isso pode ser tudo.
Pode ser um valor inteiro, pode ser um valor booleano.
Apenas sabemos que antes era atribuído a 0x1.
Vamos recapitular um pouco isso.
Estamos usando os três no momento.
Ele já foi gratuito e também antes.
Tudo bem.
Todos esses são registros que foram configurados no aplicativo original.
E podemos ver que a nossa transição está funcionando corretamente, pois tudo o que está abaixo desse código
deve funcionar ao lado do nosso to do aqui.
Isso é algo que temos que observar um pouco para chegar à parte do contexto, mas o restante deve estar
provavelmente bem.
Isso não está faltando agora, é a string.
Certo, então vamos avançar um pouco agora.
Está bem.
Aqui temos o ponto em que estamos agora.
Portanto, vamos também traçar um pouco a linha que notamos.
Está bem.
Estamos aqui neste momento.
Portanto, estamos invocando o método estético.
Ah, sim.
Agora precisamos voltar ao roxo ou a algo que se pareça com o roxo.
Pode ser que sim, e agora temos nossa interação com a interface do usuário.
Então, o Android que faz um brinde faz um texto.
Está tudo bem.
Essa é a classe de torradas do Android.
Nada.
Precisamos nos ajustar aqui.
E agora temos três parâmetros.
Agora está ficando interessante.
A primeira é esta parte aqui.
Então, vamos tentar pular isso dessa forma, ok?
Eu também sou assim.
Vejamos, nós dois é o contexto.
Isso está correto.
Podemos ver o contexto do conteúdo do Android.
Perfeito.
O que são esses outros, então temos a sequência de caracteres java lang.
Esta é esta parte aqui.
Este é o v três.
Muito bem, nós três.
Sim, temos cordas aqui.
Perfeito.
E por último, mas não menos importante, vamos ver.
Então, este aqui.
Esse é um valor inteiro.
É antes.
Então, sim, agora sabemos que esse é um valor inteiro.
Vamos escrever isso.
Valor inteiro e este é um.
Portanto, isso também está funcionando corretamente.
E então voltamos a ter essa interface gráfica, essa UI gráfica.
Então, nós escrevemos isso e isso se transforma em V to.
Isso significa que, nesse momento, estamos substituindo B dois.
O V2 é agora nosso objeto de brinde.
Portanto, optamos por substituir essa parte.
Mas isso não tem problema algum, pois não estamos mais usando o contexto.
Portanto, se rolarmos a tela um pouco para baixo, vejamos.
Nesse contexto?
Não.
Não, não consigo mais vê-lo.
Talvez possamos nos aprofundar um pouco mais nisso, mas acho que agora é a transição em que tudo
está funcionando bem.
Testamos nosso código, ele funciona e agora estamos em nossos registros originais sem ter sobrescrito
nada até agora.
Devemos tomar cuidado com o zero e queremos que esses dois não sejam realmente sobrescritos.
E também esse objeto bruto do PC.
Portanto, isso é irreal.
Essa é uma abordagem realmente perigosa.
Precisamos tomar cuidado com elas, mas o resto parece absolutamente perfeito.
Muito bem.
Então, vamos mudar a cor para ter certeza de que até aqui tudo está bem.
Ok, então chamamos o método show.
Portanto, aqui temos nosso brinde, o texto de criação e, em seguida, temos nossos três parâmetros.
Para mim, nós, três antes do show de pensamento.
Portanto, esta é a linha de código.
A seguir, vejamos.
Estamos sobrescrevendo a b2 mais uma vez.
Portanto, nosso texto foi mostrado.
Portanto, também podemos nos livrar dessa mensagem de brinde aqui atribuindo-me a e lamentando esse
objeto brinde a outra string e zero x.
Estamos reatribuindo B para que isso esteja funcionando agora.
Provavelmente, a única coisa que eu gostaria de fazer é manter o controle desses tipos.
Então, por exemplo, vamos dar um pulo aqui no meio.
Esta, por exemplo, é a nova matriz desta linha.
Vamos ver se tudo está funcionando corretamente aqui.
Se esse for o caso, é provável que esse código esteja funcionando de forma independente até o momento.
Portanto, não precisamos ajustar nada neste momento, caso haja uma incompatibilidade em relação a determinados tipos,
é claro que teremos de dar uma olhada.
Mas não precisamos examinar todo o código.
Só precisamos nos concentrar nesses valores.
Então, aqui estamos criando um novo array e o estamos criando no V V7 e neste aqui.
Vejamos, qual é este aqui?
Não estou totalmente familiarizado com essa instrução.
Portanto, gostaria de dar uma olhada nisso.
Então, vamos dar uma olhada na nova matriz.
Muito bem, aqui está.
New array we x, we by type, ele gera um novo array do tipo ID, que é o ID do tipo, e o tamanho do elemento e coloca a
referência em this is the amount of elements, this is the type e o coloca
em X e perfeito, vamos voltar.
Isso significa que estamos criando uma matriz de objetos de deslocamento típica com o tamanho anterior e a colocamos
em V sete.
Portanto, sete é a nossa matriz e o tamanho é anterior.
Vamos ver onde o before foi usado pela última vez.
Vejamos.
Isso remonta um pouco ao passado.
Está bem.
Bem, a última vez que estive aqui foi logo antes.
Isso está correto.
Vejamos.
Está bem.
Portanto, estamos criando uma matriz e o tamanho do elemento é um.
Portanto, esse não é o comprimento da matriz, mas sim o tamanho do elemento.
E então, vejamos, temos a constante V oito, então vamos escrevê-la um pouco mais aqui.
We eight agora está sendo atribuído a zero zero.
Está bem.
Em seguida, temos um byte get e isso é algo que também quero pesquisar, porque não consigo
memorizar se temos esse array e qual é o parâmetro de tamanho e o que está sendo armazenado em algum lugar.
Vamos dar uma olhada rápida nisso.
Está bem.
Aqui temos que ele obtém um valor de byte de uma matriz de bytes em v x OC.
Essa é uma mordida no x de nossa matriz.
A matriz é referenciada por V por OC essa é a nossa matriz e está sendo indexada pelo conjunto V.
Tudo bem.
Sim.
Ok, vamos escrever isso.
Portanto, essa instrução significa simplesmente que estamos tendo algo como A9.
Esse é o nosso valor de byte que está sendo referenciado por V três e o índice v cinco.
É isso que essa linha faz.
Vamos verificar se esses parâmetros estão corretos.
Rolamos a tela para cima.
Onde estivemos na última vez que usamos três.
Aqui.
Sim, esse é o confiável comprimento da matriz.
Assim, obtemos o número de elementos do nosso byte diretamente no V seis.
Ah, esse também é um ponto interessante.
Teremos que dar uma olhada nesse caso, mas não analisamos tudo.
Mas isso é algo muito importante aqui.
Então, vou fazer isso rapidamente.
Está bem.
Mas, primeiro, vamos terminar este.
Está bem.
Sabemos que o we three está sendo inicializado aqui.
Portanto, talvez devêssemos traçar algumas linhas.
Portanto, nós três estamos sendo inicializados ou definidos como uma matriz de bytes.
Está bem.
E então vamos ver qual era o outro parâmetro v five e podemos ver que v five está sendo definido como zero depois.
O V5 está sendo referenciado como i.
Portanto, MI cinco é o nosso zero zero e essa é a variável de referência ai.
Quais são os meios que usamos v cinco?
Não, não estamos atribuindo isso.
Portanto, este aqui está funcionando perfeitamente.
Essa linha significa que estamos tendo o seguinte.
Vou limpar isso depois, pois, caso contrário, ficará muito confuso no momento.
Portanto, este aqui, nós três é a nossa matriz de bytes e B cinco é o índice.
Portanto, estamos nos referindo ao índice três zero e escrevemos isso em.
Para a V9.
Isso também está funcionando corretamente, sem confusão de tipos ou coisas do gênero.
Tudo está configurado corretamente.
Está bem.
Vamos dar uma olhada nessa parte.
Mas, primeiro, deixe-me limpar isso um pouco.
Tudo bem.
Até agora, tudo bem.
O que é isso?
Ponto interessante com este aqui.
Portanto, nesta linha aqui, podemos ver que entramos em uma instrução if casual, vamos ver se cinco é maior, caso contrário, seis, saltamos
para a condição zero.
Então, vamos escrever isso.
Vamos ver onde está a condição zero.
Vamos colocar isso na tela.
Aqui está.
Portanto, saltamos para baixo aqui.
Portanto, essa é a condição zero.
Até agora, tudo está normal.
Vamos ignorar esse código neste momento.
E esse código é interessante porque temos um rótulo go to aqui.
Mas onde fica isso?
Ir para o salto.
Perdemos alguma coisa?
Acho que não.
Portanto, se você rolar a tela para baixo, poderá ver.
Oh, isso é interessante.
Vamos para o trabalho de parto.
Portanto, se este aqui não for verdadeiro, então entraremos neste bloco aqui.
E esse bloco agora pode ir até o final.
E esse "go to" está se referindo ao início.
Então, este aqui é o nosso loop for.
E esta é a continuação, em que iteramos sobre nossa matriz e, sim, isso é incrível, na minha opinião,
porque é assim que um loop for se parece.
Por isso, temos um rótulo aqui.
Ok, então já temos condições.
Vamos ver quais são esses parâmetros.
Nós cinco e nós seis.
O que são esses.
Então, vamos voltar um pouco.
Quero dizer, aqui já estamos vendo isso.
Não precisamos voltar atrás.
B cinco é zero.
Be five está sendo inicializado com zero zero e podemos ver que v five foi atribuído a ie depois.
Portanto, esse é o nosso oc.
Isso significa que temos cinco, ou seja, essa é a nossa variável de contador crescente.
Vejamos.
Qual é a outra parte?
Vamos falar com outro ouvinte.
A outra parte é we six e we six é o comprimento da matriz.
Então, vamos ver o que o comprimento do array está fazendo.
Quero dizer, o comprimento da matriz está demorando.
Sim, acho que podemos adivinhar isso porque o comprimento do array está considerando o comprimento do nosso array em v seis.
Sim.
Caso não tenha 100% de certeza, você deve definitivamente pesquisar.
Mas agora, depois de ver essa instrução, sim, consigo me lembrar do que está fazendo.
Portanto, isso significa v seis nessa parte aqui e esse é o comprimento da nossa matriz e essa é exatamente a condição que
temos aqui.
Se I for maior do que o comprimento do nosso array, passaremos para a condição zero.
Isso significa que nossa variável de contagem se tornou maior do que a matriz que queremos iterar.
Então, saltamos para a condição zero, que está aqui.
Se esse não for o caso, entraremos nesse código e examinaremos todo o código.
Portanto, vou limpar isso mais uma vez.
Portanto, vamos escrever sobre isso.
Então, percorremos todo esse código até chegarmos a essa linha, essa linha de destino, e depois voltamos novamente.
Então, começamos aqui e, mais uma vez, estamos verificando se nosso olho aumentou aqui.
Essa parte é I é igual a I mais um, ou seja, I mais mais.
Em seguida, ele será verificado novamente aqui.
Agora sou maior ou maior que o V6?
Sim.
Então, pulamos fora.
Caso contrário, voltaremos a isso mais uma vez e teremos esse salto para trás.
Por que isso é tão importante agora?
Porque isso é algo que você pode criar acidentalmente.
Mas, desta vez, estamos tendo uma condição de interrupção, que é esta parte aqui.
Portanto, essa é a nossa condição de ruptura.
Portanto, se não tivéssemos essa condição de interrupção, digamos que essa condição tenha desaparecido, ela não estaria disponível.
E nós brincamos com esses rótulos de Trump.
O que está acontecendo neste momento?
Criamos um loop infinito.
Este aqui é um loop infinito.
O aplicativo falhará e você poderá procurar esse erro por um bom tempo.
Porque o que está acontecendo aqui.
Então, vamos até aqui, acessamos o rótulo e voltamos ao nosso código agora.
Tudo bem.
Mas, aqui, voltamos ao nosso código e ao início.
Tudo bem, então vamos para baixo até o fim e percebemos que precisamos ir para cima novamente
e assim por diante.
Portanto, isso está acontecendo o tempo todo.
Esse é o nosso loop infinito.
Portanto, se você brincar com esses rótulos afiados, certifique-se de não estar pulando para cima.
E, se for o caso, certifique-se de que você tenha alguma condição de interrupção, de que ele esteja realmente deixando
esse código em um determinado momento.
Tudo bem.
A nota curta e estressante é que ela não é muito importante para essa tarefa no momento.
Acho que é interessante ver até que ponto os loops são construídos aqui e como você pode criar acidentalmente
um loop infinito.
Tudo bem, perfeito.
Vamos limpar isso mais uma vez.
Está bem?
Quero dizer, até agora, tudo bem.
Podemos ir para essa parte agora mesmo, porque todo o resto já foi analisado.
Sim.
Aqui está ficando interessante mais uma vez.
Portanto, construtor de cordas.
Ok, vamos pegar uma linha aleatória.
Por exemplo, vamos pegar essa linha aqui.
Tudo ainda está funcionando corretamente?
Temos B cinco e V seis.
B cinco devem estar no fluxo de impressão.
Vejamos, o MI 5 está sendo usado aqui.
OC Sim, aqui temos um fluxo de impressão.
Isso está correto.
E depois temos isso.
Desculpe, estamos aqui, temos v six e V six agora é do tipo string móvel e podemos ver que sim,
esse é o valor de retorno ou o tipo de retorno.
Ele será movido para v seis, o que significa que V seis é do tipo string móvel.
Portanto, é provável que eles estejam se alinhando.
Quero dizer, pode ser sorte.
Isso deve significar que não há nenhum erro no meio, mas isso é bastante improvável no momento.
Muito bem, vamos nos mover para baixo.
Temos nosso brinde.
Ah, este aqui.
Este aqui?
Sim.
Devemos observar essa parte agora mesmo.
Bem, aqui podemos ver que estamos reutilizando ou reatribuindo v cinco.
Já usamos isso bem antes de mim.
Cinco foram e e imprimir fluxo oc.
Portanto, o V5 está sendo reciclado neste momento e será atribuído ao contexto.
Portanto, este aqui é o tipo de campo OC.
Portanto, o tipo de campo é do contexto OC e, mais uma vez, precisamos nos certificar de
que não haja esse nome de pacote nele.
Portanto, precisamos substituir esse nome de pacote por, pois isso é algo que precisamos fazer.
Está bem.
E então estamos pulando para fora desse código.
Tudo bem.
Portanto, agora precisamos nos certificar de que a transição para o exterior também seja perfeitamente adequada.
Nesse caso, é uma tarefa fácil, pois podemos ver que a chave secreta precisa estar no registro que desejamos.
Chave secreta.
E eu também estou sendo.
Já percebemos que também podemos ser qualquer outra coisa, porque ela foi reciclada.
Temos de tomar cuidado com o zero e o zero porque esses foram os únicos registros configurados anteriormente
em nosso código.
No código original.
Esta parte aqui, portanto, nós zero precisamos ser o gerador de chaves e a chave secreta precisa estar em V um e p zero precisa
ser o nosso parâmetro.
Portanto, isso é algo que precisamos analisar agora.
Portanto, precisamos entrar em nosso código e procurar esses valores.
Mas, pelo que vejo, não estamos fazendo algo com V zero e também não estamos fazendo algo que queremos.
Quero dizer, sim, ele tinha um espião sendo atribuído a uma chave secreta, mas isso está correto.
Caso contrário, não o estamos usando.
Então, vamos rolar a tela para baixo.
Sim.
É isso aí.
É fácil.
Queremos uma chave secreta.
Vamos descobrir se temos zero.
Esse objeto é um chaveiro e p zero deve ser nosso parâmetro.
Vamos ver se isso está correto.
Portanto, queremos uma chave secreta.
Tudo bem.
Onde usamos o zero?
Temos isso aqui?
Não, não consigo ver v zero.
Portanto, talvez esse objeto-chave da cozinha já tenha sido reciclado porque não está sendo usado.
Após nossa primeira inicialização, não estamos mais fazendo nada com o keychain e, portanto, ele pode ser simplesmente
ignorado.
Tudo bem.
O último item a ser verificado é o p zero.
P zero.
Vejamos.
O sp0 foi usado aqui.
Em algum outro lugar?
Não é perfeito.
Podemos ver que estamos chamando o Cypher para a Final.
E esse é o nosso parâmetro.
Nosso parâmetro é apesar da matriz.
E se você der uma olhada no código original, verá que ele será chamado com o parâmetro original
com este, o que significa que a transição para o código original também está funcionando perfeitamente.
Não conseguimos mais encontrar o chaveiro.
Esse objeto gerador de chaves pode ser zero, mas ele simplesmente foi reciclado.
Ele não está sendo usado depois disso e queremos que ele continue sendo definido como chave secreta.
Acho que não.
Fizemos um trabalho incrível, por isso temos a maior parte desse material aqui.
E também a abordagem, quero dizer, é bem legal, certo?
Temos que perder aqui mesmo.
Mas não precisamos ajustar mais nada além desses dois nomes de pacotes.
Isso é tudo o que precisamos mudar.
E então o código está funcionando perfeitamente.
Nós cuidamos de todos esses registros.
Vimos que o código está funcionando corretamente.
Esses tipos estão funcionando corretamente.
Ainda não demos uma olhada em um loop for.
Portanto, isso é muito, muito bom.
Sim.
Encerrar nossa tarefa ou jornada smarty que já fizemos até agora.
Uma modificação está faltando nesta parte aqui.
Portanto, também precisamos nos preocupar com essa tarefa.
Tudo bem.
Essas são as nossas três regras no momento para aumentar o número de registros e alterar o suporte a smiley.
De maneira difícil.
Vamos fazer isso agora mesmo.
Em seguida, daremos uma olhada na atividade principal ou talvez vejamos se ela está sendo construída
ou se há alguns erros no momento.
Está bem.
Portanto, vamos corrigir isso primeiro.
Sim, estamos no método correto.
Certifique-se também de que eles não estejam corrigindo acidentalmente o outro método.
Portanto, primeiro queremos aumentar esses registros para 15.
Espero que eles tenham 16 anos.
Mas, sim, vamos descobrir isso e, então, poderemos oferecer suporte ao hardware.
Vamos ver qual é a principal atividade aqui?
Então, entramos na atividade principal.
Quero dizer, isso também pode ser algo completamente diferente.
Pode ser alguma outra atividade ou coisas do gênero.
Portanto, essa deve ser a atividade principal.
Mas essa é a única atividade que temos em nosso aplicativo e, portanto, queremos imprimi-la
aqui.
Aqui, definimos a visualização do conteúdo para que possamos ver toda essa parte aqui.
E agora estamos procurando, vejamos, alguns replays.
Vamos ver como podemos substituí-lo.
Substitua o Controle h.
Portanto, queremos substituí-lo por este caminho, e queremos substituir esta parte aqui.
Sim.
Então, podemos aumentar um pouco o tamanho?
Não, mas deve funcionar.
Portanto, vamos observar isso bem de perto e ver se podemos substituí-lo.
Como podemos fazer isso?
Está bem.
Clicando em Enter.
Então vamos ver.
Com e escolher a atividade principal como uma atividade principal.
Tudo bem, isso é perfeitamente aceitável.
Ok, então aumentamos essa justiça.
Ajustamos essas duas imagens.
Então, vamos reproduzir isso novamente.
Estou muito animado para ver se isso funciona.
Estamos recebendo um erro.
Esse já é um rótulo com esse nome.
Ah, tudo bem.
Sim, 250 a 4.
Não tenho certeza se é agora este número de linha ou este, mas temos problemas com nossos rótulos.
Esses rótulos não foram alterados até o momento, portanto, não alteramos esses rótulos, o que significa
que temos que ir para zero ou obtivemos a condição zero e acho que temos dois deles no momento.
Vejamos.
Condição zero.
Parece bom.
Vamos ver o que está acontecendo com o go to go to zero.
Aqui temos e vamos para a instrução.
CB Ah, sim, se você tiver que ir para o rótulo e também aqui, então agora temos que ir para os rótulos e, é claro,
o programa não sabe para onde pular para o nosso loop for ou para a região de saída.
Então, vamos ajustar isso aqui.
Quero dizer, a maneira mais fácil é fornecer nosso próprio rótulo, rótulo próprio, e então precisamos
descobrir a referência a este que está aqui e este seria o patch.
Portanto, a condição zero não está sendo usada em nenhum lugar?
Não.
Interessante.
Legal.
Isso significa que eles devem construir agora mesmo, caso você também possa, é claro, ajustar a condição zero.
Mas vamos ver.
Legal.
Isso parece perfeito.
Portanto, essa parte já foi concluída.
Se você tentar instalar esse aplicativo, ele falhará porque não estamos tendo esse contexto estático no momento em
nossa atividade principal.
Portanto, vamos voltar à parte gráfica e fazer a segunda parte.
Sei que este vídeo já é longo.
Desculpe-me por essa, mas essa é uma tarefa incrível.
E nós estamos recapitulando tudo agora mesmo.
Temos rótulos, temos condições if, temos tipos de registro, valores, novas instruções e sim.
E todas essas coisas incríveis.
Está bem.
Agora estamos voltando à atividade principal e eu os verei em um tablet gráfico para a última
tarefa aqui.
Vamos lá.
Está bem.
Portanto, aqui temos o método on create e podemos ver que adicionamos este código aqui e este é
o nosso código, o que significa que a tela um é o código original do aplicativo e este também é o código original do aplicativo.
E agora temos a mesma abordagem.
Portanto, descobriremos quais registros estão sendo usados nessa parte na primeira parte e se estamos sobrescrevendo-os
na segunda parte.
Portanto, se esse for o caso, precisamos restaurá-los na terceira parte ou precisamos contornar isso aumentando
esses registros locais ou outras coisas.
Ok, vamos desenhar também nossa linha nesta linha, a linha de separação, e depois vamos retroceder.
Assim como fizemos no exemplo anterior, aqui já temos V zero e P zero.
Então, vamos ver qual é o zero que zeramos e agora invocamos o virtual.
Isso está em um parâmetro e é um valor inteiro.
Muito bem, zero é um valor inteiro e esse valor inteiro é este aqui.
Portanto, zero está sendo atribuído a 0x7f, B nulo e assim por diante.
Está bem.
E então temos P zero, p zero.
Vejamos.
P zero, estamos usando P zero.
Quero dizer, estamos usando-o diretamente aqui.
Portanto, essa deve ser a referência.
Sim.
Este aqui tem como atividade principal o hacking de aplicativos comuns.
Portanto, essa é a nossa principal referência de atividade.
Portanto, esse é o nosso objeto, a atividade principal.
Esse objeto.
Então, o que mais temos?
Também temos um aqui.
E P1 é o nosso parâmetro e esse parâmetro é do tipo bundle OS bundle.
Portanto, tenho certeza de que não estamos brincando com isso.
Está bem.
Portanto, agora temos que descobrir se tudo foi alinhado corretamente e, se estivermos substituindo, zeramos
se podemos fazer isso ou se ainda está sendo usado.
Portanto, vamos nos aprofundar nesse assunto.
Agora, nosso código p zero em nosso código também é a atividade principal, mas essa não está correta.
Portanto, aqui temos o suporte a sorrisos, o caminho difícil e isso precisa ser substituído por A's.
Portanto, esta é a nossa tarefa aqui
e o p zero seria, posteriormente, uma referência à atividade principal.
E esse é o objeto que podemos ver.
Sim, isso está funcionando perfeitamente bem.
Atividade principal, esse p zero perfeito.
Tudo está bem com este.
Ah, mas aí a coisa começa a ficar interessante.
Estamos movendo o resultado para V zero.
Portanto, neste ponto, estamos substituindo o V zero e o que está sendo movido para o v zero.
Estamos chamando get application context e estamos movendo o contexto.
E esse pote aqui no zero.
Portanto, estamos substituindo o zero.
Portanto, precisamos ter certeza de que o zero aqui está sendo usado pela última vez nesse código de método, pois, caso
contrário, se o zero estiver sendo usado na próxima parte em qualquer lugar e o substituirmos pelo contexto,
isso causará problemas.
Tudo bem.
Está bem.
Portanto, vamos seguir em frente por enquanto e depois verificaremos isso.
Vamos ver se temos que fazer algo mais.
E então temos o objeto put.
Portanto, estamos colocando esse objeto no contexto.
E isso também não faz sentido porque, mais uma vez, não se trata desse contexto, mas do contexto.
Portanto, como objeto colocado, o contexto neste momento é colocado na atividade principal.
Contexto, contexto.
Está bem.
Portanto, isso será colocado no contexto da atividade principal.
Vamos fazer desta forma.
E isso é perfeitamente aceitável.
Portanto, estamos fazendo referência a esse contexto para a atividade principal, esse objeto.
Ok, isso está funcionando corretamente.
Agora, vamos ver.
Perfeito.
No código original, podemos ver que o zero agora está sendo usado com outro valor, outro valor inteiro.
Portanto, não precisamos restaurar o zero aqui porque o zero está sendo sobrescrito nessa parte.
Vamos também fazer essa linha de transição.
Dessa forma, o zero agora está sendo atribuído a um novo valor em 0x7f08 null e assim por diante.
Isso significa que não há problema algum em substituí-lo neste momento.
Esse é o OC porque ele foi reciclado de qualquer maneira.
Uma instrução depois no código original.
Tudo bem.
Isso é algo que também não tenho certeza do que está acontecendo no momento.
Portanto, deixe-me apontar o problema agora mesmo.
Está bem.
Portanto, aqui temos nosso contexto e o zero foi definido para o contexto do aplicativo get.
Mas temos isso aqui.
E então estamos colocando esse contexto no contexto da atividade principal.
Não, isso está funcionando perfeitamente bem.
Desculpe.
Fui um pouco rápido demais nesse caso.
Esse é o campo estético.
Portanto, sim, isso está funcionando perfeitamente bem.
Talvez devêssemos esclarecer isso um pouco e nos concentrar apenas nessa parte agora, porque a transição
aqui, todo o resto está funcionando.
Correto.
Está bem.
Vamos nos concentrar apenas nessa parte.
Então, aqui temos a atividade principal, obter o contexto do aplicativo.
Portanto, esta linha.
Essa linha se parece com esta atividade principal.
Ponto.
Obter o contexto do aplicativo.
Vou resumir isso agora mesmo.
E não temos parâmetros, mas temos um tipo de retorno do contexto.
Vamos fazer essa parábola.
Está bem.
Portanto, esse é o tipo de retorno ou o objeto de retorno nesse caso.
E estávamos armazenando isso em v zero.
Portanto, o V zero se torna essa parte agora.
Ok, até agora tudo bem.
Acho que essa parte está clara, talvez não esteja escrita de forma clara, mas acho que está clara.
Em seguida, temos um objeto put e estamos colocando agora o zero no contexto da atividade principal.
Portanto, esse contexto está aqui, o que significa que poderíamos reescrevê-lo da seguinte maneira.
Atividade principal.
Contexto de pensamento porque é um ID de campo estático, podemos fazer referência a ele dessa forma.
Agora somos zero.
Portanto, nesse ponto, o zero foi atribuído e pode ser reutilizado como uma linha depois.
Este aqui.
Isso não tem problema algum, pois já salvamos nosso contexto nesse campo de contexto mais importante, que é
nossa referência no momento.
Tudo bem.
Portanto, tudo tem funcionado corretamente por aqui.
Além do fato de termos um suporte sorridente, de maneira difícil, esses são os dois únicos ajustes.
Este aqui.
E temos o outro.
Precisamos fazer isso agora mesmo.
Vamos fazer isso.
Vamos colocar o aplicativo de volta e ver se ele funciona.
Se isso acontecer, quero dizer, foi difícil.
Mas, veja bem, não temos absolutamente nenhum limite.
Poderíamos escrever e concluir o aplicativo aqui e poderíamos implementar e reter o
servidor nesse aplicativo que imprime essas chaves secretas e faz muitas coisas engraçadas.
Portanto, vamos voltar ao passado.
Vamos criar esse aplicativo e ver se ele está funcionando.
Está bem?
Já inserimos o código.
Aqui está nosso contexto e o que precisamos ajustar é este.
Portanto, precisamos copiar isso e colocá-lo aqui e também aqui.
Sim, salvamos isso e tudo deve estar funcionando, correto?
Agora mesmo.
Então vamos ver.
Estou muito animado para ver se isso funciona.
Claro que não, porque temos esse cílio aqui.
De onde vem esse cílio?
Ah, sim.
Cometi um erro ao copiar e colar.
Tenho quase certeza.
Sim.
Está faltando o ponto e vírgula.
Tudo bem.
Sim.
Legal.
Então, entramos em um ano assim.
Sim.
Em seguida, sentamos nesse aplicativo, assinamos esse aplicativo e desinstalamos o original.
Temos que conectá-lo.
Vamos ver.
Esta é a nossa cópia da tela do ADB.
Isso é suporte.
De maneira difícil.
Sim, não nos importamos com isso.
Agora temos o patch.
Isso é um aplicativo.
Tudo bem.
E agora vamos ver.
Vamos instalá-lo.
Sim, podemos fazer isso várias vezes.
Desculpe, está fora do ar.
É um pacote somente de teste.
Portanto, teste.
E vamos recuperar a cópia da tela novamente.
Ok, vamos manter isso em primeiro plano e abrir também a saída do logcat do ADB para ver se tudo está funcionando
corretamente.
Portanto, vamos fechar esses itens e vamos pegar as criptomoedas.
Está bem.
Talvez uma chave criptográfica.
Caso contrário, poderemos obter outros itens de criptografia.
Muito bem, vamos ver.
Três, dois, ou talvez.
O que esperamos neste momento?
Esperamos nossa mensagem de brinde e essa incrível e sofisticada cadeia de chaves criptográficas como um valor ASCII aqui.
Muito bem, então vamos fazer isso.
3 para 1.
Incrível invadir seu aplicativo e pronto.
Verifique a saída bloqueada do ADB.
Isso é incrível.
Não parece tão incrível como está parecendo agora.
Quero dizer, fizemos a transição dessa atividade para o nosso código de patch e vice-versa.
Portanto, aplicamos nosso patch para obter essa chave incrível aqui e também podemos interagir com os componentes da interface
do usuário.
Portanto, também poderíamos imprimir outra coisa e inserir toda a atividade aqui.
Portanto, nossa própria desfiguração ou coisas do gênero, mas não sou fã dessas desfigurações e coisas do gênero.
Talvez em relação à apresentação para o cliente, poderíamos fazer algo ainda mais sofisticado agora.
Mas isso já é bastante difícil, porque configuramos tudo corretamente para podermos fazer
o que quisermos agora.
Também podemos interagir com serviços, provedores de conteúdo e receptores de transmissão.
Podemos inserir o que quisermos.
Isso pode ser muito útil se você trabalhar com vários colegas em um projeto e eles fizerem, por exemplo,
a parte do teste de penetração do aplicativo Web.
Digamos que o tráfego de rede tenha sido criptografado mais uma vez com um SSL, ele foi criptografado com
algumas chaves e essas chaves podem mudar o tempo todo.
Portanto, agora você pode escrever isso e enviar essas chaves para seus colegas em um servidor da Web automaticamente
sempre que iniciar esse aplicativo.
Portanto, você não tem mais limites, pode escrever um servidor de depuração inteiro nesse aplicativo
e começar a depurá-lo.
Tudo é possível e agora sabemos por quê.
Portanto, Smiley é absolutamente.
Essa é uma habilidade absolutamente ninja.
Tudo bem.
Até agora, tudo bem.
Eu diria que este vídeo já está muito longo e, por isso, o cortamos aqui.
No próximo vídeo, resolveremos as outras partes relacionadas aos parâmetros, ao tipo de
retorno e também ao vetor de inicialização.
E vamos descobrir como podemos usar essa chave para descriptografar essa mensagem aqui.
Tudo bem.
Portanto, esta será a última parte antes de voltarmos ao nosso desafio da faixa preta.
Mas, se você quiser pular essa parte, fique à vontade, pois as coisas mais importantes já
foram mostradas nesta parte.
Tudo bem.
Portanto, estou realmente ansioso para vê-lo na próxima seção.