format PE GUI 5.01 NX at 0x771A0000

entry EntryTestASLR32
include '%fasm%\include\win32a.inc'
section '.idata' import data readable writeable
library kernel32,'KERNEL32.DLL', user32,'USER32.DLL'
import user32, MessageBoxA,'MessageBoxA'
import kernel32, ExitProcess,'ExitProcess'

section '.text' code readable executable

EntryTestASLR32:
; mov eax, [label2]
 invoke MessageBoxA, 0, mb_text, 0, 0
 invoke ExitProcess, 0

section '.data' data readable writeable
mb_text db "text",0
label2 dd 0

section '.reloc' data readable discardable fixups
    

Does this also affect DLLs? The relocation mechanism is the same for both.

Not a problem on Win11, afaict.
(Relocation happens as expected.)

Anything you put into section marked as FIXUPS (or into DATA FIXUPS block) is appended on top of the fixups directory data.

section '.reloc' data readable discardable
data fixups
dw 0
end data    

format PE GUI 5.01 NX at 0x10000000


; kernel32.dll base address on my virtual computers:
; 0x7C800000 - WinXPx32 - no ASLR
; 0x76F60000 - WinVistaSp2x64 with all updates - affected
; 0x75DA0000 - Win7sp1x32 with all updates - affected
; 0x771A0000 - Win8.1x64 with all updates - affected
; 0x75AF0000 - Win10x32 21H2 build 19044.1865 with all updates - not affected
; 0x76630000 - Win11x64 21H2 build 22000.832 with all updates - not affected
; 0x75BD0000 - Windows Server 2022 Standard 21H2 build 20348.587 with all updates - not affected


entry EntryTestASLR32

include '%fasm%\include\win32a.inc'

section '.idata' import data readable writeable

library kernel32,'KERNEL32.DLL',\
        user32,'USER32.DLL',\
        shlwapi,'SHLWAPI.DLL'

import  user32,\
        MessageBoxA,'MessageBoxA'
import  kernel32,\
        GetModuleHandleA,'GetModuleHandleA',\
        GetModuleFileNameW,'GetModuleFileNameW',\
        CreateFileW,'CreateFileW',\
        GetFileSizeEx,'GetFileSizeEx',\
        LocalAlloc,'LocalAlloc',\
        LocalFree,'LocalFree',\
        ReadFile,'ReadFile',\
        CloseHandle,'CloseHandle',\
        ExitProcess,'ExitProcess'
import  shlwapi,\
        wnsprintfA,'wnsprintfA'

section '.text' code readable executable

EntryTestASLR32:

; enable/disable this line for change '.reloc' size
        mov     eax, this_label_for_align_reloc
; enable - reloc size invalid
; disable - reloc size normal


        invoke  GetModuleHandleA, t_kernel32
        mov     [kernel32_address], eax 

        invoke  GetModuleHandleA, 0
        mov     [current_address_MEM], eax

        stdcall get_addr_from_PE_header
        mov     [current_address_PE], eax

        mov     eax, [current_address_PE]
        test    eax, eax
        jz      aslr_fail
        cmp     eax, [current_address_MEM]
        je      aslr_fail
        cinvoke wnsprintfA, text_buffer, size_text_buffer, t_mask_OK, [kernel32_address], [current_address_MEM], [current_address_PE]
        jmp     view_res
        
aslr_fail:
        cinvoke wnsprintfA, text_buffer, size_text_buffer, t_mask_ERR, [kernel32_address], [current_address_MEM], [current_address_PE], [kernel32_address]
        
view_res:
        invoke  MessageBoxA, 0, text_buffer, mb_header, 0
        invoke  ExitProcess, 0




proc get_addr_from_PE_header
locals
 dqFileSize dq ?
 dwTemp dd ?
 filename dw MAX_PATH dup (?)
endl
        push    edi
        push    esi
        push    ebx

        lea     edx, [filename]
        invoke  GetModuleFileNameW, 0, edx, MAX_PATH

        lea     ecx, [filename]
        invoke  CreateFileW, ecx, GENERIC_READ, FILE_SHARE_READ or FILE_SHARE_WRITE or FILE_SHARE_DELETE, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0
        cmp     eax, INVALID_HANDLE_VALUE
        je      .err0
        mov     ebx, eax ; hFile

        lea     esi, [dqFileSize]
        mov     dword [esi], 0
        mov     dword [esi+4], 0
        invoke  GetFileSizeEx, ebx, esi
        test    eax, eax
        jz      .err0
        cmp     dword [esi+4], 0
        jnz     .err0
        mov     esi, [esi+0]
        test    esi, esi
        jle     .err0

        invoke  LocalAlloc, LPTR, esi
        test    eax, eax
        jz      .err0
        mov     edi, eax

        lea     edx, [dwTemp]
        invoke  ReadFile, ebx, edi, esi, edx, 0
        test    eax, eax
        jz      .err0
        invoke  CloseHandle, ebx

        lea     ecx, [edi + 0x3C] ; IMAGE_DOS_HEADER.e_lfanew
        mov     ecx, [ecx]
        add     ecx, edi

        lea     ecx, [ecx + 0x34] ; IMAGE_NT_HEADERS32.OptionalHeader.ImageBase
        mov     esi, [ecx]
        
        invoke  LocalFree, edi
        mov     eax, esi
        jmp     .return

.err0:  xor     eax, eax

.return:
        pop     ebx
        pop     esi
        pop     edi
        ret
endp


section '.data' data readable writeable
kernel32_address dd ?
current_address_MEM dd ?
current_address_PE dd ?
this_label_for_align_reloc dd ?

t_kernel32 db "kernel32.dll",0

mb_header db "ASLR test2",0

t_mask_OK db    "kernel32 address in memory: 0x%08X",13,10,\
                "current process address in memory: 0x%08X",13,10,\
                "base address in the PE-header of the current process: 0x%08X",13,10,13,10,\
                "ASLR test result: OK",0

t_mask_ERR db   "kernel32 address in memory: 0x%08X",13,10,\
                "current process address in memory: 0x%08X",13,10,\
                "base address in the PE-header of the current process: 0x%08X",13,10,13,10,\
                "ASLR test result: Change the address in the first line of the source to '0x%08X' and rebuild the program.",0

size_text_buffer = 2048
text_buffer rb size_text_buffer

section '.reloc' data readable discardable fixups

    

In Ghidra, I see that in '.reloc' there is a link to the table, there is a real value in table+4 (for example, 0x0000000A), I fix it to 0x0000000C - and the program starts normally.

The PE specification states that each relocation block needs to start on a 32-bit boundary, which is not the same as each block needing to have an aligned size, but in practice this only makes a difference in the final block. The implementation in fasm 1 took the specification quite literally - not aligning the length of the final block.

section '.reloc' data readable discardable fixups
if (($ - $$) mod 4) > 0
 display "invalid fixup size!",13,10
 err
end if    

IMAGE_REL_BASED_ABSOLUTE | 0 | The base relocation is skipped. This type can be used to pad a block.

If fasm is updated with a fix what is a good way to pad the reloc section?