WEBVTT

00:00.140 --> 00:04.880
Bem, aqui estamos nós, de volta ao ponto de partida, e não tenho certeza de como você se sente agora.

00:04.880 --> 00:08.180
Portanto, se você puder resolver isso, não estou esperando.

00:08.180 --> 00:11.900
Mas se você pudesse resolver isso, seria fantástico.

00:11.900 --> 00:14.510
Portanto, isso seria muito, muito grande.

00:14.510 --> 00:20.570
E você pode ficar muito, muito orgulhoso de si mesmo, caso tenha tido dificuldades nessa, mas isso

00:20.570 --> 00:24.020
não é problema algum, porque essa aqui é difícil.

00:24.020 --> 00:25.400
Não é tão fácil assim.

00:25.400 --> 00:27.470
Eu diria que é moderado.

00:27.470 --> 00:34.760
Portanto, sim, a engenharia reversa de coisas como essa exige muito tempo e muita prática para se tornar

00:34.760 --> 00:35.900
bom nisso.

00:35.900 --> 00:41.360
E mesmo que você tenha feito isso por alguns anos, ainda se depara com coisas que podem ser

00:41.360 --> 00:43.970
melhoradas ou melhoradas nesse ponto.

00:43.970 --> 00:46.700
Portanto, isso leva um bom tempo.

00:46.700 --> 00:48.680
E sim, não fique desmotivado.

00:48.680 --> 00:52.490
Se você não conseguiu resolver esse problema agora, vamos dar uma olhada nele.

00:52.490 --> 00:58.850
E sim, vamos ver onde você teve dificuldades e qual foi o obstáculo.

00:58.850 --> 00:59.900
Muito bem.

00:59.900 --> 01:00.350
Está bem.

01:00.350 --> 01:01.430
Então, vamos dar uma olhada.

01:02.250 --> 01:02.760
Tudo bem.

01:02.760 --> 01:05.970
Portanto, o vídeo a seguir explicará isso em detalhes.

01:05.970 --> 01:11.400
Mas eu gostaria de lhe dar uma rápida introdução à solução ou, pelo menos, à tarefa que

01:11.400 --> 01:12.690
temos de realizar.

01:12.690 --> 01:15.060
Portanto, no lado esquerdo, obtivemos o resultado.

01:15.060 --> 01:17.850
E, no lado direito, temos a entrada do usuário.

01:17.970 --> 01:24.780
Essa entrada do usuário precisa ser codificada na base 32 e, em seguida, decodificada, o que significa que teremos

01:24.780 --> 01:26.460
bytes aqui depois.

01:26.700 --> 01:28.800
Agora, o que acontece é o seguinte.

01:28.800 --> 01:33.660
Estamos juntando dois bytes e fazendo XOR entre eles.

01:33.660 --> 01:38.700
Por exemplo, pegamos o primeiro e o segundo e os exportamos.

01:38.700 --> 01:44.430
E o resultado desse deve ser a letra L, porque essa letra está sendo armazenada

01:44.430 --> 01:50.820
em nosso resultado e comparada com a letra L. Isso se repete agora para cada caractere.

01:50.820 --> 01:54.930
Portanto, nossa solução precisa ser o ponto de exclamação lulls.

01:54.930 --> 02:02.370
Portanto, precisamos recriar esse padrão com nossa entrada, o que significa que simplesmente seguimos em frente.

02:02.370 --> 02:08.850
Agora, os próximos dois bytes estão sendo combinados entre si, o que deve resultar

02:08.850 --> 02:14.880
na letra O, o próximo L, o próximo set e o último ponto de exclamação.

02:15.240 --> 02:21.780
Portanto, nosso desafio agora é descobrir quais dois bytes combinados entre si levam

02:21.780 --> 02:24.900
à letra l o l ver ponto de exclamação.

02:24.900 --> 02:25.860
Muito bem.

02:25.980 --> 02:31.380
Ok, agora vamos entrar em uma explicação muito, muito detalhada.

02:32.160 --> 02:33.810
Certo, voltemos à nossa acusação.

02:33.810 --> 02:40.920
O que precisamos fazer é ter um valor codificado na base 32, que é decodificado, que é xored e, em seguida,

02:40.920 --> 02:44.430
a parte XOR precisa corresponder a esse padrão.

02:44.430 --> 02:50.040
Já mencionei anteriormente que, se fizermos XOR de um valor com outro valor, obteremos um resultado.

02:50.040 --> 02:56.190
E se pegarmos esse resultado e fizermos XOR com um desses dois valores, obteremos o outro valor.

02:56.190 --> 03:02.430
Isso significa que, se quisermos obter um L aqui para nosso primeiro valor, podemos fazer isso da seguinte maneira.

