Por que voltar neste vídeo?
Aprenderemos como conectar uma função nativa nesta primavera.
Compare função com liberdade.
Portanto, vamos nos aprofundar diretamente no assunto.
Portanto, aqui estamos de volta à VM do Ubuntu e tenho a maioria das coisas ainda abertas.
Por exemplo, este aqui.
Essa é a função que queremos conectar.
Vamos ver essa função de comparação de strings.
Tudo bem.
Para fazer isso, precisamos obter o endereço e, em seguida, podemos simplesmente usar nosso interceptor dot attach.
E este aqui, por sinal.
Esse não é o endereço.
Esse é o deslocamento nesta imagem aqui.
Portanto, não podemos simplesmente usar esse valor em nosso ponto de interceptação anexado.
Temos que enumerá-lo, mas isso não é nada demais.
Portanto, vamos abrir nosso editor de código e ver como podemos fazer isso.
Portanto, estamos criando um novo arquivo.
Este é o JavaScript.
Portanto, a primeira coisa que precisamos fazer é obter o endereço da função de comparação de cadeias
de caracteres e, em seguida, precisamos nos conectar a ela com nosso interceptor para anexar a esse endereço.
Em seguida, temos nossos retornos de chamada e precisamos imprimir esses parâmetros.
Tudo bem.
E vamos fazer isso aqui.
Então, colocamos este à esquerda e este à direita.
Começamos aqui obtendo o endereço da função de comparação de strings.
Portanto, obter o endereço está dentro do módulo enumerar exportações ou importações.
Portanto, temos que identificar se essa é uma exportação ou uma importação em uma unidade econômica.
Já vimos que se trata de uma importação, mas também podemos pensar nisso.
Essa é uma função que foi definida na Ellipse.
C E essa função está sendo incluída no boleto.
C em nosso código.
Portanto, sabemos que esse é um produto importado.
Vamos também tirar a Frida e colocá-la à direita, pois assim será muito mais fácil brincar
com ela.
Nós nos conectamos a esse processo.
Vamos ver se ele ainda está executando esse aplicativo.
Sim, ele ainda está funcionando.
Então, entramos nesse processo, ele vem embalado e então veremos o Funk da Liberdade.
Não, tenho que procurá-lo no XML do manifesto do Android.
Temos esse nome de pacote.
C liberdade do funk.
Eu li errado?
Está bem.
Isso é um pouco.
Isso é interessante.
Vejamos.
Esse aplicativo ainda está ativo.
Talvez devêssemos tentar reiniciá-lo com liberdade.
Sim.
Não tenho certeza.
Parece estar um pouco atrasado.
Portanto, basta reiniciar esse aplicativo ou fechá-lo e começar com liberdade.
Tudo bem.
Então, agora vamos ver um ponto de módulo enumerar as importações.
Essa é uma função que requer a biblioteca que queremos enumerar, e podemos obtê-la no diretório
libs.
Aqui temos um lábio de traço nativo iluminado como, a propósito, se você estiver olhando para a atividade principal,
o lábio na frente não é mencionado aqui.
Portanto, aqui só temos o nativo dash lip e, por isso, acho que a melhor maneira é simplesmente verificar esse diretório lip
aqui e retirar todo o nome da biblioteca desse diretório.
Muito bem.
Está bem.
Então, deixe o Native Dash.
Vamos ver se isso funciona.
Perfeito.
Agora podemos ver que temos todas essas funções livres.
Senhora, preparar, senhora.
Copiar, malloc e assim por diante.
Aqui temos nossa comparação de strings.
Mas não queremos fazer isso o tempo todo dessa forma, procurando manualmente por esse valor.
Portanto, estamos adotando nossa abordagem, iterando sobre essa matriz e encontrando esta.
Também podemos ver que essa função foi importada do ponto de elipse so, exatamente o que
pensamos.
Vejamos.
Isso funciona.
Portanto, nós o copiamos.
Aqui estamos criando um novo array, importando a função array.
E aqui temos este.
Em seguida, precisamos iterar sobre essa matriz.
Portanto, aumente um pouco o tamanho e importe a matriz de funções para cada uma delas.
Em seguida, temos nossa função anônima e, dentro dessa função, temos nossos elementos.
Está bem.
E agora esse é um único elemento que tem um endereço, módulo, nome e tipo.
Isso significa que se o nome do ponto do elemento e, em seguida, inclui.
Sim.
Isso inclui o que temos.
Compilador de strings.
Acho que foi uma comparação de strings.
Em seguida, imprima-o e bloqueie o elemento do nome no console e o elemento do endereço no console.
Vamos ver se isso funciona.
Sim.
Temos um compere de cordas neste endereço.
Legal.
Portanto, agora podemos criar nosso novo endereço.
Muito capaz.
E podemos atribuir esse endereço aqui.
Ok, isso definitivamente não é bom.
Não é um bom nome para essa pessoa.
Em risco de descendência.
Compare.
Talvez.
Vamos fazer desta forma.
E este é igual ao endereço de início do elemento.
Muito bem, agora temos o endereço e podemos usar nosso interceptor dot attach.
Portanto, oops de interceptor em maiúsculas.
Não anexado.
Então, temos nosso endereço.
Offspring COMPERE E então temos nossos retornos de chamada e estamos clicando duas vezes nisso.
Entre colchetes, digite.
E, em seguida, temos nosso retorno de chamada na entrada, que tem nossos argumentos.
E este é importante no momento x e vamos ver.
E zero é o nosso valor e x um e esse é o valor da bandeira.
Está bem.
Então, aqui temos esses retornos de chamada de entrada.
E isso significa que queremos imprimir talvez ambos.
Assim, saberemos o que inserimos e com o que foi comparado.
Preciso adicionar o espaço aqui agora para imprimir esse valor.
Temos que aprender algumas coisas novas.
Mas, primeiro, vamos fazer isso de maneira simples.
Talvez digamos que o parâmetro um seja igual
a zero e
o parâmetro dois seja igual a x um.
Talvez possamos ver se estamos conseguindo pelo menos alguma coisa aqui e depois temos essa única função.
Que é o valor de retorno.
E isso é muito interessante porque, se você estiver dando uma olhada nesta, se estiver usando
a cadeia de caracteres da página principal, compare-a aqui.
Podemos ver as comparações de strings retornando um valor inteiro.
Podemos descobrir com base no que exatamente está faltando?
Sim.
Está bem.
Isso não é tão fácil de entender.
Vejamos.
Sim.
Para ser sincero, não estou gostando nada disso.
Tenho que procurar em outro lugar.
Está bem.
Por isso, gosto de usar a referência do C++ ponto com.
Vamos ver se é um pouco mais fácil lá dentro.
Está bem.
Vamos rolar a tela um pouco para baixo.
Sim.
Parâmetros de retorno.
Legal.
Portanto, isso parece um pouco ou um pouco mais compreensível.
Aqui está.
Será que é tão difícil dar uma explicação fácil para esse caso?
Se o valor de retorno da comparação de cadeias de caracteres for definido como zero, então as duas cadeias de caracteres estão sendo iguais.
Isso significa que também podemos alterar o valor de retorno da string em comparação para influenciar todo o nosso
resort.
O aplicativo pode pensar que o resultado está correto e executa todas as outras coisas que estão lá.
Portanto, essa pode ser uma solução incrível que funciona.
Depende do caso de uso em relação ao nosso caso de uso, em que precisamos obter essa chave do aplicativo.
Não é uma possibilidade, mas talvez para outros.
Está bem.
Portanto, agora sabemos que a opção de conectar o valor de retorno é uma opção, mas gostaríamos de observar esses parâmetros.
Está bem.
Então, vamos voltar ao assunto.
Isso significa que, aqui, podemos simplesmente imprimir o valor de retorno.
E este é o valor de retorno.
E isso está sendo impresso aqui.
Está bem.
E vamos ver se isso funciona.
Portanto.
Sim.
Com relação a esse, não estamos imprimindo-os no momento.
Acho que estamos apenas recebendo os endereços.
Mas vejamos, eu colei e essa não é uma boa abordagem.
Portanto, devemos reiniciar esse aplicativo.
E depois retomar.
E agora estamos colando.
E aqui está.
Agora vamos voltar à tela do smartphone.
Eu acertei o check-in por 3 a 1.
Tudo bem.
O que acontece aqui?
O que acontece é que temos muitas funções de comparação de strings em nosso método aqui.
Portanto, agora estamos conectando todas as funções de comparação do Spring nesse aplicativo.
Quero dizer, parece funcionar e tem um visual absolutamente fantástico.
Mas acho que isso não é algo que queremos ter.
No entanto, vamos primeiro descobrir como podemos imprimir esses parâmetros.
E assim faremos.
Encontraremos uma solução para nos concentrarmos apenas em nossa contribuição aqui.
Muito bem.
Está bem.
Então, voltemos ao nosso script e a este aqui.
Acho que esse é um valor de retorno.
Podemos usar nossa abordagem em duas polegadas 32.
Vejamos.
Este não.
E aqui está.
Portanto, precisamos sair dessa situação.
Ops.
Em seguida, precisamos reiniciar esse aplicativo e retomá-lo para podermos usá-lo.
Então vamos ver.
Estou acertando o clique ou o check-in em 3 para 1.
Muito bem.
Aqui podemos ver que agora temos valores inteiros.
E, no entanto, também vimos que eles podem ser maiores, menores ou zero.
Depende do fato de a string ser igual ou não.
Aqui podemos ver, por exemplo, que há duas cadeias de caracteres idênticas relacionadas a essas referências.
Portanto, vamos ver como podemos imprimir essas cadeias de caracteres por trás desses endereços.
Infelizmente, acho que nossa abordagem de conversão de tipo Java não funciona aqui.
No entanto, vamos tentar fazer isso rapidamente.
Portanto, precisamos de nossa referência de classe de string, Java use e, em seguida, Java Lang string, e precisamos fazer o typecast.
Portanto, as instâncias são iguais ao Java cast.
E então, vejamos.
Não tenho mais certeza sobre isso.
Portanto, temos que examinar a documentação.
Então, dentro do roteiro de viagem, estamos procurando o elenco.
Sim, temos que usar o Java cast.
O primeiro argumento é o nosso ponteiro e o segundo é a classe para a qual queremos fazer o typecast.
Se voltarmos para este, isso significa que este é zero.
Esse é o nosso indicador.
E, a propósito, neste momento ele está em zero.
Por quê?
Porque não estamos mais na função de decaimento.
Portanto, nosso primeiro parâmetro não é um ponteiro de ambiente relacionado ao Java e à deterioração.
Agora, esse é realmente um argumento que foi fornecido à string.
Compare este aqui.
E esse é o nosso s um e o nosso argumento um é o nosso is dois.
Muito bem.
Portanto, não estamos mais dentro da palavra k.
No momento, estamos na palavra C++ simples.
Portanto, todos os argumentos são exatamente como os temos nessa definição de função aqui.
Ok, vamos fechar isso e ver.
Atos 1a0.
Desculpe.
E esta é a nossa referência de classe de string.
Então, vamos ver se podemos fazer isso dessa forma.
Isso deve ser alterado como um suporte único.
Então, vamos sair.
Sue.
Estamos entrando na abertura deste aplicativo, 3 a 1.
OC ele trava para que possamos ver.
Sim, erro de detecção de olho em cadeia, objeto em cadeia e coisas desse tipo que não podemos usar e fazer typecast
da nossa referência de string Java para essa referência aqui.
Agora, trata-se de uma cadeia de caracteres C simples e, portanto, não é possível fazer a digitação dessa forma.
Agora, a questão é: como podemos acessar esse valor?
E, infelizmente, desta vez a resposta não pode ser encontrada na documentação oficial.
Não sei por que, mas não é nada demais.
Eu lhe mostrarei como podemos fazer isso.
E quero dizer, então temos tudo pronto.
Você só precisa assistir a esses vídeos se quiser saber como imprimir parâmetros de indicação, avião,
ver parâmetros ou parâmetros de viagem.
Muito bem.
Está bem.
Então, vamos voltar ao nosso código.
Este aqui.
Portanto, este não está funcionando.
Isso é ruim.
Não é a pergunta.
Como está funcionando?
E temos no freedom outro objeto interessante, que é o objeto de memória.
Portanto, podemos usar a memória.
E então temos esse método.
Vejamos, vamos reiniciar esse aplicativo.
Memória.
Certo.
Além disso, temos muitas coisas para ler e ver.
Esse não é o ponteiro para ler a string UTF eight.
Tudo bem.
Esse é o método que queremos usar.
E também aqui temos que fornecer um ponteiro e um endereço para essa função.
E essa é agora nossa arte em zero.
Está bem.
Vamos ver se isso funciona.
E cole-o.
Ganhei do frango por 3 a 1.
E podemos ver.
Sim, parece funcionar.
Temos essa corda aqui.
Parâmetro um, temos este aqui, mensagem do sistema operacional Android e coisas do gênero.
Portanto, não parece ser assim.
Funcionou, mas parece estar funcionando.
Sim, acho que é assim que funciona.
Tudo bem.
Portanto, é assim que podemos imprimir uma string em relação a uma função C simples no freedom.
Vamos fazer o mesmo com a outra parte e com esta aqui.
Então, copiamos isso.
E estamos usando este telefone aqui.
Eu sinto muito.
Não é este aqui.
Muito bem, vamos ver se ainda funciona e, em seguida, também podemos compará-los e ver os resultados, se realmente estiver
funcionando.
Estamos reiniciando esse aplicativo ou preciso fornecer esse gancho de atributo de não aprovação em 3 para 1.
E vejamos, esse era um fio.
Este é o outro.
Eles não são iguais.
Vamos encontrar algumas cadeias de caracteres que tenham sido iguais.
É isso aí.
Sim.
Sistema operacional Android e sistema operacional Android.
E essas cordas têm sido iguais.
Portanto, esse valor de retorno é zero.
Legal.
E isso significa que, ali, precisa haver nossa bandeira.
E também a outra parte que foi comparada.
Como podemos encontrar isso agora mesmo?
Quero dizer, poderíamos salvar isso em um arquivo externo e navegar por ele.
Mas essa não é a ideia.
A abordagem mais fácil é a pasta.
Se tivermos isso aqui, podemos escrever uma instrução if mais uma vez, por exemplo, podemos dizer
if isso aqui.
Talvez devêssemos escrever isso em uma variável e nomeá-la.
Usamos uma entrada.
Está bem.
Essa é a nossa entrada de usuário.
E agora estamos pesquisando todas as funções de composição de string que têm um argumento com a entrada
do usuário.
Isso significa que esta é a função de comparação de strings que está sendo usada aqui.
Muito bem.
Está bem.
Portanto, se a entrada do usuário incluir e, em seguida, vamos ver o sinalizador.
E então queremos imprimir esses dois parâmetros.
Tudo bem.
E isso deve funcionar.
O que estamos fazendo no momento é o seguinte.
Vamos desenhar isso rapidamente.
Está bem.
Em nosso interceptor attach e neste aqui, agora estamos conectando todas essas funções de
comparação de strings e comparando o parâmetro um e o parâmetro dois.
E obtemos muitos resultados se você estiver usando este aqui.
Portanto, trata-se de uma grande quantidade de resultados.
Vimos isso no exemplo anterior.
Portanto, queremos limitá-lo e estamos limitando-o da seguinte forma.
Estamos obtendo nosso ARX zero, que é a entrada do usuário neste aqui, e agora estamos dizendo ao freedom para imprimir
apenas esses parâmetros de comparação de strings.
Ou seja, ainda estamos conectando-os, mas só os imprimiremos se esse parâmetro aqui contiver
esse sinalizador de palavra, que é este aqui.
Se esse for o caso, nós o imprimimos, o que significa que não estamos tendo esses menus no momento.
Temos apenas esses dois que comparam nossa bandeira com o valor.
Ou seja, se tivermos várias cadeias de caracteres que contenham o sinalizador,
precisaremos escolher um payload diferente aqui, talvez um, dois, três, cinco, quatro, seis, oito, seis, sete, nove, um.
Se estivermos fornecendo esta aqui como a entrada do usuário, poderemos pesquisar no ARX zero
essa entrada do usuário e, ao fazer isso, poderemos limitá-la a imprimir apenas esta, essa função de comparação de
strings.
Muito bem.
Quero dizer, ainda estamos conectando-os e isso pode ser um pouco lento, mas estamos imprimindo
apenas este.
Vamos tentar isso.
Ok, então limpamos a tela e agora vamos ver.
Portanto, vamos encerrar esse caso.
Reiniciamos.
Está bem.
Agora, eu colo o script e você faz a verificação em 3 para 1.
Tudo bem, podemos ver que o Flex parece estar sendo contido muito, muito mais frequentemente do que o esperado.
Não, desculpe.
Isto é.
Esse é o valor de retorno.
Minha culpa é que ainda estamos imprimindo todos esses valores de retorno e podemos ver que tenho que fechar este.
Isso está fora de controle no momento.
Vamos encerrar o assunto.
Muito bem.
Você pode ver o abraço e ver a função um pouco bagunçada.
Tudo bem.
Eu não tinha pensado nisso.
Ainda estamos imprimindo o valor de retorno.
Portanto, isso também é aceitável.
Nunca.
Não importa.
Basta mantê-lo dessa forma.
Portanto, estamos apenas ignorando o valor de retorno neste momento.
Vamos tentar mais uma vez.
Está bem.
Nós o colamos e verificamos 3 para 1, então o temos.
Legal.
Só temos um.
Sim, temos apenas um e podemos ver que o parâmetro um é a bandeira.
Essa é a nossa entrada de usuário e aqui podemos ver o parâmetro dois, que libera os ganchos.
Muito bem, liberamos os ganchos de forma insana.
Isso significa que esta é a nossa bandeira que está sendo comparada com o nosso valor aqui.
Perfeitamente agradável.
Se você alterar esse e ver apenas a bandeira, poderemos verificar agora que estamos fornecendo apenas a bandeira.
Certo, perfeito.
Isso significa que, mesmo que você esteja conectando essa cadeia de caracteres ou comparando funções que são muitas, podemos limitar
a saída àquelas em que estamos interessados.
Este aqui, podemos defini-lo ou manipulá-lo de alguma forma, usando um identificador exclusivo e verificando
esse identificador em nosso argumento.
Quero dizer, a bandeira também está sendo incluída nesta aqui.
E deixe-me falar novamente sobre isso.
Podemos ver que ele também está incluído no parâmetro dois, mas esse não está sendo verificado, apenas o que estamos fornecendo
no parâmetro um, que também está incluído no código-fonte aqui.
Quero dizer, para ter 100% de certeza, podemos escolher um mais exclusivo.
E, por exemplo, múltiplos três, quatro, cinco, seis e um pequeno erro de digitação nove, oito zero.
Vamos fazer isso aqui também.
Um, dois, três, quatro, cinco, seis, 7980.
E vamos reiniciar esse aplicativo.
Currículo médio.
Aqui está.
E agora vamos colá-lo neste aqui.
Se for o caso, vamos verificar se você está usando FLAC, pois assim não veremos nenhuma saída.
Mas se você estiver usando o 1234567980.
Então, podemos ver que temos nossa saída aqui.
Tudo bem.
Esse é um truque incrível, absolutamente útil.
Se voltarmos a este, talvez também possamos ver como podemos conectar esse valor de retorno aqui.
Pode ser interessante ver qual é o valor de retorno dessa função.
E se habilitarmos este aqui, estaremos conectando novamente todos os valores de retorno, o que definitivamente
é algo que não queremos ter.
Obtemos muitas saídas para obter apenas o valor de retorno disso.
Em uma dessas funções de comparação de strings, precisamos usar ou introduzir uma nova variável porque essas funções
são independentes e, portanto, não podemos fornecer um parâmetro para a outra.
Mas, quero dizer, podemos definir isso globalmente.
Então, vejamos, estamos criando aqui uma nova função e esta está definida como false, um valor booleano.
Tudo bem.
Se estivermos dentro de nossa função, estaremos definindo esse valor como verdadeiro.
E se esse for definido como true, então estaremos imprimindo o valor de retorno.
Está bem.
E, depois disso, precisamos defini-lo como falso mais uma vez, pois, caso contrário, todos esses valores
de retorno seriam impressos após essa função.
Está bem.
Então, vamos elogiar isso rapidamente, apresentando o novo estado para obter o ou, digamos, para.
Imprima apenas o valor de retorno de nossa string.
Compare.
E aqui, verificando se essa é a nossa comparação de strings na qual estamos interessados, e aqui, definindo-a novamente
como falsa.
Caso contrário, todos os valores de retorno posteriores seriam impressos.
Muito bem.
É isso que essa nova variável faz.
Vamos ver se isso funciona.
Portanto, fechamos e reiniciamos o processo.
Retomamos e, em seguida, você pega o roteiro.
Talvez eu faça isso um pouco maior.
Sim, podemos usar todo esse OC e o colamos.
Verde.
Sim, isso deve funcionar.
Então vamos ver.
Estamos nos abraçando neste momento por causa disso.
Se clicarmos em verificar, nada.
Não aparece nada, o que é bom.
Mas se você estiver fazendo um, dois, três, quatro, cinco, 67980.
E, mais uma vez, o cheque foi dado em 3 a 1.
É isso aí.
E também podemos ver o valor de retorno.
Não é idêntico.
Legal, não é?
Vamos verificar se esse está realmente funcionando.
Portanto, vamos fornecer também este aqui.
Então, temos que fazer esse ajuste mais uma vez.
Sim.
Portanto, temos que reiniciar esse aplicativo.
Currículo.
Ou seja, você também pode aplicar isso sem pausa.
Não sei por que não o estou usando, então é um pouco irritante, mas sim, fique à vontade para usá-lo.
Ok, então estamos aplicando este e vamos ver agora que temos o sinalizador original e este agora
deve retornar um valor de retorno de zero e vamos ver.
E 3 para 1 líquidos, então podemos ver que esse é definitivamente o valor de retorno.
Sim.
Com relação à nossa função aqui, estamos realmente precisos com nosso gancho no momento.
Portanto, se voltarmos, agora estamos apenas imprimindo a comparação de strings aqui e aqui e não outra.
Quero dizer, com relação ao gancho, estamos definitivamente enganchando todas as outras comparações de strings, mas não
as estamos imprimindo.
Muito bem.
Está bem.
Então, este aqui é incrível e esse truque é muito legal.
Ele será muito útil se você estiver fazendo engenharia reversa de bibliotecas nativas e quiser conectar determinadas funções,
por exemplo, funções de biblioteca C.
Está bem.
Talvez uma última coisa com relação a este aqui.
Essa abordagem, que vi no comentário do desenvolvedor gratuito, de que a leitura de oito cadeias de caracteres UTF pode,
às vezes, não funcionar, é também uma função adicional que tenta ler e as cadeias de caracteres.
Infelizmente, isso é muito complexo no âmbito da liberdade.
Portanto, o free que não sabe até o momento que tipo de string tem e esses tipos são diferentes.
Portanto, temos que experimentá-lo.
Se alguma delas funcionar nesse caso, a leitura de oito cadeias de caracteres UTF funcionará perfeitamente.
Mas também gostaria de mencionar que temos outras funções.
Por exemplo, este aqui, talvez seja melhor verificarmos em liberdade, pois não consigo me lembrar
mais corretamente.
Então, vamos fazer isso aqui, certo?
Acho que sim.
Sim, é uma corda C.
Está bem.
Essa também é uma função que tenta ler e extrair uma cadeia de caracteres de um endereço.
E, sim, se essa abordagem UTF eight não funcionar, podemos tentar esta aqui.
Talvez.
Vamos ver se isso funcionaria.
Portanto.
Ou você sabe o quê?
Vamos mantê-los aqui.
E agora vamos lá.
Vamos fornecê-los aqui.
Está bem.
E aqui temos que inserir X zero.
Isso não é R0.
E aqui temos que inserir.
Box one, e precisamos nos certificar de que também estamos obtendo ou ajustando essa caixa.
Vamos ver se isso funciona.
Também não tenho certeza sobre isso, mas pode ser útil.
Então vamos ver.
Estamos reiniciando esse aplicativo.
Ah, nós retomamos.
Fornecemos nosso script e temos que fornecer o sinalizador correto.
Está bem.
E vamos ver.
Três, dois, um.
Sim.
Sim, funciona.
Perfeito.
Portanto, caso uma abordagem não funcione, basta tentar a outra.
Portanto, na folha de dicas, também fornecerei algumas outras.
Não podemos falar sobre todos eles e também não está claro quando devemos usar o quê, porque isso realmente
depende da biblioteca e isso é algo que não podemos fazer engenharia reversa ou descobrir.
Para esse caso, é apenas um erro de tentativa.
Se encontrar alguns erros, dê uma olhada na folha de dicas.
E se ainda encontrar erros, escreva-me uma mensagem.
Eu também prometi a você que temos várias abordagens e uma delas é que isso também
é incrível, pois na Chitra temos essa função aqui neste endereço.
É claro que esse não é o endereço real, mas podemos criar um gancho que seja realmente preciso nesse endereço,
de modo que possamos dizer ao freedom para que ele conecte apenas essa única função aqui.
E isso é incrível, porque vamos supor que não tenhamos acesso fácil aos nossos parâmetros de entrada, mas
queremos descobrir o que está acontecendo lá, então podemos conectar a função nativa, mas e então obteremos
muitos resultados.
Portanto, uma tonelada de produção, o que resulta em apenas um gancho.
Exatamente.
Nesse ponto, isso seria muito bom.
Certo?
Vamos resolver isso.
Mas, desta vez, não estamos fazendo isso em um formulário inteligente real.
Portanto, não estamos fazendo isso aqui.
Estamos usando a máquina virtual.
Prepararei uma seção bônus completa sobre a depuração de dispositivos Android e também de aplicativos na máquina
virtual.
Mas, com relação aos dispositivos Android, temos que levar em conta muitos aspectos, o que tornaria este vídeo desnecessário.
Mas na máquina virtual é muito mais fácil.
Portanto, estamos fazendo essa abordagem lá.
Mas não se preocupe, pois, na seção de bônus, você obterá todas as informações
necessárias para realizar um trabalho preciso como esse aqui no seu dispositivo.
Por enquanto, vamos parar com isso aqui e colocar nossa máquina beta, certo?
Se estivermos usando uma máquina virtual, vamos ver se essa máquina ainda está em execução.
Sim, ainda estamos conectados a esse dispositivo e temos apenas um dispositivo ADB.
Portanto, se você ainda tiver vários dispositivos listados, a maneira mais fácil é simplesmente desconectar
o dispositivo e, em seguida, usar o servidor ADB Kill Dash e reconectar-se à máquina virtual.
Sim.
E então devemos ter acesso a este.
Tudo bem, perfeito.
Já podemos ver que temos um prompt x 86, o que significa que, se quisermos conectar uma biblioteca na versão
x 86, teremos que usá-la também dentro dela.
Portanto, precisamos carregar isso no Twitter porque todos esses endereços e extrações serão alterados.
Esta aqui é a arquitetura e é completamente diferente da x 86.
Tivemos uma pequena seção sobre isso e o smartphone está usando uma arquitetura ARM, enquanto o seu
PC está usando uma versão X86.
Tudo bem.
Portanto, isso significa que precisamos encerrar esse projeto e nos aproximar dele.
Tudo bem.
E depois temos isso aqui.
E esse é o nosso projeto.
Portanto, podemos permanecer em nosso projeto e incluir essa biblioteca mais uma vez, mas desta vez para a versão
x86.
Então, vamos fazer isso.
Estamos abrindo o navegador de código e, em seguida, dentro do arquivo de importação de arquivos, estamos
selecionando não este, mas o x 86, caso estejamos usando a versão x86 e 64 bits, então é claro que você
precisa usar o x86 64.
Os endereços também podem mudar, mas a abordagem é a mesma.
Então, você está pronto para ir.
Também usando este aqui, farei isso para a versão de 32 bits.
Então, selecionamos esse arquivo para ser importado e agora podemos ver que ele já existe.
Portanto, com qualquer nome de programa, temos que fazer um ajuste e eu simplesmente nomeio esse salto
como native x 86.
Podemos ver que ele foi detectado automaticamente pela Chitra e tudo o que precisamos fazer é simplesmente carregar
isso.
Está bem.
E então temos uma varredura rápida que busca todas essas informações.
E agora, mais uma vez, esse pequeno nativo x 86 não foi analisado.
Você gostaria de analisá-lo agora mesmo?
Continuo dizendo que sim.
E, desta vez, não temos esse localizador de instruções agressivo e, desta vez, estamos usando apenas esse ID de parâmetro
compilado.
Och, esse x 86 não tem modos como arm ou thump.
Portanto, também não estamos tendo esse descobridor de instruções agressivo aqui.
Também podemos ver que algumas bibliotecas não foram encontradas, mas isso não é nada demais.
Essas também são apenas bibliotecas externas e estamos interessados nessa função que é usada nessa lista,
portanto, podemos simplesmente ignorá-la.
Está bem.
Podemos ver que ele está sendo analisado também na parte inferior.
Certo.
Agora, temos que esperar até que este seja concluído.
Ele já foi concluído.
E vamos voltar à nossa árvore de símbolos.
E estamos procurando por esconde-esconde mais uma vez.
Quero dizer, os símbolos são os mesmos em relação ao nome, mas agora podemos ver que o resultado é um
pouco diferente.
Sim.
Temos mais algumas coisas aqui.
E também podemos ver este.
É sim, essa tipificação aqui é um pouco mais confusa.
No entanto, vamos pegar um tablet gráfico e fazer uma análise rápida aqui.
Muito bem, vamos fazer isso.
Bem, aqui temos nosso tablet gráfico e vamos cultivar maçãs.
Então, aqui no primeiro parâmetro, esquecemos mais uma vez o nosso ponteiro de ambiente, este
aqui, este é o nosso objeto this.
E aqui no parâmetro três, estamos tendo nossa cadeia de negociação.
Portanto, este é o nosso objeto ou a nossa, digamos, entrada de usuário.
Com relação a esses parâmetros, é exatamente a mesma coisa.
E vamos renomear isso para que possamos fazer isso clicando aqui e pressionando a letra L neste.
E esse é o nosso ambiente e ponteiro.
Eu sinto muito.
Ponto de ambiente agora.
E este aqui.
Este é o nosso.
Esse objeto.
E esta é a nossa entrada de usuário.
Está bem.
Agora vamos rastrear essa entrada do usuário.
Está bem.
A entrada do usuário está sendo atribuída ao local 64.
Portanto, também precisamos renomear a entrada do usuário.
Ops.
E, desta vez, parece ser em um bar local.
Vejamos.
Nossa contribuição de usuário também está sendo usada no Local 14.
Este aqui e aqui podemos ver, mais uma vez, a cadeia de caracteres UTF, nosso ponteiro de ambiente e este aqui
é um endereço.
Não nos importamos com esse até que tenhamos nossa entrada de usuário, o que significa que isso será feito depois de nossa entrada
de usuário.
Portanto, essa também é a nossa entrada de usuário.
Temos muitas entradas ou referências de usuários aqui.
E, mais uma vez, dentro dessa comparação de strings, podemos ver que temos a entrada do usuário.
Legal.
E esta está em uma variável local e podemos ver que ela não foi definida.
Quero dizer, neste aqui, não estamos conseguindo imprimir esse belo texto, então ele não está aparecendo neste aqui
e não está mostrando nossa bandeira no momento.
Portanto, o sublinhado local para ver essa é a nossa bandeira.
Mas, desta vez, não estamos tendo acesso tão fácil a ele.
Portanto, queremos conectar essa função, essa função de comparação de strings.
Talvez devêssemos esclarecer isso.
Portanto, queremos conectar essa função.
E, mais uma vez, queremos observar esse parâmetro.
E também queremos observar esse parâmetro.
Essa é a nossa bandeira.
Está bem.
Portanto, vamos dar uma olhada nesse caso.
Este é o endereço.
Mas esse não é o endereço do dispositivo.
Se passarmos o mouse sobre ele, obteremos muitas informações úteis.
Então, passo o mouse sobre esse endereço.
Sim.
Então, deixe-me limpar a tela, talvez.
Está bem.
Portanto, aqui temos um deslocamento baseado em imagem, este aqui.
E isso significa o seguinte.
Nossa biblioteca, nossa biblioteca nativa, a biblioteca.
Como tudo isso será carregado em um anúncio e em um deslocamento fixo, isso significa que o valor será adicionado
a ele.
Digamos que o valor seja 0x1.
Nesse valor, por exemplo, não precisa ser esse valor e isso realmente não importa.
E Chitra está carregando essa biblioteca nesse endereço fixo e, portanto, agora temos esse deslocamento.
Portanto, em mais oito D, seis C, esse é um valor hexadecimal mais esse deslocamento, agora podemos encontrar essa instrução, essa função de
comparação de strings.
Recebemos apenas alguns itens adicionais.
Vejamos.
Temos o deslocamento do bloco de memória, mas, para ser honesto, podemos ignorá-lo.
Isso não é realmente relevante.
E então obtivemos a função offset, que também pode ser muito útil.
Nossa função é chamada de esconde-esconde.
Portanto, em nossa biblioteca, temos essa função.
Esconder e procurar.
E assim por diante.
E agora estamos tendo um deslocamento dessa função para esse ponto.
Digamos que este é o ponto em que a comparação de strings
está agora e este é o deslocamento aqui mais zero x CC.
Portanto, esse é o deslocamento da função para a comparação da string aqui.
Acho que mais tarde iremos até este e depois veremos este.
Tudo bem.
E depois temos este.
Quero dizer, é exatamente a mesma coisa aqui.
Isso significa que, a partir do ponto de partida dessa biblioteca, a biblioteca de traços negativos é toda acrescida desse
valor, e esse é o valor que será usado posteriormente.
Portanto, estamos usando esse deslocamento para identificar onde essa função está localizada em nossa máquina virtual.
Tudo bem.
Portanto, isso foi muito importante no momento, e estamos nos aprofundando bastante na engenharia reversa dessa biblioteca
nativa.
Vamos tentar resumir isso rapidamente.
O que é importante?
A parte importante é que identificamos onde a entrada do usuário será comparada.
Essa é a função que precisamos conectar.
Nesse caso, trata-se de uma comparação de cadeia de caracteres aqui e, desta vez, não queremos enganchar todas as comparações de cadeia de caracteres.
Queremos apenas conectar essa função de comparação de strings.
Portanto, precisamos obter o endereço deste.
Mas este aqui não é o endereço real porque o smartphone está carregando essas bibliotecas em
diferentes pontos.
Ele também pode mudar toda vez que iniciarmos um aplicativo.
Talvez.
Vamos falar sobre isso rapidamente.
E esse aplicativo está carregando muitas bibliotecas.
Por exemplo, esta aqui, nossa biblioteca nativa, a biblioteca.
Portanto, haverá também outra, por exemplo, a lib C.
Vamos ver também.
E haverá muitas outras bibliotecas que foram carregadas.
Todos eles agora serão atribuídos a determinados endereços de memória, como, por exemplo, sete, H, B, B e assim
por diante.
E este estará em zero X, sete F e assim por diante.
Isso significa que, com base no layout da memória do nosso smartphone, estamos obtendo endereços diferentes
e, por exemplo, este aqui.
Portanto, o que Chitra está fazendo é o seguinte.
E Chitra está carregando essa biblioteca em sua ferramenta.
E ela se dirigiu ao fornecimento de um endereço base, por exemplo, zero x dez 000000.
E, a partir desse ponto, tudo estará alinhado e será sempre igual com base nisso.
Esse é o endereço base.
Portanto, sempre que fornecemos o mesmo endereço base, temos nossas funções no mesmo ponto.
Por exemplo, este aqui.
Essa é a nossa função.
Esconder e procurar.
Tudo bem.
Está bem.
Portanto, essa é a diferença entre esse endereço e a função free to, que é zero x dez.
E não tenho mais certeza.
Digamos que seis C seja diferente do endereço real nesse dispositivo.
Portanto, agora podemos dizer que estamos obtendo uma vez o endereço real em nosso dispositivo
e este aqui, e então podemos aplicar todos esses patches nesse endereço.
Sim.
E isso normalmente funcionaria, mas não mais nos smartphones modernos, porque toda vez que estamos reiniciando
um aplicativo.
Portanto, toda vez que ele for reiniciado.
Esses endereços mudam.
Portanto, depois disso, isso pode ser 0x7200 dez.
O motivo dessa alteração é o recurso de segurança, denominado randomização do layout do
espaço de endereço LR.
Então, vamos supor que identificamos um estouro de buffer em nosso aplicativo e, por exemplo, nesta biblioteca em um determinado
ponto, digamos, aqui.
Portanto, aqui estamos tendo um estouro de buffer.
O que um invasor faz é o seguinte: o invasor pula para uma determinada função
e, por exemplo, a função do sistema em nosso loop.
C e, em seguida, está executando um comando ali.
Ao ter uma randomização de layout baseada em endereço.
O invasor pode substituir esse endereço nesse momento, mas não sabe onde o Lipsey do sistema
está localizado.
Existem algumas contramedidas com relação a isso, do ponto de vista de um invasor.
Mas vamos tornar isso não muito complexo para que o invasor possa sobrescrever esse ponteiro nesse endereço e o
invasor possa tomar a decisão de onde queremos avançar no programa.
Mas se estivermos atribuindo sempre um novo endereço ao endereço base, esse layout aqui
mudará.
Portanto, neste caso, o deslocamento ainda é o mesmo.
Mas neste caso, por exemplo, não é mais dez e agora é 721.
Talvez ele esteja localizado agora no número 710 ou talvez em um número completamente diferente, 80, 20 e coisas do gênero.
Isso significa que o endereço que será codificado aqui, neste caso, não pode ser confiável, será usado para saltar para
uma determinada função dentro do binário da biblioteca.
Está bem.
Isso agora está se aprofundando muito na exploração, que também não é o tema deste tópico.
Gostaria apenas de salientar que sim.
Que não podemos confiar nesses endereços Chitra e que também estamos recebendo sempre um novo endereço aqui
ao reiniciar o aplicativo, portanto, também não podemos confiar nesses valores fixos.
Ok, esse é o motivo por trás disso.
É uma contramedida.
Ele é chamado de LR e é bom tê-lo em nosso smartphone, para ser honesto.
Está bem.
Então, agora vamos voltar ao nosso tópico principal, que é conectar essa função,
essa função de comparação de strings que está aqui.
Agora sabemos por que não podemos simplesmente usar esse endereço aqui.
Isso mudará e mudará toda vez que lançarmos esse aplicativo.
Mas o que não muda é o deslocamento, este aqui.
Esse deslocamento não altera a biblioteca iluminada.
Este aqui.
Isso muda.
Mas não a compensação.
Portanto, está absolutamente claro o que precisamos fazer.
Quero dizer, não agora, mas se tivermos feito isso uma vez, ficará claro que precisamos obter o endereço desta
biblioteca, desta, deste endereço, e podemos fazer isso com liberdade, o que é absolutamente incrível.
Portanto, podemos dizer ao free que, para buscar esse endereço dessa biblioteca, precisamos adicionar esse deslocamento a
essa biblioteca.
E isso é compensado, o que significa que acabamos neste endereço.
Com esse endereço, podemos usar nosso interceptador.
Interceptor dot attach nesse endereço e, em seguida, também podemos fornecer nossos retornos de chamada.
Desculpe-me, mas o suporte não está perto disso.
Temos que fornecer nossos retornos de chamada.
Portanto, acho que não é a escrita mais limpa, mas acho que sabemos o que temos aqui.
Talvez.
Vamos fazer isso.
Chamadas de retorno.
Muito melhor, eu acho.
Está bem.
No entanto, faremos isso depois.
Portanto, este é o nosso plano.
E, com esse plano, estamos apenas conectando esse endereço aqui.
E esse endereço é esse composto de string única.
Isso significa que estamos tendo acesso a esses parâmetros.
Onde eles estão?
Aqui.
E este e também este.
Assim, podemos imprimi-los depois e fazer um gancho realmente preciso em nossa biblioteca nativa,
o que é incrível, certo?
Com certeza.
Vamos reunir tudo isso em um único script e fazer o seguinte.
Está bem.
Primeiro, vamos criar um novo script.
Ele mudou para JavaScript.
E as pessoas resumem rapidamente as medidas que precisamos tomar.
A primeira é obter o endereço base dessa biblioteca e obter o endereço base desse lit nativo.
Desculpe, ela é nativa iluminada e iluminada como uma biblioteca antiga.
Em seguida, estamos obtendo o deslocamento em nossa função de comparação de fluxo.
Em seguida, somamos os dois, o que resulta no endereço que queremos enganchar.
E, então, tudo o que precisamos fazer é simplesmente imprimir os parâmetros.
Tudo bem.
E este é o nosso plano de ataque.
Então, vamos ver a compensação.
Isso é algo que podemos obter da Chitra marcando esse endereço e mantendo o mouse sobre ele.
Podemos ver que o deslocamento é HD seis.
Veja que o H no final significa simplesmente que se trata de um valor hexadecimal.
Portanto, HD seis C.
Verde.
Vamos ver o offset HD e o six c.
Talvez possamos colocar isso à direita e verificar isso.
Sim.
Esse é o nosso deslocamento e esse é um valor hexadecimal.
Perfeito.
Agora precisamos obter o endereço base dessa biblioteca nativa.
E a liberdade, é claro, tem uma função incrível para isso.
Mas, primeiro, precisamos iniciar o servidor gratuito em nossa máquina virtual.
Portanto, aqui temos os dados locais temporários e aqui
temos este que libera o servidor.
A propósito, atualizei a Frieda.
Acho que isso não importa, mas, caso você tenha novos recursos ou tenha problemas com
a versão mais atualizada, gostaria de tê-la em meu curso.
Muito bem.
Caso encontre algum problema relacionado à versão antiga ou a esta aqui, escreva-me uma
mensagem.
Nós resolveremos isso.
Portanto, o servidor Frieda está em execução neste momento e vamos voltar à nossa tela.
Ele já está instalado?
Sim.
E esta é a nossa função C Frieda.
E se você clicar na faixa, a bandeira estará errada.
Tudo bem.
Isso está funcionando perfeitamente.
Portanto, agora podemos anexar o número três a este, sem custo para você.
Com hacking de aplicativos para ver o funk do Freedom.
Sim.
Eu me deparei com isso com bastante frequência.
Não tenho certeza do motivo por trás disso, mas o que funciona é que, se estivermos reiniciando
esse aplicativo com a opção F, nosso gancho funcionará.
Portanto, retome.
Sim.
Portanto, podemos ver que isso funciona.
Não sei qual é o motivo por trás disso.
Tudo bem, talvez.
Vamos colocar este à esquerda e este à direita.
Portanto, dentro do módulo, temos outra função interessante, que é obter o endereço base aqui, e então simplesmente precisamos
fornecer a biblioteca onde queremos ter o endereço do espaço, no nosso caso, um
pequeno traço nativo aceso.
Portanto, essa é a nossa biblioteca e queremos buscar esse endereço espacial, e aqui está ele.
Esse é o endereço base.
Talvez.
Vamos tentar algo.
Se estivermos reiniciando esse aplicativo, vamos ver se ele muda.
E mais uma vez.
Sim.
Portanto, podemos ver aqui que estamos tendo um diferente.
Isso significa que.
Não podemos simplesmente confiar em um único.
Precisamos buscar isso em tempo de execução.
Portanto, este aqui é agora nosso novo endereço base.
Vamos colocar isso à direita e anotar.
Esse é o comando para obter esse endereço.
E estamos criando uma nova variável para armazenar esse endereço de nossa string, comparação e função.
Não.
Esse é o endereço, ou vamos chamá-lo assim.
Está bem.
Vamos colocar o mouse à direita e atribuir isso a uma nova variável.
O endereço do espaço variável.
Está bem.
Portanto, essa função aqui também é um recurso incrível.
Ou seja, o autor também pode ter pensado nisso para não calcular sempre manualmente o deslocamento em relação
ao endereço de espaço.
Então, estamos falando agora sobre este, este pequeno traço nativo LIPOSOMAL Plus HD six C.
Portanto, nosso deslocamento aqui, o que precisamos fazer é buscar esse valor e adicionar
esse valor em cima dele, porque essa é a diferença do nosso lábio, lábio nativo desde o início.
Opa, essa não é uma linha reta, mas acho que dá para chegar a esta aqui.
Muito bem.
Essa é a compensação no momento.
E isso também não muda.
Não precisamos fazer isso manualmente.
E Frida tem essa característica incrível.
Vamos aumentar um pouco o tamanho.
Podemos usá-lo e, em seguida, podemos simplesmente fornecer nossa compensação para este.
Portanto, estamos usando este e este e, em seguida, vamos aumentar o tamanho novamente.
Estamos adicionando esse valor a ele e vamos ver.
E lá vamos nós.
Agora podemos ver que esse valor foi adicionado no topo.
E isso significa este aqui agora.
Esse é o nosso endereço para isso.
Cordas.
Cópia.
Desculpe.
Cordas.
Compare.
Função aqui.
Este aqui.
Está bem.
Portanto, podemos resumir isso juntos.
E, na cadeia de ferramentas de deslocamento, compare e funcione talvez com a.
Vamos aumentar um pouco o tamanho para que você possa ler todo o comentário.
Está bem.
Endereço base.
Ou talvez possamos renomear isso.
Endereço para o gancho.
Como nosso endereço final, precisamos anexar.
Portanto, este é agora o endereço que está sendo aplicado ao nosso ponto de interceptação de interceptação anexado a partir
deste que também está incluído aqui.
Ou seja, ele também nos renomeou.
É a compensação da nossa função de comparação de molas.
Está bem.
Agora temos tudo junto.
Isso também já foi feito.
E a única coisa que precisamos fazer é usar nosso interceptor attach nesse caso.
Portanto, intercepte esse pensamento.
E então temos nosso endereço para enganchar e este.
E depois temos nossas callbacks.
Clique duas vezes no colchete algumas vezes e dê enter na chamada de retorno.
E, nessa função aqui, temos nossos argumentos.
E esta é agora a função de comparação de string única em nosso dash lit nativo como nossa biblioteca.
E isso realiza a verificação da bandeira.
Muito bem, vamos imprimir isso.
O parâmetro um é.
E agora estamos usando o ponto de memória para ler UTF.
Preciso ter isso liberado, pois não consigo memorizar.
Portanto, o ponto de memória lê a cadeia de caracteres UTF oito.
Este aqui.
E estamos usando isso em arcos e zero.
Está faltando um suporte e aí está.
E isso pode ser excluído.
Esse é o nosso parâmetro um.
E agora estamos fazendo isso como parâmetro.
E, nesse período, há algumas promessas.
Também estamos fazendo isso em licença e função.
Esse é agora o nosso valor vermelho e, desta vez, podemos imprimir diretamente esse valor de retorno porque estamos conectando
apenas uma única função.
Portanto, isso não será inundado.
Como no exemplo anterior, conectamos todas as funções de comparação de strings.
Muito bem.
Está bem.
Portanto, este aqui é o nosso valor de retorno.
E este nós conhecemos.
O valor de retorno para o valor de retorno é zero.
Se as cadeias de caracteres forem iguais.
Igual.
Isso significa que nosso valor de retorno é um número inteiro.
Sim.
E isso parece perfeito.
Vamos ver se isso funciona.
Ou seja, são apenas algumas linhas para conectar uma função muito complexa na biblioteca nativa.
Incrível, não é?
Vamos ver se isso funciona.
Então, vamos copiar isso.
Está bem.
Estamos reiniciando esse aplicativo.
Retomo manualmente.
Espero que você tenha anexado essa pausa racional do traço para que não seja a lixeira como estou fazendo agora.
Está bem.
Aqui temos nosso aplicativo.
Estou muito animado se este estiver funcionando.
Está bem.
Sem setas.
Vejamos.
Estou batendo.
Check-in.
Três, dois, um.
Está bem.
Estamos recebendo um erro, mas também estamos tendo esse sinalizador em Saint Felix.
Tudo bem.
O primeiro parâmetro parece funcionar, mas o segundo não.
E agora também temos que mencionar que estamos em uma arquitetura diferente.
Isso significa que esses parâmetros foram alterados.
Agora eu sei muitas coisas.
E isso é realmente lamentável.
E, infelizmente, não podemos falar sobre tudo isso neste momento.
Se tiver alguma dúvida, é claro, fique à vontade para me escrever uma mensagem.
Mas vou tentar resumir isso rapidamente.
Lamento muito que seja tão complexo no momento, mas talvez você consiga descobrir o que está acontecendo.
E isso seria absolutamente incrível.
Portanto, no último exemplo, nosso primeiro parâmetro, e essa era a cadeia de caracteres que inserimos
nesse aplicativo, e este aqui agora tem uma arquitetura diferente e, portanto, a convenção de chamada
é diferente.
Esses parâmetros estão sendo trocados e, no primeiro parâmetro, não estamos tendo nossa string no momento.
Estamos tendo essa solução, essa aqui.
E, para ser sincero, não sei por que não conseguimos decodificar esse segundo e esse outro.
Essa é a nossa string que está sendo fornecida a essa função aqui.
Portanto, talvez haja algum problema com relação à tipificação.
Tudo bem.
Então é isso que está acontecendo aqui.
Quero dizer, é incrível.
Podemos ver que estamos conectando apenas uma única função, esta aqui.
E parece funcionar.
Quero dizer, funciona.
Temos a prova aqui.
Portanto, o que podemos tentar é o seguinte.
Em vez de usar isso, leia UTF eight.
Podemos tentar usar isso.
Leia a cadeia de caracteres C e vamos ver.
Och, não, não vamos mais ter a Frida.
Eu o recebo de volta porque gostaria de usar a antologia de Frida.
Portanto, leia C string nesse caso.
Está bem.
Leia, vamos ver.
Talvez na primavera.
Veja, o Spring consegue imprimi-lo.
Vejamos.
Quero dizer, podemos deixar isso em aberto.
Aplicamos agora nosso patch.
Como o aplicativo está sendo retomado.
Não temos certeza sobre isso.
Talvez possamos mudar isso.
Está bem.
Estamos batendo o check-in em 3 para 1.
Tudo bem.
Não estamos recebendo um erro, mas podemos ver este.
Quero dizer, ele não está sendo convertido em uma cadeia de caracteres C e parece que também não há cadeia de caracteres marinha, mas pelo menos
não estamos recebendo um erro.
Farei algumas pesquisas sobre isso, o que está acontecendo lá dentro, e depois fornecerei uma atualização sobre como
conectar esse parâmetro.
No momento, também não tenho ideia de por que esse é o caso em relação a esta postagem e ao desenvolvedor principal que
podemos ver.
Você não pode ser chamado de byte em uma determinada posição.
Portanto, isso se refere a brincar com a leitura de string C ou leitura de string UTF oito.
Portanto, lidar com cadeias de caracteres quando a codificação não é conhecida no momento é muito difícil.
E, infelizmente, não há uma maneira fácil.
Temos que usar muitas opções e simplesmente testá-las para ver se funcionam.
Tudo bem.
Está bem.
Muito bem, conforme prometido, aqui está a atualização referente ao problema do parâmetro.
Pode ser um problema em uma versão mais antiga do freedom, que atualmente está mais atualizada, o que pode
ser um problema com o freedom em geral e com a arquitetura x86.
No momento, recapitulei tudo e, com relação ao parâmetro, ele está funcionando em um dispositivo AMD.
Então, vamos dar uma olhada.
E essa é a biblioteca nativa.
Portanto, agora vamos verificar a biblioteca para a arquitetura ARM de 64 bits, pois estou usando agora o dispositivo
irreal e o pixel 2, e este é um OC de arquitetura ARM de 64 bits.
Carregamos isso no Chitra e verificamos a comparação da cadeia de caracteres porque esse deslocamento
agora é diferente, podemos ver que esse deslocamento agora está em f0b8.
Vamos colocar isso em nosso script.
Então, aqui podemos ver o nosso script antigo, mas já o atualizei.
Vamos dar uma olhada nesse caso.
Tudo bem.
Podemos ver que este era o offset antigo, e tudo o que fiz foi apenas atualizá-lo para o novo offset.
Então, vamos também marcar isso aqui e o comentário.
Está bem.
E agora eu não mudei nada.
Portanto, ainda nos livramos dos argumentos de oito cadeias de caracteres um e dois e também do valor de retorno.
Mas, no valor de retorno, ainda temos alguns problemas, então não tenho certeza de por que ele não está sendo impresso.
Vou depurar isso no free to script e farei um capítulo inteiro sobre a depuração do código do Android
free the code Código C e coisas desse tipo.
Por enquanto, temos que esperar e até que eu descubra.
Ok, mas voltando ao assunto.
Essa era a nossa tarefa.
Então vamos ver.
Esse é agora o nosso script.
Vamos executar a liberdade e, em seguida, vamos colocar o smartphone aqui e agora vamos executar isso.
Então, vamos reiniciar esse aplicativo.
Tudo bem, podemos retomar.
E agora temos que copiar e colar este código e este código no console.
Tudo bem.
Parece um pouco bagunçado, mas estamos prontos para começar.
E agora tudo o que faço é simplesmente clicar em verificar.
E lá vamos nós.
Podemos ver que essa é a nossa entrada fornecida.
Podemos ver que está em um fio cristalino.
E aqui também está o segundo parâmetro.
Essa é a nossa bandeira.
Perfeito.
O que está faltando agora é esse valor de retorno, e eu preciso depurá-lo.
Pode ser que, no caso de deixar a função de comparação de strings com base em uma chamada assíncrona, ela não esteja
sendo impressa no momento.
Mas, sim, farei um capítulo inteiro relacionado a isso.
Se você quiser ter os parâmetros e o valor de retorno, acho que basta escolher a outra abordagem em relação
a essa string.
Compare que não enganchamos e o endereço dedicado onde enganchamos todos eles, e então nos certificaremos de que
estamos atingindo os parâmetros e também os valores de retorno.
Muito bem.
Está bem.
Portanto, isso é tudo para este vídeo no momento.
Talvez possamos fazer uma pequena recapitulação com Chitra.
Identificamos onde nossos parâmetros estão sendo passados para esta função e para esta aqui.
Portanto, nós o rastreamos a partir deste.
Born to this one and from here into this function, então sabemos que essa é a função que queremos procurar aqui.
Vimos que temos um endereço, mas esse endereço não é real.
Esse endereço será calculado com base no ponto de carregamento desse endereço.
Além dessa compensação.
Infelizmente, isso mudará toda vez que relançarmos o aplicativo.
Portanto, não podemos usar um valor codificado.
Mas isso não é absolutamente nenhum problema para nós e para a Frieda neste momento, porque a Frieda tem esse recurso incrível
para colar endereços dessa biblioteca e esse recurso ainda mais incrível para adicionar automaticamente determinado valor
a esse endereço.
Portanto, com essa linha, estamos obtendo o deslocamento dentro do nosso aplicativo para esse ponto aqui, para esse endereço
no nosso aplicativo para smartphone.
Com isso, o resto fica bem fácil.
Podemos aplicar nosso interceptor dot attach a esse endereço e, em seguida, usar esses argumentos para
imprimi-los.
Não sei ao certo por que ele está desaparecendo no momento, mas fornecerei uma atualização para esse
vídeo aqui e também na planilha.
Fornecerei várias opções que você pode experimentar para ler em determinada cadeia de caracteres.
Aqui temos o menu de retorno e acho que não verificamos o valor de retorno, portanto, vamos voltar.
Está bem.
Parece que o valor de retorno não é impresso aqui.
Talvez por causa desse erro, isso seja um pouco estranho.
Ok, este também é lamentável.
E, por enquanto, não tenho nenhuma explicação para esse fato.
Também sobre isso, fornecerei uma atualização.
Qual é o problema e como resolvê-lo?
Com relação à nossa abordagem de hooking, vimos que também podemos hookar uma função realmente precisa em nosso
código completo e também vimos que podemos hookar todas essas funções em nosso código, o que será um pouco
confuso.
Mas também sabemos como lidar com esse problema, fornecendo um identificador exclusivo.
Aqui, por exemplo, este 11234567980.
E, em seguida, verificar esse identificador exclusivo e imprimir apenas essa função que tem esse conjunto
como argumento.
Aqui vimos que isso funciona perfeitamente bem.
E essa também é a minha recomendação de escolha para este aqui.
Muito bem.
Tudo bem.
E isso é tudo para este vídeo agora.
E no próximo, daremos uma olhada na captura do filme no mundo real.
Esse será nosso desafio de leitura de blocos.
E, neste caso, não é tão fácil assim.
Portanto, se você puder resolver isso, seria fantástico.
E então você merece absolutamente seu bloco vermelho.
Você entraria absolutamente de graça.
E ao conectar todos esses métodos Java, criar novas instâncias, observar instâncias ou brincar com o
NDDC ou até mesmo executar funções-chave, como estamos fazendo aqui.
Então, foi isso que aprendemos neste capítulo, e é muita coisa, e é incrível que você ainda esteja lá
e tenha conseguido chegar até o final deste capítulo.
Portanto, estou realmente ansioso para vê-lo na próxima seção.
Talvez dar um mergulho no desafio.
Vejo você lá.