Bem-vindo de volta.
No último vídeo, fizemos um tipo de prototipagem para escrever um pequeno aplicativo para Android que
pode ser usado para treinar determinados tópicos, por exemplo, instruções if.
Esse vídeo bônus concentrou-se no processo de desenvolvimento de aplicativos no Android.
Em um nível muito alto, pode ser útil saber essas coisas, mas elas não são necessárias para este curso
aqui.
Este curso é sobre hacking de aplicativos Android e é exatamente isso que faremos agora
neste vídeo.
Simplesmente fazemos a engenharia reversa do aplicativo que escrevemos no último vídeo e, portanto,
não é necessário assistir a esse vídeo bônus ou que esse aplicativo esteja fazendo é simplesmente reduzir nossas vidas
em um.
Se você pressionar esse botão, encontrará esse apk no anexo da seção e poderá
simplesmente fazer o download e entrar nesse vídeo agora mesmo.
Está bem.
Vamos dar uma olhada nesse código aqui, pois queremos continuar praticando o smiley sempre que possível,
e faremos isso juntos agora mesmo.
Então, sim, vamos passar por isso juntos e aprenderemos novas instruções e descobriremos como funciona
a instrução if.
Portanto, vamos lá.
Então, vamos ver o que temos.
Temos nosso método virtual.
Isso significa que temos um método público aqui que é rotulado como get hit.
Esse é o nome do nosso método.
Vamos escrever isso.
Obter.
Está bem.
Também podemos ver que esse método não tem nenhum parâmetro.
Legal.
Também podemos ver que o tipo de retorno é void.
Portanto, não estamos devolvendo nada.
Isso também é bom.
Tudo bem.
Aqui temos nosso protótipo de função.
Já está pronto.
Uma linha de código de smiley.
Legal.
Em seguida, temos os locais também.
Isso significa que temos dois registros locais.
Mas não sabemos se são variáveis ou espaços reservados para determinados valores.
Fazemos a abordagem de cima para baixo.
Portanto, passamos por essa instrução uma após a outra.
Não estamos pesquisando isso no momento.
Portanto, devemos ter isso em mente.
Temos dois registros locais.
Está bem.
Em seguida, temos I get v0 p zero OQ.
Sabemos que p0p0 é um parâmetro especial.
Ele está segurando esse objeto.
Está bem.
Vamos ver o que essa instrução faz.
Já enfrentamos isso.
Sim, muitas vezes neste momento.
Mas, de qualquer forma, vamos dar uma olhada para ter 100% de certeza.
Também não leva muito tempo.
Você verá isso.
Então, deixe-me trocar.
Aqui está.
Temos nossos códigos de diálogo aqui.
E sim, nós simplesmente buscamos essa instrução.
Recebo o ID do campo X com y que lê um campo de instância no qual a instância é referenciada por v y.
Muito bem, vamos voltar.
Portanto, temos um campo de instância aqui e podemos encontrar esse campo de instância após esse erro, o que significa
que o nosso campo de instância está incorreto.
Temos essa vida de pontos.
Este aqui é apenas referente ao objeto que sabemos que é da classe player.
Portanto, este é um objeto de jogador.
Ok, então é isso que o nosso P zero está segurando e esse valor é agora colocado em v zero.
E vamos escrever isso.
Zero é igual.
Esse ponto está vivo.
Está bem.
Esse é o registro PC.
Digamos que o registro do PC seja o único que eu gostaria de substituir.
Caso contrário, gosto de manter os valores originais do registro.
Em seguida, temos a barra constante quatro.
Queremos 0x1.
Estamos colocando esse valor em v um e estamos colocando apenas quatro bits devido a essa barra quatro.
Mas isso não importa aqui porque o valor um é 0001.
Então, vamos escrever isso.
O que essa linha faz é inicializar o registro, nosso segundo registro local, com o valor um.
Muito bem, temos um subtraço int para endereçar e só temos dois registros.
Quero dizer, está claro o que ele faz.
Mas, de qualquer forma, vamos dar uma olhada para ter certeza de onde o resultado está sendo armazenado.
É aqui ou é aqui, subtraímos isso disso ou vice-versa? Se não tiver 100% de certeza, basta pesquisar.
Por isso, estamos procurando por um sub-dash int.
Esse tem agora três registros.
Portanto, temos que adicionar este.
Sim.
Está bem.
Calcula we x menos v y e coloca o resultado em v x OC.
Portanto, estamos calculando isso menos isso e o resultado.
Vamos fazer isso, isso, menos isso.
E o resultado está sendo colocado novamente em v zero.
Portanto, estamos tendo zero.
Vamos voltar a trocar é igual a ser zero menos v um, o que significa que se substituirmos agora nosso v zero pelo com
a referência aqui.
Portanto, o V zero está segurando nosso ponto que vive este.
Isso significa que nosso v zero agora é igual.
Esse ponto vive menos o que queremos e v um é um.
Portanto, menos um.
Isso é o que essa linha aqui faz em relação à configuração dos registros anteriores.
Está bem.
Em seguida, temos o I put I put 0p0.
Portanto, estamos colocando esse local aqui em nossa instância novamente, em nossas vidas repletas de instâncias.
De qualquer forma, vamos dar uma olhada rápida para ter 100% de certeza.
Eu coloco wi x coloca wi x em um campo de instância.
A instância é referenciada por wi-fi.
Temos que tomar cuidado.
Recebo leituras da direita para a esquerda e coloco esta leitura da esquerda para a direita.
Portanto, estamos colocando esse valor agora na linha PC.
Aqui estamos buscando o valor de p zero em V zero.
Portanto, se você não estiver 100%, você entenderá esse ponto.
Tudo bem.
Então vamos ver.
Isso significa que estamos tendo p zero e isso interrompe a vida.
Agora é igual a v zero e v zero é esse ponto vive menos um.
Portanto, neste ponto, estamos apenas reduzindo um ou subtraindo um.
A partir daí, Todd vive.
Está bem.
Vamos colocar as informações que conhecemos.
Isso não é uma instrução.
É apenas um lembrete para nós de que estamos subtraindo um dos que vivem.
Finalmente, temos nossa declaração if.
Vamos dar uma olhada.
Vamos colocar uma cor dramática para isso.
Portanto, temos se há menos, talvez menos igual, e então este é zero, talvez nós zero, e então temos
este.
Isso parece estranho aqui.
Tudo bem.
Vamos dar uma olhada nisso.
Por isso, primeiro procuramos essa instrução.
Se o traço menos for igual a sim, OC.
Deixe-me rolar a tela para baixo.
Aqui está.
Verifica se o x é menor ou igual.
Temos zero ao quadrado dois, mas ter um zero ao quadrado qualquer coisa ainda é zero.
Não sei ao certo por que ele está apontado dessa forma estranha aqui, mas isso significa
que se x for menor ou igual a zero e depois de saltarmos para este aqui, o alvo aqui, podemos ver um exemplo.
Se menos for igual a zero, nós zeramos.
E, em seguida, saltamos para este aqui, que salta para a posição atual, mais esse deslocamento.
Tudo bem.
Isso parece ainda mais estranho, na minha opinião.
Então, vamos voltar ao nosso código.
Não quero ficar muito confuso.
Está bem.
A primeira coisa que precisamos fazer é ler isso em voz alta e ler da seguinte maneira.
A primeira é se virmos uma linha, que é a primeira leitura, e a segunda leitura for menor que zero, então pule para
a condição zero.
Se você ler isso em voz alta dessa forma, podemos escrever da mesma maneira.
Vamos fazer isso se.
Nós zero é menos é igual a zero.
Em seguida, saltamos para a condição zero.
Tudo bem.
Vamos limpar isso rapidamente.
Vamos encontrar essas condições aqui agora mesmo.
Portanto, obtivemos o código na condição de sublinhado zero.
Vamos entrar.
Digitalização.
Aqui está.
Aqui temos este aqui.
Está bem.
Portanto, se essa condição for verdadeira, passaremos desta para esta aqui.
Movemos um nesse caminho do código.
E isso é incrível porque agora essa é a nossa filial.
Estamos com nosso código e esse código tem algumas ramificações, true e false.
E, ao ir para uma ramificação, estamos pulando o caminho do outro código, e é isso que estamos
fazendo aqui.
Estamos pulando esse código aqui agora.
Temos que seguir em frente no frio.
Talvez voltemos a esse assunto.
Mas, por enquanto, estamos apenas mantendo-o.
Tudo bem.
Portanto, essa também é a nossa verdadeira condição.
Vamos colocar isso.
Verdadeiro.
Portanto, se essa afirmação for verdadeira, o que significa que essa é a nossa condição verdadeira.
Está bem.
Depois, passamos para cá.
Vamos ver o que estamos fazendo depois.
Portanto, temos nossa instrução if e agora estamos colocando o valor de zero em v zero.
Está bem.
Portanto, zero é igual a zero.
E agora temos uma entrada booleana.
Isso é interessante porque nosso valor zero pode ter vários significados.
Ele pode ter ou ser usado como o número zero ou como uma declaração booleana.
Declaração booleana ou booleano.
Sim.
O estado booleano é, por exemplo, verdadeiro ou falso.
Esses dois estados.
E, nesse caso, estamos tendo um zero, o que significa que um zero é o estado falso?
Portanto, esses valores podem ter vários significados nesse caso.
Está bem.
E, em seguida, estamos colocando esse falso de volta em nosso objeto.
E que tipo de objeto encontraremos após o erro aqui.
É o estado do ponto, portanto, temos esse campo de instância do estado do ponto e também podemos ver isso aqui.
Esse estado de ponto é do tipo booleano, o que faz sentido porque estamos colocando um booleano nele.
Está bem.
Isso significa que temos nosso estado de ponto.
Agora é igual a zero, o que significa que nosso estado de ponto é esse.
Agora é igual a falso porque nosso zero é um valor booleano e é falso.
Muito bem.
Vamos voltar ao verde.
O que está acontecendo aqui?
Então temos este.
Vamos lá.
Vamos marcar isso rapidamente.
Portanto, temos este.
Também recebemos este.
Esse é apenas um número de linha.
Então, em relação ao nosso código Java, temos esse go to aqui.
Isso parece interessante porque essa é a segunda condição se tivermos que começar com esses dois pontos
aqui.
Nesse caso, vá para zero.
Podemos pular essa parte.
Isso é muito importante porque também tenho muita dificuldade nesse ponto.
Se, mais tarde, você corrigir algum código e se deparar com essa instrução, ficará pensando:
"Ah, bem, agora o que tenho de fazer, tenho de pular ou posso deixar para lá?
Tenho que excluí-lo?
A regra é que, se esquecermos os dois pontos e depois o que alguns vão, podemos simplesmente pular isso.
Isso será ignorado.
Portanto, vamos examinar essa instrução aqui.
Ei, sou eu do futuro.
Mas então minha garantia de qualidade.
Eu me deparei com este aqui, e...
Sim, sabe de uma coisa?
Podemos tornar isso muito mais fácil.
É claro que isso não afeta apenas as instruções, portanto, podemos ter em mente a seguinte regra se estivermos
usando dois pontos e depois o nosso rótulo.
Esse é um rótulo que faz referência a outra pessoa no programa, portanto, podemos simplesmente ignorá-lo.
Mas se você tiver uma instrução e condicionar algo assim na frente do nosso ponto e vírgula,
teremos que investigar isso, porque essa é uma decisão que está sendo tomada e, depois, vamos dar
esse salto ou não.
Portanto, essa instrução não pode ser simplesmente ignorada.
E, para resumir rapidamente, ter uma linha, começando com os dois pontos, é apenas a referência
do campeão.
Estamos ignorando isso, mas tendo uma instrução na frente de nosso cólon, precisamos considerar isso.
Portanto, não podemos simplesmente ignorar isso.
Temos que descobrir o que está acontecendo lá.
E, depois, se você vai dar esse salto ou não.
Muito bem.
Perfeito.
Está bem.
E, depois disso, retornamos de nossa função.
Portanto, também entendemos esse e esse retorna depois.
Tudo bem.
Está bem.
Essa é a nossa declaração if verdadeira.
Parece um pouco bagunçado, mas, sim, introduzimos alguns novos comandos aqui ou novas instruções.
Temos nosso IFF, que faz um sim.
E declaração e condição.
Se zero é menos, é igual a zero.
É isso que o conjunto aqui significa.
Estamos comparando com zero.
Em seguida, saltamos para essa condição.
Portanto, essa é a nossa declaração verdadeira.
Ok, vamos limpar isso antes que fique ainda mais bagunçado.
Está bem.
Agora discutimos nossa declaração verdadeira, mas também temos um caso falso.
Portanto, vamos dar uma olhada em como o código se parece em relação aos padrões ou, neste caso, ao caso dos
anúncios.
Vamos dar uma olhada.
Então, começamos a ler o texto mais uma vez.
Dizemos isso em voz alta para nós mesmos.
Dizemos que, se B zero for menor que zero, então pule para essa condição.
Mas agora não saltamos para essa condição porque estamos assumindo que temos um estado falso.
Tudo bem.
Com relação ao estado, simplesmente seguimos em frente na linha de código.
Portanto, estamos aqui agora.
Isso significa linha 22 e linha 22.
Essa é apenas a nossa referência Java.
Portanto, não há nada de especial nesse caso.
Então, temos nossa entrada booleana mais uma vez.
Interessante.
Vejamos, agora estamos colocando P zero e, novamente, P zero é o nosso caso.
E aqui temos o campo de instância deste que é o estado do tipo booleano.
Portanto, podemos simplesmente escrever nosso código aqui, daqui em diante.
Então, o que temos aqui?
Temos esse estado de ponto.
Agora é igual ao que queremos.
E é por isso que gosto de manter esses registros, porque agora podemos consultar nosso código.
O que queríamos da última vez?
Nesse caso, podemos ver este aqui.
Depois disso, subtraímos esse, mas não o reatribuímos.
Portanto, o valor ainda é o mesmo e podemos ver que não o usamos mais.
Isso significa que nosso v um está mantendo esse valor aqui e agora estamos colocando um booleano em nosso
estado this, o que significa que estamos colocando o valor um, o que significa o estado true em nosso estado desktop.
Portanto, esse estado total agora é igual a verdadeiro com base nesse estado.
Está bem.
Portanto, também temos este aqui.
Tudo bem.
Agora, temos que ir para "vamos marcar isso de forma diferente".
Um pouco de cor púrpura.
Tudo bem.
Agora temos aqui nossa instrução Trump, porque, caso contrário, continuaríamos neste código
aqui e este é este código aqui.
Portanto, o go to no início indica que depois não há rótulo.
E saltamos para esse rótulo agora e essa é a diferença entre esse código dois e esse go
to, que tem esse go to na frente e esse código no go to sublinhado zero.
Portanto, nesse caso, estamos procurando esse rótulo aqui e o encontramos nessa linha.
Isso significa que estamos pulando deste aqui para este aqui.
Está bem.
Acho que você não pode mais ler isso.
Portanto, vamos limpar isso rapidamente.
Portanto, estamos pulando dessa forma para outra melhor.
Isso significa automaticamente que estamos pulando a parte seguinte.
Isso, isso, isso e isso.
Tudo bem.
E o que é essa parte?
E essa parte é exatamente o que está aqui.
Portanto, é bom que tenhamos pulado essa parte.
Caso contrário, interferiríamos com esse código aqui.
Está bem.
Portanto, é preciso mencionar algumas regras.
Se, capitão, se o traço menos for igual a zero, então temos uma condição posterior, que está no rótulo.
Se a afirmação for verdadeira, saltamos para esse rótulo.
Nesse caso, seria aqui.
Se a afirmação for falsa.
Simplesmente continuamos com nosso código até atingirmos essa meta também.
Não precisa ser em go to, por exemplo.
Também poderíamos deixar a função neste momento e talvez não houvesse nenhum objetivo a ser alcançado.
Isso também é possível.
Mas se você também atingir essa meta, precisamos verificar o rótulo por trás disso.
Go to, nesse caso, começa com dois pontos.
E então, sim, na maioria das vezes, acho que toda vez que isso acontece, ele vai para o sublinhado um, zero
dois e assim por diante, e então temos que procurar em nosso código por isso, ir para o rótulo e depois pular para este
aqui.
Ao fazer isso, estamos pulando algum código que é pretendido e, em seguida, continuamos simplesmente aqui.
Portanto, agora temos o quadro de retorno.
Vejamos.
Então, depois disso, estamos retornando dessa função e é assim que o código se parece.
E isso é muito interessante, não é?
Porque se você der uma olhada nisso, talvez descubra alguma coisa.
Eu lhe darei alguns momentos e, sim, voltarei depois.
Vamos dar uma olhada nesse código e ver se há algo estranho acontecendo.
Alguns momentos depois.
Primeiro, vamos criar algum espaço.
Portanto, vamos nos livrar desse.
Tudo bem.
E agora, você ainda consegue se lembrar de como era o código Java?
Sim.
Interessante.
Nosso código Java não era parecido com o seguinte.
Portanto, temos o nosso "se" e depois temos o "ponto" "vidas".
É maior que zero.
Tenho certeza de que é assim que nosso código Java se parece.
Então, cometemos um erro aqui?
Fizemos algo errado?
Absolutamente não.
Interpretamos esse código de forma absolutamente correta.
Analisamos linha por linha e este é o código correto extraído da parte do smiley.
Então, agora a pergunta é: teremos o mesmo resultado?
Seria ridículo se não fosse assim.
Certo.
Vamos dar uma olhada.
Portanto, em nosso caso e em nosso código Java, temos esse ponto zero criador vivo e, em seguida, seguimos em frente.
Caso contrário, perderemos o ganho.
Vejamos agora que temos que se zero é menos é igual a zero, isso significa que não temos nenhuma vida sobrando,
pois é isso que temos se tivermos zero ou menos de zero vidas.
Depois, temos a declaração aqui.
É interessante.
Isso é correto.
Estamos colocando nosso estado desse ponto em um modo falso.
Essa foi exatamente a parte que obtivemos em nosso código Java no caso dos anúncios e aqui temos o OC.
Isso significa que estamos tendo mais do que zero vidas.
Esta parte aqui e aqui podemos ver que sim, podemos continuar com o jogo porque temos nossa data
igual a true.
Está bem.
Portanto, a questão agora é: por que o compilador está fazendo isso?
Bem, isso pode estar relacionado à otimização do compilador para o computador.
Pode ser mais rápido calcular se você tem menos ou igual a zero vidas e, em seguida, calcular se você
tem mais de zero vidas.
E é por isso que o compilador optou por criar esse código nessa instrução aqui, dessa forma.
E, em minha opinião, isso é realmente incrível.
Por quê?
Porque estamos ainda mais ou mais próximos da parte original do que o código Java, porque aqui podemos
ver o que será executado.
Não estamos verificando se o valor é maior que zero.
Não, estamos verificando se o valor é menor que zero.
E depois entramos nessa instrução aqui.
Caso contrário, seguiremos em frente nesta parte aqui.
E, na minha opinião, acho isso incrível, porque somos mais exatos do que o ridículo do código Java, se você observar
o código do smiley aqui.
Está bem.
Como você pode ver, estou muito empolgado com isso.
Na primeira vez, fiquei muito confuso porque pensei: "Tudo bem, deve haver um erro aqui".
Em seguida, verifiquei o código e percebi que, espera, o quê?
Esse é exatamente o mesmo código, mas um pouco diferente, apenas em uma ordem diferente, mas ainda assim o resultado
está correto.
E, no entanto, isso foi absolutamente surpreendente para mim.
Além de todo o meu hiper agora, vamos voltar às declarações if.
O que aprendemos?
Portanto, vamos limpar isso rapidamente.
Então, se chegarmos a uma instrução if, temos vários pontos a considerar.
Antes de mais nada, precisamos verificar o que é essa declaração?
Se zerarmos menos que é igual a zero, vamos para essa condição e essa é a nossa declaração verdadeira,
então ignoramos o restante e pulamos para essa condição ou para esse rótulo
aqui, esse aqui.
Portanto, esse código será ignorado por enquanto.
Simplesmente seguimos em frente.
E se encontrarmos e começarmos com o Colon aqui, simplesmente ignoramos isso porque não está
relacionado à nossa instrução.
Então, temos que fazer isso mais uma vez com relação à declaração falsa e dentro da declaração falsa.
Ignoramos esse alvo aqui e simplesmente continuamos com nosso código até que possamos encerrar esse rótulo
depois.
Em seguida, saltamos para este rótulo e continuamos nesta parte aqui.
Isso significa que estamos ignorando todo o resto.
Tudo bem.
Sei que se eu olhar para esta imagem aqui, pode ser um pouco confuso.
Mas não se preocupe, passamos por isso várias vezes.
Também daremos uma olhada em alguns slides e continuaremos praticando bastante porque, desta vez,
estamos apenas comparando com um valor zero.
Há também um caso adicional.
Se for necessário registrar valores, como, por exemplo, se B zero for maior do que o desejado, teremos um registro
adicional aqui, mas aprenderemos isso mais tarde.
Por enquanto, vamos nos concentrar apenas na comparação com zero e, em seguida, simplesmente introduzimos um novo registro e o
restante permanece o mesmo.
Ok, isso é tudo para este vídeo por enquanto.
E no próximo, fazemos a mesma abordagem, mas em nossos slides, que parecem um pouco mais limpos.
E aqui vamos nos aprofundar cada vez mais no assunto.
Se você tiver alguma dúvida, fique à vontade para me escrever, é claro.
Mas talvez elas também possam ser esclarecidas nos próximos vídeos, porque continuaremos praticando isso repetidamente
se as declarações forem muito importantes e, portanto, vamos seguir em frente no próximo vídeo.