WEBVTT

00:00.470 --> 00:03.830
Olá e bem-vindos ao primeiro vídeo de nossa série.

00:03.860 --> 00:10.520
Conforme prometido, no primeiro vídeo, vamos nos concentrar nas funções nativas de engenharia reversa com o

00:10.520 --> 00:11.060
Ghidra.

00:11.060 --> 00:17.090
Portanto, isso pode ser, por exemplo, uma biblioteca que vem com um aplicativo Android e que contém código nativo

00:17.090 --> 00:19.490
que faz algumas coisas sofisticadas.

00:19.490 --> 00:22.670
E queremos descobrir o que é esse material sofisticado.

00:22.670 --> 00:27.080
Portanto, vamos ver se há algum aplicativo que cubra esse tópico.

00:27.080 --> 00:29.030
E se você abrir essas telas de crack.

00:29.030 --> 00:30.110
Sim, é isso mesmo.

00:30.110 --> 00:31.400
Já é o próximo.

00:31.400 --> 00:35.840
Portanto, infelizmente, o código abaixo não tem uma biblioteca nativa incluída.

00:35.840 --> 00:40.250
Por isso, simplesmente escolhi o próximo, que é o validador de licenças do Android.

00:40.250 --> 00:47.330
Portanto, o validador de licença do Android é um crack me que implementa uma função de validação de chave em código nativo,

00:47.330 --> 00:51.980
empacotado como um executável Elf autônomo para dispositivos Android.

00:52.640 --> 00:58.880
Isso significa que temos um binário que é executado no dispositivo Android, e esse binário é uma chave ou contém uma função de

00:58.880 --> 01:02.240
validação de chave, que precisa passar por engenharia reversa.

01:02.420 --> 01:08.660
O autor, também mencionado posteriormente por esse simples aplicativo de amostra, não fez mapas.

01:08.660 --> 01:15.920
Embora esse aplicativo de amostra possa não representar um cenário do mundo real, e esse é, eu diria,

01:15.920 --> 01:22.280
o caso frequente dos Ctfs do Android que foram terceirizados para o componente nativo.

01:22.280 --> 01:30.020
Portanto, se analisarmos esses desafios de Captcha, é mais parecido com a engenharia reversa de um binário ARM.

01:30.020 --> 01:36.920
No entanto, essa habilidade ainda é necessária e bastante útil porque, se um aplicativo vier com uma

01:36.920 --> 01:41.840
biblioteca, esse código estará sendo usado no aplicativo Android.

01:41.840 --> 01:46.010
Portanto, precisamos analisar ou precisamos ser capazes de analisar esse código.

01:46.010 --> 01:47.480
O que ele está fazendo?

01:47.480 --> 01:50.690
E então, sim, veremos se conseguimos encontrar falhas.

01:51.380 --> 01:56.750
Portanto, mesmo que não represente uma aplicação no mundo real, ainda assim vamos dar uma olhada

01:56.750 --> 01:57.320
nela.

01:58.070 --> 01:58.790
Está bem.

01:58.790 --> 02:04.130
Portanto, ele serve como uma valiosa ferramenta de aprendizado para compreender o básico da execução simbólica.

02:04.130 --> 02:04.790
Tudo bem.

02:04.940 --> 02:11.690
Não falamos sobre execução simbólica, mas esse também é um tópico que não está realmente relacionado ao Android.

02:11.690 --> 02:15.890
A execução simbólica é muito boa para resolver problemas, sim.

02:15.890 --> 02:21.470
Desafios de capturar a bandeira ou coisas como, uh, número de série, validador de licença e coisas do gênero.

02:21.470 --> 02:25.490
Portanto, a execução simbólica é mais ou menos assim.

02:25.520 --> 02:30.380
Temos um ponto inicial em nosso código e um ponto final em nosso código.

02:30.380 --> 02:36.680
E queremos descobrir quais parâmetros temos de fornecer para percorrer o gráfico de fluxo completo

02:36.680 --> 02:38.630
desse código e chegar lá.

02:38.630 --> 02:44.990
Portanto, a execução simbólica é diferente da emulação porque a execução simbólica está fazendo anotações.

02:44.990 --> 02:51.500
Por exemplo, nesse ramo, o valor de x precisa ser maior que dez para ir para o lado esquerdo.

02:51.500 --> 02:54.440
E se for menor que dez, ele vai para o lado direito.

02:54.440 --> 02:55.790
Sobre a parte da emulação.

02:55.820 --> 03:02.990
Estamos adotando apenas um caminho porque, nesse momento, nosso valor não tem um valor concreto, mas

03:02.990 --> 03:08.570
a execução simbólica é capaz de perceber todos esses diferentes, digamos, um.

03:10.170 --> 03:11.100
Condições.

03:11.100 --> 03:12.480
A palavra é condições.

03:12.480 --> 03:17.070
Essas diferentes condições permitem criar uma carga útil posteriormente.

03:17.220 --> 03:19.800
Não é um tópico por si só.

03:19.800 --> 03:22.950
Já usei, por exemplo, um pouco de raiva no passado.

03:22.950 --> 03:27.720
Não sou especialista nesse assunto, mas já o usei para resolver alguns captcha, refletir desafios e você

03:27.720 --> 03:31.590
pode passar um ano inteiro e fazer um curso inteiro sobre execução simbólica.

03:31.590 --> 03:35.370
Portanto, talvez eu inclua uma breve introdução a esse tópico.

03:35.370 --> 03:42.090
Mas acho que, sim, digamos que, se você lida com binários ofuscados, ele pode ser útil, mas não o estou usando

03:42.090 --> 03:45.090
com frequência para resolver essas tarefas.

03:45.090 --> 03:48.390
Mas, mesmo assim, vamos ver se você está interessado, me avise.

03:48.390 --> 03:53.820
E, sim, se eu receber o feedback de que vocês querem ter um vídeo separado sobre esse assunto,

03:53.820 --> 03:55.320
nós o cobriremos.

03:55.320 --> 03:55.950
Tudo bem.

03:56.790 --> 04:01.980
Isso pode ser aplicado em situações práticas ao lidar com aplicativos Android, eu sugeriria.

04:01.980 --> 04:02.280
Hmm.

04:02.880 --> 04:03.720
Está bem.

04:03.720 --> 04:05.550
Bibliotecas nativas ofuscadas.

04:05.550 --> 04:05.910
Sim.

04:05.910 --> 04:08.490
Esse é um caso em que ele pode ser útil.

04:08.490 --> 04:09.450
Isso é verdade.

04:09.450 --> 04:10.320
De fato.

04:10.320 --> 04:11.160
E assim por diante.

04:11.160 --> 04:15.750
Muito bem, então o autor deste é Bernhard Mueller, eu acho.

04:15.840 --> 04:17.760
Espero que a pronúncia esteja correta.

04:18.360 --> 04:19.830
Parece alemão para mim.

04:19.830 --> 04:21.210
E vamos ver.

04:21.210 --> 04:23.640
E este está disponível aqui.

04:23.640 --> 04:25.320
Então, abrimos esta.

04:25.320 --> 04:31.170
E aqui temos o validador de licenças do Android, que desperta interesse, é claro, e assim por diante.

04:31.170 --> 04:32.730
Não há keygen disponível.

04:32.730 --> 04:35.850
Gere uma chave serial válida que seja aceita pelo aplicativo.

04:35.850 --> 04:37.680
Certo, então.

04:38.670 --> 04:45.720
Com relação à descrição, parece que pode haver várias soluções disponíveis.

04:45.720 --> 04:51.090
Precisamos gerar uma chave serial válida, o que significa que pode haver mais.

04:51.090 --> 04:53.610
Portanto, pode haver algum padrão nesse aplicativo.

04:53.610 --> 04:59.400
E, sim, esse padrão pode se aplicar a várias entradas diferentes.

05:00.350 --> 05:01.610
Instalação.

05:01.610 --> 05:06.650
Então, baixamos esse desafio e ele parece ser um binário validado.

05:06.650 --> 05:08.450
Colocamos isso em dados temporários locais.

05:08.450 --> 05:10.100
Tornamos isso executável.

05:10.100 --> 05:11.780
Começamos com isso.

05:11.780 --> 05:13.790
Recebemos essa dica pelo uso.

05:13.790 --> 05:16.550
Portanto, temos que fornecer o serial como parâmetro.

05:16.790 --> 05:19.220
Temos esse parâmetro.

05:19.220 --> 05:22.220
E, se estiver errado, receberemos um formato errado de série incorreto.

05:22.220 --> 05:25.520
E se fornecermos esse parâmetro, obteremos.

05:25.520 --> 05:31.070
Inserção da base 32 decode out length check license product activation pass.

05:31.070 --> 05:32.270
Parabéns.

05:32.270 --> 05:37.760
Muito bem, vou instalar isso em meu dispositivo e executá-lo.

05:37.760 --> 05:41.180
Se você não tiver um dispositivo real, não poderá executar esta etapa.

05:41.180 --> 05:43.970
Mas isso não é necessário para resolver esse desafio.

05:43.970 --> 05:45.800
Portanto, trata-se de um desafio inverso.

05:45.800 --> 05:49.010
E tudo isso pode ser feito apenas com a análise do código.

05:49.010 --> 05:55.430
No entanto, gostaria de mostrar como o aplicativo é executado e, em seguida, daremos uma olhada na solução desse

05:55.430 --> 05:59.120
desafio e também na aplicação de algumas técnicas de reversão.

05:59.450 --> 06:04.130
Hum, o que estou fazendo pode ser útil também para você, caso analise códigos.

06:04.130 --> 06:05.930
Tudo bem, ok.

06:05.930 --> 06:08.240
Então, eu sugeriria que fizéssemos isso.

