Bonjour tout le monde.

Voila j'ai un programme fini et j'aimerais le proteger.
En gros j'aimerais encoder son corps avec un XOR et une clé simple
Le programme aurait une routine qui lui permettrais de se desencoder avant de se lancer. Mais comment faire pour encoder le programme juste apres la routine de decryptage ,sinon le programme ne pourras pas se lancer si j'encode tout ?

Dites moi si vous avez rien compris j'ai du mal a expliquer.

Si tu utilise un cryptage symetrique, il te faut un endroit ou mettre la cle. Si tu met la cle avec le programme, ya pas d interet a faire ca puisque n importe qui est assez intelligeant pour lancer ton programme dans un debugger pourra la recuperer.

Si tu met la cle autre part, ca veut dire qu il faut la distribuer paralellement a ton programme, juste aux personnes qui vont l utiliser. La c est plus cense. C est de ca que tu parles ?

En fait la question que je te pose serait plus : pourquoi as tu besoin d encoder ?

- limiter l acces juste a certaines personnes ?
- empecher le debugage, desassemblage ?
- prouver que le programme vient bien de toi ?
- prouver qu il n a pas ete modifie par un tiers ?

Suivant ces points, peut etre qu un cryptage asymetrique ou juste un hashage conviendrait ?

Le 12 août 2005 - 17 h 57, kha a écrit : - empecher le debugage, desassemblage - prouver qu il n a pas ete modifie par un tiers

Ca serait un mix des deux options mais je sais pas par ou commencer.

Tu devrais devori trouver ton bonheur la alors
http://www.softpedia.com/get/Programming/Packers-Crypters-Protectors/

Ok vais jeter un coup d'oeil mais j'ai l'impression que ce ne sont que des programmes deja compilé. Je souhaiterais en coder un moi meme pour apprendre .

Tu devrais jeter un coup d'oeil aux démos de 64k, généralement, elles sont compressées : il y a donc un loader qui décompresse l'image de l'exécutable en mémoire, puis qui dirige l'exécution vers son point d'entrée.

Ça te ferait un point de départ pour écrire ta routine de décodage qui récupérerait d'une manière ou d'une autre (messagebox, paramètre de ligne de commande, fichier...) la clé de décodage.
La routine en elle-même ne doit pas être très compliquée.
Par ailleurs, pour vérifier l'intégrité de ton fichier, il suffit de faire un hash, de ton fichier et de le comparer à une valeur précalculée. Par contre, là, le problème, c'est qu'il suffit de connaître le hash du fichier modifié pour faire croire que tout va bien...

Bon, enfin, si tu arrives à quelque chose, n'hésite pas à revenir !

J'ai trouver une source sympa sur Cppfrance.com mais j'ai un endroit ou je bloque.
J'ai la fonction suivante :

char * InjectHash(LPCTSTR lpFileName, LPCTSTR lpFileNameKey) { ... du code ... hFile = CreateFile(lpFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL); if(hFile == INVALID_HANDLE_VALUE) return NULL; ... du code .... }

Dans mon main j'aimerais appeler InjectHash de la facon suivante :

char * Chemin = (char*) malloc(128); // on cast car en C++
strcpy(Chemin,"./test/key.txt");
InjectHash(argv[0],Chemin); //pour faire des tests.

Le probleme c'est qu'il me demande des unsigned short * et moi je lui envoi des char * .

Comment on peut convertir des char * en LPCTSTR ??

un LPCTSTR, c'est un vulgaire const char *.
Sinon, je ne vois pas où il te demande un unsigned short * ? Parce que les conversion de pointeurs, c'est risqué... Tu peux mettre un peu plus de contexte ?

Par ailleurs, au lieu de faire
char * Chemin = (char *)malloc(128)
, puisqu'on est en C++, fais plutôt
char * Chemin = new char[128];
Ça fait la même chose, sauf qu'il n'y a plus besoin du cast, et que ça fait plus C++

Enfin, pourquoi tu ne fais pas plutôt
const char Chemin[] = "./test/key.txt"; ?

edit : ou LPCTSTR Chemin = ...

j'ai trouver mon erreur :

J'avais un #define UNICODE qui trainais

remarque, tu peux aussi ! Mais alors passe au wchar_t.

C'est remoi
voila je m'amuse à coder mes strings pour les rendre plus difficile a lire.

Par exemple j'ai un tableau de chaine.

char login [2] [16] = { { 'm' , 'a' , 'm' , 'a' , 'n' , '\0' } , { 'p' , 'a' , 'p' , 'a' , '\0' } };
Ensuite je les passe en valeur hexa.

char login [2] [16] = { { 0x6D , 0x61 , 0X6D , 0x61 , 0x6E , '\0' } , { 0x70 , 0x61 , 0x70 , 0x61 , '\0' } };

Puis ensuite juste pour le debut je decale les valeurs de 2

char login [2] [16] = { { 0x6F , 0x63 , 0X6F , 0x63 , 0x70 , '\0' } , { 0x72 , 0x63 , 0x72 , 0x63 , '\0' } };

Bon et maintenant dans mon programme a un moment je dois utiliser les bonnes valeurs, donc faut que je retrouve les valeurs du debut en redecalant de 2.

J'ai essayer ca mais c'est pas ca et je trouve pas comment faire.

