Flameswor10's Simple/Step Encryption Methods

**flameswor10** · 07-11-2011

Simple Encryption/Decryption:

Code:

char* FlameCrypt(char string[], int key)
{
	int length = strlen(string);
	char* tempstring = new char[length + 1];
	for (int i = 0; i < length; i ++)
		tempstring[i] = string[i] + key;
	tempstring[length] = 0;
	return tempstring;
}
char* FlameDecrypt(char string[], int key)
 {
	int length = strlen(string);
	char* tempstring = new char[length + 1];
	for (int i = 0; i < length; i ++)
		tempstring[i] = string[i] - key;
	tempstring[length] = 0;
	return tempstring;
}

Step Encryption/Decryption

Code:

char* FlameCrypt(char string[], int key)
{
	int length = strlen(string);
	char* tempstring = new char[length + 1];
	for (int i = 0; i < length; i ++)
	{
		int KeyStep = key + i;
		tempstring[i] = string[i] + KeyStep;
	}
	tempstring[length] = 0;
	return tempstring;
}
char* FlameDecrypt(char string[], int key)
 {
	int length = strlen(string);
	char* tempstring = new char[length + 1];
	for (int i = 0; i < length; i ++)
	{
		int KeyStep = key + i;
		tempstring[i] = string[i] - KeyStep;
	}
	tempstring[length] = 0;
	return tempstring;
}

I made both of them myself, Now to explain the encryption method.

Code:

//The definition of the function.
char* FlameCrypt(char string[], int key)
{
//length = the ammount of characters in the string you are trying to encrypt/decrypt.
	int length = strlen(string);
//tempstring = It stores temporary information while you are encrypting/decypting.
	char* tempstring = new char[length + 1];
//a for loop to loop through all the characters, and add the ammount integers that you defined as the 'key'
	for (int i = 0; i < length; i ++)
		tempstring[i] = string[i] + key;
//Convert the tempstring so you can return it as as a complete word or mumbo jumbo.
	tempstring[length] = 0;
//return the completed shit.
	return tempstring;
}

Usage.

Code:

int main()
{
	char* String;
	cout << "Encrypting: Steven is awesome jaja:" << endl;
	String = FlameCrypt("Steven is awesome jaja:", 5);
	cout << "Encrypted String: " << String << endl;
	cout << "" << endl;
	cout << "Decrypting: " << String << endl;
	String = FlameDecrypt(String, 5);
	cout << "Decrypted String: " << String << endl;
	cout << "" << endl;

	cout << "Encryption Example: Flameswor10 (key = 1 - 9)" << endl;
	cout << "" << endl;
	for (int i = 1; i < 10; i ++)
		cout << FlameCrypt("flameswor10", i) << endl;
	system("pause");
    return 0;
}

Now, you can learn how to implement it into your hack.
Hackshield looks for some text such as Aimbot and other stuff, so if you use my encryption. Not only will it get rid of Hex Edit Leechers, it will also make your hack a bit more undetected.

Step Encryption:

Simple Encryption:

Enjoy, I hope you learn something.
Ofcourse, you can edit it and make it even more complicated, there are endless ammounts of editing you can do, you can even add hex values to the text.

**SrNooB** · 07-11-2011

yuno post in right section

**flameswor10** · 07-11-2011

Originally Posted by SrNooB

yuno post in right section

It is right section

It helps the CA users,

**.::SCHiM::.** · 07-11-2011

This won't help in the long run. Advanced signature scanners won't look at the specific bytes, but rather at the underlying logic and relation between the bytes. Consider:

Code:

// NEXON:         ascii values: 78 69 88 79 78
encstr = FlameCrypt("NEXON", 5);
//encstr = "SJ]TS"   ascii values: 83 74 93 84 83

Now the string is unreadable for human eyes but with a bit of math that can be reversed even without knowing the key. Consider:

Code:

// NEXON:         ascii values: 78 69 88 79 78

// Relation between first and second character:

69-78 = -9 (meaning that the 2nd character is 9 characters lower in the ASCII table then the first)