03:02.430 --> 03:03.150
Portanto, para.

03:06.240 --> 03:08.280
Estamos lidando com bytes aqui.

03:08.280 --> 03:11.250
Então, sim, estamos tomando um L.

03:15.460 --> 03:21.010
Que é este 176, então hex 76, ok, zero x4.

03:21.040 --> 03:30.790
Veja que se estivermos pegando zero x4 C e, por exemplo, estivermos dividindo-o com 555, então obteremos o valor 25.

03:30.790 --> 03:33.490
Portanto, vamos também colocar um hexágono em torno dele.

03:36.790 --> 03:38.470
Então, obtemos o valor 19.

03:38.500 --> 03:46.690
Podemos pegar o que quisermos aqui, porque esta é a parte em que estamos entrando como nosso primeiro, uh, personagem.

03:46.690 --> 03:50.170
Então, talvez possamos colocar isso no Visual Studio Code.

03:51.500 --> 03:54.830
Portanto, o primeiro caractere da nossa entrada.

03:57.070 --> 03:59.800
É 0X55.

03:59.800 --> 04:00.910
Vejamos.

04:01.450 --> 04:04.660
Sim, 0X55 é nossa primeira entrada.

04:05.280 --> 04:06.210
Está bem.

04:06.210 --> 04:12.840
Isso significa que precisamos pegar o resultado desse como a próxima entrada.

04:16.800 --> 04:17.580
Por quê?

04:18.210 --> 04:19.350
Porque.

04:20.000 --> 04:28.190
Em nosso código, estamos pegando nosso primeiro elemento e comparando-o com o próximo.

04:28.190 --> 04:35.000
Desculpe, mas estamos pegando o primeiro elemento e fazendo XOR com o próximo, o que significa que agora

04:35.000 --> 04:39.860
estamos tendo a entrada 0X55, e esse elemento é xorado com zero x 19.

04:39.860 --> 04:44.930
E isso significa que se fizermos xor zero x 19, a ordem não importa.

04:44.930 --> 04:50.630
Mas vamos fazer isso dessa forma, se fizermos o XOR dessa forma.

04:52.350 --> 04:54.150
Obtemos 0X4C.

04:54.720 --> 04:59.700
Assim, ao fornecer esses dois bytes, temos nosso primeiro caractere, que é L.

05:03.900 --> 05:07.890
Ok, isso precisa ser feito para todos mais uma vez.

05:09.160 --> 05:10.540
Oh, vamos lá.

05:11.770 --> 05:16.780
Então, usamos nossos novos hacks de desempenho.

05:16.960 --> 05:21.340
Ou seja, você também pode criar um script para isso, mas gostaria de mostrar a abordagem manual.

05:22.300 --> 05:28.090
Então, vamos exportar isso agora mesmo com um valor aleatório ou vamos fazer isso desta forma.

05:28.120 --> 05:30.250
Oh é zero x para f.

05:30.640 --> 05:32.110
Vamos fazer isso passo a passo.

05:33.890 --> 05:34.640
Está bem.

05:34.970 --> 05:40.790
Tomamos zero x para F e agora podemos usar o mesmo valor cinco cinco novamente.

05:40.790 --> 05:42.530
Ou podemos usar zero zero.

05:42.560 --> 05:44.750
Essa é a nossa contribuição para o próximo.

05:49.080 --> 05:50.220
Valor aqui.

05:50.400 --> 05:53.520
Por isso, gosto de manter cinco e cinco.

05:54.570 --> 05:57.270
Portanto, agora estamos obtendo zero x-1a.

05:57.270 --> 06:10.260
Isso significa que, se estivermos usando zero x 55 e essa entrada três nessa parte aqui, obteremos oh porque esses dois

06:10.260 --> 06:12.060
juntos x ord.

06:14.020 --> 06:15.760
Leva dois zero x4 f.

06:15.760 --> 06:16.720
Vamos fazer isso.

06:22.530 --> 06:23.340
Sim.

06:23.340 --> 06:23.940
Está bem.

06:23.940 --> 06:24.870
O próximo.

06:28.030 --> 06:29.890
Estamos em quatro e cinco.

06:31.370 --> 06:33.020
Hum, sim.

06:33.020 --> 06:34.130
Em mim mais uma vez.

06:34.130 --> 06:37.400
Portanto, podemos usar os mesmos valores aqui.

06:40.440 --> 06:53.940
Como, mais uma vez, zero x 55 foi combinado com 0X190X19, podemos ver zero x para c e zero x para c sl.

06:53.940 --> 06:56.490
Certo, então é este aqui.

06:56.490 --> 06:59.910
Agora precisamos nos preparar.

07:01.820 --> 07:03.590
Para seis e sete anos.

