; Reversing procedure.
;
proc ReverseString, Input, Output, InputLen

  pushf
       push    ecx esi edi

     mov     ecx, [InputLen] ; Length of the input string
                                ; without following zero byte.

  mov     esi, [Input]    ;
   add     esi, ecx        ; 
  dec     esi             ; Now esi points to the last
                                ; non-zero byte of the input
                                ; string.
   
    mov     edi, [Output]   ; Pointer to the output buffer.

 ; Reversing loop.
   ;
   .Loop:
          std
         lodsb
               cld
         stosb
               loop    .Loop

   pop     edi esi ecx
 popf

    ret
endp
    

include 'win32ax.inc' 

.data
        InputStr        db "Exemplary string."
    InputStrLen     = $ - InputStr
                      db 0
        
    ReversedStr     rb InputStrLen
                      db 0
.code

   start:
          invoke  MessageBox, HWND_DESKTOP, InputStr, "Original string", MB_OK

          stdcall ReverseString, InputStr, ReversedStr, InputStrLen

               invoke  MessageBox, HWND_DESKTOP, ReversedStr, "Reversed string", MB_OK

               invoke  ExitProcess, 0

          ; Reversing procedure.
              ;
           proc    ReverseString, Input, Output, InputLen

                  pushf
                       push    ecx esi edi

                     mov     ecx, [InputLen] ; Length of the input string
                                                ; without following zero byte.

                  mov     esi, [Input]    ;
                   add     esi, ecx        ; 
                  dec     esi             ; Now esi points to the last
                                                ; non-zero byte of the input
                                                ; string.
                   
                    mov     edi, [Output]   ; Pointer to the output buffer.

                 ; Reversing loop.
                   ;
                   .Loop:
                          std
                         lodsb
                               cld
                         stosb
                               loop    .Loop

                   pop     edi esi ecx
                 popf

                    ret
         endp

.end start
    

.data
_RevStrOff dd -1 ;; current working offset
_RevStrStart dd 0 ;; constant start pointer
_RevStrEnd dd 0 ;; constant end pointer
_RevStrSync dd 0 ;; synchronization semaphore
_RevStrThrCnt dd 0 ;; number of threads in RevStr's worker thread pool

.code
;; Create a bunch (optimal amount) of threads
;; with RevStrThread as the Thread Proc
...
;; This function is not thread safe LOL
RevStr:
 MOV ecx,[esp+8] ;; len
 MOV eax,[esp+4] ;; ptr
 CMP ecx, 1 ;; useless length
 JLE .die
 CMP eax, -1 ;; useless string
 JE .die
 MOV edx, [_RevStrThrCnt]
.sync:
 CMP [_RevStrSync], edx
 JNE .sync
 LEA edx, [eax + ecx - 1] ;;end
 MOV [_RevStrEnd], edx
 SHR ecx, 1 ;; len / 2
 DEC ecx ;; (len / 2) -1
 MOV [_RevStrStart], eax
 MOV [_RevStrOff], ecx
.wait: ;;wait for the thread pool to finish
 CMP [_RevStrOff], 0 ;; wait while offset >= 0
 JGE .wait
.die:
 RET 8

RevStrThread:
.reset: ;; reset and go into wait mode
 MOV [_RevStrOff], -1
 LOCK ADD [_RevStrSync], 1
 JMP .wait
.work:
 LOCK SUB [_RevStrSync], 1
 MOV esi, [_RevStrStart] ;; start ptr
 MOV edi, [_RevStrEnd] ;; end ptr
.again:
 MOV ebx, -1
 LOCK XADD [_RevStrOff], ebx ;; ebx = current offset
 CMP ebx, ebx ;; reset if offset < 0 
 JS .reset
 LEA ecx, [ebx*-1] ;; -offset
 MOV al, byte[esi + ebx]
 MOV ah, byte[edi + ecx]
 MOV byte[esi + ebx], ah
 MOV byte[edi + ecx], al
 JMP .again
.wait: ;; wait for a new string
 CMP [_RevStrOff], 0 ;; wait while offset < 0
 JL .wait
 JMP .work
    

push a dword to save a byte is not optimal.

It requires a buffer - better to do it in place.
Buffers are not easy to come up with.

proc StrReverse lpString:DWORD
mov eax,[lpString]                       ; put string address in EAX
mov edx,eax                            ; same in EDX
@@:                                    ; move EDX to the end of string
add edx,1
cmp byte [edx],0
jne @B
sub edx,1                              ; return EDX to last not null character
@@:
mov cl,byte [eax]          ; swap EAX and EDX, moving from two brinks
mov ch,byte [edx]          ; in opposite directions
mov [eax],ch                   ; while EAX is less than EDX
mov [edx],cl
add eax,1
sub edx,1
cmp eax,edx
jl @B
ret
endp