lea eax,[text-1]
mov ecx,size
@@:
        mov bh,byte[eax]
        inc eax
        mov bl,byte[eax]
        xor byte[eax],bh
        mov bh,byte[eax+1]
        inc eax
        xor byte[eax],bl
        loop @b    

is this CBC method ?

size = strlen(string);
string[0] = string[0] xor string[size]; xor the first with last
for(i = 1, i<=size, i++)
{    
    string[i] = string[i] xor string[i-1]; xor  2with1, 3with2,4with3....

}
    

macro dbcryptstr label_name, string, length
{
     local x,y
common     
    label   label_name
  db      string
      db 0
        
    len = length 
       repeat len
          load x from label_name + len - % + 1
                load y from label_name + len - %
            x = x xor y
         store x at label_name + len - % + 1
 end repeat
  load x from label_name
      load y from label_name + length
     x = x xor y
 store x at label_name
}



dbcryptstr szMystring, '123456789', 9
dbcryptstr szMyOtherString, 'blablablalbalba, 15
    

I have no idea how these macroses work

Where can I start ?

STRSIZE equ 9

section '.data' data readable writeable 
 szPause db 'PAUSE',0
      szOrig  db '123456789',0
  szEncr  db '.........',0
  szUncr  db '.........',0              
     
    
    
section '.code' code readable executable 
start: 
     

encrypt:
        mov     ecx, STRSIZE-1 ;ecx = size of string
encloop:
        lea     esi, [szOrig + ecx]
 lea edi, [szOrig + ecx -1]
  
    mov     al, [esi]
   mov bl, [edi]
       xor al, bl
  mov [szEncr + ecx], al
      loop encloop
        mov al, [szOrig]
    lea esi, [szEncr + STRSIZE - 1]
     xor al, [esi]
       mov [szEncr], al
    
uncrypt:
    ;the same process as encrypt but inverted
   mov al, [szEncr]
    lea esi, [szEncr + STRSIZE - 1]
     xor al, [esi]
       mov [szUncr], al
    
    xor ecx, ecx
uncloop:    
    lea     esi, [szUncr + ecx]
 lea edi, [szEncr + ecx + 1]
 
    mov     al, [esi]
   mov bl, [edi]
       xor al, bl
  mov [szUncr + ecx + 1], al
  inc ecx
     cmp ecx, STRSIZE-1
  jne  uncloop

exit:
       cinvoke system, szPause
    

or overflowz didn't know what he wanted xD

include 'win32axp.inc'

;;;; DATA

message db 'This is a test message to check the cipher implementation', 0
;message db 'Hello World! :D', 0
align 16 ; WARNING: Padding with constant pattern may leak information (not sure actually)
message.blocks = ($ - message) / 16

db 0 ; Just to make sure MessageBox stops reading memory
align 16

key     db 'LocoDelAssembly!' ; Yep, exactly 16 bytes :D
IV      db '0123456789ABCDEF' ; <- This is stupid in real life as it MUST BE random

start:
      stdcall encrypt, message, message, message.blocks, IV, key
      invoke  MessageBox, 0, message, 'Encrypted', 0

      stdcall decrypt, message, message, message.blocks, IV, key
      invoke  MessageBox, 0, message, 'Decrypted', 0

      invoke  ExitProcess, 0


; Pointers must be 16-byte aligned
proc encrypt, pDest, pSrc, count, pIV, pKey

      mov     ecx, [count]
      mov     eax, [pIV]
      mov     edx, [pKey]
      movaps  xmm0, dqword [eax]
      movaps  xmm1, dqword [edx]
      mov     edx, [pDest]
      mov     eax, [pSrc]

      add     ecx, ecx
      lea     ecx, [ecx*8]
      lea     eax, [eax + ecx - 16]
      lea     edx, [edx + ecx - 16]
      neg     ecx
      jmp     .done?

.loop:
; Xor with previous encrypted block (or IV if first iteration)
      xorps   xmm0, [eax + ecx]

; Block cipher encryption (just simple XOR with key)
      xorps   xmm0, xmm1

; Store encrypted block
      movaps  [edx + ecx], xmm0

.done?:
      add     ecx, 16
      jle      .loop

      ret
endp


; Pointers must be 16-byte aligned
proc decrypt, pDest, pSrc, count, pIV, pKey

      mov     ecx, [count]
      mov     eax, [pIV]
      mov     edx, [pKey]
      movaps  xmm2, dqword [eax]
      movaps  xmm1, dqword [edx]
      mov     edx, [pDest]
      mov     eax, [pSrc]

      add     ecx, ecx
      lea     ecx, [ecx*8]
      lea     eax, [eax + ecx - 16]
      lea     edx, [edx + ecx - 16]
      neg     ecx
      jmp     .done?

.loop:
; xmm0 = Previous encrypted block (or IV if first iteration)
; xmm2 = Current block
; Note: The the inputs of the first two steps are not like the Wikipedia's diagram just for convinience
;       (something permissible in this case thanks to the associativity property of the XOR operation)
      movaps  xmm0, xmm2
      movaps  xmm2, [eax + ecx]

; Block cipher decryption (just simple XOR with key)
      xorps   xmm0, xmm1

; Xor with previous encrypted block (or IV if first iteration)
      xorps   xmm0, xmm2

; Store encrypted block
      movaps  [edx + ecx], xmm0

.done?:
      add     ecx, 16
      jle      .loop

      ret
endp

.end start