06:08.240 --> 06:11.990
Então, clicamos em download, ok.

06:12.200 --> 06:13.100
E vamos ver.

06:13.730 --> 06:15.050
É válido.

06:15.050 --> 06:15.980
Tudo bem.

06:17.810 --> 06:23.450
ADB adb push validate into data local tmp.

06:24.890 --> 06:25.760
Está bem.

06:26.060 --> 06:26.990
Shell do ADB.

06:27.050 --> 06:32.090
Portanto, isso precisa ser uh ou precisa ser executado em um smartphone.

06:32.150 --> 06:40.940
Também não tenho certeza se podemos emular esse binário com o qemu porque ele pode ter sido escrito especialmente para a arquitetura

06:40.940 --> 06:46.670
Android, obtendo todas as coisas, essas bibliotecas e coisas assim.

06:46.700 --> 06:52.160
Talvez seja possível, mas, como já mencionado, não é necessário ter isso em execução.

06:52.160 --> 06:54.620
Então, vou lhe mostrar como é.

06:54.620 --> 06:56.180
Você também pode ver isso aqui.

06:56.180 --> 06:58.610
E depois faremos tudo isso em Ghidra.

06:58.640 --> 06:59.300
Está bem.

06:59.600 --> 07:00.290
Está bem.

07:01.280 --> 07:03.530
Então, começamos esse programa.

07:03.530 --> 07:05.840
Em seguida, recebemos essa instrução de uso, ok.

07:05.840 --> 07:08.540
Testamos o 1234.

07:08.540 --> 07:10.670
Formato incorreto de série incorreta.

07:10.670 --> 07:11.450
Está bem.

07:11.450 --> 07:13.490
Vamos tentar a outra parte aqui.

07:16.320 --> 07:17.040
Tudo bem.

07:17.040 --> 07:17.940
Parabéns.

07:17.940 --> 07:19.200
O desafio foi resolvido.

07:19.200 --> 07:21.810
Não foi tão difícil assim, acho que sim.

07:21.810 --> 07:22.980
Espero que você tenha aprendido alguma coisa.

07:22.980 --> 07:23.940
E eu sugeriria.

07:23.940 --> 07:24.210
Não.

07:24.210 --> 07:24.900
É claro que sim.

07:24.960 --> 07:25.560
Hum, sim.

07:25.560 --> 07:26.520
É uma brincadeira.

07:26.520 --> 07:28.860
Vamos ver como esse binário se parece.

07:28.860 --> 07:36.570
Então, primeiro realizamos um arquivo para ver do que se trata.

07:36.570 --> 07:39.570
Podemos ver que se trata de um binário Elf, portanto, é um executável.

07:41.320 --> 07:45.280
32 bits, mas também é executado em uma arquitetura de 64 bits.

07:45.310 --> 07:48.310
Este, hum, este aqui, está em pixel, que é de 64 bits.

07:48.310 --> 07:50.950
Portanto, isso não deve ser um problema.

07:50.950 --> 07:52.810
É a arquitetura ARM.

07:52.840 --> 07:58.780
Ele é vinculado dinamicamente e é despojado, o que significa que não há nenhum símbolo nele, o que torna a reversão

07:58.780 --> 08:00.370
um pouco mais difícil.

08:00.370 --> 08:05.320
Mas é assim que você obtém essas bibliotecas ou binários.

08:05.380 --> 08:07.180
Hum, vamos chamá-lo de.

08:07.180 --> 08:11.680
Não, vamos dizer que não é de hoje, porque isso está muito, muito fora de moda por um tempo.

08:11.680 --> 08:14.170
Você não obtém símbolos de depuração na maioria dos casos.

08:14.170 --> 08:16.870
Portanto, temos que lidar com esse problema.

08:16.870 --> 08:19.990
Então, vamos começar com as crianças e depois dar uma olhada nesta.

08:19.990 --> 08:25.210
Ferramentas Chitra ok.

08:27.210 --> 08:28.320
Vamos encerrar o assunto.

08:31.190 --> 08:33.350
Portanto, aqui está a visão geral.

08:33.380 --> 08:43.910
Entramos no arquivo do novo projeto Non-shared project porque estamos trabalhando sozinhos no Ghidra um validator Android

08:43.940 --> 08:44.540
CTF.

08:44.540 --> 08:46.100
Fornecemos o nome do projeto.

08:46.910 --> 08:48.980
E então temos várias opções diferentes.

08:48.980 --> 08:55.010
Temos o navegador de código, temos o depurador, mas o depurador é apenas um invólucro para o gdb.

08:55.010 --> 08:58.280
Portanto, o ghidra não vem com seu próprio depurador.

08:58.880 --> 08:59.660
Um.

09:00.990 --> 09:03.300
Sim, acho que podemos dizer isso dessa forma.

09:03.480 --> 09:07.200
Há opções para emular e depurar, mas é um invólucro.

09:07.200 --> 09:08.460
Nós temos essa.

09:08.460 --> 09:09.690
Esse é o emulador.

09:09.690 --> 09:12.660
Esse é um recurso incrível que foi adicionado no passado.

09:12.660 --> 09:18.810
Portanto, talvez consigamos imitar isso, mas isso ficaria fora de controle se nos aprofundássemos demais

09:18.810 --> 09:19.980
no assunto.

09:19.980 --> 09:27.780
E aqui está o rastreamento de versão, o que significa que podemos aplicar um determinado estado em um aplicativo.

09:28.320 --> 09:34.230
E se o aplicativo for atualizado, podemos realizar o rastreamento de versão para ver o que foi alterado.

09:34.230 --> 09:38.220
Isso é usado com bastante frequência para encontrar vulnerabilidades.

09:38.220 --> 09:43.290
Por exemplo, se você tiver um binário com uma vulnerabilidade e o fornecedor corrigir

09:43.290 --> 09:51.720
essa vulnerabilidade, você poderá identificar o que o fornecedor alterou e ver onde a vulnerabilidade poderia estar.

09:51.720 --> 09:56.040
É claro que, na maioria das vezes, o fornecedor está realizando mais do que apenas uma alteração.

09:56.040 --> 09:57.840
Portanto, ainda está um pouco bagunçado.

09:57.840 --> 09:59.550
Mas essa é uma ferramenta útil.

09:59.580 --> 10:02.460
Ok, até agora isso é tudo para Ghidra.

10:02.730 --> 10:04.110
E vamos iniciar o navegador de código.

10:08.640 --> 10:15.480
Vamos também copiar esse binário em um novo estado.

10:20.690 --> 10:26.510
Portanto, criamos um diretório CTF e, em seguida, validamos os downloads.

10:26.510 --> 10:28.250
E colocamos isso no CTF.

10:28.250 --> 10:36.890
Portanto, esse é o nosso novo ponto de partida agora, ok, estou abrindo o Nautilus nesse diretório.

10:37.340 --> 10:38.660
Então, temos isso aqui.

10:38.930 --> 10:41.630
E agora eu simplesmente arrasto e solto no Ghidra.

10:42.720 --> 10:46.560
A Chitra é inteligente o suficiente para reconhecer que se trata de um executável ARM.

10:46.830 --> 10:50.040
Um VI V8 de 32 bits little endian.

10:50.610 --> 10:51.480
Está bem.

10:54.270 --> 10:55.710
Então ela simplesmente passou.

10:55.710 --> 11:00.690
E agora, a Chitra está nos pedindo para analisar esse binário.

11:00.690 --> 11:05.940
Gostaríamos de analisá-lo porque Chitra está fazendo todas essas referências, hum, a compilar e decodificar

11:05.940 --> 11:07.410
e coisas assim.

11:07.410 --> 11:07.920
Portanto.

11:07.920 --> 11:08.460
Sim.

11:08.670 --> 11:11.100
E aqui eu gostaria de acrescentar duas opções.

11:11.100 --> 11:17.820
O primeiro é o ID do parâmetro de compilação que torna os parâmetros um, sim.

11:17.820 --> 11:25.200
Ou melhora um pouco a descompilação desses parâmetros, o que significa que podemos obter tipos

11:25.200 --> 11:27.720
melhores e coisas do gênero.

11:28.050 --> 11:31.380
E também o localizador de instruções agressivas da ARM.

11:32.040 --> 11:38.010
Portanto, a arquitetura ARM pode ser executada no modo de 32 bits, que é o modo ARM, e no modo thump,

11:38.010 --> 11:39.420
que é o modo de 16 bits.

11:39.420 --> 11:48.000
E Chitra está tentando identificar se há algumas instruções de 16 bits que seriam perdidas de outra

11:48.000 --> 11:48.660
forma.

11:48.660 --> 11:53.370
Portanto, há oportunidades de alternar entre esses dois modos na arquitetura ARM.

11:53.370 --> 11:57.540
E, ao aplicar isso, Chitra está realizando todas essas verificações.

11:57.570 --> 12:01.680
É claro que isso tem um lado negativo em binários pequenos.

12:01.680 --> 12:02.880
Absolutamente nenhum problema.

12:02.880 --> 12:08.880
Se você tiver um binário grande e estivermos falando de, digamos, dez MB.

12:08.940 --> 12:13.560
Então, dez megabytes podem levar um bom tempo.

12:13.560 --> 12:20.160
Então, digamos, 40 minutos, hum, para realizar essas verificações, o que eu gosto de fazer é, se eu tiver binários enormes, iniciar

12:20.160 --> 12:25.710
o Chitra com opções básicas, talvez o parâmetro de compilação id, algo que eu ainda queira incluir.

12:25.710 --> 12:28.140
Caso contrário, excluo esses dois.

12:28.170 --> 12:32.370
Iniciar a análise de que eu, hum, obtive esse resultado mais rapidamente.

