Discussion :

[Seinen]

Bonjour à toutes et à tous,

mon problème de la semaine est de crypter une chaîne de caractères...
Cependant, la petite difficulté est qu'une fonction doit prendre en argument cette chaîne crypter et savoir l'utiliser.

Connaitriez-vous un tutoriel sur ce sujet ou bien une fonction adéquat en C++ ?

Je vous remercie.
Seinen.

[koala01]

Salut,

Il faudrait déjà savoir le genre de cryptage que tu souhaites effectuer...

Le "plus simple" (comprend: celui qui sera le plus facile à appliquer, mais qui sera aussi le plus facile à "cracker") est le cryptage de Cesar ou une de ses variantes:

Tu choisi une "clé" numérique, par exemple 1597, puis tu boucle sur chaque caractère de ta chaine en ajoutant 1 au premier caractère, 5 au deuxième, 9 au troisième 7 au quatrieme et en recommençant avec les caractères suivant jusqu'à ce que tu aie parcouru l'ensemble de la chaine d'origine.

Pour la décrypter, il "suffit" de faire le mouvement inverse: retrancher 1 au premier caractère, 5 au deuxième, 9 au troisième, 7 au quatrième en recommancant jusqu'au bout.
(à vrai dire, César se contentais de décaler, pour un même message, ses lettre d'une valeur toujours égale )

D'autres méthodes de cryptages existe, dis nous laquelle "t'inspire" et nous te dirons comment y arriver

[gnto]

En cherchant sur le net on trouve cette biblio : http://www.cryptopp.com/

Ca dépend de ce que tu veux faire mais la tu as les algos les plus utilisés (AES,RSA)

NB : Je ne l'ai jamais utilisée

[Charlemagne]

Le "plus simple" (comprend: celui qui sera le plus facile à appliquer, mais qui sera aussi le plus facile à "cracker") est le cryptage de Cesar ou une de ses variantes:

Ca dépend de la longueur de la clé.

Y'a aussi un cryptage avec une double clé (ou plus). En général on préfère choisir 2 mots clés plutôt que des nombres (par commodité pour s'en souvenir) et on associe à chaque lettre un nombre (A=1, B=2..., ou bêtement le code ASCII)
Le tout étant de prendre des clés dont les longueurs respectives sont premières entre elles, ainsi on a quasiment l'équivalent d'une grande clé dont la longueur correspond au produit des longueurs des petites clés.
A ma connaissance, c'est l'un des rares cryptages simples pratiquement incassable.

Sinon, c'est clair qu'il y plus costaud comme cryptage (J'ai eu des cours la dessus, mais ça remonte à une paire d'années.) . La notion de clé publique est sympa aussi...

[Seinen]

En fait, dans mon programme, j'ouvre un répertoire situé sur un serveur. Le chemin est pour le moment en dur (par ex :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

chemin[]= \\\\mon_serveur\\Seinen\\mon_projet;

).

Ce que je souhaite c'est crypter le code de mon programme pour ne plus faire apparaître ce chemin lorsqu'on essaye de bidouiller l'exécutable.
Je suis entrain de réfléchir tout en écrivant, et je pense que finalement, il me faudrait plutôt crypter le code plutôt que simplement le chemin...

Je n'avais pas précisé, mais j'utilise Visual Studio et je peux utiliser toutes les fonctions MFC.

[yan]

Pourquoi cela n'existerait plus ?

Parce que MFC, c'est pas terrible terrible et ca devrait disparaitre
Mais bon, on ne choisie pas toujours.

Si j'ai bien compris, tu veut juste que \\\\mon_serveur\\Seinen\\mon_projet; ne soit pas visualisable dans ton executable?

[Seinen]

Oui c'est exactement ça.
Pour le moment il est en dur dans le code source et je cherche un moyen de soit le faire disparaître, soit de le brouiller lorsque l'on ouvre l'exécutable.

Sachant que je dois aussi l'utiliser pour aller ouvrir un répertoire... Et c'est ce dernier point qui me fait mal à la tête (comment allez ouvrir un répertoire si le chemin est crypté ?).

[yan]

Donc a mon avis, tu n'as pas besoin d'un truc supercompliqué.
Un simple xor ou un neg sur ta chaîne devrait suffire.
http://tuxy2885.free.fr/index.php?cat=tutorial&id=crypt

Ce qu'il faut, c'est que la ligne
chemin[]= \\\\mon_serveur\\Seinen\\mon_projet;
contienne le path déjà crypté. Ensuite tu décrypte pendant l'exécution.

Voici un exemple à peu prés similaire. J'utilise "essai rapide" qui est crypté. Si tu regarde l'exe généré, tu ne trouve rien

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <iterator>
 
//foncteur de decriptage
struct f_decript
{
    f_decript( unsigned char key): m_key(key){}
    unsigned char operator()(unsigned char & c)
    {
       return  c^m_key;
    }
    //clef a utiliser
    const unsigned char m_key;
};
 
