bool SonLetras(const char* buf)
{
#define MAX_ALFA 53
	const char alfabetico[] = {
		'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
		'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
	int ok=0;
	int len = strlen(buf);
	for(int i=0; i<len; i++){
		for(int j=0; j<MAX_ALFA; j++){
			if(buf[i]==alfabetico[j]){
				ok++;
				break;
			}}}
	if(ok==len) return true;
	return false;
}

//
// By 85
// elhacker.net
// InterceptAPI: (googleado en 5 segundos XD)
// 2013
//


#pragma comment (lib,"Shlwapi.lib")
#include<windows.h>
#include <Shlwapi.h>
#include<stdio.h>

///////////////////////////////////////////////////////////

char* mystrlwr(char* a){

	static bool onlyonce=false;
	if(!onlyonce){
		onlyonce=true;
		printf("\nSTRLWR INTERCEPTADA!\n");
	//	MessageBox(0,0,0,0);
	}
	return a;
}

//
BOOL InterceptAPI(HMODULE hLocalModule,const char* c_szDllName,const char* c_szApiName, DWORD dwReplaced)
{
    DWORD dwOldProtect;
    DWORD dwAddressToIntercept=(DWORD)GetProcAddress(GetModuleHandle((char*)c_szDllName),(char*)c_szApiName);
	printf("add: %x\n", dwAddressToIntercept);
	printf("dll: %s\n", c_szDllName);
	printf("api: %s\n", c_szApiName);
//	system("pause");
	if(!dwAddressToIntercept) return false;
    BYTE *pbTargetCode = (BYTE *) dwAddressToIntercept;
    BYTE *pbReplaced = (BYTE *) dwReplaced;
    VirtualProtect((void *) dwAddressToIntercept, 5, PAGE_WRITECOPY, &dwOldProtect);
    *pbTargetCode++ = 0xE9;        // jump rel32
    *((signed int *)(pbTargetCode)) = pbReplaced - (pbTargetCode +4);
    VirtualProtect((void *) dwAddressToIntercept, 5, PAGE_EXECUTE, &dwOldProtect);
    FlushInstructionCache(GetCurrentProcess(), NULL, NULL);
    return TRUE;
}

//
void Dummy(){

	strlwr(new char[] = "85 de elhacker.net :D\0");
}

//
int main(){

	Sleep(500);
	char l_s11[] = {'m','s','v','c','p','6','0','.','d','l','l',0};
	char l_s12[] = {'m','s','v','c','p','7','1','.','d','l','l',0};
	char l_s13[] = {'m','s','v','c','p','1','0','0','.','d','l','l',0};
	char l_s[] = {'m','s','v','c','r','t','.','d','l','l',0};
	char l_api[] = {'_','s','t','r','l','w','r',0};
	char l_exe[] = {'m','s','v','c','r','t','_','h','o','o','k','.','e','x','e',0};
	char FileName[256];
	if(!GetModuleHandle(l_s)) ExitProcess(0);
	GetModuleFileName(GetModuleHandle(NULL), FileName, sizeof(FileName));
	PathStripPath(FileName);
	if (strcmp(FileName, l_exe) == 0){
		InterceptAPI(GetModuleHandle(NULL), l_s, l_api, (DWORD)mystrlwr);
                /* else: no se ha interceptado ! */
	}
	else 
	{ /* no se ha interceptado ! */ return 0;}
	Dummy();
	printf("\n");
	system("pause");
	return 0;
}

__declspec(naked) int __stdcall m_atoi(char* szTarget, unsigned int dwLength)
{
	#define SUB_OFFS 48

	__asm {
		push ebp; //Save old framepointer value
		mov ebp, esp; //Copy ESP into EBP -> EBP:[Old-EBP:4][Ret-Addr:4][dwLength:4][szTarget:4]
		sub esp, 5; //Allocate 5 bytes [EBP-4]: unsigned int dwResult, [EBP-5]:char cMinusChar
		mov dword ptr [ebp-4], 0; //Zero bytes of dwResult value. dwResult holds entire result value
		mov byte ptr[ebp-5], 0; //Zero byte of cMinusChar. cMinusChar holds first char @szTarget for '-' check

		cmp szTarget, 0; //Check if szTarget is a null pointer
		je fEnd; //If so goto function end
		cmp dwLength, 0; //Check if string length is zero
		je fEnd; //If so goto function end

		//Save registers for use
		push ebx; //Holds mulitplied value of current positon.
		push ecx; //Used for loop cmd
		push edx; //For saving temporary stuff
		push esi; //Holds start address + length of string
		pushf; //For modifying direction flag

		mov ebx, 1; //Set to one. The first position is the ones, second tens, third hundrets, etc.
		mov ecx, dwLength; //Copy length to ECX for counting

		mov esi, szTarget; //Copy string address to ESI
		add esi, ecx; //Add string length
		dec esi; //Decrement not to go too far (because of zero position)

		push eax; //Save EAX temorarly
		mov eax, szTarget; //Copy string address to EAX
		mov al, byte ptr[eax]; //Copy the first byte to AL
		mov byte ptr[ebp-5], al; //Copy it to EBP-5 (cMinusChar)
		pop eax; //Restore EAX

		cmp byte ptr[ebp-5], '-'; //Check if the char is a minus char
		jne fOvr1; //If not goto fOvr1
		dec ecx; //Decrement, because we ignore the '-' char to not corrupt the entire number

	fOvr1:
		std; //Set direction flag to 1 to go from hight to low addresses
fLoop:
		xor eax, eax; //Clear bits of EAX
		lodsb; //Copy byte at [ESI] to AL and extend ESI (in this case decrement)
		sub al, SUB_OFFS; //Substract offset to make from char to real number
		mul ebx; //Multiplicate EAX with EBX depending on its current position. Ones with 1, Tens with 10, Hundrets with 100, etc.
		mov edx, dword ptr[ebp-4]; //Copy entire result value to EDX
		add edx, eax; //Add EAX on it
		mov dword ptr [ebp-4], edx; //Copy back to result value

		mov eax, ebx; //Copy EBX to EAX 
		mov ebx, 10; //Copy 10 to EBX
		mul ebx; //Multiply with 10 to go to the next positon: 1*10 = 10, 10*10 = 100, 100*10 = 1000, etc
		mov ebx, eax; //Copy back to EBX

		loop fLoop; //Goto fLoop and decrement ECX if not already zero

		cmp byte ptr[ebp-5], '-'; //Check if first char was '-'
		jne fOvr2; //If not goto fOvr2
		mov eax, [ebp-4]; //Copy result value to EAX
		mov ebx, -1; //Copy -1 to EBX
		imul ebx; //Make signed multiplication to make a positive value to a negative one
		mov [ebp-4], eax //Copy back to result value
	
fOvr2:
		//Restore all used registers
		popf;
		pop esi;
		pop edx;
		pop ecx;
		pop ebx;
		
	fEnd:
		mov eax, dword ptr[ebp-4]; //Copy result value to EAX for result
		add esp, 5; //Remove both stack variables
		pop ebp; //Restore EBP
		ret 8; //Restore Ret-Address and remove the 8 argument bytes
	}
}

while(1)
{
	if(copia>=10)
	{
		copia /= 10;
		unidades_decimales++;
	}
	else
	{
		break;
	}
}

int unidades_decimales = 1;
int copia;
for (copia = num; copia >= 10; copia /= 10)
   unidades_decimales++;

push
push
call
.......
push ebp
mov ebp, esp

mov esp, ebp
pop ebp
retn 

add esp, 0x8

//
// By 85
// elhacker.net
// 2013
//

#include<windows.h>
#include<stdio.h>

void Test(){
	char test1[] = {'o','c','h','e','n','t','a','y','c','i','n','c','o',0};
	char test11[] = {'o','c','h','e','n','t','a','y','c','i','n','c','o',0};
	char test111[] = {'o','c','h','e','n','t','a','y','c','i','n','c','o',0};
	char test1111[] = {'o','c','h','e','n','t','a','y','c','i','n','c','o',0};
	char test11111[] = {'o','c','h','e','n','t','a','y','c','i','n','c','o',0};
	char testA[256];
	strcat(testA,test1);
	strcat(testA," 85\0");
	printf(test1);
	printf("\n\n");
	char test2[] = "ochentaycinco1\0";
	char test22[] = "ochentaycinco2\0";
	char test222[] = "ochentaycinco3\0";
	char test2222[] = "ochentaycinco4\0";
	char test22222[] = "ochentaycinco5\0";
	const char* testX = "ASD\0";
	char testB[256];
	strcat(testB,test2);
	strcat(testB," 85\0");
	printf(test2);
	printf("\n\n");
	printf(testX);
	printf("\n\n");
}

int main()
{
	Test();

	char test11111[] = {'o','c','h','e','n','t','a','y','c','i','n','c','o',0};
	char test22222[] = "ochentaycinco11\0";
	const char* testX = "WWW\0";
	printf("TEST1\n");
	printf(testX);
	printf("\n");
	printf(new char[] = "wwwwwww\n");
	printf(new char[] = "xxxxxxx\n");
	printf(new char[] = "AAAAAAA\n");
	system("pause");
	return 0;
}

void Test1(BYTE* array_de_bytes, char* cadena_de_bytes_en_formato_string){ //Cadena de bytes a string

void Test2(char* cadena_de_bytes, BYTE* cadena_de_bytes_resultante)
{
	static  BYTE Tabla[256] =
	{
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0,
		0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
	};

	int Position;
	int Length_de_bytes_resultante; // :)

	Position = 0;
	while (cadena_de_bytes[Position] != '\0')
	{
		cadena_de_bytes_resultante[Position >> 1] = (Tabla[cadena_de_bytes[Position]] << 4) + Tabla[cadena_de_bytes[Position + 1]];
		Position = Position + 2;
	}
	Length_de_bytes_resultante = Position >> 1;

	for (Position = 0; Position < Length_de_bytes_resultante; Position = Position + 1)
	{
		printf("%02X", cadena_de_bytes_resultante[Position]);
	}
	printf("\n");

}