12:32.370 --> 12:39.930
Em seguida, já comece a analisar um pouco e faça isso em uma verificação separada de que, sim, a Chitra está fazendo isso mais uma vez com todas

12:39.930 --> 12:44.760
essas opções definidas e, se isso tiver sido concluído, poderei mudar para esse projeto

12:44.760 --> 12:47.520
se for realmente crítico em termos de tempo.

12:48.090 --> 12:49.650
No momento, é um binário pequeno.

12:49.650 --> 12:51.390
Portanto, mantemos essas duas opções verificadas.

12:52.180 --> 12:52.900
Está bem.

12:54.080 --> 12:55.250
Analisar.

12:55.370 --> 12:55.880
Sim.

12:55.910 --> 12:57.680
E aqui está uma janela importante.

12:57.860 --> 13:04.040
Podemos ver que o binário validate um tem dependências.

13:04.040 --> 13:09.080
Portanto, essas são bibliotecas que não foram incluídas porque não temos essas bibliotecas.

13:09.110 --> 13:15.080
Isso significa que se tivermos funções exportadas, por exemplo, em printf e coisas do gênero, elas não poderão

13:15.080 --> 13:16.220
ser resolvidas.

13:16.250 --> 13:20.060
Às vezes é bom ter isso resolvido.

13:20.060 --> 13:22.220
Mas isso significa que precisamos obter essas bibliotecas.

13:22.220 --> 13:26.390
Podemos tentar buscá-las no smartphone, pesquisar on-line e coisas do gênero.

13:26.390 --> 13:35.480
Mas se você não tiver 100% de certeza de que essa é a biblioteca nessa versão, as coisas também podem ficar confusas.

13:35.480 --> 13:41.870
A menos que você não descubra e funcione em uma biblioteca como essa, que é muito importante para

13:41.870 --> 13:42.380
nós.

13:42.380 --> 13:47.960
Gosto de manter esse projeto como está, porque assim não começamos cometendo erros.

13:47.960 --> 13:51.380
Portanto, obtivemos uma nova configuração com poucas informações.

13:51.380 --> 13:56.660
Talvez no início, sim, mas pelo menos está correto nesse ponto.

13:56.660 --> 13:58.400
Está bem, está bem.

14:00.040 --> 14:00.760
Portanto.

14:00.760 --> 14:02.290
E sim, aqui está.

14:02.290 --> 14:09.100
Reduzi um pouco a resolução porque obtive uma tela branca e isso atrapalharia o vídeo para

14:09.100 --> 14:09.880
vocês.

14:09.880 --> 14:13.240
Portanto, está um pouco confuso em relação à fonte.

14:13.240 --> 14:16.720
E não estamos tendo muito espaço, mas acho que é possível.

14:17.320 --> 14:17.890
Está bem.

14:17.890 --> 14:23.560
Se estamos analisando isso agora, temos que pensar no que queremos alcançar e no que queremos alcançar para resolver

14:23.560 --> 14:24.370
esse desafio.

14:24.370 --> 14:28.330
E esse desafio está sendo resolvido se fornecermos o parâmetro correto.

14:28.450 --> 14:30.070
Portanto, portanto.

14:31.600 --> 14:33.730
Se voltarmos, não estará aqui.

14:36.340 --> 14:37.240
É aqui.

14:38.920 --> 14:45.460
Portanto, podemos ver que esse aplicativo já nos fornece muitas informações úteis sobre as

14:45.460 --> 14:46.090
saídas.

14:46.090 --> 14:50.770
Podemos ver que houve uso, número de série incorreto, formato errado.

14:50.770 --> 14:54.430
Portanto, essa é uma condição que não queremos alcançar.

14:54.610 --> 14:57.880
Temos um código D de base 32 inserido.

14:57.880 --> 15:04.720
Portanto, esse aplicativo parece fazer algo com a base 32, o que também já é interessante.

15:04.720 --> 15:06.010
Temos um comprimento de saída.

15:06.010 --> 15:09.010
Obtivemos a licença de verificação e depois isso.

15:09.010 --> 15:10.180
Parabéns.

15:10.180 --> 15:17.440
Portanto, esse é o ramo ou o código de programa que queremos alcançar.

15:17.440 --> 15:20.710
Portanto, vamos tentar encontrar isso em nosso binário.

15:21.880 --> 15:23.740
Portanto, estamos copiando isso.

15:23.740 --> 15:25.000
Parabéns.

15:25.000 --> 15:26.680
E estamos procurando por cadeias de caracteres.

15:26.680 --> 15:30.370
Então, vamos salvar isso primeiro, ok.

15:30.370 --> 15:32.200
Em seguida, entramos na janela.

15:33.200 --> 15:38.390
E não, vamos pesquisar e depois procurar por strings, ok.

15:38.390 --> 15:40.790
Buscamos pelo menos três.

15:40.790 --> 15:43.730
E nós pegamos todos os blocos carregados.

15:44.900 --> 15:49.700
Agora temos todas essas cadeias de caracteres e podemos colocar isso aqui para ver.

15:49.700 --> 15:51.620
Sim, a ativação do produto foi aprovada.

15:51.620 --> 15:52.730
Parabéns.

15:52.730 --> 15:55.460
Portanto, se agora clicarmos duas vezes neste.

15:56.630 --> 16:00.860
Em seguida, Chitra abriu a referência da corda no plano de fundo.

16:00.860 --> 16:02.960
Portanto, se minimizarmos isso, poderemos ver.

16:02.960 --> 16:04.160
Sim, aqui está.

16:04.280 --> 16:07.850
Portanto, aqui podemos ver a ativação do produto aprovada.

16:07.850 --> 16:08.840
Parabéns.

16:08.840 --> 16:11.510
E este está sendo referenciado nesta função aqui.

16:11.510 --> 16:13.520
Esse é o endereço dessa função.

16:13.520 --> 16:17.270
E esses são os endereços em que essa string está sendo usada.

16:18.850 --> 16:22.330
Isso significa que se clicarmos duas vezes nessa referência aqui.

16:22.930 --> 16:26.110
Acabamos na função que está usando essa parte.

16:26.110 --> 16:29.800
E isso já parece um pouco bagunçado, o que é bom, eu acho.

16:29.800 --> 16:32.380
Assim, podemos ver a ativação do produto aprovada.

16:32.380 --> 16:33.610
Parabéns.

16:35.550 --> 16:41.370
Também podemos ver que temos duas referências, mas no código descompilado há apenas uma.

16:42.180 --> 16:44.610
Vamos ver se voltamos para a janela de cadeias de caracteres.

16:45.120 --> 16:46.950
Desculpe, mas não as cordas.

16:46.950 --> 16:48.300
Temos que voltar.

16:48.300 --> 16:51.150
Mas não quero estragar tudo agora.

16:51.630 --> 17:01.110
Portanto, se usarmos a tecla Control e depois a tecla de seta para a esquerda, voltaremos à janela anterior.

17:02.250 --> 17:08.220
Portanto, aqui podemos ver que o endereço é 844 e o 848 estava sendo referenciado.

17:08.220 --> 17:12.990
Assim, podemos ver que temos duas referências aqui, mas apenas uma em nosso código descompilado.

17:12.990 --> 17:14.760
E isso agora é muito importante.

17:14.790 --> 17:23.850
A Chitra está fazendo um trabalho incrível em relação à descompilação de um código de montagem e recupera essa representação em

17:23.850 --> 17:24.420
C aqui.

17:24.420 --> 17:30.660
Mas, às vezes, é claro que pode haver erros nesse código aqui e, portanto, não podemos confiar totalmente

17:30.660 --> 17:31.800
nele.

17:31.800 --> 17:36.030
Também precisamos dar uma olhada no código de montagem do braço se quisermos analisar isso.

17:37.160 --> 17:42.500
Portanto, se clicarmos neste, chegaremos a este ponto e a esta parte aqui.

17:42.500 --> 17:47.630
E se você clicar em "congratulations" (parabéns), verá que ela foi mencionada duas vezes aqui.

17:47.630 --> 17:49.940
Portanto, isso está correto no código de montagem.

17:49.940 --> 17:59.000
E também pode estar correto aqui, porque este está apenas adicionando um valor ao registro R3.

17:59.000 --> 18:03.380
E este está copiando esse valor para outro registro.

18:03.380 --> 18:05.240
Portanto, não há problema algum.

18:05.240 --> 18:09.830
No entanto, não podemos confiar totalmente nessa parte aqui.

18:09.830 --> 18:13.820
Portanto, às vezes também precisamos verificar o código de montagem.

18:14.480 --> 18:15.350
Tudo bem.

18:16.040 --> 18:21.770
Então, o que eu gosto de fazer aqui é identificar a função que queremos alcançar, e eu gosto

18:21.770 --> 18:23.750
de dar uma olhada nelas.

18:23.780 --> 18:24.260
Hum, sim.

18:24.290 --> 18:25.010
Saídas.

18:25.010 --> 18:26.780
O que essa função está fazendo.

18:26.780 --> 18:32.000
Temos esse nome de função aqui, e este é um pouco confuso porque tem apenas o nome fun.

18:32.000 --> 18:37.250
E, em seguida, o endereço dessa função, se você, por exemplo, não fizer isso agora,

18:37.250 --> 18:40.520
só quero mostrar se você clicar em algum lugar.

18:41.950 --> 18:47.230
Isso já é interessante, mas não é o que estou procurando aqui.

18:48.010 --> 18:50.380
Aqui temos apenas esse nome de função.

18:50.380 --> 18:53.020
Temos isto, nome da função, isto, isto e assim por diante.

18:53.020 --> 18:57.940
Não temos a menor ideia do que essas funções fazem, e precisamos investigar cada uma delas.

