Ir para conteúdo

Fernando Mercês

Administradores
 Perfil  Explorar Conteúdo

  • Postagens

    1.524

  • Registro em

  • Última visita

  • Dias Ganhos

    174

 Tipo de Conteúdo 

Posts postados por Fernando Mercês

    Engenharia reversa e C

    em Geral

    Postado

    Opa,

    Em 04/07/2024 em 13:14, Guilherme23 disse:

    vai informar pelo Youtube também ?

    Sim, por todos os nossos canais. 🙂

    Em 04/07/2024 em 13:14, Guilherme23 disse:

    Será necessário algum conhecimento prévio?

    Sim, os requisitos estão no fim do texto aqui.

    Abraço!

    Engenharia reversa e C

    em Geral

    Postado

    Oi @Guilherme23, tudo em paz e contigo?

    Estamos planejando uma turma do curso A Arte da Engenharia Reversa (pago, online e ao vivo). Em relação aos cursos gratuitos, não lançaremos outros sobre estes tópicos este ano. Segue um resumo do que temos sobre ER e 😄

    Sobre C, temos:

    Há ainda um livro muito legal de dicas de C e Assembly que o autor nos permitiu disponibilizar para download aqui. Chama-se Dicas - C e Assembly para arquitetura x86-64.

    Por hora, isto é tudo. 🙂

    Grande abraço e bons estudos. Qualquer outra dúvida é só falar.

    Abraço!

    Feedback das Aulas

    em Treinamento DFIR

    Postado

    Em 05/06/2024 em 14:37, rsievering@hotmail.com disse:

    Existe algum certificado que eu possa emitir.???

    Opa, tudo bem? Obrigado por terminar o curso! No momento não emitidos certificados para os cursos livres pois não temos nenhuma maneira automatizada de fazê-lo.

    Um abraço!

    Como abrir um arquivo .exe

    em Windows

    Postado

    Olá!

    Se alguém tiver tempo, pode ser que consiga te ajudar sim, mas se você quiser aprender e fazer você mesmo, ou se unir com alguém da comunidade e fazer junto, recomendo que comece pelos nossos treinamentos gratuitos aqui. Dependendo do quanto você já conhece, pode ser interessante fazer o de C primeiro e depois o CERO. Aí você pode estudar também pelo livro Fundamentos de Engenharia Reversa e o de Assembly, ambos gratuitos. Tá tudo no menu Ensino aqui mesmo no nosso site. 🙂

    Abraço,

    Fernando

    Criar Gráficos na Linguagrm C

    em C/C++

    Postado

    Eu nunca usei essas funções da GDI, mas pelo que vi na documentação da LineTo(), ela usa a “caneta” padrão:

    The line is drawn by using the current pen and, if the pen is a geometric pen, the current brush.

    Meus conhecimentos de Paint me dizem que o caminho é alterar a caneta antes de chamar a LineTo(). Pelo que vi, tem que criar a caneta no seu código com a CreatePen():

    HPEN caneta = CreatePen(PS_SOLID, 2, RGB(0, 0, 0));

    No exemplo acima usei uma caneta sólida, de espessura 2 e cor preta. Depois precisa atribuir a caneta à sua tela:

    SelectObject(tela, caneta);

    Se tudo der certo a LineTo vai usar essa caneta ao invés da padrão, mas não testei viu? Tô no celular. hehe

    Abraço!

    • Agradecer 1

    breakpoint OptinalHeader.AddressOfEntryPoint

    em Geral

    Postado

    Opa, bem vindo @Crystoppher!

    Em algum momento da vida, o x64dbg passou a criar um símbolo exportado (na aba Símbolos/Symbols) chamado OptionalHeader.AddressOfEntryPoint. O nome deste símbolo vem do fato de o endereço do entrypoint ser um campo do cabeçalho chamado Optional Header. No disassembly, se você estiver diante de um endereço de um símbolo, o x64dbg coloca o nome do símbolo do lado. 😉

    Abraço.

    • Agradecer 1
    • Curtir 1

    Programação em Baixo Nível - print_rax.asm

    em Assembly

    Postado

    Legais as perguntas! 🙂

    Em 17/10/2023 em 21:39, Nitczi disse:

    Na linha onde está "sar rax,cl" vi que isso é uma operação de bit shifting para a direita, pesquisei em alguns sites para ver como ficaria essa operação e o resultado é sempre 5, mas rodando o programa o resultado é 1, por que?

    O nome é deslocamento aritimético para a direita. Tem o deslocamento lógico também, que é feito pela instrução SHL. 😉

    O que essa instrução faz é, tomando o número em binário, "empurrar" todos os bits para a direita e aí o bit que "sobra" à esquerda é preenchido com zero ou um (caso ele já seja 1). Por exemplo: 

    0011 SAR 1 = 0001
