.data
ArraySize dd 0
NewChar byte '*'

.code
;String character replace code
CharReplace proc
cmp r8d, 0
jle LoopEnd

mov eax, 0
mov ArraySize, r8d
mov bl, NewChar

LoopStart:
cmp eax, ArraySize
jge LoopEnd
inc eax
cmp cl, dl         <----- here
je ChangeChar
add rcx, 1
jmp LoopStart

ChangeChar:
mov byte ptr[rcx], bl
add rcx, 1
jmp LoopStart


LoopEnd:
ret
CharReplace endp
end

#include <iostream>
#include <conio.h>
#include <Windows.h>
#include <string>

extern "C" void CharReplace(void * arr, char, int size);

int main()
{
std::string s = "aakjflijafllwlieeaf";
int size = s.size();

char * cArray = new char[size];

for(int i = 0; i < size; i++)
{
 cArray[ i ] = s.at( i );
}

CharReplace(cArray, 'a', size);

for(int i = 0; i < size; i++)
{
 std::cout << cArray[ i ];
}

_getch();
delete [] cArray;
return 0;
}

aakjflijafllwlieeaf

.section .data

enter_pass:
.ascii "Enter the password\n\0"
password:
.ascii "abgirl"
.equ password_len, . - password
corr_pass:
.ascii "Password is right\n\0"
incorr_pass:
.ascii "Password is wrong\n\0"

.section .bss

.equ in_pass_size, 500
.lcomm in_pass, in_pass_size

.section .text

.global _start

_start:

movl $1, %ebx
movl $enter_pass, %ecx
movl $20, %edx
movl $4, %eax
int $0x80                            #linux print to stdout

movl $0, %ebx
movl $in_pass, %ecx
movl $in_pass_size, %edx
movl $3, %eax
int $0x80                         #linux get line stdin

movl $password, %ebx
movl $in_pass, %edx
movl $password_len, %ecx            #moving the values into the registers

loop:                                       #the checking loop (dont mind the registers this is 32bit but the logic is there (this is also at&t syntax so it looks a bit different)
movb (%ebx), %al                #move first byte of ascii array into %al (to be checked)
xorb (%edx), %al                 #xors the first entered  byte to the hard coded byte
cmpb $0, %al                        #if 0 is stored in %al (review xor and how it works if you dont understand why 0 is there)
jg incorr                                 #if the output is greater than 0 its incorrect (aka letters are different. you can change this line to jump to a label to do a replace then add a label after the jg call to jump back into the checking.)
inc %ebx                              
inc %edx                               #increase the position of the stdin input as well as character array
dec %ecx                              #decrease the length of the character array
cmpl $0, %ecx                       #if there are still bytes to be read
jg loop                                    #loop again (sicne we increased the addresses by 1 byte when the loop loops again it will be moving and checking the next bye in teh array)
jmp corr                                 #else if there is no bytes and we havent jumped to incorrect we are good.

incorr:
movl $1, %ebx
movl $incorr_pass, %ecx
movl $19, %edx
movl $4, %eax
int $0x80                           #print incorrect to stdout then exit
jmp return

corr:
movl $1, %ebx
movl $corr_pass, %ecx
movl $19, %edx
movl $4, %eax
int $0x80                         #print correct to stdout

return:
movl $0, %ebx
movl $1, %eax
int $0x80                               %linux exit

movb (%ebx), %al  #not sure if you need to move the byte back into the register. xor might of overwritten it.
cmpb $0x00, %al
je array_finished

.data
ArraySize dd 0
NewChar byte '*'

.code
CharReplace proc
cmp r8d, 0;Check if array size parameter is = 0
jle LoopEnd;Jump to end if true!

mov eax, 0
mov ArraySize, r8d
mov r9b, NewChar

LoopStart:
cmp eax, ArraySize
jge LoopEnd
inc eax
cmp byte ptr[rcx], dl
je ChangeChar

add rcx, 1
jmp LoopStart

ChangeChar:
mov byte ptr[rcx], r9b
add rcx, 1
jmp LoopStart

LoopEnd:
ret
CharReplace endp
end

.section .text
.globl _start
_start:
  jmp start
enter:
  pop %rcx
  inc %rcx
  jmpq *%rcx
detected:
  int3
start:
  call enter
detectbreak:
  push $0x3458cc6a
  int3
  jz detected

.section .text
.globl _start
_start:
  jmp start         #(1)goto start
enter:
  pop %rcx          #(3)since we used call we can pop the return address off the stack
  inc %rcx          #(4)increase address +1
  jmpq *%rcx        #(5)jump to that address
detected:
  int3              #(10)never reached
start:
  call enter        #(2)goto enter
detectbreak:
  push $0x3458cc6a  #(6)push a hex string to stack
  int3              #(7)issue a breakpoint
  jz detected       #(9)shouldnt jump

.section .text
.globl _start
_start:
  jmp start         #(1)goto start
enter:
  pop %rcx          #(3)since we used call we can pop the return address off the stack
  inc %rcx          #(4)increase address +1 (our address we are actually jumping to is detectbreak +1
                    # so the initial push statement is jumped pass
  jmpq *%rcx        #(5)jump to that address
detected:
  int3              #(10)breakpoint is now hit
start:
  call enter        #(2)goto enter
detectbreak:
  push $0x3458cc6a  #(6)push a hex string to stack (we skipped the push though so we are now execing byte code
  #    0x6a 0xcc 0x58 0x34 0xCC
  #    Translation:
  #    0x6a 0xcc             pushb $0xcc
  #    0x58                  pop %rax
  #    0x34 0xcc             xor $0xcc, %al

  int3               #(7)issue a breakpoint
  jz detected        #(9)jump to detected after breakpoint because zero flag is now set

testasm:     file format elf32-i386


Disassembly of section .text:

08048054 <_start>:
8048054:       eb 05            jmp    804805b <start>      #(1)0xeb is byte code for "short jump"
                                                            #0x05 is how many bytes to jump

08048056 <enter>:
8048056:       59               pop    %ecx                 #(3)call pushed 0x8048060 onto the stack
                                                            #our return address. we put it in ecx
8048057:       41               inc    %ecx                 #we increase our address by 1. (now 0x8048061)
8048058:       ff e1            jmp    *%ecx                #we jump to 0x8048061

0804805a <detected>:
804805a:       cc               int3                        #(5)our final location

0804805b <start>:
804805b:       e8 f6 ff ff ff   call   8048056 <enter>      #(2)0xe8 is "call" and needs a realitive
                                                            #address to offset from its own.
                                                            #0xf6ffffff jmps to enter:

08048060 <detectbreak>:
8048060:       68 6a cc 58 34   push   $0x3458cc6a          #(4)0x68 is push. it starts at 8048060 but
                                                            #since we are jumping to 8048061 we
                                                            #skipped over that push and we are now
                                                            # executing bytecode hidden in the push
# 0x6a 0xcc 0x58 0x34 0xCC                                  
# Translation:
# 0x6a 0xcc             pushb $0xcc                          #0x6a is push byte and 0xcc is the value
# 0x58                  pop %rax                             #0x58 is pop rax (we get 0xcc into rax
# 0x34 0xcc             xor $0xcc, %al                       #0x34 is xor [byte], %al abd 0xcc is the value

8048065:       cc               int3                        #0xcc is "break point"
8048066:       74 f2            je     804805a <detected>   #this line is fucked should be jz but w/e
                                                            #because we set the zero flag in eax this would
                                                            #now jump to the other breakpoint.