07:08.710 --> 07:10.600
Então, mais uma vez.

07:13.510 --> 07:17.380
Audie set.

07:20.170 --> 07:21.340
Hex 90.

07:21.370 --> 07:24.250
Certo, agora precisamos obter um zero x para H.

07:24.280 --> 07:26.860
Vamos pegar o 55 mais uma vez.

07:30.110 --> 07:34.970
Estamos recebendo 15 e o hexágono 15 é 0XF.

07:35.090 --> 07:35.930
Está bem.

07:36.440 --> 07:43.910
Portanto, aqui temos 0C0X0F junto com esse conjunto.

07:44.000 --> 07:47.090
Isso precisa receber um ponto de exclamação.

07:47.090 --> 07:47.900
Portanto.

07:48.850 --> 07:54.160
O ponto de exclamação é o nosso ponto de exclamação!

07:54.460 --> 07:55.660
33.

07:55.690 --> 07:56.560
Isso é um hexágono.

07:56.560 --> 08:01.390
2121 Xored com cinco.

08:01.390 --> 08:02.170
Cinco.

08:05.630 --> 08:06.680
Em hexadecimal.

08:06.680 --> 08:07.790
É este aqui.

08:09.740 --> 08:12.980
Certo, mais uma vez.

08:20.210 --> 08:26.540
Então, vamos criar um novo arquivo e pegá-lo.

08:28.060 --> 08:29.350
Hum, mordidas para fora.

08:33.410 --> 08:34.100
Está bem.

08:37.920 --> 08:40.950
E vamos remover o zero x.

08:41.340 --> 08:42.210
Em Python.

08:42.210 --> 08:44.130
Acho que é assim.

08:44.190 --> 08:45.060
Está bem.

08:47.620 --> 08:49.990
Também pode usar printf.

08:52.680 --> 08:53.340
Sim.

08:53.340 --> 08:57.930
Então, se pegarmos isso agora e codificarmos com base32.

08:58.670 --> 09:04.970
Portanto, esta deve ser uma solução funcional se eu ainda não tiver cometido um erro.

09:05.630 --> 09:08.150
Portanto, vamos tentar fazer isso, ok.

09:08.180 --> 09:12.260
Dados do shell ADB local temp.

09:13.450 --> 09:15.820
Validar 3 para 1.

09:16.510 --> 09:17.170
Sim.

09:17.170 --> 09:17.740
Perfeito.

09:17.740 --> 09:18.220
Legal.

09:18.220 --> 09:19.210
Funciona.

09:19.270 --> 09:22.750
Então, essa foi a mágica por trás disso.

09:22.900 --> 09:23.200
Um.

09:25.020 --> 09:31.290
Ao fazer o XOR de dois valores juntos, mas podemos definir os valores que queremos fazer o XOR juntos.

09:31.290 --> 09:37.650
Portanto, ao ter um valor hresult e definir um deles, obtemos automaticamente o valor

09:37.650 --> 09:39.300
que está faltando.

09:39.480 --> 09:46.560
E, com esses dois, podemos aplicar isso para criar nossa string de bytes e essa string de bytes, temos que fazer

09:46.560 --> 09:47.310
isso.

09:47.310 --> 09:49.020
Role-o pela parte de trás agora mesmo.

09:49.020 --> 09:50.730
Portanto, nossa string de bytes.

09:55.150 --> 09:57.580
Está, então, na base 60.

09:57.700 --> 10:02.170
Base 32 codificada porque este está decodificando.

10:02.170 --> 10:05.380
Portanto, ele precisa ser codificado na base 32.

10:05.380 --> 10:10.630
E se apresentarmos isso como um argumento aqui, teremos uma cadeia inválida.

10:11.280 --> 10:12.510
Para.

10:14.010 --> 10:16.380
Este aqui para chegar a esta parte aqui.

10:16.380 --> 10:23.580
Portanto, com relação a isso, agora temos uma cadeia válida que passa por essas verificações e termina com o sucesso

10:23.580 --> 10:26.130
do ponto de exclamação lol set.

10:27.120 --> 10:30.960
Para ser sincero, achei que isso não era fácil.

10:30.960 --> 10:37.800
Ela tem algumas partes complicadas e, sim, foi um bom desafio.

10:37.800 --> 10:40.380
Se você estiver interessado em raiva, entre em contato comigo.

10:40.380 --> 10:44.040
Em seguida, faremos um vídeo sobre a raiva para saber como resolver esse problema.

10:44.040 --> 10:46.020
Isso será muito mais fácil.

10:46.080 --> 10:50.820
Hum, e sim, também podemos ver que podemos ter várias soluções.

10:50.820 --> 10:54.240
Por exemplo, outra solução é.