1100 SAR 1 = 1110

    O código faz 0x1122334455667788 SAR 0x3c (60) na primeira iteração do loop. Para entender, você teria que converter 0x1122334455667788 para binário e fazer a operação de deslocamento aritimético para a direita sessenta vezes, entende? Então vamos lá:

    0x1122334455667788 em binário é: 0001 0001 0010 0010 0011 0011 0100 0100 0101 0101 0110 0110 0111 0111 1000 1000 (observe a parte em negrito, que será deslocada para a direita).

    Deslocando somente uma vez para a direita, teremos:

    0000 1000 1001 0001 0001 1001 1010 0010 0010 1010 1011 0011 0011 1011 1100 0100

    O zero foi colocado à esquerda porque o bit original era zero.

    Agora você teria que fazer o processo mais 59 vezes para chegar no resultado 1. 🙂

    Fiz um programa em Python aqui para simular, trabalhando com o número como se fosse uma string. Espero que não confunda mais. 🤣 

    rax = '0001000100100010001100110100010001010101011001100111011110001000'

print(f'rax = {rax}')

for i in range(1, 61):
    if rax[0] == '0':
        rax = '0' + rax[:-1]
    else:
        rax = '1' + rax[:-1]

    print(f'rax SAR {i:02d} = {rax}')

    A saída é: 

    rax = 0001000100100010001100110100010001010101011001100111011110001000