for(int i=0;i\<2;i++) for(int j=0;j!='\0';j++) printf("Valeur originelle : %c \n",compagnion[i][j--]);

J'ai tester aussi :

printf("Valeur originelle : %c \n",compagnion[i][--j]);
printf("Valeur originelle : %c \n",compagnion[i][j]--);

Ca doit etre nul à faire , mais mon neurone ermite n'a pas percuté.

ton décalage de 2, c'est une variante du chiffre de César. Très faible comme cryptage, mais ça peut suffire pour ton exercice.
Si tu as décalé en +2, pour retrouver le caractère d'origine faudrait faire -2, non ? parce que --j décrémente de 1 seulement...

Pour essayer : Crypto++ Library (j'ai pas creusé, je sais pas au juste si ça correspond à ce que tu cherches)

EDIT : inutile de passer en "valeur hexa", parce que 'm' ou sa valeur hexa ou sa valeur binaire c'est toujours la même chose ! c'est qu'une représentation "humaine".
Et comme 'm' est un int, tu peux faire des opérations arithmétiques directement.

Je plussoie bernie.

Sinon, autre idée de cryptage, si tu n'utilises pas 8 bits (par exemple, si tu n'as que des lettres majuscules, ça ne te fait que 5 bits. Même avec 7 bits, ça marche) : ne stocke que les bits nécessaires et compacte tout ça. C'est plus lourd question algo, mais ça te fera les pieds

Le but est de compresser la chaîne. Mettons que tu n'aies que des lettres : tu ne stockerais alors que l'ordre de la lettre dans l'alphabet, et empilerais tes caractères les uns à la suite des autres en mémoire sans padder sur 8 bits. La reconstruction de la chaîne en ASCII ne se ferait qu'à l'exécution. Exemple de codage de SALUT (sur 5 bits) :
ASCII : 0x41 0x53 0x4C 0x55 0x54
alpha : 0x00 0x12 0x02 0x14 0x13
binaire (8 bits) : 00000000 00010010 00000010 00010100 00010011
binaire (compressé) : 00000100 10000101 01001001 10000000

Évidemment, il faut compléter avec des 0 à la fin et mettre quelque part le nombre de caractère de la chaîne.
Mais en observant les 4 octets ci-dessus, qui verrait une chaîne ?

Si tu as décalé en +2, pour retrouver le caractère d'origine faudrait faire -2, non ? parce que --j décrémente de 1 seulement... EDIT : inutile de passer en "valeur hexa", parce que 'm' ou sa valeur hexa ou sa valeur binaire c'est toujours la même chose ! c'est qu'une représentation "humaine". Et comme 'm' est un int, tu peux faire des opérations arithmétiques directement.

I'm a stupid guy je suis à l'ouest total en ce moment.

EDIt : J'ai trouvé , je vais passer par le cryptage Xor, c'est amplement suffisant.

Au fait : c est pour proteger ton programme de quoi ? ta grand maman ou des pirates sur le net ?

Le 22 août 2005 - 23 h 15, kha a écrit : Au fait : c est pour proteger ton programme de quoi ? ta grand maman ou des pirates sur le net ?

chiffre de césar -> sa grand-mère, ou sa petite soeur.

Le 22 août 2005 - 23 h 15, kha a écrit : Au fait : c est pour proteger ton programme de quoi ? ta grand maman ou des pirates sur le net ?

Ni l'un ni l'autre , juste pour apprendre et dans l'optique d'évoluer.
J'aurais pu coder mes chaines de caractere en AES mais c'est pas le but.

Bernie38 ->

Bon, et ça marche, alors ? Tu as un petit bout de code pour nous ?

Wé ca doit pouvoir se faire.

Alors donc les chaines suivantes :

char login [2] [16] = { { 'm' , 'a' , 'm' , 'a' , 'n' , '\0' } , { 'p' , 'a' , 'p' , 'a' , '\0' } };
Ensuite je les passe en valeur hexa.

char login [2] [16] = { { 0x6D , 0x61 , 0X6D , 0x61 , 0x6E , '\0' } , { 0x70 , 0x61 , 0x70 , 0x61 , '\0' } };

Puis ensuite je crypte chaque caractere avec un XOr selon cette table :

a 0x61 ^ 0xDF = 0xBE
b 0x62 ^ 0xDF = 0xBD
c 0x63 ^ 0xDF = 0xBC
d 0x64 ^ 0xDF = 0xBB
e 0x65 ^ 0xDF = 0xBA
f 0x66 ^ 0xDF = 0xB9
...

Ce qui donne :

int login [2] [16] = { { 0xB2 , 0xBE , 0XB2 , 0xBE , 0xB1 , '\0' } , { 0xAF , 0xBE , 0xAF , 0xBE , '\0' } };


Le code ci dessous permet d'avoir la table complete :

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

int main()
{

FILE * hex = NULL;
hex = fopen("asciixor.txt","w+");
if(hex == NULL) return 1;
for(int i=0x2D;i<=0x7A;i++)
{
fprintf(hex," %s %x %x \n",&i,i,i^0xDF);
}

if(hex != NULL) fclose(hex);


return 0;
}

EDIT : l'etape du passage des caractere en code hexa comme l'as dis bernie38 et juste pour montrer les etapes , c'est inutile , on peut passer directement du caractere 'a' à 0xBE