décrypter la fonction à l'exécution et l'utiliser QT C++

Question

Je suis nouveau sur QT et j'essaye de créer une fonction cryptée. Dans l'ensemble ce que vous faites en C/C++ est:

• Prenez pointeur de fonction
• faire la page de la fonction rwx
• chiffrez (pour l'exemple que je crypter et décrypter dans le même programme)
• décrypter et l'exécuter

Un simple code en C se produira à peu près comme ceci:

void TestFunction() 
{ 
    printf("\nmsgbox test encrypted func\n"); 
} 
// use this as a end label 
void FunctionStub() { return; } 

void XorBlock(DWORD dwStartAddress, DWORD dwSize) 
{ 
    char * addr = (char *)dwStartAddress; 
    for (int i = 0; i< dwSize; i++) 
    { 
     addr[i] ^= 0xff; 
    } 
} 

DWORD GetFuncSize(DWORD* Function, DWORD* StubFunction) 
{ 
    DWORD dwFunctionSize = 0, dwOldProtect; 
    DWORD *fnA = NULL, *fnB = NULL; 

    fnA = (DWORD *)Function; 
    fnB = (DWORD *)StubFunction; 
    dwFunctionSize = (fnB - fnA); 
    VirtualProtect(fnA, dwFunctionSize, PAGE_EXECUTE_READWRITE, &dwOldProtect); // make function page read write execute permission 
    return dwFunctionSize; 
} 



int main() 
{ 

    DWORD dwFuncSize = GetFuncSize((DWORD*)&TestFunction, (DWORD*)&FunctionStub); 
    printf("use func"); 
    TestFunction(); 
    XorBlock((DWORD)&TestFunction, dwFuncSize); // XOR encrypt the function 
    printf("after enc"); 
    //TestFunction(); // If you try to run the encrypted function you will get Access Violation Exception. 

    XorBlock((DWORD)&TestFunction, dwFuncSize); // XOR decrypt the function 
    printf("after\n"); 
    TestFunction(); // Fine here 

    getchar(); 
} 

Lorsque j'essaie d'exécuter un tel exemple dans QT, j'obtiens une erreur d'exécution.

Voici le code dans l'intervalle QT:

void TestFunction() 
{ 
    QMessageBox::information(0, "Test", "msgbox test encrypted func"); 
} 
void FunctionStub() { return; } 

void XorBlock(DWORD dwStartAddress, DWORD dwSize) 
{ 
    char * addr = (char *)dwStartAddress; 
    for (int i = 0; i< dwSize; i++) 
    { 
     addr[i] ^= 0xff;    // here i get seg. fault 
    } 
} 

DWORD GetFuncSize(DWORD* Function, DWORD* StubFunction) 
{ 
    DWORD dwFunctionSize = 0, dwOldProtect; 
    DWORD *fnA = NULL, *fnB = NULL; 

    fnA = (DWORD *)Function; 
    fnB = (DWORD *)StubFunction; 
    dwFunctionSize = (fnB - fnA); 
    VirtualProtect(fnA, dwFunctionSize, PAGE_EXECUTE_READWRITE, &dwOldProtect); // Need to modify our privileges to the memory 

    QMessageBox::information(0, "Test", "change func to read write execute "); 
    return dwFunctionSize; 
} 




void check_enc_function() 
{ 

    DWORD dwFuncSize = GetFuncSize((DWORD*)&TestFunction, (DWORD*)&FunctionStub); 
    QMessageBox::information(0, "Test", "use func"); 
    TestFunction(); 
    XorBlock((DWORD)&TestFunction, dwFuncSize); // XOR encrypt the function -> @@@ i get seg fault in here @@@ 
    QMessageBox::information(0, "Test", "after enc"); 


    TestFunction(); // If you try to run the encrypted function you will get Access Violation Exception. 

    XorBlock((DWORD)&TestFunction, dwFuncSize); // XOR decrypt the function 
    QMessageBox::information(0, "Test", "after dec"); 
    TestFunction(); // Fine here 

    getchar(); 
} 

Pourquoi cela se produit? QT est censé se comporter comme la précision en C++ standard ...

post Scriptum. De manière intéressante dans le même ordre d'idées, quelle est la manière la plus légitime de garder une fonction importante cryptée (la raison pour laquelle elle est cryptée est DRM)?

Légitimement, je veux dire que les anti-virus ne me marqueront pas comme un virus parce que je me défends.

PS2

Si je passe une fonction cryptée sur le réseau (par exemple, je vais construire un schéma client du serveur que le client demande la fonction dont il a besoin pour exécuter à partir du serveur et le serveur envoie à si il est approuvé) Comment puis-je arranger les symboles pour que la fonction ne s'effondre pas?

PS3

Comment QT puis-je désactiver les défenses de DEP et ASLR? (À mon avis pour que je puisse exécuter PS 2. Je dois les annuler)

Merci yoko

Answer 1

L'exemple est un comportement non défini sur mon système.

La question première et principale dans votre code est:

void TestFunction() { /* ... */ } 
void FunctionStub() { return; } 

Vous supposez que le compilateur mis FunctionStub après TestFunction sans rembourrage. J'ai compilé votre exemple et FunctionStub dans mon cas était au-dessus de TestFunction qui a abouti à une dwFunctionSize négative.

dwFunctionSize = (fnB - fnA); 

TestFunction located at @ 0xa11d90 
FunctionStub located at @ 0xa11b50 
dwFunctionSize = -0x240 

également dans XorBlock

addr[i] ^= 0xff; 

ne fait rien.Je suppose que vous voulez écrire dans XorBlock à l'emplacement de la mémoire à XOR TestFunction entier.

Vous pouvez faire quelque chose comme ceci:

void XorBlock(DWORD dwStartAddress, DWORD dwSize) 
{ 
    DWORD dwEndAddress = dwStartAddress + dwSize; 
    for(DWORD i = dwStartAddress; i < dwEndAddress; i++) { 
     // ... 
    } 
} 

Answer 2

Je ne vois pas spécifiques à Qt dans votre exemple. Même si c'est l'appel de la fonction Qt, c'est juste un appel. Donc je suppose que vous avez un comportement indéfini dans les deux exemples, mais seulement le second se bloque.

Je ne vois aucune raison pour que le compilateur et l'éditeur de liens maintiennent l'ordre des fonctions. Par exemple, GCC vous permet de spécifier la section de code pour chaque fonction. Vous pouvez donc le réorganiser en exécutable sans réordonner dans cpp.

Je pense que vous avez besoin de certaines choses spécifiques au compilateur pour le faire fonctionner.