10:57.730 --> 10:58.030
Uh.

10:58.030 --> 10:58.960
Vejamos.

10:58.990 --> 11:01.990
Basta alterar um parâmetro aqui.

11:03.700 --> 11:06.220
Portanto, nosso URL mais uma vez.

11:10.290 --> 11:11.880
Zero para XC.

11:12.330 --> 11:16.440
Se agora fizermos XOR com zero, por exemplo.

11:23.710 --> 11:25.510
Então, estamos recebendo isso de volta.

11:25.510 --> 11:30.100
Ok, então essa seria, eu acho, a solução mais fácil.

11:33.080 --> 11:33.680
Não estou.

11:33.680 --> 11:35.750
Esse é sempre o caso?

11:36.200 --> 11:36.620
Um.

11:40.610 --> 11:41.420
Sim.

11:41.630 --> 11:45.530
O valor xored com zero é ele mesmo.

11:45.560 --> 11:45.920
Sim.

11:45.920 --> 11:49.070
Porque somente zero e um dão uma diferença.

11:49.070 --> 11:51.110
E não estamos tendo um único conjunto aqui.

11:51.110 --> 11:51.890
Portanto.

11:52.160 --> 11:52.640
Está bem.

11:52.640 --> 11:54.980
Essa é a solução mais fácil, eu acho.

11:55.280 --> 11:57.380
Este agora também deve funcionar.

11:57.380 --> 11:59.120
Então, vamos analisar isso mais uma vez.

12:00.810 --> 12:09.570
Pressiono o controle F0X ponto a ponto para ter uma expressão regular para buscar dois caracteres após esse x.

12:10.140 --> 12:10.890
Um.

12:11.190 --> 12:13.080
Windows enter.

12:13.080 --> 12:14.070
Sem controle.

12:14.070 --> 12:14.760
Entre.

12:14.940 --> 12:16.830
Nós copiamos isso.

12:21.610 --> 12:22.870
Nós o colamos aqui.

12:22.900 --> 12:26.890
Nós pegamos todos os personagens no início.

12:31.100 --> 12:35.660
E então estamos substituindo isso pela barra invertida x.

12:35.690 --> 12:36.380
Está bem.

12:37.840 --> 12:42.820
Portanto, imprima F base 32.

12:45.070 --> 12:47.920
Este é o que o autor forneceu?

12:48.800 --> 12:49.280
Não.

12:50.290 --> 12:52.180
Mas este também deve funcionar.

12:52.210 --> 12:53.050
Vejamos.

12:57.060 --> 12:57.690
Sim.

12:57.870 --> 12:58.410
Um.

12:58.410 --> 12:59.070
Dados.

12:59.670 --> 13:01.200
Temperatura local.

13:03.810 --> 13:04.890
Validar.

13:06.850 --> 13:07.510
Perfeito.

13:07.510 --> 13:09.880
Mais uma vez, ele funciona muito bem.

13:09.880 --> 13:12.250
Portanto, acho que essa seria a maneira mais fácil.

13:12.250 --> 13:13.690
Se tivermos algo assim.

13:13.690 --> 13:16.810
Simplesmente pegue a letra e, em seguida, faça o xored com zero zero.

13:16.810 --> 13:20.470
Assim também para todos os um com zero zero e assim por diante.

13:20.470 --> 13:23.620
Portanto, letra zero zero, letra zero zero.

13:23.620 --> 13:28.240
Então, obtemos o resultado com muito mais facilidade e não precisamos descobrir dessa forma.

13:28.240 --> 13:29.050
Muito bem.

13:29.500 --> 13:33.490
Ok, espero que você tenha gostado desse desafio, caso contrário, me avise.

13:33.490 --> 13:36.820
Depois, tento me concentrar em outras partes.

13:36.820 --> 13:43.900
Sim, continuaremos com alguns ou adicionaremos outros tópicos relacionados a Webviews.

13:43.900 --> 13:47.170
Em seguida, analisaremos o primeiro desafio aqui.

13:49.120 --> 13:52.360
Hum, isso é algo que eu ainda não pesquisei.

13:55.500 --> 13:56.310
Este aqui.

13:56.310 --> 13:58.980
Portanto, isso também será totalmente novo para mim.

13:58.980 --> 14:03.600
E sim, vamos ver se somos bons em resolver todos eles.

14:03.720 --> 14:07.770
Estou bastante confiante, mas vamos ver.

14:07.770 --> 14:08.490
Muito bem.

14:08.490 --> 14:09.210
Está bem.

14:09.210 --> 14:12.210
Essa é a próxima coisa que teremos que analisar.

14:12.210 --> 14:14.910
Portanto, estou ansioso para vê-lo lá.
