Com Win 10x64 eu consigo aprender assembly x80/x86/x64?

[Saraiva Saraiva]

Não encontrei área de duvida então pesquisei e peguei o path da área onde membro publicou a duvida.

Eu consigo programar assembly x86 na estrutura x64, os registradores das versões anteriores estão contidas nele?

Alguém tem máterial para "Helllo Word" entre outros?

 

 

 

[fredericopissarra]

x80? 8080? 8 bits? Nope! A não ser que tenha um cross assembler.

Com o resto, pode-se usar o NASM, MASM ou GAS.

[fredericopissarra]

Recomendo que não se tende aprender assembly construindo aplicações standalone...

Por exemplo, uma aplicação Windows (Win32) completa em asm pode ser feita com dois arquivos, com o NASM:

; win32.inc
%define CS_VREDRAW 1
%define CS_HREDRAW 2
%define CS_DBLCLKS 8

%define COLOR_WINDOW  5

%define WM_DESTROY  2

%define IDI_APPLICATION 32512
%define IDC_ARROW       32512

%define CW_USEDEFAULT   0x80000000

%define WS_OVERLAPPED   0x000000
%define WS_CAPTION      0xc00000
%define WS_SYSMENU      0x080000
%define WS_THICKFRAME   0x040000
%define WS_MINIMIZEBOX  0x020000
%define WS_MAXIMIZEBOX  0x010000
%define WS_OVERLAPPEDWINDOW (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX)

%define MB_OK 0
%define MB_ICONERROR 0x10

struc WNDCLASS
  .style:         resd  1
  .lpWndProc:     resd  1
  .cbClsExtra:    resd  1
  .cbWndExtra:    resd  1
  .hInstance:     resd  1
  .hIcon:         resd  1
  .hCursor:       resd  1
  .hbrBackground: resd  1
  .lpszMenuName:  resd  1
  .lpszClassName: resd  1
endstruc

struc MSG
  .hWnd:    resd  1
  .message: resd  1
  .wParam:  resd  1
  .lParam:  resd  1
  .time:    resd  1
  .pt:      resd  2
endstruc

; winapp.asm

  bits 32

%include "win32.inc"

  section .data

winapp_class: db  "MyWinAppClass",0
winapp_title: db  "My Windows App",0
msg_caption:  db  "Error",0
msg_text:     db  "Error creating main window.",0

wc:   istruc WNDCLASS
        at WNDCLASS.style,          dd  (CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS)
        at WNDCLASS.hbrBackground,  dd  (COLOR_WINDOW+1)
      iend

msg:  istruc MSG
      iend

  section .bss

hWnd: resd  1

  section .text

; Imported from kernel32.exe & user32.exe
extern __imp__LoadIconA@8
extern __imp__LoadCursorA@8
extern __imp__RegisterClassA@4
extern __imp__CreateWindowExA@48
extern __imp__MessageBoxA@16
extern __imp__UpdateWindow@4
extern __imp__ShowWindow@8
extern __imp__GetMessageA@16
extern __imp__TranslateMessage@4
extern __imp__DispatchMessageA@4
extern __imp__DefWindowProcA@16
extern __imp__PostQuitMessage@4

  global _WindowMessagesHandler@16

struc WndMsgHandlerStk
.oldebp:  resd  1
.retaddr: resd  1
.hWnd:    resd  1
.uMsg:    resd  1
.wParam:  resd  1
.lParam:  resd  1
.size:
endstruc

WNDMSGHANDLERSTKSIZE equ WndMsgHandlerStk.size - WndMsgHandlerStk.hWnd

  align 16
_WindowMessagesHandler@16:
  push  ebp
  mov   ebp,esp

  cmp   dword [esp + WndMsgHandlerStk.uMsg],WM_DESTROY
  jz    Handle_Destroy

  push  dword [ebp + WndMsgHandlerStk.lParam]
  push  dword [ebp + WndMsgHandlerStk.wParam]
  push  dword [ebp + WndMsgHandlerStk.uMsg]
  push  dword [ebp + WndMsgHandlerStk.hWnd]
  call  dword [__imp__DefWindowProcA@16]
  jmp   HandlerExit

Handle_Destroy:
  push  dword 0
  call  dword [__imp__PostQuitMessage@4]
  xor   eax,eax

HandlerExit:
  pop   ebp
  ret   WNDMSGHANDLERSTKSIZE 

  global _WinMain@16

struc WinMainStk
.oldebp:        resd  1
.retaddr:       resd  1
.hInstance:     resd  1
.hPrevInstance: resd  1
.lpszCmdLine:   resd  1
.nCmdShow:      resd  1
.size:
endstruc

WINMAINSTKSIZE equ WinMainStk.size - WinMainStk.hInstance

  align 16
