Au moment de la compilation de la chaîne de chiffrement

Solution parfaite n'existe pas, elle est ici.

J'ai aussi pensé que ce n'était pas possible, même si c'est très simple, les gens ont écrit des solutions là où vous avez besoin d'un outil personnalisé pour analyser le construit fichier par la suite et d'analyse pour les chaînes et chiffrer les cordes, comme ça, ce qui n'était pas mauvais mais je voulais un paquet qui est compilé à partir de Visual Studio, et il est possible maintenant!

Ce que vous avez besoin est C++ 11 (Visual Studio 2015 mise à Jour 1 de la boîte)

la magie qui se passe avec cette nouvelle commande constexpr

Par la magie qui se passe dans cette #define

#define XorString( String ) ( CXorString<ConstructIndexList<sizeof( String ) - 1>::Result>( String ).decrypt() )

Il ne déchiffre pas le XorString au moment de la compilation, seulement au moment de l'exécution, mais il va chiffrer la chaîne uniquement au moment de la compilation, de sorte que les chaînes n'apparaissent pas dans le fichier Exécutable

printf(XorString( "this string is hidden!" ));

Il permet d'imprimer "this string is hidden!" mais vous ne le trouverez à l'intérieur de fichier Exécutable comme des chaînes de caractères!, vérifiez vous-même avec Microsoft Sysinternals Strings programme lien de téléchargement: https://technet.microsoft.com/en-us/sysinternals/strings.aspx

Le code source complet est assez grand, mais pourrait facilement être inclus dans un fichier d'en-tête. Mais aussi tout à fait aléatoire de sorte que la chaîne cryptée sorties seront toujours changer à chaque nouvelle compilation, la graine est modifiée en fonction du temps qu'il a fallu rassembler, à peu près solide,la solution parfaite.

Créer un fichier appelé XorString.h

#pragma once
//-------------------------------------------------------------//
//"Malware related compile-time hacks with C++11" by LeFF   //
//You can use this code however you like, I just don't really //
//give a shit, but if you feel some respect for me, please //
//don't cut off this comment when copy-pasting... ;-)       //
//-------------------------------------------------------------//
////////////////////////////////////////////////////////////////////
template <int X> struct EnsureCompileTime {
enum : int {
Value = X
};
};
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//Use Compile-Time as seed
#define Seed ((__TIME__[7] - '0') * 1  + (__TIME__[6] - '0') * 10  + \
(__TIME__[4] - '0') * 60   + (__TIME__[3] - '0') * 600 + \
(__TIME__[1] - '0') * 3600 + (__TIME__[0] - '0') * 36000)
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
constexpr int LinearCongruentGenerator(int Rounds) {
return 1013904223 + 1664525 * ((Rounds> 0) ? LinearCongruentGenerator(Rounds - 1) : Seed & 0xFFFFFFFF);
}
#define Random() EnsureCompileTime<LinearCongruentGenerator(10)>::Value //10 Rounds
#define RandomNumber(Min, Max) (Min + (Random() % (Max - Min + 1)))
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
template <int... Pack> struct IndexList {};
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
template <typename IndexList, int Right> struct Append;
template <int... Left, int Right> struct Append<IndexList<Left...>, Right> {
typedef IndexList<Left..., Right> Result;
};
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
template <int N> struct ConstructIndexList {
typedef typename Append<typename ConstructIndexList<N - 1>::Result, N - 1>::Result Result;
};
template <> struct ConstructIndexList<0> {
typedef IndexList<> Result;
};
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
const char XORKEY = static_cast<char>(RandomNumber(0, 0xFF));
constexpr char EncryptCharacter(const char Character, int Index) {
return Character ^ (XORKEY + Index);
}
template <typename IndexList> class CXorString;
template <int... Index> class CXorString<IndexList<Index...> > {
private:
char Value[sizeof...(Index) + 1];
public:
constexpr CXorString(const char* const String)
: Value{ EncryptCharacter(String[Index], Index)... } {}
char* decrypt() {
for(int t = 0; t < sizeof...(Index); t++) {
Value[t] = Value[t] ^ (XORKEY + t);
}
Value[sizeof...(Index)] = '\0';
return Value;
}
char* get() {
return Value;
}
};
#define XorS(X, String) CXorString<ConstructIndexList<sizeof(String)-1>::Result> X(String)
#define XorString( String ) ( CXorString<ConstructIndexList<sizeof( String ) - 1>::Result>( String ).decrypt() )
////////////////////////////////////////////////////////////////////

OriginalL'auteur SSpoke

C'est une réponse tardive, mais je suis sûr qu'il ya une meilleure solution.

Veuillez vous référer à la accepté de répondre à ici.

Fondamentalement, il montre comment utiliser la ADVobfuscator lib pour obscurcir les cordes aussi simple que:

