Compile-time string encryption

Perfekte Lösung existiert, hier ist es.

Außerdem dachte ich, dass dies nicht möglich war, obwohl es sehr einfach ist, Leute schrieb-Lösungen, wo müssen Sie ein benutzerdefiniertes tool zum Scannen der integrierte Datei anschließend und führen Sie einen scan strings und verschlüsseln Sie die Zeichenfolgen, wie das, was war nicht schlecht, aber ich wollte ein Paket zusammengestellt, die von Visual Studio, und es ist jetzt möglich!

Was Sie brauchen, ist C++ 11 (Visual Studio 2015 Update 1 out of the box)

die Magie passiert mit diesem neuen Befehl constexpr

Durch Magie passiert in diesem #define

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

Es nicht entschlüsseln XorString zur compile-Zeit, nur zur Laufzeit, aber es verschlüsselt die Zeichenkette nur im compile-Zeit, also die Zeichenfolgen werden nicht in die Ausführbare Datei

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

Wird es drucken Sie "this string is hidden!" aber Sie werden nicht finden, es in die Ausführbare Datei als strings!, prüfen Sie es selbst mit Microsoft Sysinternals Strings Programm-download-link: https://technet.microsoft.com/en-us/sysinternals/strings.aspx

Den vollständigen source-code ist Recht groß, aber könnte leicht aufgenommen werden, in eine header-Datei. Aber auch eher zufällig, so dass die verschlüsselte Zeichenfolge Ausgänge immer wechselt mit jedem neuen kompilieren, das Saatgut wird geändert basierend auf der Zeit, die es dauerte, es zu kompilieren, ziemlich solide,perfekte Lösung.

Erstellen Sie eine Datei namens 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() )
////////////////////////////////////////////////////////////////////

Dies ist eine späte Antwort, aber ich bin mir sicher, dass es eine bessere Lösung gibt.

Plese beziehen sich auf die akzeptierten Antworten hier.

Grundsätzlich, es zeigt, wie der ADVobfuscator lib zur Verschleierung von strings so einfach wie:

#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;
}

wenn Sie bereit sind, verwenden Sie C++11-features, variadic templates können verwendet werden, um compile-time-Verschlüsselung von Zeichenfolgen variabler Länge, ein Beispiel wäre diese.

Siehe auch diese, die Sie finden könnten besser erklärt.

Kann ich nicht kompilieren, die der compiler wirft zahlreiche Fehler, ich war auf der Suche nach anderen Lösungen für die schnelle string-Verschlüsselung und fand heraus, über dieses kleine Spielzeug https://www.stringencrypt.com (war nicht schwer, 1. Ergebnis in Google für die string-Verschlüsselung Schlüsselwort).

Dies ist, wie es funktioniert:

1. Geben Sie die label-Namen sagen szeichenkette
2. Geben Sie die string-Inhalte
3. Sie auf Verschlüsseln
4. Es nimmt einen string an und verschlüsselt es
5. Es erzeugt Entschlüsselung Quellcode in C++ (viele andere Sprachen werden unterstützt)
6. Fügen Sie das snippet in Ihrem code

Beispiel string "StackOverflow ist genial!", der output-code (jede einzelne Zeit es ist, generiert der code etwas anders Aussehen). Es unterstützt sowohl ANSI (char) und UNICODE (wchar_t) geben Sie Zeichenfolgen

ANSI-Ausgang:

//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-Ausgabe:

//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);

Jetzt weiß ich, es ist vielleicht nicht die perfekte Lösung, aber es funktioniert für mich und mein compiler.