int main()
{
    std::vector<unsigned char> crypt_path;
    unsigned char key =00101101;//clef ecrit en binaire :0xxxxxx avec x =0 ou 1
    crypt_path.push_back('e'^key);//un peu chiant
    crypt_path.push_back('s'^key);
    crypt_path.push_back('s'^key);
    crypt_path.push_back('a'^key);
    crypt_path.push_back('i'^key);
    crypt_path.push_back(' '^key);
    crypt_path.push_back('r'^key);
    crypt_path.push_back('a'^key);
    crypt_path.push_back('p'^key);
    crypt_path.push_back('i'^key);
    crypt_path.push_back('d'^key);
    crypt_path.push_back('e'^key);
    //affichage sous forme de caratère
    std::copy(crypt_path.begin(),crypt_path.end(),std::ostream_iterator<unsigned char>(std::cout," "));
    std::cout<<std::endl;
    //affichage sous forme hexa
    std::copy(crypt_path.begin(),crypt_path.end(),std::ostream_iterator<unsigned int>(std::cout<<std::hex," "));
    std::cout<<std::endl;
 
    std::string path;
    //decriptage avec un foncteur
    std::transform(crypt_path.begin(),crypt_path.end(),std::back_inserter(path),f_decript(key));
    //affichage du path
    std::cout<<path<<std::endl;
 
    return 0;
}

Comme j'utilise les algo :
http://r0d.developpez.com/articles/algos-stl/

[nicroman]

C'est la deuxieme requete d'obfuscation de données (serveur, compteur) en 1 semaine...
Je me demande bien quelle est cette nouvelle lubie...

Tiens... pour le serveur, tu peux t'embêter 10 ans à crypter ta chaine, dès que tu vas l'utiliser (pour te connecter au serveur... même si je doute que \\\\xxxxx\\jjjj marche bien ), ca va apparaitre en gros sur tous les firewalls du gars, donc absoluement aucun interêt...

Le chemin du fichier ? Visible dans les ouvertures handle avec le chemin complet...

De toute manière je vois vraiment pas l'interêt de cacher un chemin d'accès...

[yan]

Le chemin du fichier ? Visible dans les ouvertures handle avec le chemin complet...

Oui mais ça c'est à l'exécution et faut savoir le faire.
Pour une raison x ou y il veut que l'on ne voit pas ce path en ouvrant l'exe dans un éditeur...

De toute manière je vois vraiment pas l'interêt de cacher un chemin d'accès...

Y as toujours moyen d'en trouver une

[Seinen]

Un simple xor ou un neg sur ta chaîne devrait suffire.
http://tuxy2885.free.fr/index.php?cat=tutorial&id=crypt

Ce qu'il faut, c'est que la ligne
chemin[]= \\\\mon_serveur\\Seinen\\mon_projet;
contienne le path déjà crypté. Ensuite tu décrypte pendant l'exécution.

Merci Mongaulois pour les chemins et l'exemple, je vais essayer ça.

C'est la deuxième requête d'obfuscation de données (serveur, compteur) en 1 semaine...
Je me demande bien quelle est cette nouvelle lubie...

Ce n'est pas à moi qu'il faut demander, je ne suis qu'un simple stagiaire qui exécute ce qu'on lui demande .

ça va apparaitre en gros sur tous les firewalls du gars, donc absolument aucun intérêt...

Comme le disait Mongaulois, je veux juste que le chemin soit invisible dans mon exécutable quand tu l'ouvres avec NotePad++, par exemple.

De toute manière je vois vraiment pas l'intérêt de cacher un chemin d'accès...

Si si, je t'assures qu'il y en a une, je ne le demande pas pour embêter le monde (quoique...)

[yan]

En y réfléchissant, faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
std::string path;
path.push_back('e');
path.push_back('s');
path.push_back('s');
path.push_back('a');
path.push_back('i');
path.push_back(' ');
path.push_back('r');
path.push_back('a');
path.push_back('p');
path.push_back('i');
path.push_back('d');
path.push_back('e');

suffit peut être, je crois que je me suis un peu enflammé

[Seinen]

je crois que je me suis un peu enflammé

Lol, peut-être. Cependant, je pense que niveau cryptage et d'un point de vue sécurité, rien n'est trop compliqué ^^.

[nicroman]

Comme le disait Mongaulois, je veux juste que le chemin soit invisible dans mon exécutable quand tu l'ouvres avec NotePad++, par exemple.

Oui j'ai bien compris....
Mais encore une fois:
- ou bien ce chemin est utilisé par l'executable et il apparaitra en gros dans le systeme que tu l'obfusques ou non
- ou bien ce chemin n'est pas utilisé par l'executable et il n'y a pas à l'inclure dedans