18:57.940 --> 19:03.370
Portanto, ao aplicar determinados nomes ao que eles podem fazer, fica um pouco mais legível.

19:03.370 --> 19:04.900
Esse código está correto.

19:04.900 --> 19:10.660
Portanto, se voltarmos ao controle e depois à seta para a esquerda, tudo bem.

19:10.660 --> 19:13.780
Portanto, não tenho a menor ideia do que essa função está fazendo.

19:13.780 --> 19:18.220
Mas parece lidar com parabéns e com uma teoria incorreta.

19:18.280 --> 19:23.770
Portanto, eu entro nessa e gosto de usar atalhos, mas é difícil de seguir.

19:23.770 --> 19:25.810
Portanto, eu faço isso na GUI.

19:25.960 --> 19:27.580
Renomeamos essa função.

19:27.580 --> 19:30.760
Então, clique com o botão direito do mouse para renomear a função e eu a nomeio assim.

19:30.760 --> 19:35.920
Agora, por exemplo, o sucesso da decisão falhou.

19:37.100 --> 19:42.950
Agora, se encontrarmos isso mais tarde em nossa decisão de código de sucesso ou falha, então saberemos.

19:42.950 --> 19:50.840
Sim, esta é a função que controla se passamos na verificação de série

19:50.840 --> 19:53.270
ou se falhamos aqui.

19:53.810 --> 20:00.530
Ok, então identificamos a função que queremos alcançar e agora precisamos obter o caminho para essa

20:00.530 --> 20:01.280
função.

20:01.280 --> 20:06.320
E há outra janela muito útil que talvez não esteja disponível para você no momento.

20:06.320 --> 20:10.880
Portanto, vou fechar isso aqui e depois mostrar como você pode ativar isso.

20:10.880 --> 20:14.510
Este está dentro da árvore de chamadas de função da janela.

20:16.290 --> 20:23.370
E este mostra agora todas as funções de entrada ou todas as chamadas de entrada relacionadas a essa função.

20:23.370 --> 20:26.520
Então, qual função está chamando esta aqui?

20:26.520 --> 20:31.380
E também mostra quais funções estão sendo chamadas por esta aqui.

20:31.380 --> 20:34.650
Por exemplo, no lado direito, podemos ver todas essas funções.

20:34.650 --> 20:35.970
Eles estão sendo chamados.

20:35.970 --> 20:38.760
Mas não é isso que está nos interessando no momento.

20:38.760 --> 20:41.190
Queremos saber como podemos alcançá-lo.

20:41.190 --> 20:46.080
Portanto, damos uma olhada nas chamadas recebidas, não nas chamadas efetuadas.

20:46.080 --> 20:49.380
Portanto, podemos ver que essa é a nossa função.

20:49.380 --> 20:52.110
E este está sendo chamado por este aqui, ok.

20:52.110 --> 20:53.280
Vamos clicar duas vezes.

20:54.390 --> 20:59.730
E aqui já podemos ver que essa função está sendo chamada pela função de entrada.

20:59.730 --> 21:05.700
Portanto, essa é a nossa cadeia de chamadas completa no momento, o que é bastante impressionante, pois não é muito.

21:05.700 --> 21:08.790
Temos nossa função de entrada, que é esta aqui.

21:08.790 --> 21:11.700
Essa função de entrada chama essa.

21:12.470 --> 21:16.760
E este chama a atenção para o sucesso e o fracasso de nossas decisões.

21:16.760 --> 21:23.660
Portanto, se chegarmos a esse ponto na função de sucesso, então, nossa entrada foi válida.

21:24.080 --> 21:24.890
Está bem.

21:25.770 --> 21:29.250
Portanto, esta aqui parece ser a nossa função principal.

21:29.250 --> 21:29.940
Por quê?

21:29.940 --> 21:32.310
Porque temos a função de entrada aqui.

21:32.310 --> 21:35.100
Aqui está um pouco do que está sendo preparado.

21:35.100 --> 21:39.150
E aqui temos esse primeiro ponteiro de função que termina aqui.

21:39.150 --> 21:43.080
Portanto, essa é a primeira função que está sendo chamada em nosso código de usuário.

21:43.080 --> 21:45.690
E também podemos ver um pouco de uma estrutura.

21:45.690 --> 21:50.550
Temos os parâmetros e obtivemos o valor de retorno.

21:50.550 --> 21:53.520
Portanto, nosso valor de retorno aqui é indefinido.

21:53.520 --> 21:55.980
Mas estamos retornando aqui um valor inteiro.

21:55.980 --> 22:00.750
E se pensarmos na estrutura de uma função principal, ela normalmente se parece com isso.

22:03.040 --> 22:08.440
Portanto, temos um int main argc char argv.

22:10.330 --> 22:10.870
Está bem.

22:10.870 --> 22:16.330
Portanto, esse é o valor de retorno, um valor de retorno e um número inteiro como um número inteiro.

22:16.840 --> 22:23.080
Argc é o primeiro parâmetro e Accaee é o uh, digamos, o número de.

22:24.460 --> 22:29.560
Argumentos que fornecemos ao nosso binário, estamos chamando de yes.

22:29.560 --> 22:36.340
Portanto, se abrirmos esse binário sem um parâmetro, teremos um argumento, que é o caminho para

22:36.340 --> 22:37.120
o binário.

22:37.120 --> 22:42.280
Se fornecermos um parâmetro, teremos dois parâmetros.

22:42.550 --> 22:50.710
Assim, por exemplo, se você o abrir dessa forma, valide, então argc seria um, porque esse é o caminho

22:50.710 --> 22:53.710
referente a esse binário.

22:53.710 --> 23:02.710
E se dissermos que validamos nosso número de série, então xy seria dois porque temos o primeiro, que

23:02.710 --> 23:07.120
é o caminho, mais nosso parâmetro ou argumento.

23:07.120 --> 23:09.580
Não importa como você queira chamá-lo.

23:10.570 --> 23:11.410
Está bem.

23:11.410 --> 23:14.500
Em seguida, temos nosso argv, que é este aqui.

23:14.500 --> 23:16.900
E esse é apenas um array de strings.

23:16.900 --> 23:18.580
Portanto, esses são nossos parâmetros.

23:18.580 --> 23:19.930
Por exemplo, este aqui.

23:20.200 --> 23:20.860
Tudo bem.

23:22.120 --> 23:23.800
Então vamos ver.

23:24.730 --> 23:26.260
Vamos manter isso em aberto aqui.

23:29.170 --> 23:30.010
Está bem.

23:30.070 --> 23:36.970
O que eu gostaria de fazer é reatribuir essa assinatura de função porque ela parece errada.

23:37.600 --> 23:39.430
Então, por que isso parece errado?

23:39.430 --> 23:42.670
Porque se dermos uma olhada nesse parâmetro dois.

23:42.700 --> 23:46.660
E, a propósito, essa é uma opção que eu configurei, mas não está configurada para você.

23:47.140 --> 23:53.920
Se você clicar no parâmetro, talvez seja necessário clicar com o botão do meio do mouse para que eles sejam destacados.

23:53.920 --> 23:58.360
E essa é uma opção que você pode executar aqui com uma ferramenta de edição.

23:58.360 --> 23:59.140
Opções.

24:00.780 --> 24:07.260
Você pode procurar o mouse e, em seguida, o destaque de texto do cursor, e pode alternar do meio para a esquerda.

24:07.260 --> 24:11.940
Então, basta clicar neste e ele destacará todas essas ocorrências.

24:12.480 --> 24:12.990
Está bem.

24:12.990 --> 24:17.010
Portanto, este aqui está sendo convertido em um ponteiro de caractere duplo.

24:17.010 --> 24:22.620
E também temos uma referência de índice aqui.

24:23.690 --> 24:29.480
Portanto, se virmos algo assim, o que eu gosto de fazer é simplesmente aplicar isso como um parâmetro aqui

24:29.480 --> 24:31.850
para ver se o código fica mais legível.

24:31.850 --> 24:36.470
É simplesmente uma tentativa e erro para ver se faz mais sentido.

24:36.470 --> 24:40.430
Dessa forma, podemos ver que temos um ponteiro duplo inteiro aqui.

24:40.700 --> 24:44.000
Hum, mas presumo que essa seja a função principal.

24:44.000 --> 24:45.830
Portanto, vamos tentar desta forma.

24:45.830 --> 24:50.930
Clicamos com o botão direito do mouse e digitamos novamente o ponteiro de caractere duplo variável.

24:51.500 --> 24:53.510
Por que essa sobreposição.

24:53.510 --> 24:55.310
Isso é muito irritante.

24:56.200 --> 24:58.330
Ok, vamos selecionar este.

24:58.770 --> 25:04.770
Então, eu clico em 3 para 1, e temos que verificar se este se torna um pouco mais legível.

25:05.040 --> 25:06.240
3 para 1.

25:06.720 --> 25:09.330
Sim, isso parece muito melhor agora.

25:09.360 --> 25:09.990
Está bem.

25:09.990 --> 25:11.820
Agora vamos aplicar também o restante.

25:11.820 --> 25:13.680
Então, clicamos com o botão direito do mouse.

25:13.680 --> 25:16.200
E também podemos dizer editar a assinatura da função.

25:17.290 --> 25:19.690
Portanto, podemos dizer que esse é um tipo de retorno.

25:19.690 --> 25:23.770
E renomeamos isso para main ou provavelmente main, caso não tenha certeza.

25:23.770 --> 25:27.670
Mas, neste momento, temos certeza de que ela está sendo chamada pela função de entrada.

25:28.460 --> 25:29.060
Está bem.

25:29.060 --> 25:34.520
Então, também podemos fornecer, quero dizer, este é RC e este é o nome argv, por exemplo.

