repeat 4 {
; four mov instructions
; four xor instructions
mov [dest+(%-1)*4],eax
 }
    

mov edi,[variable]
mov esi,[constant]
repeat 4
  lodsd
  xor eax,[other]
  stosd
end repeat
    

repeat 4
movzx eax,byte
movzx ebx,byte
movzx ecx,byte
movxz edx,byte
; four mov al/ah, [eax+byte_table]
mov [dest],eax
end repeat
    

mov ebx,byte_table
repeat 4
mov al, byte
mov ah,byte
shl eax,16
mov al,byte
mov ah,byte
xlatb
ror eax,8
xlatb
ror eax,8
xlatb
ror eax,8
xlatb
ror eax,8
mov [dest],eax
end repeat
    

Okay, from the start I've had many problems with endian-ness:

When moving from memory to a register, it goes from 1,2,3,4 to 2,1,4,3.

When moving from register to memory, it goes from 1,2,3,4 to 4,3,2,1

When using an operation (like xor) from register to memory, the memory operand goes from 1,2,3,4 in memory to 4,3,2,1 before the operation.

When using the bswap instruction (register), it goes from 1,2,3,4 to 4,3,2,1.

Everytime I receive user input I almost always have to perform bswap to fix it out before I even think of working with it.

I see two different types of byte-swapping in my computer, are my results normal?

But most importantly, what is with the 2,1,4,3 arrangement? I don't see why it does this when I use any mov instruction from memory to registers, because I have not heard of this type of endian-ness... What is with my computer?

Thanks, I thought I had a perfectly normal Pentium laptop with little-endianness, but apparently I've got, uhh, what you said. I have no deadlines, but what I do have is time.

What this applies to is my attempt at taking a byte[] from memory, using it to create another byte[] after all operations are done with. The only problem is that when I ever get user input, I almost always have to swap it and then end up with the wrong type of array, I don't see any way to get it right...

; -----------------------------------------------------------------------------
;
; aes encryption - user interface
; -----------------------------------------------------------------------------
 aes_encuser:

; preserve registers

    sub     esp, aes_stack_space
    mov     [esp+12], esi
    mov     [esp+ 8], edi
    mov     [esp+ 4], ebp
    mov     [esp+ 0], ebx

; obtain input parameter

    cld
    mov     esi, [esp+aes_stack_space+aes_encrypt_in_blk] ; lodsd
    mov     edi, aes_state.state                          ; stosd

; format user input to little-endian architectures, first key addition

  rept 4 column {
    lodsd
    xor     eax, d[aes_state.keys+(column-1)*4]
    stosd         }

; perform the 13 normal rounds

 if aes_encrypt_unroll

  rept 13 round
  { table_lookup_key_add (aes_state.state),(aes_state.state),((round)*16) }

 else

    mov     edx, 13
    mov     edi, aes_state.keys+16  ; add edi,16?
@@: table_lookup_key_add (aes_state.state),(aes_state.state),edi
    add     edi, 4*4
    dec     edx
    jnz     @b

 end if

; final round and key addition

    table_lookup_final (aes_state.state),(esp+aes_stack_space+aes_encrypt_out_blk),(224)

; restore registers and return

    mov     ebx, [esp+ 0]
    mov     ebp, [esp+ 4]
    mov     edi, [esp+ 8]
    mov     esi, [esp+12]
    add     esp, aes_stack_space
    ret 8
    

; -----------------------------------------------------------------------------
;
; core aes routines
; -----------------------------------------------------------------------------
 macro table_lookup_key_add source,dest,key {
  rept 4 column {
    movzx   eax, b[source+((column-1) mod 4)*4+0]
    movzx   ebx, b[source+((column+0) mod 4)*4+1]
    movzx   ecx, b[source+((column+1) mod 4)*4+2]
    mov     eax, [eax*4+aes_tables.tab_t1]
    xor     eax, [ebx*4+aes_tables.tab_t2]
    movzx   ebx, b[source+((column+2) mod 4)*4+3]
    xor     eax, [ecx*4+aes_tables.tab_t3]
    xor     eax, [(column-1)*4+key]
    xor     eax, [ebx*4+aes_tables.tab_t4]
    mov     d[dest+(column-1)*4], eax \} } ; stosd . . . / sub edi,16

 macro table_lookup_final source,dest,key   {
  rept 4 column {
    movzx   eax, b[source+((column+1) mod 4)*4+2]
    movzx   ebx, b[source+((column+2) mod 4)*4+3]
    movzx   ecx, b[source+((column-1) mod 4)*4+0]
    movzx   edx, b[source+((column+0) mod 4)*4+1]
    mov     al,  b[eax+aes_tables.tab_s] ; xlatb gives more instructions...
    mov     ah,  b[ebx+aes_tables.tab_s]
    shl     eax, 16
    mov     al,  b[ecx+aes_tables.tab_s]
    mov     ah,  b[edx+aes_tables.tab_s]
    xor     eax, [(column-1)*4+key]
    mov     [dest+(column-1)*4], eax \} } ; stosd . . . / sub edi,16
    

Hope it helps, the key schedule I am using is a dword[] (reversed in memory). I have chosen this path so when I use memory operands for xor operations it translates to normal.