_WinMain@16:
  push  ebp
  mov   ebp,esp

  ;-----------------
  ; Registra a classe de janela.
  ;-----------------
  mov   eax,[ebp+WinMainStk.hInstance]
  mov   [wc+WNDCLASS.hInstance],eax

  push  dword IDI_APPLICATION
  push  dword 0
  call  dword [__imp__LoadIconA@8]
  mov   [wc+WNDCLASS.hIcon],eax

  push  dword IDC_ARROW
  push  0
  call  dword [__imp__LoadCursorA@8]
  mov   [wc+WNDCLASS.hCursor],eax

  mov   eax,_WindowMessagesHandler@16
  mov   [wc+WNDCLASS.lpWndProc],eax

  mov   eax,winapp_class
  mov   [wc+WNDCLASS.lpszClassName],eax

  push  wc
  call  dword [__imp__RegisterClassA@4]

  ;-----------------
  ; Cria a nova janela.
  ;-----------------
  push  dword 0
  push  dword [ebp+WinMainStk.hInstance]
  push  dword 0
  push  dword 0
  push  dword 480
  push  dword 640
  push  dword CW_USEDEFAULT
  push  dword CW_USEDEFAULT
  push  dword WS_OVERLAPPEDWINDOW
  push  winapp_title
  push  winapp_class
  push  dword 0
  call  dword [__imp__CreateWindowExA@48]
  test  eax,eax
  jnz   created_ok

  ;----
  ; Em caso de erro com CreateWindowEx...
  ;----
  push  dword (MB_OK | MB_ICONERROR)
  push  msg_caption
  push  msg_text
  push  dword 0
  call  dword [__imp__MessageBoxA@16]
  xor   eax,eax
  jmp   WinMainExit

  ;----
  ; Tudo ocorreu bem com CreateWindowEx...
  ;----
created_ok:
  mov   [hWnd],eax    ; Salva o handle.

  ;---- Update and Show...
  push  eax
  call  dword [__imp__UpdateWindow@4]
  push  dword [ebp+WinMainStk.nCmdShow]
  push  dword [hWnd]
  call  dword [__imp__ShowWindow@8]

MessageLoop:
  push  dword 0
  push  dword 0
  push  msg
  push  dword [hWnd]
  call  dword [__imp__GetMessageA@16]
  test  eax,eax
  jz    ExitLoop

  push  msg
  call  dword [__imp__TranslateMessage@4]

  push  msg
  call  dword [__imp__DispatchMessageA@4]
  jmp   MessageLoop

ExitLoop:
  mov   eax,[msg+MSG.wParam]

WinMainExit:
  pop   ebp
  ret   WINMAINSTKSIZE

Mais o Makefile:

# Makefile
CC=i686-w64-mingw32-gcc

.PHONY: all clean

all: winapp.exe

winapp.exe: winapp.o
	$(CC) -s -o $@ $^ -Wl,-subsystem=windows

winapp.o: winapp.asm win32.inc
	nasm -f win32 -o $@ $<

clean:
	-rm *.o

Note que o gcc é necessário aqui para linkagem dos surrogates das bibliotecas dinâmicas kernel32.dll, user32.dll e gdi32.dll.

O código é, essencialmente, o mesmo gerado por um programinha em ?

/*
   Gabarito de Programa em C para Windows.
 */
#include <windows.h>

HWND mainWindowHandle;

LRESULT CALLBACK WindowMessageHandler(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   LPSTR lpszCmdLine, int nCmdShow)
{
  MSG msg;
  static const char *className = "MyWinAppClass32";
  WNDCLASS wc = {};

  wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
  wc.lpfnWndProc = WindowMessageHandler;
  wc.hInstance = hInstance;
  wc.hIcon = LoadIcon(hInstance, IDI_APPLICATION);
  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
  wc.lpszClassName = className;

  RegisterClass(&wc);

  if ((mainWindowHandle = CreateWindow(
                className,
                "My Win32 App",
                WS_OVERLAPPEDWINDOW,
                CW_USEDEFAULT, CW_USEDEFAULT,
                640, 480,
                NULL,
                NULL,
                hInstance,
                NULL
              )) == NULL)
  {
    MessageBox(NULL, "Error creating window!", "Error", MB_OK | MB_ICONERROR);
    return 0;
  }

  UpdateWindow(mainWindowHandle);
  ShowWindow(mainWindowHandle, nCmdShow);

  while (GetMessage(&msg, NULL, 0, 0))
  {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }

  return msg.wParam;
}

LRESULT CALLBACK WindowMessageHandler(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  switch (uMsg)
  {
    case WM_DESTROY:
      PostQuitMessage(0);
      break;

    default:
      return DefWindowProc(hWnd, uMsg, wParam, lParam);
  }

  return 0;
}

Não há NENHUM ganho em escrever o código acima diretamente em ASM...
Pior ainda... o código em C é portável (compile-o para x86-64 e ele funciona), o em ASM não é.

[Saraiva Saraiva]

Eai overMaster, programador desde  antes 1994 se loko cachoeira.

Vou pesquisar "standalone", não mais eu pretendo é entender mais e facilitar nos estudos de reversa.

Eu estava um ano fora, cheguei a ler 50 paginas de sua apostila, mas preguei no PHP estudei igual cavalo de roça para mercado de trabalho pedir WordPress. Então se tivesse desde 2014  no baixo nível acredito que estaria lá com os gringos em algum repositório de extender de algum jogo. 

C/C++ Já domino bem.  3 anos sem programar c, falei vou tentar escrever um programa trecho, pior que to mais afinado que antes, bom do alto nível para mim foi visão, do baixo para alto o mesmo, lógicas prontas. 

Finalizando, queria tentar no linux, mais PC da minha empresa não pode usar Linux por enquanto, por causa do soft de OS.

Fiz isto com 1 hora.

https://pastebin.com/raw/9F1sShvs 

 

 

[fredericopissarra]

Desde 1984!!! ?
O Curo de ASM escrevi 10 anos depois de ter começado! ?

 

[void_]

Não é querendo ser repetitivo, baba ovo, nem nada, mas tenta também esse livro:

https://s3.novatec.com.br/capas-ampliadas/capa-ampliada-9788575226674.jpg

Material atual de asm64. Como eu disse no outro tópico, esse livrou virou o meu xodó para estudar assembly. Muito bem estruturado, dinâmico e de excelente conteúdo. Esse sim valeu a pena.