25:36.700 --> 25:37.450
Sim.

25:39.280 --> 25:40.000
Está bem.

25:40.000 --> 25:43.000
E agora o código ficou um pouco mais legível.

25:43.030 --> 25:43.780
Tudo bem.

25:44.740 --> 25:46.450
Agora vamos ver.

25:46.630 --> 25:52.660
Hum, o que eu gosto de fazer é dar uma olhada rápida em algumas funções printf,

25:52.660 --> 25:59.830
porque essas funções printf já dão uma ideia e destacam quais são essas variáveis.

25:59.830 --> 26:03.850
Portanto, podemos ver que estamos usando um local c como um número inteiro.

26:03.850 --> 26:08.050
E este parece ser um comprimento fora do comum porque está sendo usado como um.

26:08.050 --> 26:12.670
Sim, como um valor decimal nessa instrução printf aqui.

26:12.670 --> 26:16.360
Portanto, este aqui é provavelmente um comprimento externo.

26:16.360 --> 26:22.780
Não temos a menor ideia do que significa out length e como ele está sendo usado, mas vamos chamá-lo de out length.

26:24.350 --> 26:24.860
Está bem.

26:24.860 --> 26:27.230
Até o momento, não consigo ver nenhum outro parâmetro.

26:27.230 --> 26:29.660
Portanto, não podemos fazer mais.

26:29.960 --> 26:32.300
Então, vamos começar do início.

26:32.300 --> 26:39.470
Se nossos arcos não forem iguais a, o que significa que fornecemos mais ou menos de um parâmetro, então

26:39.470 --> 26:41.420
entramos nessa função.

26:41.420 --> 26:45.890
Clicamos duas vezes para validar o uso e assim por diante.

26:45.890 --> 26:48.590
Portanto, essa é apenas a saída de uso.

26:48.830 --> 26:50.510
Portanto, clique com o botão direito do mouse.

26:50.510 --> 26:53.450
Ou você pode simplesmente clicar nesse local e pressionar L.

26:54.050 --> 26:57.950
Mas os atalhos e o Shedra podem ficar fora de controle.

26:57.950 --> 27:03.770
Portanto, há pessoas que passam por esse navegador e, em seguida, realizam todos esses ajustes.

27:03.770 --> 27:06.650
Tento tornar isso um pouco mais fácil de acompanhar.

27:06.650 --> 27:12.800
Então, vamos para renomear essa função, e esta é apenas uma ajuda de impressão.

27:15.110 --> 27:19.700
Ok, então eu uso o controle e a tecla de seta para a esquerda.

27:19.790 --> 27:20.840
Duas vezes.

27:20.840 --> 27:21.830
Agora estamos de volta.

27:22.460 --> 27:25.580
Isso significa que temos que fornecer um parâmetro aqui.

27:25.580 --> 27:30.920
Ok, então obtivemos o comprimento da string em nosso parâmetro que fornecemos.

27:30.920 --> 27:35.930
Portanto, argv, que é o primeiro, arg0 é o primeiro.

27:35.930 --> 27:38.810
Mas isso está relacionado ao binário um.

27:38.810 --> 27:42.680
Portanto, nosso argv é o primeiro parâmetro que fornecemos.

27:43.410 --> 27:50.370
E aqui temos uma string. length, o que significa que esse agora contém o comprimento de nossa entrada.

27:50.580 --> 27:55.020
Portanto, esse é o nosso péssimo hábito.

27:55.050 --> 27:56.880
Clique com o botão direito do mouse em renomear.

27:58.200 --> 28:01.410
Esse é o nosso comprimento de entrada.

28:04.100 --> 28:04.850
Está bem.

28:06.290 --> 28:10.970
Em seguida, podemos ver se o comprimento da entrada não é igual a zero x dez.

28:10.970 --> 28:13.400
Podemos passar o mouse sobre isso e, em seguida, ele será exibido.

28:13.400 --> 28:14.300
São 16.

28:14.300 --> 28:16.580
Mas também podemos clicar com o botão direito do mouse nessa opção.

28:16.580 --> 28:19.220
E então podemos ver a representação decimal.

28:20.590 --> 28:23.710
Se não for 16, então estamos chamando essa função.

28:23.710 --> 28:25.330
Então, vamos clicar duas vezes.

28:26.350 --> 28:27.550
Série incorreta.

28:27.550 --> 28:28.570
Formato incorreto.

28:28.570 --> 28:29.290
Está bem.

28:29.680 --> 28:32.260
Portanto, clique com o botão direito do mouse em renomear.

28:33.490 --> 28:34.810
Incorreto.

28:34.810 --> 28:36.100
Talvez impresso.

28:37.630 --> 28:38.950
Incorreto.

28:39.880 --> 28:41.590
Formato incorreto.

28:43.330 --> 28:47.740
Ok, controle e dois tempos restantes.

28:48.040 --> 28:58.420
Isso significa que, se não estivermos ou se estivermos inserindo um número com 16 caracteres, passaremos por essa verificação

28:58.420 --> 29:03.610
e deverá haver uma saída de decodificação da base 32 aqui.

29:04.030 --> 29:06.280
Então, vamos tentar fazer isso rapidamente.

29:08.190 --> 29:10.350
Ainda temos o site aberto em algum lugar?

29:11.960 --> 29:12.680
Não.

29:13.130 --> 29:14.570
Vamos fazer isso rapidamente.

29:14.570 --> 29:20.690
Portanto, o shell do ADB valida os dados temporários locais.

29:22.520 --> 29:26.360
Ok, vamos fornecer 16 caracteres.

29:28.100 --> 29:28.790
Perfeito.

29:28.790 --> 29:30.860
Podemos ver 16 caracteres.

29:30.860 --> 29:34.550
Podemos ver a base 32 decodificando o comprimento, o que quer que isso signifique.

29:34.550 --> 29:35.300
Verifique a licença.

29:35.300 --> 29:35.780
Incorreto.

29:35.780 --> 29:39.380
Serial com um caractere a menos ou a mais.

29:40.100 --> 29:41.810
Formato serial incorreto.

29:42.350 --> 29:43.520
Certo, perfeito.

29:43.520 --> 29:46.730
Até o momento, entendemos o programa, o que é bom.

29:47.690 --> 29:51.230
Em seguida, podemos ver a decodificação da base 32.

29:51.230 --> 30:00.530
E isso já é importante, pois significa que nossa entrada precisa ser codificada na base 32, suponho, a partir

30:00.530 --> 30:01.700
deste ponto.

30:01.700 --> 30:04.580
Mas vamos ter isso em mente.

30:04.580 --> 30:06.380
Então, temos essa função.

30:08.430 --> 30:11.610
E isso agora tem muitos parâmetros.

30:11.610 --> 30:16.350
E o que eu gosto de fazer é clicar neste ícone de câmera aqui.

30:16.350 --> 30:17.730
Isso tira um instantâneo.

30:17.730 --> 30:20.010
Portanto, temos isso agora em nosso lado direito.

30:20.010 --> 30:22.320
E se agora clicarmos duas vezes neste.

30:23.470 --> 30:25.240
Temos esses parâmetros aqui.

30:25.240 --> 30:28.210
Portanto, agora podemos ver o que é cada parâmetro.

30:28.210 --> 30:34.210
Por exemplo, o primeiro é zero zero e este aqui é o nosso argv1.

30:34.210 --> 30:36.430
Aqui estamos com 16.

30:36.640 --> 30:41.530
Isso é algo relacionado à pilha e é o nosso comprimento de saída.

30:43.660 --> 30:46.000
Portanto, já podemos fornecer esse nome aqui.

30:46.000 --> 30:47.740
Podemos dizer, por exemplo, o seguinte.

30:49.090 --> 30:49.900
Renomear.

30:49.900 --> 30:51.910
Esse é o nosso comprimento de saída.

30:52.900 --> 30:53.650
Está bem.

30:54.130 --> 30:57.070
No entanto, vamos dar uma olhada rápida nessa função.

30:59.880 --> 31:03.180
Tudo bem se eu vir coisas como essa?

31:04.290 --> 31:06.270
Hum, eu sou.

31:06.270 --> 31:10.140
Normalmente, não gosto de reverter isso porque.

31:13.370 --> 31:22.610
Pode ser uma função básica em C ou, por exemplo, um MD5 ou um Sha qualquer coisa ou

31:22.610 --> 31:25.100
coisas desse tipo.

31:25.100 --> 31:34.400
Portanto, não quero perder tempo invertendo funções que não são tão relevantes ou que são apenas funções

31:34.400 --> 31:35.480
básicas.

31:35.480 --> 31:40.550
Se não tivermos símbolos no printf, quero dizer, aqui temos no printf porque ele precisa ser exportado.

31:40.550 --> 31:47.750
Mas se esta for agora, hum, não sei, digamos uma função MD5.

31:48.050 --> 31:52.220
Então, podemos tentar procurar certos valores codificados.

31:52.220 --> 31:55.160
Portanto, md5, funções Sha one e coisas do gênero.

31:55.160 --> 31:58.130
Eles têm valores hexadecimais codificados que podem ser pesquisados on-line.

31:58.130 --> 32:06.860
E então, nós já sabemos, hum, agora eu gostaria de pular essa parte e ver se ela se torna importante mais tarde.

32:06.860 --> 32:10.400
Portanto, ele pode fazer algo muito importante.

32:10.400 --> 32:19.430
Mas, a menos que não seja algo que ainda não tenhamos descoberto, gosto de ignorar essas funções porque são muito complexas.

32:19.430 --> 32:23.810
E, no final, estamos revertendo algo que talvez não seja realmente relevante para nós.

32:24.950 --> 32:27.020
Hum, sim.

