Certo, amigo, volte.
Este é o vídeo bônus.
Portanto, vamos dar uma olhada em outra abordagem para resolver esse desafio.
E eu gostaria de fornecer isso a você para que veja que há muitas oportunidades.
Já temos que resolver esse desafio.
Vejamos.
Primeiro, vamos recuperar a tela do aplicativo.
Portanto, essa é a nossa verificação de rota aqui.
Sim.
Nosso dispositivo é roteado.
Tudo bem.
Portanto, este é o aplicativo.
E agora queremos contornar isso corrigindo os rótulos.
Portanto, fechamos este e vamos para o EPS.
Então, quanto à verificação da raiz, lá vamos nós.
Primeiro, descompilamos esse aplicativo.
Em seguida, abrimos todo o diretório smiley com resultados para o código.
Tudo bem, então vamos para a invasão de aplicativos e depois para o utilitário raiz.
Aqui está.
Nós removemos as janelas incômodas com um clique.
Selecione Java.
Clique nele.
Muito bem, vamos abri-lo na versão compilada ao nosso lado.
Então, Shade.
Desculpe-me.
Verificação da raiz, ponto apk.
Então, eu tenho meu modelo gráfico e ainda estamos falando sobre o método de raiz do dispositivo.
Portanto, se você cair.
Aqui está.
Então, aqui podemos ver.
Ok, temos várias verificações.
Rota de verificação, método um, dois.
E este aqui tem três.
Aqui está.
Está bem.
Portanto, esse é o método no lado da viagem.
Vamos dar uma olhada na parte do smiley.
Portanto, aqui temos nosso método roteado por dispositivo.
Isso retorna um valor booleano.
Depois, temos nossos três cheques aqui.
E isso é combinado com nossa declaração.
Então, com esse aqui, vamos analisá-lo rapidamente.
Está bem.
Começamos pelo início.
O dispositivo tem
root?
Sem parâmetros, valor de retorno booleano.
Portanto, temos uma variável local.
Desculpe.
Registro local aqui.
Em seguida, temos nossa linha dez e nossa primeira invocação estática.
Esse é o nome da classe route util dot check method check route method one.
Ok, esse resort será transferido para o v zero.
Isso significa que nosso b zero é um utilitário de rota.
Pensei em verificar o método de rota um.
E assim por diante.
Em seguida, temos nossa declaração if.
Portanto, temos isso e isso.
Em seguida, temos nossa declaração if.
Se o zero não for igual a zero, passamos para a condição um.
A condição um é esta aqui.
Então, pulamos para cá.
E sim, antes de darmos uma olhada nisso, vamos analisar rapidamente.
O que temos aqui?
Está bem.
Isso significa que se nosso Y0 não for igual a zero, significa que nosso B0 está definido como um, o que significa o valor de retorno
dessa função aqui.
E esta aqui foi uma no caso de uma declaração verdadeira aqui.
Isso significa que temos a detecção de enraizamento ou os sinais de detecção de enraizamento que identificam algo
estranho no dispositivo e o flexionam como enraizado, pois temos aqui um valor booleano.
Portanto, o método check root one retorna verdadeiro e, então, sabemos que esse dispositivo está enraizado.
Isso significa que entraremos na condição um aqui.
Também temos esse rótulo go to, mas podemos ignorá-lo e, em seguida, colocamos um à direita em nosso B zero
e o B lê um.
Mas com o valor de retorno de b1v0, desculpe, que é um e isso significa que é verdadeiro e que é a raiz do dispositivo.
Isso se torna verdade, o que significa que é ruim, pelo menos para nós, como invasores, porque nosso dispositivo está sendo sinalizado
como enraizado.
Portanto, conhecemos todas as condições de Trump que terminam aqui nesta parte.
Talvez seja o caso real.
Isso significa que nosso dispositivo é roteado.
E isso significa que cada salto para a condição um e também o rótulo de ir para zero serão feitos ou sinalizados.
Nosso dispositivo está sendo roteado.
Está bem.
Então, vamos limpar isso rapidamente.
Esses três itens significam que os dispositivos são roteados.
Está bem.
Portanto, com relação ao nosso cheque aqui, temos nosso cheque aqui.
Este é um dispositivo roteado.
Então temos.
Verdadeiro.
Os dispositivos são roteados.
E nós temos a Ford.
Verdadeiro significa que terminamos na condição um e também com a ida para o rótulo zero.
Está bem.
Vamos ver onde vamos parar se você quiser obter nossa declaração falsa aqui.
Então, qual instrução de Trump precisamos obter para habilitar esse falso.
Se essa for verdadeira, vamos para baixo.
Portanto, essa é a nossa afirmação falsa.
Ok, então temos isso mais uma vez para o método dois.
Movemos isso em v zero.
Tudo bem, então zeramos mais uma vez, não igual a zero.
Temos exatamente o mesmo código aqui.
Tudo bem.
Aqui podemos ver.
Verdadeiro.
Ainda terminamos na condição um, o que significa que nosso dispositivo está sendo roteado.
Portanto, se este também for falso, vamos nos mover.
Verificado, verificado.
Enraizar o método três na coluna zero errado.
Está bem.
E então temos o if igual a 0v0.
Então, vamos escrever isso aqui.
Então, se.
Nós zeramos.
É igual a zero.
Saltamos para a condição zero.
Se zero for igual a zero, passamos para a condição zero.
Quando o zero é zero, significa que o zero é falso.
Portanto, nosso método de verificação de raiz aqui retornará falso.
Se entrarmos na condição zero e a condição zero for esta aqui?
Portanto, movemos o valor false para o zero.
Em seguida, vamos para a etiqueta, vamos para uma, que é esta aqui, e depois voltamos para fora.
Portanto, isso significa que estamos retornando.
Eu zero.
Está bem.
Se você olhar para isso, deixe-me limpar um pouco.
Está bem.
Portanto, se dermos esse salto aqui, condição zero, e terminarmos aqui, isso se moverá para frente,
para o zero.
E este é um salto que sempre damos se estivermos nessa linha, porque não é uma instrução de salto, uma regra de
ouro e também o rótulo.
Portanto, se terminarmos nessa linha ou, digamos, na condição zero, também daremos esse salto para ir
para um e ir para um simplesmente pulará esse código ruim aqui, o que é verdade.
Passa para v zero, e não é isso que queremos ter.
Portanto, sabemos que nossa condição falsa está definida como, digamos, condição zero.
Agora, vamos ajustar nossos rótulos, independentemente do resultado, para que sempre sigam por este caminho, mesmo que o resultado
tenha sido este.
Assim, nos livramos desse caminho e direcionamos todas essas instruções de salto para esse caminho aqui
à direita.
E podemos fazer isso simplesmente ajustando todos os rótulos à condição zero.
Portanto, se esta é a condição zero e esta é a condição zero e tudo é condição zero, então não há opção
de entrar em outro ramo aqui.
Portanto, não temos opção de entrar nessa.
Essa está fora do ar agora e só podemos chegar à condição zero, o que significa que estamos colocando false no zero e, em seguida,
estamos deixando de fora essa função.
Portanto, esse será um código que nunca mais poderá ser acessado.
Muito bem.
Vamos ajustar esse patch.
Parece um pouco bagunçado, mas acho que sim.
Sim.
Mas espero que você possa acompanhar isso.
Tudo bem, vou esclarecer isso.
E agora vamos fazer o patch.
Tudo bem, ao aplicar o patch, não precisamos considerar.
Oh, agora é apenas uma declaração verdadeira ou falsa.
Temos nossas chaves de teste, ativadas ou não?
Isso é algo com que precisamos nos preocupar se invertermos a lógica, mas não se ajustarmos todos os rótulos aqui.
Portanto, nesse caso, a culpa é simplesmente nossa, esta aqui, e por isso direcionamos tudo para esta
agora.
Portanto, isso se torna a condição zero.
Além disso, isso se torna a condição zero.
Essa também se torna a condição zero.
Tudo bem.
E acho que é isso.
Sim.
Mesmo que essa verificação falhe neste momento, passamos para a condição zero, que é esta aqui.
Tudo bem.
Essa foi a única coisa com a qual tivemos que nos preocupar, porque agora temos uma lógica reversa, digamos,
dessa forma.
Aqui estamos verificando se ele não é igual a zero.
Agora estamos verificando se é igual a zero.
Mas ao alterar o rótulo também para ir para a condição zero, que é.
Pedimos que isso aconteça.
Ele está diretamente abaixo.
Não estou vendo isso.
Está bem.
Se você alterá-lo dessa forma, então, sim, não entraremos nesse código e ele se tornará esse código.
Também estou muito animado com a aparência desse aplicativo.
Se você fizer o patch dessa forma, acho que haverá uma declaração rígida, como return false.
Mas vamos ver.
Está bem.
Uma coisa que eu gostaria de acrescentar a este vídeo é que, se você aplicar patches nesses rótulos, precisará ter muito cuidado,
pois poderá criar acidentalmente loops infinitos e isso pode acontecer com muita facilidade.
Gostaria de mostrar a você o que quero dizer aqui.
Então, aqui, por exemplo, temos esse salto para a condição zero.
Aqui também estamos tendo um salto para a condição zero.
E este aqui.
Aqui estamos tendo um salto adicional para a condição zero.
E aqui estamos com nossa condição zero.
Portanto, essa é a nossa versão corrigida.
E se o compilador estiver criando esse código, ele se certificará de que o fluxo do programa esteja
correto.
Mas agora, se entrarmos nesse fluxo de controle e o corrigirmos, precisamos ter certeza de que o fluxo de controle
ainda está correto, porque o que pode acontecer é o seguinte.
Aqui, estamos tendo agora todos esses rótulos de "chump", duas condições zero.
Então, digamos que este à direita seja o código do nosso programa.
Está bem.
Portanto, aqui temos nosso código de programa e este aqui.
E esse é, por exemplo, o salto para a condição zero.
E vamos escrever da seguinte forma, condição zero.
Esse também é o caso aqui.
E esse também é o caso aqui.
E este aqui.
Condição zero.
E agora, finalmente, temos isso aqui.
Estamos fazendo isso.
Está bem.
Então, este aqui é.
E, finalmente, nossa condição.
Zero.
Não é mais tão simples, mas ainda é nossa condição.
Portanto, isso significa que todos esses idiotas acabam aqui, e isso é perfeitamente aceitável.
Então, aqui estamos nós, acabando com todos esses idiotas.
Tudo bem, até agora está tudo bem.
Mas pode ser que essa condição zero aqui não esteja relacionada aqui em nosso código de programa.
Então, digamos que essa condição zero esteja, por exemplo, entre elas.
Digamos que essa condição seja zero.
Senta-se aqui e este é agora o nosso rótulo de condição zero.
Então, o que está acontecendo agora?
Vamos remover essa parte.
Portanto, agora nossa condição zero está aqui.
E isso significa o primeiro, ou desculpe, esse salto.
O primeiro salto e também o segundo.
Trump está se referindo a este.
Está bem.
Mas agora, agora podemos ter um problema, porque depois desse aqui, estamos tendo um salto para trás.
Esse pode ser um caso inválido.
Por exemplo, se estivermos usando um loop for, também estaremos criando um caso como este.
Portanto, este é o nosso loop for.
E, em um loop de quatro, também temos essas condições, por exemplo, esse bloco aqui.
Assim, dentro do follow, saltamos, por exemplo, de volta para este.
Em seguida, subtraímos menos um de I, vamos escrever um menos menos diferente e, então, deixaremos esse trunfo condicional
nesse loop se I for menor que igual a zero e, em seguida, sairemos desse loop e continuaremos com nosso código
original.
Portanto, esse pode ser um comportamento válido.
Mas, no nosso caso, modificamos esse rótulo Trump e não estamos tendo nenhuma condição quando saímos
desse código.
Isso significa que estamos tendo agora o seguinte caso.
Então, deixe-me esclarecer isso rapidamente.
Portanto, estamos tendo agora essa condição zero.
Digamos que continuemos neste ponto do nosso código de programa e acabemos neste ponto aqui,
neste ponto, estamos voltando à condição zero.
Em seguida, o programa desce novamente até que estejamos novamente neste ponto, oh, estamos pulando de volta
para este ponto mais uma vez, o programa e assim por diante.
Acho que você entendeu o ponto em que estamos agora, sim, um loop infinito.
Loop sem fim, porque não estamos tendo nenhuma condição de sair desse loop.
E esse é o caso porque modificamos instruções adicionais de Trump, por exemplo,
esta aqui.
Quero dizer, não tenho certeza se esse é o caso agora, mas, no nosso caso, vamos
supor que essa tenha sido a condicional um antes, e essa também, se a condicional um estiver embaixo, como essa aqui,
a condicional um e, em seguida,
a Trump estão definitivamente corretas porque foram criadas pelo compilador e o compilador
cuidou dessa aqui.
Quero dizer, o de Trump não precisa ir até lá.
Também pode estar correto se eles forem para cima.
Mas há certas condições para que não acabemos voltando a isso em um loop infinito como
aqui.
Mas se os modificarmos para que não sigam esse caminho, para que voltem à condição
zero aqui, precisaremos realmente cuidar deste aqui.
Tudo bem.
Está bem.
Portanto, se você ajustar muitos rótulos em seu código, talvez seja melhor desenhar isso à direita e certificar-se de que não está
criando acidentalmente um loop infinito, como estamos fazendo neste caso aqui.
Portanto, este aqui é um loop infinito.
Ok, agora vamos voltar ao vídeo e seguir em frente.
Primeiro, aplicamos nosso patch.
Está bem?
Então, clicamos no botão salvar várias vezes.
Muito bem, então criamos esse aplicativo.
Tudo bem.
E não, isso não é possível dessa forma.
ADB em grande estilo porque nosso ipxe nomeou nosso DPC.
Muito bem.
Cópia da tela.
Deslize para cima.
Vamos verificar.
Aqui está.
Também conseguimos corrigi-lo com sucesso.
Sim.
Ao ajustar esses rótulos.
Legal.
Não é impossível.
Sim.
Temos escalas de sorrisos realmente insanas no momento.
Legal.
Tudo bem.
Vamos dar uma olhada rápida na aparência desse aplicativo em relação ao código Java.
Com e verificação de raiz.
Utilizador raiz.
Sim, exatamente.
Eu não pesquisei.
Mas tenho a sensação de que é exatamente isso que está acontecendo.
Tudo bem.
Legal.
Super agradável.
Está bem.
Portanto, também podemos ajustar nossos rótulos, mas precisamos entender o código, o código que está no arquivo do
Visual Studio.
Já fechei esse aqui.
Portanto, se identificarmos qual é a condição em que queremos chegar, podemos simplesmente ajustar todos os outros
rótulos, todos os outros rótulos para saltar para essa condição, que é esta aqui.
Está bem.
Espero que isso ajude você a tentar essa abordagem. Não é tão fácil pensar nisso quando se começa a aprender somali,
mas acho que essa abordagem também pode ser muito útil para você no futuro.
Por isso, gostaria de fazer um vídeo separado sobre isso, pois também não é
muito comum ver isso na natureza.
Ok, isso é tudo por enquanto.
Na próxima seção, daremos uma olhada em objetos e métodos, e isso será ainda mais empolgante porque
inseriremos nosso próprio código na parte somali, não apenas em uma única instrução como esta, mas inseriremos
nosso próprio código.
Então, vejo você lá.