rax SAR 01 = 0000100010010001000110011010001000101010101100110011101111000100
rax SAR 02 = 0000010001001000100011001101000100010101010110011001110111100010
rax SAR 03 = 0000001000100100010001100110100010001010101011001100111011110001
rax SAR 04 = 0000000100010010001000110011010001000101010101100110011101111000
rax SAR 05 = 0000000010001001000100011001101000100010101010110011001110111100
rax SAR 06 = 0000000001000100100010001100110100010001010101011001100111011110
rax SAR 07 = 0000000000100010010001000110011010001000101010101100110011101111
rax SAR 08 = 0000000000010001001000100011001101000100010101010110011001110111
rax SAR 09 = 0000000000001000100100010001100110100010001010101011001100111011
rax SAR 10 = 0000000000000100010010001000110011010001000101010101100110011101
rax SAR 11 = 0000000000000010001001000100011001101000100010101010110011001110
rax SAR 12 = 0000000000000001000100100010001100110100010001010101011001100111
rax SAR 13 = 0000000000000000100010010001000110011010001000101010101100110011
rax SAR 14 = 0000000000000000010001001000100011001101000100010101010110011001
rax SAR 15 = 0000000000000000001000100100010001100110100010001010101011001100
rax SAR 16 = 0000000000000000000100010010001000110011010001000101010101100110
rax SAR 17 = 0000000000000000000010001001000100011001101000100010101010110011
rax SAR 18 = 0000000000000000000001000100100010001100110100010001010101011001
rax SAR 19 = 0000000000000000000000100010010001000110011010001000101010101100
rax SAR 20 = 0000000000000000000000010001001000100011001101000100010101010110
rax SAR 21 = 0000000000000000000000001000100100010001100110100010001010101011
rax SAR 22 = 0000000000000000000000000100010010001000110011010001000101010101
rax SAR 23 = 0000000000000000000000000010001001000100011001101000100010101010
rax SAR 24 = 0000000000000000000000000001000100100010001100110100010001010101
rax SAR 25 = 0000000000000000000000000000100010010001000110011010001000101010
rax SAR 26 = 0000000000000000000000000000010001001000100011001101000100010101
rax SAR 27 = 0000000000000000000000000000001000100100010001100110100010001010
rax SAR 28 = 0000000000000000000000000000000100010010001000110011010001000101
rax SAR 29 = 0000000000000000000000000000000010001001000100011001101000100010
rax SAR 30 = 0000000000000000000000000000000001000100100010001100110100010001
rax SAR 31 = 0000000000000000000000000000000000100010010001000110011010001000
rax SAR 32 = 0000000000000000000000000000000000010001001000100011001101000100
rax SAR 33 = 0000000000000000000000000000000000001000100100010001100110100010
rax SAR 34 = 0000000000000000000000000000000000000100010010001000110011010001
rax SAR 35 = 0000000000000000000000000000000000000010001001000100011001101000
rax SAR 36 = 0000000000000000000000000000000000000001000100100010001100110100
rax SAR 37 = 0000000000000000000000000000000000000000100010010001000110011010
rax SAR 38 = 0000000000000000000000000000000000000000010001001000100011001101
rax SAR 39 = 0000000000000000000000000000000000000000001000100100010001100110
rax SAR 40 = 0000000000000000000000000000000000000000000100010010001000110011
rax SAR 41 = 0000000000000000000000000000000000000000000010001001000100011001
rax SAR 42 = 0000000000000000000000000000000000000000000001000100100010001100
rax SAR 43 = 0000000000000000000000000000000000000000000000100010010001000110
rax SAR 44 = 0000000000000000000000000000000000000000000000010001001000100011
rax SAR 45 = 0000000000000000000000000000000000000000000000001000100100010001
rax SAR 46 = 0000000000000000000000000000000000000000000000000100010010001000
rax SAR 47 = 0000000000000000000000000000000000000000000000000010001001000100
rax SAR 48 = 0000000000000000000000000000000000000000000000000001000100100010
rax SAR 49 = 0000000000000000000000000000000000000000000000000000100010010001
rax SAR 50 = 0000000000000000000000000000000000000000000000000000010001001000
rax SAR 51 = 0000000000000000000000000000000000000000000000000000001000100100
rax SAR 52 = 0000000000000000000000000000000000000000000000000000000100010010
rax SAR 53 = 0000000000000000000000000000000000000000000000000000000010001001
rax SAR 54 = 0000000000000000000000000000000000000000000000000000000001000100
rax SAR 55 = 0000000000000000000000000000000000000000000000000000000000100010
rax SAR 56 = 0000000000000000000000000000000000000000000000000000000000010001
rax SAR 57 = 0000000000000000000000000000000000000000000000000000000000001000
rax SAR 58 = 0000000000000000000000000000000000000000000000000000000000000100
rax SAR 59 = 0000000000000000000000000000000000000000000000000000000000000010
rax SAR 60 = 0000000000000000000000000000000000000000000000000000000000000001

    Com isso você prova que 0x1122334455667788 SAR 60 é igual a 1. Mas na próxima iteração do loop, RAX sofrerá uma operação SAR com 56, que já não é 1, e por aí vai... Ou seja, não é que é sempre 1. 😉

    O objetivo deste programa é você imprimir na tela cada dígito hexa do registrador RAX, não importa o que você coloque lá. Testa com 0xf0f0caf0f0ca2023 por exemplo. 😉

    Abraço!

    • Agradecer 1

    Como posso fazer um toolkit para windows?

    em C/C++

    Postado

    De nada. 🙂

    Em 26/09/2023 em 09:36, Gabriel Guedes disse:

    Botao direito em um arquiv >> Enviar para / Abrir com >> Toolkit, é feito como? Pelo instalador? Com alguma entrada no Registro?

    Dá pra fazer por registro, mas eu tentei e vi que tem limite de aninhamento das opções. Acabei usando um software chamado sendto+. O Inno Setup pode escrever as chaves de registro se você escolher fazer via registro. No caso do retoolkit, eu instruo o script do Inno Setup para instalar (copiar) o sendto+ como um programa normal e criar os atalhos.

    Em 26/09/2023 em 09:36, Gabriel Guedes disse:

    E sim! Pode ter certeza que tambem vou adorar compartilhar!

    😍

    • Curtir 1

    Como posso fazer um toolkit para windows?

    em C/C++

    Postado

    Oi @Gabriel Guedes! Que legal sua decisão de estudar programação. Acho essencial para qualquer área da computação. 🙂

    Muito interessante o projeto de criar um instalador. Existem vários softwares que criam instaladores (Inno Setup, Nullsoft Scriptable Install System (NSIS), Setup Factory, etc), mas fazer o seu próprio é com certeza um projeto muito interessante!

    Vou tentar ajudar com as dúvidas:

    Em 26/09/2023 em 08:02, Gabriel Guedes disse:

    Quais bibliotecas / features ou tópicos eu devo me preocupar?

    Quase nenhuma. Normalmente instalar significa copiar arquivos para determinados diretórios, criar atalhos e escrever em chaves de registro. Tudo isso é feito com funções da biblioteca padrão em linguagens como C# e C++.

    Em 26/09/2023 em 08:02, Gabriel Guedes disse:

    Vi que o retoolkit usa o Inno Setup para criar o instalador, o trabalho dele é instalar os programas que fazer parte do kit apenas?

    Sim. O Inno Setup suporta uma linguagem própria de scripting e cria um instalador baseado no que está nesses scripts. O código-fonte do retoolkit consiste destes scripts.

    Em 26/09/2023 em 08:02, Gabriel Guedes disse:

    Como ele faz isso sem ter o .exe de cada programa ali?

    Eu não fiz upload dos arquivos dos programas para o GitHub porque não é uma boa prática colocar arquivos que não são de texto em repositórios git, mas eu os tenho na minha máquina, no diretório d:\ret, que é de onde o script pega os arquivos do programa. Perceba que isso tá especificado aqui. 😉

    Em 26/09/2023 em 08:02, Gabriel Guedes disse:

    Quais as vantagens de fazer em C# e quais as vantagens de fazer em C++?

    Acredito que você vá aprender mais sobre um ou sobre o outro. Acredito que C# seja um pouco mais fácil e você terá que se preocupar menos com a linguagem. Por que não faz primeiro com um e depois com o outro? Assim você estuda ambas. 🙂

    Em 26/09/2023 em 08:02, Gabriel Guedes disse:

    Existe algum programa semelhante que eu posso tomar como referencia além do Retoolkit?

    De cabeça não sei, mas você pode pesquisar por instaladores feitos nas duas linguagens.

    Adoraríamos ver o progresso do teu instalador aqui! 🙂

    Um abraço e boa sorte!

    • Curtir 1

    Duvida Sobre Registradores de Propósito Geral - Intel 64 e uso do NASM.

    em Assembly

    Postado

    Oi @Samuel Araujo. Essa contagem faz sentido e é exatamente o motivo de o registrador r8 ser o r8. 🙂 Em arm por exemplo, ela é utilizada.

    No entanto, em amd64 os nomes originais foram mantidos acredito que porque preservam a ideia de sua função e também facilita pra quem já sabia i386. Por exemplo, rcx é o contador e por aí vai. Ninguém (?) usa a nomenclatura de r0 a r7 em amd64 mas o nasm a suporta sim: basta usar as macros definidas no pacote altreg no início do seu código. Veja: 

    bits 64