32:27.020 --> 32:33.410
Então, podemos clicar nisso porque, sim, ele entra na toca do coelho para que possamos ver.

32:34.550 --> 32:34.880
Hmm.

32:36.320 --> 32:38.900
Isso se torna sim.

32:40.680 --> 32:43.980
Se esse for o desafio, então sei por que deveria ser.

32:44.010 --> 32:44.610
Sim.

32:44.610 --> 32:46.320
Resolvido por execução simbólica.

32:46.320 --> 32:48.630
Mas, neste momento, vamos pular essa parte aqui.

32:50.250 --> 32:52.350
Ok, então vamos encerrar esse caso.

32:54.730 --> 32:58.690
Portanto, este é um desempenho com o comprimento da saída.

32:58.690 --> 33:00.970
Ok, isso pode ser relevante mais tarde.

33:01.420 --> 33:03.040
Não sabemos isso no momento.

33:03.040 --> 33:05.740
Então, vamos ver como entrar na licença de verificação.

33:05.740 --> 33:08.770
E podemos ver que agora temos esse parâmetro de pilha.

33:09.250 --> 33:12.220
O parâmetro da pilha também tem 16 bytes.

33:12.700 --> 33:15.670
E esses 16 bytes são iguais ao comprimento da entrada.

33:15.670 --> 33:22.090
E o que presumo neste momento é que estamos entrando em nossa função aqui, que é muito complexa.

33:22.090 --> 33:24.460
Então, talvez devêssemos renomear isso.

33:26.960 --> 33:29.420
Função complexa.

33:31.220 --> 33:36.080
Estamos entrando nessa função complexa com nosso argumento e vários outros parâmetros.

33:36.080 --> 33:41.150
E, no final, podemos escrever isso nesta parte aqui.

33:41.760 --> 33:45.120
E essa parte está sendo usada agora nessa última função.

33:45.120 --> 33:46.650
Sucesso ou fracasso da decisão.

33:46.680 --> 33:48.810
Portanto, essa é apenas a assimilação.

33:48.810 --> 33:53.550
Ou seja, podemos dar uma olhada rápida nessa função complexa em relação a esse parâmetro,

33:53.550 --> 33:54.540
que é este aqui.

33:57.530 --> 33:58.280
Está bem.

33:58.280 --> 34:01.820
Este está sendo transferido para o local 38.

34:02.490 --> 34:05.580
E este está sendo preenchido nesta e nesta função.

34:05.580 --> 34:05.820
Sim.

34:05.820 --> 34:13.920
Portanto, estamos definitivamente preenchendo esse espaço de memória com algum tipo de dado.

34:13.920 --> 34:14.700
Está bem.

34:14.790 --> 34:17.190
Podemos ver se estamos retornando para fora dessa?

34:17.190 --> 34:21.180
Nesse caso, temos que verificar o código de montagem para ele.

34:22.530 --> 34:23.310
Um.

34:25.810 --> 34:27.790
Onde retornamos.

34:28.420 --> 34:28.750
Está bem.

34:28.750 --> 34:30.520
Muitas instruções de ramificação.

34:30.520 --> 34:31.150
Sim.

34:31.150 --> 34:32.440
É complexo.

34:32.440 --> 34:33.760
Vamos ignorar isso por enquanto.

34:34.600 --> 34:38.830
Ok, então, se essa decisão for bem-sucedida ou não, vamos entrar nessa.

34:38.830 --> 34:46.240
E digamos que isso seja algo que esteja sendo executado com a nossa e com a nossa contribuição, provavelmente.

34:47.120 --> 34:49.370
Entrada modificada.

34:50.150 --> 34:50.810
Está bem.

34:52.240 --> 34:54.190
Decisão, sucesso ou fracasso.

34:55.330 --> 35:03.310
Então, aqui temos o nosso, desculpe-me, clique com o botão direito do mouse para renomear e, provavelmente, o modo de entrada.

35:04.660 --> 35:07.390
Portanto, aqui temos nossa função de sucesso e fracasso.

35:07.390 --> 35:08.080
Vejamos.

35:08.080 --> 35:12.430
Temos um monte de variáveis locais, mas elas não estão sendo usadas em instruções de impressão.

35:12.430 --> 35:14.290
Portanto, não sabemos quais são esses.

35:15.340 --> 35:16.630
Nós temos essa.

35:16.630 --> 35:17.680
Também não é conhecido.

35:17.680 --> 35:19.780
Ok, temos que começar do início.

35:19.780 --> 35:24.310
Nossa provável entrada agora está sendo transferida para esse registro local.

35:24.310 --> 35:30.250
Portanto, esse é agora o nosso mod de entrada local.

35:31.570 --> 35:32.380
Está bem.

35:32.380 --> 35:37.060
E não gosto de fornecer nomes grandes porque o código fica muito ilegível.

35:37.060 --> 35:40.030
Mas, mesmo assim, acho que não há problema.

35:40.660 --> 35:42.640
Assim, podemos ver que obtivemos o for loop.

35:42.640 --> 35:44.800
E esse loop for tem isso.

35:44.800 --> 35:47.710
Ok, este parece ser um encontro.

35:47.710 --> 35:55.210
Assim, nosso um típico para I é igual a zero I é menor que cinco ou menor que cinco.

35:56.770 --> 35:57.610
Desculpe.

36:00.110 --> 36:01.640
Ele é aumentado.

36:01.970 --> 36:04.520
Portanto, vamos mudar o nome para I.

36:06.410 --> 36:07.670
Renomear a variável.

36:07.670 --> 36:09.890
Ele também está sendo usado apenas nesta parte aqui.

36:09.890 --> 36:12.500
Portanto, podemos renomeá-lo para I.

36:12.500 --> 36:16.820
Se estiver sendo reutilizado mais tarde nesse código, talvez eu não seja tão útil.

36:16.820 --> 36:18.560
Mas, nesse caso, não há problema.

36:18.800 --> 36:19.220
Está bem.

36:19.220 --> 36:22.640
Portanto, o código já se tornou bastante legível.

36:22.640 --> 36:24.440
O que temos aqui é.

36:25.410 --> 36:29.970
Conseguimos um loop, que passa por isso cinco vezes.

36:30.180 --> 36:31.590
012.

36:31.590 --> 36:33.300
345.

36:33.330 --> 36:34.740
Tempos de por um.

36:35.490 --> 36:41.970
Em seguida, ele pega nossa entrada e faz XOR com o próximo valor de nossa entrada.

36:43.760 --> 36:49.250
Armazena isso no local 20, portanto, esse parece ser o nosso resultado.

36:52.040 --> 36:52.940
Resultado.

36:54.440 --> 36:57.020
E então ele aumenta.

36:58.580 --> 37:00.650
Nosso índice em dois.

37:00.740 --> 37:01.610
Está bem.

37:04.530 --> 37:13.890
Portanto, ter a referência aqui significa que estamos tendo a primeira entrada da nossa matriz de bytes, o que significa que este

37:13.890 --> 37:15.090
é o índice zero.

37:15.090 --> 37:19.710
Portanto, estamos usando o índice zero com o índice um.

37:20.510 --> 37:23.840
E então estamos aumentando esse índice em dois.

37:23.840 --> 37:25.490
E vamos escrever isso.

37:29.960 --> 37:36.260
Portanto, temos o resultado I para nosso primeiro valor.

37:36.260 --> 37:40.850
Parece um mod de entrada local.

37:41.000 --> 37:49.280
Portanto, temos aqui o nosso primeiro índice, que está sendo combinado com o próximo.

37:51.850 --> 37:55.360
E então aumentamos esse índice em dois.

37:58.630 --> 38:01.720
Ou seja, nosso próximo resultado.

38:04.180 --> 38:06.400
Deve se parecer com isso.

38:12.490 --> 38:17.890
Sim, ele pega esses dois valores, faz o XOR e os armazena de volta no resultado.

38:17.890 --> 38:20.020
E, em seguida, ele pega os próximos dois valores.

38:20.020 --> 38:26.680
Assim, por exemplo, se tivermos a, b, c d, então a e b estão sendo XOR.

38:26.680 --> 38:30.310
E na próxima instrução, c e d seriam XOR.

38:31.090 --> 38:36.250
Acho que estou bastante confiante de que esse é o caso aqui, a menos que.

38:36.580 --> 38:41.170
Vamos ver se é realmente com uh aumentou o AD em dois.

38:41.170 --> 38:41.650
Sim.

38:41.650 --> 38:42.340
Está bem.

38:43.210 --> 38:52.060
Às vezes, se tivermos, por exemplo, um array de números inteiros, ele conta até uh quatro, o que significa o próximo elemento.

38:52.060 --> 38:58.330
E, ao verificar se este agora está sendo adicionado por dois, estamos nos certificando de que este não

38:58.330 --> 38:59.710
é uma descompilação.

39:00.340 --> 39:07.030
Vamos chamá-lo de erro, que simplesmente pula para um próximo elemento A ou algo assim.

39:07.030 --> 39:09.760
Portanto, isso está realmente sendo incrementado em dois.

39:09.760 --> 39:12.220
Não tenho certeza se isso está claro neste momento.

39:12.220 --> 39:17.770
Acho que não está muito bem explicado, mas espero que você entenda o que quero dizer.

39:17.770 --> 39:25.480
Portanto, se tivermos uma matriz de números inteiros e quisermos obter o próximo índice, teremos que adicionar quatro, pois um número

39:25.480 --> 39:27.220
inteiro tem quatro bytes.

39:27.850 --> 39:30.820
E, portanto, obter a próxima entrada significa mais quatro.

39:30.820 --> 39:37.720
E, portanto, verificamos se este é apenas um incremento de dois, o que significa que não estamos

