Bem-vindo de volta.
Neste vídeo, verificamos nosso último método relacionado à aplicação de patches.
Se houver instruções, que é corrigir as declarações de chum para que não tenhamos alguns slides aqui.
Vamos diretamente para o nosso último exemplo e modificamos um pouco isso, porque digamos que tivemos sorte de a instrução
if ter sido apresentada da maneira correta.
Portanto, poderíamos simplesmente remover a primeira linha if e aumentar nossa potência.
Mas e se você conseguir?
E se a instrução if tiver sido trocada?
Não estamos tendo nossa declaração de ano preferido se no início.
Estamos colocando-a no final e, portanto, perpetuando a instrução if ou removendo a linha if acima.
Nós entramos no código que não queremos, portanto, simplesmente trocamos o chop.
Não estamos passando pela primeira.
Vamos entrar em nosso segundo ano com essa condição.
Mas, antes de complicar muito a conversa, vamos nos aprofundar no assunto.
Está bem.
Aqui temos a VM do Ubuntu e já abri o Android Studio.
Portanto, este é o nosso exemplo da última seção.
Ok, vamos dar uma olhada nisso.
Portanto, não temos um limite mestre aqui e isso significa que não podemos ou não chegamos a essa condição, o
que aumentaria nosso nível de potência em 100.
Portanto, isso não foi possível.
Acabamos com a declaração antiga e só a aumentamos em dez depois do que devolvemos.
Bem, esse era o código normal, mas não o aceitamos porque não queremos apenas
dez.
Queremos uma atualização de potência de 100.
Então, o que fizemos foi o seguinte.
Removemos essa linha aqui e isso faz com que ela se torne uma instrução regular, o que significa que estamos tendo uma atualização
de potência de 100 e essa parte agora será ignorada porque não podemos mais inserir essa
instrução.
Está bem.
Portanto, eu diria que essa foi uma abordagem justa para nós.
Sim.
Portanto, obtivemos um aumento de potência de 100 imediatamente sem ter uma condição lá.
Isso é bom.
Mas digamos que tivemos um pouco de sorte com isso.
Por quê?
Digamos que as coisas sejam trocadas, portanto, digamos que o corte tenha sido feito da seguinte forma.
Nossa atualização de energia agora não está mais dentro dessa declaração, está dentro dessa declaração.
E também estamos definindo isso como verdadeiro.
Vamos ver se nossa abordagem está funcionando bem agora.
Portanto, vamos excluir essa linha aqui.
Está bem.
Isso significa que temos a atualização de potência de dez OC.
Nada mal, mas não podemos mais alcançar a declaração CIF ou o caso LS dessa declaração.
Portanto, estamos saindo dessa função com apenas dez.
E sim, para ser sincero, isso não é aceitável para nós, certo?
Com certeza.
Portanto, o que faremos agora é o seguinte.
Então, clico na tela mais uma vez.
Tudo bem, então estamos tendo a tampa principal e isso é aceitável para nós.
Portanto, estamos entrando nessa declaração porque a definimos como.
Verdadeiro.
Tudo bem.
Então, obtivemos uma atualização de potência de dez OC e agora, em vez de deixar essa função aqui.
Um lançamento que alcançamos para o local.
Isso levaria a outra atualização de potência de 100 mais uma vez.
Portanto, estamos recebendo 110 no momento.
E podemos fazer isso mudando as instruções de Trump.
Portanto, antes de sairmos neste ponto, basta voltarmos e podemos fazer isso com a condição.
Então, vamos executar esse aplicativo e dar uma olhada no resultado do smiley.
Bem, aqui tínhamos o código do smiley.
Vamos dar uma olhada nisso.
Temos nosso item de has e eu tento melhorar minha escrita.
Vejamos.
Sim, item.
Aqui está.
Obtivemos o objeto do jogador.
Jogador.
Estamos retornando ao branco.
Tudo bem.
Portanto, temos um registro local.
Temos nosso jogador como parâmetro.
Sim.
E agora estamos buscando o parâmetro na instância a partir do nosso parâmetro, que significa MasterChef.
Então, este é o ponto do jogador MasterChef e começamos no zero.
Portanto, zeramos como jogadores iguais.
Tampa mestre de pontos.
E isso é do tipo booleano.
Está bem.
Então, temos nossa declaração e vamos fazer isso juntos.
Se o zero for igual a zero, passaremos para a condição zero.
Portanto, se zero for igual a zero, saltamos para esta condição e esta está aqui.
Então, fazemos esse salto, o que significa que estamos aumentando o poder do jogador em 100.
Então, sim.
Vamos juntar essas três linhas nesta aqui, porque já analisamos o poder do ponto do jogador
de função.
Mais é igual a 100.
Está bem.
Caso contrário, entraremos neste caso, o que significa que estamos obtendo o poder do jogador e aumentando-o em
dez vezes.
Portanto, nosso espaço publicitário aqui está fora do ar.
Poder de ponto do jogador.
Mais é igual a dez.
Muito bem, nosso master cap é um valor booleano e, no nosso caso, está definido como true neste momento.
Isso significa que não damos esse salto porque nosso V0 não é falso.
Portanto, se falso for igual a igual a falso.
Esse não é o caso.
O que temos aqui é se for verdade.
Equals é igual a false.
Portanto, vamos para a declaração de adição e isso significa que aumentamos nosso poder de jogador em mais dez.
Muito bem, como podemos mudar isso em relação à estrutura de campeões?
Bem, vamos dar uma olhada.
Então, vamos limpar isso rapidamente.
Está bem.
Vamos analisar isso mais uma vez.
Portanto, não estamos tendo essa condição.
Essa é falsa.
Acabamos aqui.
Está bem.
Isso significa que aumentamos nosso nível de energia em dez.
E depois temos esse "go to jump" aqui, o que significa que estamos pulando daqui para cá regularmente.
Tudo bem.
E se pegarmos esse go to e, em vez desse rótulo go to, digamos que inserimos a condição, sublinhado
zero.
Nesse caso, em vez de pular para baixo, devemos pular para o rótulo da condição
zero, que está logo abaixo, o que significa que entramos neste aqui, o que significa que temos outro à direita
de mais 101 segundos.
Portanto, estamos recebendo mais dez e mais 100.
Depois, fazemos nosso trabalho aqui e depois temos essa gravadora.
Mas isso é simplesmente ignorado porque não está na instrução de salto e nós retornamos.
Então, vamos ver como isso funciona.
Está bem.
Tudo bem.
Deixe-me limpar a tela rapidamente.
Está bem.
Portanto, temos nossa condição if igual a zero.
Não atendemos a essa condição.
Portanto, entramos neste e aqui temos esse salto e ele agora será substituído pela
condição zero sublinhado.
Então, exatamente isso, sim.
Isso significa que isso salta para essa condição e isso agora também salta para isso.
E isso deve levar a um momento de aumento do nível de potência ou a uma atualização do nível de potência de 110.
Vejamos.
Está bem.
Por isso, criei esse aplicativo.
Eu assinei.
Não quero aborrecê-lo com essas etapas novamente.
Então, acho que você já viu isso muitas vezes no passado.
E vou interromper o vídeo agora mesmo.
Tudo bem.
Já temos nossa conexão com o dispositivo.
Vamos entender isso.
Aqui está.
Agora vamos instalá-lo.
Muito bem, vamos abrir esse aplicativo.
Nosso nível de potência agora é dez, o que significa que, se eu apertar o botão, devemos ter um nível de potência de 120, porque.
Dez mais 100.
Vejamos.
Aqui está.
Eu acertei mais uma vez, 230.
Aumentamos novamente para 110 e assim por diante.
Podemos fazer isso pelo tempo que quisermos.
Portanto, o que estamos fazendo agora é entrar nessa condição, mas, em vez de sair, entramos
nela.
E isso é feito mudando o campeão.
Desculpe.
E isso é feito alterando as instruções do campeão aqui.
Legal.
Está bem.
Então, para recapitular rapidamente, eu reinicio o estado original.
Tudo bem, então o que podemos fazer?
Podemos alterar o nível do campeão aqui.
Tudo bem, isso é bom.
Já vimos isso em relação a este aqui.
O que também é possível é mover o rótulo Champ para que possamos pegar este e simplesmente adicioná-lo
aqui.
Isso também funcionará e reiniciará novamente.
Está bem.
O que também podemos fazer é invertê-las.
Portanto, em vez de se for igual a zero, podemos dizer se não for igual a zero.
E o que também está funcionando é que podemos alterar o valor do registro logo antes da instrução if.
Portanto, se tivermos esse aqui, podemos simplesmente dizer que a barra de contagem para o zero agora é verdadeira ou falsa,
como quisermos.
Essas são as opções que temos no momento.
E isso nos leva a corrigir todas as instruções que desejamos que sejam projetadas em nosso caminho.
Para ser sincero, não estou usando a instrução de campeão com muita frequência, mas às vezes ela pode ser muito útil.
Está bem.
Com relação à inserção de um novo código como este aqui.
Ainda não conversamos sobre isso, mas o faremos em breve.
Portanto, estamos próximos desse tópico no momento.
Só quero mostrar a você que essa opção é impossível porque, sim, a aplicação inteligente de patches nos
dá poder ilimitado.
Podemos fazer o que quisermos aqui.
Tudo bem.
Portanto, isso é tudo para as declarações "se" no momento.
A única coisa sobre a qual não falamos foi um caso de switch, mas um caso de switch é apenas várias instruções if.
Portanto, se tivermos um caso de switch com quatro valores, um, dois, três, quatro, o compilador simplesmente
gerará quatro instruções if se for igual a um igual a dois igual a três.
Portanto, não precisamos falar sobre isso.
Trata-se apenas de várias instruções if e isso é tudo o que você precisa saber sobre isso.
Se forem declarações, você também sabe como corrigi-las de determinadas maneiras.
Com relação a isso, apresentei-o agora, mas também o aprenderemos na seção
de inserção de smiley.
Está bem.
Portanto, agora você está mais bem preparado em relação às instruções if e já tem muito poder,
e vamos pegar isso e, sim, fazer a nossa primeira aplicação de patch no mundo real.
Vamos contornar uma detecção de rotina.
Portanto, esse será o próximo exercício.
Eu preparei um em um não código, mas também tenho um aplicativo que foi projetado como um detector de roteamento,
e isso é muito útil se você quiser realizar testes de penetração e tiver que contornar as detecções
de rotina.
Existem boas estruturas por aí que, sim, fazem um bom trabalho, mas às vezes falham porque a implementação
é bastante exclusiva e, sim, não é conhecida pelo programa, mas, analisando e corrigindo o código, você
pode contornar isso agora mesmo.
Portanto, vejo você no próximo vídeo.