%use altreg

SYS_WRITE equ 1
STDOUT    equ 1
SYS_EXIT  equ 60

section .rodata

msg:
 db `Registradores alternativos!\n`
 msg_len equ $ - msg

section .text

global _start
_start:
 mov r0, SYS_WRITE
 mov r7, STDOUT
 lea r6, [msg]
 mov r2, msg_len
 syscall

 mov r0, SYS_EXIT
 xor r7, r7
 syscall

    Usar o pacote altreg é como definir os novos nomes você mesmo. Algo como %define r0 rax, embora o nasm use %idefine no pacote altreg, que faz a definição ficar insensível ao caso, permitindo R0, r0, RAX, rax, rAX, etc. Mais detalhes no arquivo macros/altreg.mac.

    Isso é só nome e só faz sentido no código-fonte. A instrução gerada no compilado é a mesma, quer você use r0, quer você use rax. O fonte vai ficar confuso já que ninguém (?) tá acostumado com isso em amd64. Além disso, tem que decorar a ordem. Perceba que o segundo registrador é rcx, não o rbx. A ordem é A, C, D, B. Depois vem o SP, BP, SI e DI. Lembrar disso "numericamente" representa uma dificuldade adicional, mas é possível claro.

    Abraço.

    • Curtir 1
×
×
  • Criar Novo...