39:37.720 --> 39:39.040
pulando.

39:39.040 --> 39:42.370
Por exemplo, um índice curto, que é de dois bytes.

39:42.370 --> 39:44.140
Portanto, vamos pular para o próximo índice.

39:44.140 --> 39:46.480
E isso agora está realmente agregando o valor dois.

39:46.510 --> 39:53.410
Com relação à matriz de bytes, que tem um byte de tamanho, significa que estamos pulando dois elementos acima.

39:54.640 --> 39:55.480
Muito bem.

39:55.480 --> 40:01.420
Então, sim, acho que o vídeo já está ficando um pouco longo, mas vamos ver.

40:02.080 --> 40:04.240
Estamos, acho que estamos, perto do final.

40:04.240 --> 40:06.970
Já temos ou acabamos de ter essas funções aqui.

40:06.970 --> 40:07.540
Vejamos.

40:07.540 --> 40:09.790
Espero que não estejam explodindo.

40:09.790 --> 40:11.440
Portanto, dê um clique duplo nesse vídeo.

40:12.240 --> 40:12.810
Está bem.

40:12.810 --> 40:18.300
Este é um 0X4C de retorno e este é o caractere L.

40:18.300 --> 40:21.810
Portanto, também podemos clicar com o botão direito do mouse e fazer isso desta forma.

40:21.810 --> 40:31.770
Então, renomeamos essa função um para return L porque ela sempre retorna L, certo?

40:31.770 --> 40:34.050
Não sou um grande fã dessa representação.

40:34.050 --> 40:35.820
Portanto, vamos manter as coisas assim.

40:37.740 --> 40:40.080
Portanto, esse é um L de retorno, ok.

40:40.080 --> 40:45.960
Portanto, isso agora está armazenando o valor L, mas este está sendo reatribuído.

40:45.960 --> 40:53.760
Portanto, se renomeássemos isso para L local, seria errado, porque aqui ele está sendo substituído.

40:54.030 --> 40:56.670
Portanto, controle Z.

40:56.790 --> 40:59.910
Não estamos renomeando isso agora, ok.

40:59.910 --> 41:00.930
Próxima função.

41:02.720 --> 41:04.670
0X4F.

41:04.670 --> 41:05.840
Isso é um O.

41:06.470 --> 41:07.520
Renomear.

41:07.760 --> 41:09.290
Devolver tudo.

41:13.950 --> 41:16.320
Aqui está o al mais uma vez perfeito.

41:16.320 --> 41:20.310
Podemos reconhecer isso porque o renomeamos aqui.

41:20.310 --> 41:21.720
Essa é a mesma função.

41:21.930 --> 41:24.030
Então vamos ver o que está acontecendo aqui.

41:24.610 --> 41:26.230
0X5A.

41:26.230 --> 41:27.340
Isso é um conjunto.

41:33.670 --> 41:37.660
Ok, então temos essa função à esquerda 21.

41:38.940 --> 41:40.650
Ponto de exclamação.

41:44.120 --> 41:44.600
Está bem.

41:44.600 --> 41:46.160
Vamos ver o que está acontecendo aqui.

41:46.250 --> 41:50.090
Portanto, essa variável ou vamos ver o que está acontecendo aqui.

41:50.600 --> 41:52.010
Esse é o nosso loop for.

41:52.010 --> 41:54.140
Repetimos isso cinco vezes.

41:54.140 --> 42:01.190
Em seguida, armazenamos o valor de nosso primeiro e segundo elemento XOR juntos nessa parte.

42:01.190 --> 42:02.540
Então aumentamos isso.

42:02.540 --> 42:05.030
Então, chegamos a essa parte.

42:05.060 --> 42:07.220
Esse é armazenado no resultado.

42:09.940 --> 42:18.100
E para zero, e esse é armazenado no resultado um.

42:20.230 --> 42:20.950
Ops.

42:22.420 --> 42:23.200
Está bem.

42:24.590 --> 42:26.960
E então temos isso aqui.

42:27.540 --> 42:29.250
E aqui estamos nós retornando.

42:29.250 --> 42:34.560
L e, em seguida, o primeiro elemento de C do nosso resultado é comparado se for um L.

42:34.560 --> 42:36.870
Então, aqui está.

42:36.870 --> 42:47.910
Em seguida, se o resultado null sorry zero for igual a L, tudo bem.

42:49.830 --> 42:50.160
Uh.

42:50.160 --> 42:51.360
Vejamos.

42:52.840 --> 42:55.000
Então, temos outra comparação.

42:55.390 --> 42:56.920
Se retornar.

42:56.920 --> 42:57.850
Oh.

42:58.210 --> 43:04.420
Ah, isso parece um pouco confuso, mas aqui estamos atribuindo essa variável com retorno.

43:04.420 --> 43:04.750
Oh.

43:04.750 --> 43:06.490
Portanto, isso está sendo atribuído agora.

43:06.490 --> 43:06.730
Oh.

43:06.730 --> 43:07.930
E então ele é comparado.

43:07.930 --> 43:10.840
Se o resultado for tão bom.

43:12.880 --> 43:15.310
Estamos tendo menos do que estamos tendo.

43:15.310 --> 43:15.910
Oh.

43:17.640 --> 43:23.580
Então, mais uma vez, L é atribuído a U1 e está sendo comparado com o resultado dois.

43:23.610 --> 43:27.300
Portanto, o terceiro elemento é um L.

43:28.940 --> 43:32.960
Em seguida, atribuímos um conjunto a essa variável e comparamos.

43:32.960 --> 43:36.470
Se o quarto elemento estiver em um conjunto.

43:39.650 --> 43:46.370
Em seguida, retornamos o ponto de exclamação e verificamos se o quinto elemento é esse ponto de exclamação.

43:47.780 --> 43:54.770
Portanto, temos a nossa entrada e essa entrada agora está se xorando.

43:55.430 --> 43:57.200
Assim.

43:57.930 --> 44:01.200
Em seguida, ele compara esses elementos.

44:03.300 --> 44:05.730
Uh, fica L. O. L.

44:05.760 --> 44:08.580
Coloque o ponto de exclamação para que o lolz.

44:09.360 --> 44:10.080
Tudo bem.

44:10.230 --> 44:14.370
O que não sabemos no momento é essa parte aqui no meio.

44:15.360 --> 44:16.740
Portanto, se você voltar atrás.

44:19.300 --> 44:27.550
Agora, com essa função complexa, podemos fazer uma suposição ousada de que estamos inserindo a decodificação Base32, o que

44:27.550 --> 44:31.870
significa que nossa entrada precisa ser codificada em 32 bits.

44:31.870 --> 44:34.090
Então, vamos escrever isso aqui.

44:34.120 --> 44:37.360
Podemos definir e comentar com o botão direito do mouse.

44:37.990 --> 44:40.000
Então, temos várias opções diferentes.

44:40.000 --> 44:44.620
Postar comentário significa que estamos adicionando esse comentário após essa instrução.

44:44.710 --> 44:51.880
Acho que o comentário sobre a promessa são esses asteriscos que estão apenas na visualização da montagem.

44:52.150 --> 44:55.240
Comentário repetível Não tenho certeza sobre esse comentário no momento.

44:55.240 --> 45:01.330
O comentário de final de linha o colocaria no final da linha, mas é difícil de ler no código de montagem.

45:01.330 --> 45:07.390
Por isso, gosto de usar comentários prévios, o que significa que eles estão sendo adicionados antes na visualização da montagem e também na visualização

45:07.390 --> 45:08.380
descompilada.

45:08.380 --> 45:21.910
Portanto, nossa entrada provavelmente precisa ser codificada em base32, a menos que o desenvolvedor nos engane aqui.

45:24.500 --> 45:29.630
Ok, agora podemos ver que colocamos esse comentário aqui, mas gostaríamos de tê-lo aqui.

45:29.630 --> 45:31.940
Esse é o caso porque, hum.

45:33.120 --> 45:37.950
As instruções de montagem estão um pouco erradas em relação ao código descompilado.

45:37.950 --> 45:43.560
Ou digamos que o código descompilado esteja fora das instruções de montagem, porque no lado esquerdo estamos corretos.

45:43.560 --> 45:48.270
No lado direito, pode haver erros, portanto, podemos clicar com o botão direito do mouse no comando.

45:49.670 --> 45:54.650
Então, podemos usar esse controle X para cortá-lo.

45:54.920 --> 46:00.110
E então entramos nessa colocação e dizemos aqui, comente.

46:01.880 --> 46:07.040
Defina o pré-comentário e não haverá problema algum em tê-lo aqui.

46:07.070 --> 46:07.850
Está bem.

46:09.550 --> 46:15.730
Portanto, o que o código está fazendo é pegar nosso argumento, que precisa ser, ou provavelmente é, basicamente

46:15.760 --> 46:17.830
uma base 32 codificada.

46:18.750 --> 46:21.000
Em seguida, estamos verificando se temos um parâmetro.

46:21.000 --> 46:22.290
Se não, nós recebemos a ajuda.

46:22.290 --> 46:23.820
Ele obtém o comprimento da string.

46:23.820 --> 46:26.460
Ele verifica se foram fornecidos 16 caracteres.

46:27.320 --> 46:28.970
Codificado em Base32.

46:28.970 --> 46:30.470
Isso é importante neste momento.

46:31.310 --> 46:35.840
Se não, está imprimindo no formato errado, então é mais provável.

46:35.840 --> 46:37.130
Vamos renomear isso.

46:40.910 --> 46:45.560
Provavelmente decodificação base32.

46:47.690 --> 46:51.470
Provavelmente, ele se baseia em 32 decodificações.

46:52.700 --> 46:54.410
Escreve-o neste aqui.