// Relation between second and third:

88-69 = 19(meaning that the 3rd character is 19 characters higher in the ASCII table then the second)

// Relation between 3rd and first:

88-78 = -10(meaning the first is 10 characters lower then the 3rd)

etc, etc

This relation MUST be scrambled before you can even speak of a basic encryption. Because this relation is still present in the encrypted string, the code can be easily broken.

Code:

//encstr = "SJ]TS"   ascii values: 83 74 93 84 83

If nexon has the relation mask of the string "NEXON" the only thing they have too check for is this relation, it will match the real string, as well as any encrypted variables:

mask: -9, 19, -10

J-S = -9                         // 1st match
]-J = 19                         // 2nd match
]-S = -10                       // 3rd match

With more values(eg. all relations in the string) in the relation mask this method is 100% accurate and unable of producing false positives.

Try a harder form of encryption (scrambles the input before encrypting it):
note: This is still not a very strong encryption, and relations can still be found, however not as many as to ensure 100% perfect matches

Code:

#include <iostream>
#include <windows.h>

char Nexon[] = "Aimbot";

void Encrypt(char* str, int key){

char *tempstr = new char[ strlen(str)+1 ];


	for(int i = 0, int y = strlen(str)-1; i != strlen(str); i++, y--){
	    	tempstr[i] = str[y];
	}
	
	tempstr[strlen(str)] = '\0';



	for(int si = 0, int yk = key; si != strlen(tempstr); si++, yk--){
		tempstr[si] = tempstr[si]+yk;
	}


	for(int s = 0; s != strlen(str); s++){
		str[s] = tempstr[s];
	}


	delete [] tempstr;

return;
}

void Decrypt(char* str, int key){

char *tempstr = new char[ strlen(str)+1 ];

    	for(int si = 0, int yk = key; si != strlen(str); si++, yk--){
		str[si] = str[si]-yk;
		}
	
		for(int i = 0, int y = strlen(str)-1; i != strlen(str); i++, y--){
	    tempstr[i] = str[y];
		}
	
		tempstr[strlen(str)] = '\0';

		
		for(int s = 0; s != strlen(str); s++){
		str[s] = tempstr[s];
		}

	delete [] tempstr;
return;

}



int main(){


	for(int i =0; i != sizeof(Nexon); i++){
		printf("%c = %d\n", Nexon[i], (int)Nexon[i]);
	}

	Encrypt((char*)&Nexon[0], 63);

	for(int c =0; c != sizeof(Nexon); c++){
		printf("%c = %d\n", Nexon[c], (int)Nexon[c]);
	}


	Decrypt((char*)&Nexon[0], 63);

	for(int d =0; d != sizeof(Nexon); d++){
		printf("%c = %d\n", Nexon[d], (int)Nexon[d]);
	}


	system("pause");
	return 0;

}

**flameswor10** · 07-11-2011

Nice schim.
But I did say, simple encryption.
Step encryption does a better job though.

**Cediquer** · 07-11-2011

well this is nice

**DeadLinez** · 07-11-2011

This the same Algorithm that some keygen mes use, very easy to spot on OllyDbg, Just search: "Search (Name) Current in current Module" then find some common StrLen, Right click set a breakpoint on all refrences, Hit a break point, trace up or down a little, And then Bam! You would be able to make your very own simple version of a "keygen" or a decryper from that, Same goes for the steps, i suggest a combination of RC4, or XOR, or even AES. But its simple for beginners. Good job

**flameswor10** · 07-12-2011

Originally Posted by DeadLinez

This the same Algorithm that some keygen mes use, very easy to spot on OllyDbg, Just search: "Search (Name) Current in current Module" then find some common StrLen, Right click set a breakpoint on all refrences, Hit a break point, trace up or down a little, And then Bam! You would be able to make your very own simple version of a "keygen" or a decryper from that, Same goes for the steps, i suggest a combination of RC4, or XOR, or even AES. But its simple for beginners. Good job

Ahahaha, I was thinking of combining mine with those other enctyprions as well ><
But I'll release that later