#include "MetaString.h"
using namespace std;
using namespace andrivet::ADVobfuscator;
void Example()
{
/* Example 1 */
//here, the string is compiled in an obfuscated form, and
//it's only deobfuscated at runtime, at the very moment of its use
cout << OBFUSCATED("Now you see me") << endl;
/* Example 2 */
//here, we store the obfuscated string into an object to
//deobfuscate whenever we need to
auto narrator = DEF_OBFUSCATED("Tyler Durden");
//note: although the function is named `decrypt()`, it's still deobfuscation
cout << narrator.decrypt() << endl;
}

OriginalL'auteur karliwson

si vous êtes prêt à utiliser le C++11 caractéristiques, variadic templates peut être utilisé pour faire de la compilation de cryptage des chaînes de longueur variable, un exemple serait cette.

Voir aussi cette, que vous pouvez trouver mieux expliqué.

OriginalL'auteur Necrolis

Je ne peut pas compiler, le compilateur renvoie d'innombrables erreurs, j'étais à la recherche d'autres solutions pour rapide de chaîne de cryptage et a découvert ce petit jouet https://www.stringencrypt.com (n'était pas dur, 1er résultat dans Google pour le cryptage des chaînes de mots clés).

Voilà comment cela fonctionne:

1. Vous entrez le nom de l'étiquette dire sString
2. Vous entrez le contenu de la chaîne
3. Vous cliquez sur Chiffrer
4. Il prend la corde et la crypte
5. Il génère de décryptage de code source en C++ (de nombreuses autres langues sont prises en charge)
6. Vous coller ce morceau de code dans votre code

Exemple de chaîne "StackOverflow est génial!", le code de sortie (à chaque fois qu'il génère du code légèrement différent). Il prend en charge ANSI (char) et UNICODE (wchar_t) type de cordes

ANSI de sortie:

//encrypted with https://www.stringencrypt.com (v1.1.0) [C/C++]
//sString = "StackOverflow is awesome!"
unsigned char sString[26] = { 0xE3, 0x84, 0x2D, 0x08, 0xDF, 0x6E, 0x0B, 0x87,
0x51, 0xCF, 0xA2, 0x07, 0xDE, 0xCF, 0xBF, 0x73,
0x1C, 0xFC, 0xA7, 0x32, 0x7D, 0x64, 0xCE, 0xBD,
0x25, 0xD8 };
for (unsigned int bIFLw = 0, YivfL = 0; bIFLw < 26; bIFLw++)
{
YivfL = sString[bIFLw];
YivfL -= bIFLw;
YivfL = ~YivfL;
YivfL = (((YivfL & 0xFF) >> 7) | (YivfL << 1)) & 0xFF;
YivfL ++;
YivfL ^= 0x67;
YivfL = (((YivfL & 0xFF) >> 6) | (YivfL << 2)) & 0xFF;
YivfL += bIFLw;
YivfL += 0x0F;
YivfL = ((YivfL << 4) | ( (YivfL & 0xFF) >> 4)) & 0xFF;
YivfL ^= 0xDA;
YivfL += bIFLw;
YivfL ++;
sString[bIFLw] = YivfL;
}
printf(sString);

UNICODE de sortie:

//encrypted with https://www.stringencrypt.com (v1.1.0) [C/C++]
//sString = "StackOverflow is awesome!"
wchar_t sString[26] = { 0x13A6, 0xA326, 0x9AA6, 0x5AA5, 0xEBA7, 0x9EA7, 0x6F27, 0x55A6,
0xEB24, 0xD624, 0x9824, 0x58A3, 0x19A5, 0xBD25, 0x62A5, 0x56A4,
0xFC2A, 0xC9AA, 0x93AA, 0x49A9, 0xDFAB, 0x9EAB, 0x9CAB, 0x45AA,
0x23CE, 0x614F };
for (unsigned int JCBjr = 0, XNEPI = 0; JCBjr < 26; JCBjr++)
{
XNEPI = sString[JCBjr];
XNEPI -= 0x5D75;
XNEPI = (((XNEPI & 0xFFFF) >> 14) | (XNEPI << 2)) & 0xFFFF;
XNEPI = ~XNEPI;
XNEPI -= 0xA6E5;
XNEPI ^= JCBjr;
XNEPI = (((XNEPI & 0xFFFF) >> 10) | (XNEPI << 6)) & 0xFFFF;
XNEPI --;
XNEPI ^= 0x9536;
XNEPI += JCBjr;
XNEPI = ((XNEPI << 1) | ( (XNEPI & 0xFFFF) >> 15)) & 0xFFFF;
sString[JCBjr] = XNEPI;
}
wprintf(sString);

Maintenant, je sais que ça peut pas être la solution parfaite, mais il fonctionne pour moi et mon compilateur.

OriginalL'auteur Marco Hastan