Attention, sous Windows EBX est à sauvegarder, en 32 bits il n'y a que EAX, ECX et EDX qu'on peut considérer comme écrasés.

dec ecx
cmp ecx,0
CMP est absolument inutile et donc NUISIBLE pour les perfs. DEC positionne deja le flag ZF, on peut donc direct le lire avec JNE (ou JNZ idem).

Employer DIV pour faire du ultoa() est de l'absolu contre performant.

etc, etc, pas le temps de prendre point par point.
Ne le prends pas mal mais autant te dire qu'il n'y aura rien à garder de tout cela si tu veux continuer (et je t'y invite) en ASM.

J'ai oublié de préciser que je ne traite que le mode protégé.

Quelques grosses différences:
- Passage des params.
- Alignement correct de RSP.
- Obligation de continuer avec FPU pour tant de calculs.
etc...

Salut,
je ne voudrais pas abuser mais démarrer du 32 bits fin 2011 est quasi aussi obsolète que du 16 bits.

En ce cas les sources en priorité et un lien vers les ressources ira impec.

SVP, faire upgrade de la source pour y déposer les sources (le zip).
Un simple lien se brise si facilement...
Merci d'avance.

NIET,
c'est la compile du FULL code C qu'il faut comparer au reste.

Eternel discours entre le pseudo ASM qui finira toujours moins efficace que du bon C et le vrai ASM dont le seul but devrait être l'optimisation maximale.

mov byte ptr[eax + ecx-1], '0'
shr edx, 1
adc byte ptr[eax + ecx-1], 0

NON !!! on ne réécrit pas 2 fois en mémoire le meme octet. Il y a des registres et il convient de s'en servir.
Quand on met une fonction en ASM c'est qu'on va faire mieux que le compilo C sinon on s'abstient.

PROG TESTE ET FONCTIONNANT

J'ai fait sur VC++, je n'utilise plus MASM depuis des lustres.
La syntaxe est idem, c'est pur ASM.
J'ai juste changé les chaines pour retrouver le bmp et les entrées dans la BDR afin de nettoyer.

#include <windows.h>

char szappname[] = "TrnsBmp";
char szMybmp[] = "aaa.bmp";
char szRegKey[] = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\OEMInformation";
char szRegKeyValueMOV[] = "Powered by BruNews";
char szRegKeyValueMO[] = "Model";


__declspec(naked) void __stdcall myWinMain()
{
  __asm {
    lea     eax, [esp - 272]
    mov     edx, 264
    mov     esp, eax      ; buffer[264] + handle en [esp+264] + ESI
    mov     [eax + 268], esi
    
    push    edx
    push    eax
    call    dword ptr GetSystemDirectory
    lea     edx, [esp + eax]        ; sur fin de sysDir
    mov     ecx, offset szMybmp
    mov     esi, esp                ; ESI = ADDR chaine
    mov     byte ptr[edx], 5Ch      ; '\'
cpyBMP:
    mov     al, byte ptr[ecx]
    add     edx, 1
    add     ecx, 1
    mov     [edx], al
    test    al, al
    jne     short cpyBMP
    
    push    0
    push    esi                 ; ADDR chaine newFileName
    push    offset szMybmp
    call    dword ptr CopyFile
    lea     edx, [esi + 264]    ; ADDR handle
    test    eax, eax
    je      progEND             ; inutile aller plus loin si pas copie
    
    push    edx
    push    KEY_SET_VALUE
    push    0
    push    offset szRegKey
    push    80000002h           ;  HKEY_LOCAL_MACHINE
    call    dword ptr RegOpenKeyEx
    mov     esi, [esp + 264]    ; ESI = handle BDR
    test    eax, eax
    jne     progEND
    
    push    19    ; TAILLE de szRegKeyValueMOV AVEC 0 final
    push    offset szRegKeyValueMOV
    push    REG_SZ
    push    0
    push    offset szRegKeyValueMO
    push    esi
    call    dword ptr RegSetValueEx
    test    eax, eax
    jne     closeBDR
    ; POUR LA SUITE ON CONSIDERERA OK ECRITURE VU QUE 1er REUSSI
    
    ; Comme tout est bon, tu continueras seul les 5 RegSetValueEx suivants
    
    
    ; ICI POUR TEST QUE EST ALLE JUSQU'AU BOUT
    mov     eax, esp
    push    0
    push    offset szappname
    push    eax
    push    0
    call    dword ptr MessageBox
    
closeBDR:
    push    esi
    call    dword ptr RegCloseKey
progEND:
    pop     esi
    add     esp, 268
    push    0
    call    dword ptr ExitProcess
    ret     0
  }
}

ah ok, tu dois encore utiliser le chainage fait au début. Excuse mais je n'ai vraiment pas le temps de me pencher sérieusement sur ton affaire.
Puisque la chaine pat de ESP, on ne doit pas toucher à ce qui a été réservé, les 264 au dessus de ESP.
Alors change le sub  esp, 264
sub esp, 268  ; 4 de plus pour le handle
idem en bas: add esp, 268 en sortie

ensuite devient
lea  eax, [esp + 264]
après le RegOpenKeyEx, recup du handle:
mov  ecx, [esp+264]
le reste ne devrait pas chnager

Ta chaine se trouve en ESP, quand tu as besoin, après le push ESI sera en [esp = 4].
push  esi
j'ai besoin de l'adresse de chaine
lea  eax, [esp + 4]
et tu peux la PUSHer (eax) pour une API quand besoin.