Jump to content

Sckoofer B

Membros
  • Posts

    9
  • Joined

  • Last visited

Recent Profile Visitors

The recent visitors block is disabled and is not being shown to other users.

Sckoofer B's Achievements

4

Reputation

  1. Um link do github que foi compartilhado no grupo C/C++/42 (telegram). ---> https://github.com/kamranahmedse/developer-roadmap Esse "mapa da vida" foi elaborado por algumas pessoas que acreditam que esse "pequeno" guia aborda muitos assuntos que eles acreditam ser de grande importância para a carreira de programador (provavelmente baseado no mercado estrangeiro). O que você acrescentariam ou removeriam desse roadmap? Lembrando que está no Github e sugestões podem ser aceitas. E o roadmap do engenheiro reverso? Será que está descrito no livro "Fundamentos da engenharia reversa"? Ainda não tive tempo de ler tudo.
  2. Sim, muito interessante a explicação do Frederico, não sabia que sempre que se usa ESP ou EBP numa referência à memória, automaticamente um seletor seria usado. Na verdade eu achava que os seletores, como dito em duas video aulas de Assembly (e acho que no material de x64 que o Frederico escreveu) seriam usados em uma situação bem específica, por exemplo, programar um sistema operacional ou um driver, e que não deveríamos nos preocupar em usar os seletores. E outra coisa, não sabia que a ausencia do prólogo é sinônimo de código otimizado, já que os poucos códigos que ví , que foram gerados por um disassembler, todos eles usam o prólogo pra começar uma função. Também não sabia que o uso dele era opcional. Para divulgação de material daqueles que trazem conteúdo para o mente binária, o Fernando Fresteiro (M4st3r3k) também tem um vídeo mostrando o uso do Stack Frame e também explica sobre:
  3. Ah sim, então pelo o que entendi, um descompilador não seria capaz de mostrar uma representação completa de um código compilado, já um disassembler é o "pacote completo" 😂. É bom saber disso, sendo assim o pessoal do hex-rays estava apenas defendendo o uso do descompilador deles, pois está presente na versão paga do IDA (IDA Pro), e eles, como muitos comerciantes, estavam fazendo a propaganda do produto deles, tentando convencer as pessoas à pagar mais de 500 dólares pra conseguir essa opção, pois é. E ainda vejo que é vantajoso saber interpretar o disassembler, pois não dispensa ferramentas que não dispõe de um descompilador.
  4. E aproveitando que a procura por documentos sobre baixo nível teve alta, achei legal lembrar que, caso alguém esteja procurando por mais documentos gratuitos sobre assembly, aqui mesmo no mente binária estão disponíveis vários links para vários documentos sobre assembly. Link do Tópico: https://www.mentebinaria.com.br/forums/topic/618-apanhadão-de- assembly/ Como alternativa aos PDFs, também existe essa série de vídeos no youtube (x86_64 Linux Assembly, usando o compilador NASM e usando o padrão INTEL): Sempre lembrando que não tem necessidade de se forçar à estudar apenas aquele material escolhido, ou apenas aquele outro. Tenha sempre em mãos outras fontes, lembre-se que niguém é dono da verdade, assim como não existem professores perfeitos ou materiais perfeitos. Cada um tem sua forma de aprender, tem alguns que preferem focar em estudar várias coisas ao mesmo tempo e sentem ainda mais dificuldade, não aprendem quase nada, já outros são exatamente o oposto. E divirta-se =D, o caminho que leva até o objetivo pode ser longo as vezes, lembre-se de torná-lo prazeroso o máximo possível, pra não desanimar e para que a auto cobrança não falem mais alto.
  5. section .data bem_vindo db "Chega ae",10,10,0 Cgh equ $ - bem_vindo Entrada_1 db "Digite um número: ",0 Enter_1 equ $ - Entrada_1 Entrada_2 db "Digite outro número: ",0 Enter_2 equ $ - Entrada_2 A_som db "1) A soma entre esses dois valores é: ",0 summ equ $ - A_som A_sub db "2) A subtracao entre esses dois valores é: ",0 subb equ $ - A_sub A_mul db "3) A multiplicacao entre esses dois valores é: ",0 mull equ $ - A_mul A_div db "4) A divisao entre esses dois valores é: ",0 divv equ $ - A_div Pula_linha db 10,10,0 num_lin equ $ - Pula_linha section .bss Num_1: resb 2 Num_2: resb 2 Resultado: resb 2 section .text global _start _start: mov rax, 1 mov rdi, 1 mov rsi, bem_vindo mov rdx, Cgh syscall mov rax, 1 mov rdi, 1 mov rsi, Entrada_1 mov rdx, Enter_1 syscall mov rax, 0 mov rdi, 0 mov rsi, Num_1 mov rdx, 2 syscall mov rax, 1 mov rdi, 1 mov rsi, Entrada_2 mov rdx, Enter_2 syscall mov rax, 0 mov rdi, 0 mov rsi, Num_2 mov rdx, 2 syscall _Somar: mov rax, 1 mov rdi, 1 mov rsi, A_som mov rdx, summ syscall mov al, [Num_1] mov bl, [Num_2] ;converte da tabela ASCII sub al, '0' sub bl, '0' ;somar add al,bl ;converte para a tabela ASCII add al, '0' mov [Resultado],al mov rax, 1 mov rdi, 1 mov rsi, Resultado mov rdx, 2 syscall mov rax, 1 mov rdi, 1 mov rsi, Pula_linha mov rdx, num_lin syscall _Subtrair: mov byte [Resultado], 0 mov rax, 1 mov rdi, 1 mov rsi, A_sub mov rdx, subb syscall mov al, [Num_1] mov bl, [Num_2] ;converte da tabela ASCII sub al, '0' sub bl, '0' ;subtrair sub al,bl ;converte para a tabela ASCII add al, '0' mov [Resultado],al mov rax, 1 mov rdi, 1 mov rsi, Resultado mov rdx, 2 syscall mov rax, 1 mov rdi, 1 mov rsi, Pula_linha mov rdx, num_lin syscall _Multiplicar: mov rax, 1 mov rdi, 1 mov rsi, A_mul mov rdx, mull syscall mov al, [Num_1] mov bl, [Num_2] ;converte da tabela ASCII sub al, '0' sub bl, '0' ;multiplicar mul bl ;converte para a tabela ASCII add al, '0' mov [Resultado],al mov rax, 1 mov rdi, 1 mov rsi, Resultado mov rdx, 2 syscall mov rax, 1 mov rdi, 1 mov rsi, Pula_linha mov rdx, num_lin syscall _Dividir: mov rax, 1 mov rdi, 1 mov rsi, A_div mov rdx, divv syscall mov al, [Num_1] mov bl, [Num_2] ;converte da tabela ASCII sub al, '0' sub bl, '0' ;dividir div bl ;converte para a tabela ASCII add al, '0' mov [Resultado],al mov rax, 1 mov rdi, 1 mov rsi, Resultado mov rdx, 2 syscall mov rax, 1 mov rdi, 1 mov rsi, Pula_linha mov rdx, num_lin syscall mov rax, 60 mov rdi, 0 syscall A ideia foi desse cara aqui: https://stackoverflow.com/questions/9435659/calculator-in-assembly-language-linux-x86-nasm-division
  6. -> https://www.hex-rays.com/products/decompiler/compare/compare_vs_disassembly/ Nota: não entendo nada, só to aqui de visita. : Eu gostaria de saber de alguns exemplos, na prática, que um Disassembler seria indispensável, ou seja, o seu uso seria de extrema importância para realizar a tarefa, sem ele não haveria como prosseguir (talvez a análise de código que se modifica sozinho, self-modifying code, talvez um malware)?
  7. Olá. Vejam esse link por favor https://code.visualstudio.com/license Trecho retirado da página "Parágrafo 5. Scope of License This license applies to the Visual Studio Code product. Source code for Visual Studio Code is available at https://github.com/Microsoft/vscode under the MIT license agreement. The software is licensed, not sold. This agreement only gives you some rights to use the software. Microsoft reserves all other rights. Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement. In doing so, you must comply with any technical limitations in the software that only allow you to use it in certain ways. You may not reverse engineer, decompile or disassemble the software, or otherwise attempt to derive the source code for the software except and solely to the extent required by third party licensing terms governing use of certain open source components that may be included in the software; remove, minimize, block or modify any notices of Microsoft or its suppliers in the software; use the software in any way that is against the law; share, publish, rent or lease the software, or provide the software as a stand-alone offering for others to use. " Já traduzi isso aqui mas não entendo direito, o que isso significa? Visual Code é de código aberto. É permitido fazer engenharia reversa no Visual Code? Sim ou não?
×
×
  • Create New...