46:54.410 --> 46:56.000
Aqui estão.

46:56.000 --> 47:02.630
É por isso que o comprimento de saída pode ter sido zero antes, porque não era possível usar a base 32.

47:02.990 --> 47:03.230
Um.

47:03.230 --> 47:04.130
Decodifique isso.

47:04.130 --> 47:05.570
Vamos experimentar isso.

47:05.570 --> 47:08.840
Isso é algo, hum.

47:10.110 --> 47:11.460
Podemos verificar.

47:11.850 --> 47:18.480
Portanto, aqui podemos ver que o comprimento de saída é zero porque esse não é um formato de codificação de base 32 válido.

47:18.510 --> 47:19.800
Vamos ver se conseguimos.

47:21.440 --> 47:21.980
Oof!

47:21.980 --> 47:22.610
Um.

47:24.820 --> 47:27.070
Como conseguimos isso exatamente?

47:28.410 --> 47:29.100
16.

47:29.100 --> 47:32.520
Mas, mesmo assim, vamos fazer isso da seguinte maneira: a, b, c, d.

47:33.030 --> 47:35.070
Temos a base 32?

47:36.000 --> 47:37.890
Sim, nós a temos.

47:38.160 --> 47:39.000
Está bem.

47:39.000 --> 47:40.980
Agora não tenho certeza.

47:40.980 --> 47:45.090
12345678 ok.

47:45.090 --> 47:47.520
Vamos fazer isso duas vezes.

47:49.950 --> 47:55.320
Então, temos 16 bytes e vamos ver se agora obtemos um comprimento.

47:56.920 --> 47:57.400
Um.

47:57.400 --> 47:58.780
Aqui no comprimento externo.

47:58.780 --> 48:05.500
Isso significa que, muito provavelmente, ele está realizando essa codificação, decodificação e decodificação.

48:05.500 --> 48:05.800
Sim.

48:05.800 --> 48:07.510
Portanto, 3 para 1.

48:07.840 --> 48:08.290
Sim.

48:08.290 --> 48:08.830
Perfeito.

48:08.830 --> 48:13.720
Podemos ver que temos um comprimento de saída de dez, ok.

48:15.430 --> 48:19.630
Portanto, isso é codificado em base32, ok.

48:19.630 --> 48:24.670
Isso significa que chegamos facilmente a esse ponto aqui.

48:26.090 --> 48:30.980
Ao fornecer uma entrada codificada em 32 base32.

48:31.730 --> 48:40.550
Hum, o que é complicado agora é que nossa entrada de base 32 precisa ser e xored com ela mesma.

48:40.550 --> 48:40.880
Desculpe.

48:40.880 --> 48:44.870
Não, não, nós estamos bagunçando ou eu estou bagunçando as coisas agora.

48:44.870 --> 48:45.440
Desculpe.

48:46.580 --> 48:47.660
Vamos voltar.

48:48.770 --> 48:50.720
Base 32 decodificada.

48:50.720 --> 48:53.870
Portanto, aqui temos uma matriz de bytes depois.

48:53.870 --> 48:57.050
Portanto, o que estamos fazendo aqui é colocar o nosso.

48:59.950 --> 49:01.630
Nossa página 64.

49:01.870 --> 49:02.200
Desculpe.

49:02.200 --> 49:03.970
Base 32.

49:04.120 --> 49:04.630
Sou eu.

49:04.630 --> 49:06.430
Não estou acostumado com a base 32.

49:06.460 --> 49:07.300
Então, uh.

49:07.300 --> 49:09.400
Sim, estamos colocando nosso.

49:11.470 --> 49:13.480
Esqueça o que você viu.

49:13.480 --> 49:15.790
Estamos lançando nossa base 32.

49:15.820 --> 49:22.900
Uh, entrada em uma função de decodificação, e estamos recebendo de volta os bytes brutos.

49:22.900 --> 49:24.970
Então, hum.

49:24.970 --> 49:29.620
Sim, aqui estamos tendo bytes ao entrar nessa função.

49:30.010 --> 49:31.900
Então, vamos renomear isso.

49:33.310 --> 49:40.270
Essa é a base 32 decodificada, o que significa bytes.

49:40.840 --> 49:44.140
Ok, vamos entrar nessa.

49:45.640 --> 49:53.350
E vamos renomear esse nome para provavelmente bytes de entrada.

49:53.590 --> 49:54.340
Está bem.

49:54.640 --> 49:56.200
Isso é muito importante.

49:56.200 --> 49:58.240
Então, aqui estamos nós com bytes.

49:58.240 --> 49:59.290
E isso significa.

50:00.540 --> 50:02.280
Agora temos que fazê-lo.

50:02.460 --> 50:09.780
Agora precisamos encontrar uma maneira de fazer X ou fazer com que nossos bytes façam X juntos.

50:11.580 --> 50:14.670
O que resulta em moradores locais.

50:16.160 --> 50:21.170
Também podemos entrar nesse gráfico de função de exibição.

50:21.680 --> 50:24.140
Então, acho que pode ser um pouco mais fácil de ver.

50:24.500 --> 50:24.950
Sim.

50:26.560 --> 50:27.070
Está bem.

50:27.070 --> 50:28.300
Podemos simplesmente aumentar o zoom.

50:28.300 --> 50:32.740
Portanto, aqui temos o início de nossa função de sucesso da decisão.

50:32.740 --> 50:36.580
Não é realmente importante que você leia todas as linhas.

50:36.580 --> 50:38.350
Trata-se apenas do panorama geral.

50:38.920 --> 50:39.430
Está bem.

50:39.430 --> 50:41.050
Então, temos algumas coisas aqui.

50:41.970 --> 50:47.040
Em seguida, este é o nosso loop while, com o qual estamos xorando nossas coisas.

50:47.430 --> 50:50.250
E então podemos ver que sim, isso parece perfeito.

50:50.250 --> 50:52.230
Podemos ver que ele se compara.

50:52.230 --> 50:58.290
Se a nossa saída nos der um resultado de "l o l", coloque um ponto de exclamação.

50:58.290 --> 51:04.800
Se esse for o caso, a ativação do produto será bem-sucedida e, se não for, acabaremos aqui.

51:04.800 --> 51:07.530
Também podemos marcar isso com a cor truz.

51:08.830 --> 51:13.630
Portanto, essa é a parte que não queremos alcançar, e essa é a parte que queremos alcançar.

51:14.690 --> 51:19.610
Agora, se pudermos salvar isso e voltar.

51:20.530 --> 51:23.500
Agora também temos isso destacado aqui.

51:23.530 --> 51:24.430
Está bem.

51:25.030 --> 51:27.850
Portanto, este vídeo já está um pouco longo.

51:27.850 --> 51:30.160
E eu gostaria de dividi-lo em duas partes.

51:30.160 --> 51:36.220
Vamos recapitular isso rapidamente, porque é um pouco difícil ou, no momento, isso não está realmente relacionado

51:36.220 --> 51:38.890
ao hacking de aplicativos Android.

51:38.890 --> 51:45.160
Está mais relacionado à engenharia reversa, que pode ou pode ser necessária para invadir aplicativos Android.

51:45.160 --> 51:51.070
Portanto, vamos fazer uma recapitulação e, depois, você pode tentar resolver isso por conta própria, caso se sinta completamente

51:51.070 --> 51:53.260
sobrecarregado, sem problema algum.

51:53.620 --> 51:57.370
Hum, faremos isso no próximo vídeo juntos.

51:57.370 --> 51:58.720
Então vamos ver.

51:59.890 --> 52:00.430
Está bem.

52:00.430 --> 52:03.130
Portanto, vamos tomar essas medidas.

52:03.190 --> 52:07.780
As etapas consistem em fornecer uma entrada codificada em base32.

52:08.140 --> 52:12.040
Esse é então decodificado com base32.

52:12.430 --> 52:16.270
Hum, e então talvez, talvez façamos desta forma.

52:16.270 --> 52:28.870
E, na próxima etapa, nosso resultado está sendo xored.

52:31.240 --> 52:32.620
Assim.

52:33.880 --> 52:39.940
E depois vamos ter esse mais dois, hum, aqui depois.

52:41.290 --> 52:43.720
Esse resultado está sendo verificado.

52:44.230 --> 52:48.430
Se o resultado zero tiver se tornado o valor L.

52:49.660 --> 52:56.170
Se, uh, o resultado um se tornou o valor.

52:56.170 --> 52:57.460
Ah, e assim por diante.

52:57.460 --> 53:01.120
Então, é como se estivesse tudo bem.

53:02.110 --> 53:04.900
No próximo vídeo, apresentaremos a solução para esse caso.

53:04.900 --> 53:07.060
Portanto, você pode tentar resolver isso.

53:07.060 --> 53:08.500
Não estou esperando isso.

53:08.500 --> 53:15.250
Não porque você não seja capaz de fazê-lo, porque se você não tiver feito essa engenharia reversa com frequência, todas

53:15.250 --> 53:20.920
essas coisas, como xoring de valores entre si e coisas assim, esses padrões são novos para você e você

53:20.920 --> 53:22.840
precisa aprender isso primeiro.

53:22.840 --> 53:24.610
Eu também passei por essa fase.

53:24.610 --> 53:31.570
Portanto, sim, agora reconheço esses padrões, mas é um processo de aprendizado, portanto, não se desmotive

53:31.570 --> 53:32.860
com isso, certo?

53:33.310 --> 53:34.060
Tudo bem.

53:34.060 --> 53:39.160
Portanto, estou ansioso para vê-lo no próximo vídeo, onde apresentaremos a solução para esse

53:39.160 --> 53:39.670
caso.

53:39.700 --> 53:40.840
Vejo você lá.