Decrypter une chaine

Bonjour,
je cherche à décrypter une chaine en c++ dans une dll , cette chaine est crypter par la fonction crypt de windev et envoyer dans la dll:
https://doc.pcsoft.fr/?3024014
il y a plusieurs type de cryptage possible , je peux tout à fait éviter de prendre cette fonction windev (si vous avez un petit code des deux cotés ).
Si on peut éviter aussi de voir le mot de passe en clair en cas de débug sur ma dll en c++, cela serait top .
merci de vos conseille.

1) Tu peux prendre la bibliothèque "mbed TLS": elle est faite pour l'embarqué, très peu de source et une licence qui le permet (du moins à ce que je comprends :whistle:)
Tu mets les sources dans tes projets, un include qui va bien et c'est fini.

2) Il faut faire de l'obfuscation.

Le truc basique: c'est un algo avec un XOR :mrgreen: (*) ... que tout monde dit que c'est de la m$rd$

Ensuite, ce n'est pas suffisant.
Tu peux avoir un petit buffer assez large pour contenir toutes tes données obfusquées.
Ce buffer est rempli avec de l'aléatoire fixe et les vraies données sont mises "n'importe comment".

L'inconvénient c'est que les données à cacher se retrouvent 1 instant en clair en mémoire (parce qu'avant de les utiliser, il faut les désobfusquer, et 1 fois utilisées, il faut les "détruire").

Et le deuxième inconvénient, ce que dans ton code, tu as des données illisibles même pour toi :mrgreen:

Regarde ici (**)

Édit: je viens de m'apercevoir que dans mon code j'ai crypt/ decrypt alors que ce serait plus précis de dire obfuscate/ desofuscate :mrgreen:
Et c'est du code C, parce que ce sont juste des opérations classiques (addition, négation logique, ...) et un XOR

* Un exemple de code en C, avec un entier en plus que tu as choisi

Code:

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
typedef struct s_Data_Holder {
    unsigned short* obfuscated_data;
 
    unsigned char** array_datas;
 
    unsigned char val1;
    unsigned char val2;
} Data_Holder;
 
 
void data_holder_crypt(Data_Holder* holder, unsigned char data, unsigned short index) {
//  if ((holder != NULL) && (holder->obfuscated_data != NULL)) {
        unsigned short final = data;
 
        ++final;
        final += index;
        final += holder->val1;
        final = ~final;
        final ^= holder->val2;
 
        holder->obfuscated_data[index] = final;
//}
}
 
 
unsigned char data_holder_decrypt(Data_Holder* holder, unsigned short data_index, unsigned short index) {
    unsigned char ret;
 
//  if ((holder != NULL) && (holder->obfuscated_data != NULL)) {
        unsigned short data;
 
        data = holder->obfuscated_data[data_index];
 
        data ^= holder->val2;
        data = ~data;
        data -= holder->val1;
        ret = (unsigned char) (data - index);
        --ret;
//  } else {
//      ret = 0;
//  }
 
    return ret;
}

**:
On veut cacher dans notre code une chaîne qui a été obfusquée ainsi :
FF1A FF6F FF1A FF0F FF64 FF66 FF09 FF1D FF77 FF1C FF77 FF0A FF6A FF1B FF6E FF05

Code:

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
//  Initialisation
    key_holder.val1 = 0x96;
    key_holder.val2 = 0x14;
 
    key_holder.obfuscated_data[13] = 0xFF3F; key_holder.obfuscated_data[ 3] = 0xFF01;
    key_holder.obfuscated_data[58] = 0xFF1B; key_holder.obfuscated_data[38] = 0xFF61;
    key_holder.obfuscated_data[20] = 0xFF0A; key_holder.obfuscated_data[10] = 0xFF09;
    key_holder.obfuscated_data[11] = 0xFF6E; key_holder.obfuscated_data[46] = 0xFF75;
    key_holder.obfuscated_data[36] = 0xFF2A; key_holder.obfuscated_data[14] = 0xFF66;
    key_holder.obfuscated_data[59] = 0xFF7C; key_holder.obfuscated_data[62] = 0xFF1D;
    key_holder.obfuscated_data[39] = 0xFF0D; key_holder.obfuscated_data[50] = 0xFF17;
    key_holder.obfuscated_data[47] = 0xFF1C; key_holder.obfuscated_data[24] = 0xFF65;
    key_holder.obfuscated_data[60] = 0xFF00; key_holder.obfuscated_data[42] = 0xFF13;
    key_holder.obfuscated_data[22] = 0xFF09; key_holder.obfuscated_data[18] = 0xFF74;
    key_holder.obfuscated_data[40] = 0xFF38; key_holder.obfuscated_data[41] = 0xFF6E;
    key_holder.obfuscated_data[23] = 0xFF3A; key_holder.obfuscated_data[12] = 0xFF61;
    key_holder.obfuscated_data[56] = 0xFF77; key_holder.obfuscated_data[16] = 0xFF77;
    key_holder.obfuscated_data[57] = 0xFF74; key_holder.obfuscated_data[29] = 0xFF0E;
    key_holder.obfuscated_data[15] = 0xFF0C; key_holder.obfuscated_data[26] = 0xFF1D;
    key_holder.obfuscated_data[ 1] = 0xFF64; key_holder.obfuscated_data[21] = 0xFF1C;
    key_holder.obfuscated_data[ 4] = 0xFF63; key_holder.obfuscated_data[ 8] = 0xFF6F;
    key_holder.obfuscated_data[19] = 0xFF6A; key_holder.obfuscated_data[ 2] = 0xFF7C;
    key_holder.obfuscated_data[34] = 0xFF6F; key_holder.obfuscated_data[17] = 0xFF1A;
    key_holder.obfuscated_data[ 6] = 0xFF77; key_holder.obfuscated_data[53] = 0xFF1D;
    key_holder.obfuscated_data[33] = 0xFF0F; key_holder.obfuscated_data[ 7] = 0xFF0F;
    key_holder.obfuscated_data[25] = 0xFF1A; key_holder.obfuscated_data[52] = 0xFF1A;
    key_holder.obfuscated_data[61] = 0xFF3A; key_holder.obfuscated_data[55] = 0xFF1F;
    key_holder.obfuscated_data[44] = 0xFF1C; key_holder.obfuscated_data[ 9] = 0xFF15;
    key_holder.obfuscated_data[27] = 0xFF10; key_holder.obfuscated_data[ 5] = 0xFF19;
    key_holder.obfuscated_data[63] = 0xFF05;
 
// ...
 
//  Desobfuscate
    buffer[ 0] = data_holder_decrypt(&key_holder, 52, 14);
    buffer[ 1] = data_holder_decrypt(&key_holder,  8, 15);
    buffer[ 2] = data_holder_decrypt(&key_holder, 25, 16);
    buffer[ 3] = data_holder_decrypt(&key_holder, 33, 17);
    buffer[ 4] = data_holder_decrypt(&key_holder,  1, 18);
    buffer[ 5] = data_holder_decrypt(&key_holder, 14, 19);
    buffer[ 6] = data_holder_decrypt(&key_holder, 10, 20);
    buffer[ 7] = data_holder_decrypt(&key_holder, 53, 21);
    buffer[ 8] = data_holder_decrypt(&key_holder,  6, 22);
    buffer[ 9] = data_holder_decrypt(&key_holder, 21, 23);
    buffer[10] = data_holder_decrypt(&key_holder, 56, 24);
    buffer[11] = data_holder_decrypt(&key_holder, 20, 25);
    buffer[12] = data_holder_decrypt(&key_holder, 19, 26);
    buffer[13] = data_holder_decrypt(&key_holder, 58, 27);
    buffer[14] = data_holder_decrypt(&key_holder, 11, 28);
    buffer[15] = data_holder_decrypt(&key_holder, 63, 29);

Merci de ta réponse foetus
effectivement , je n'avais pas pensé à tout simplement faire une table d'échange de caractère tout simplement pour coder 'crypter' la chaine, çà suffira largement ,et c'est très simple de mon coté , de toute façon même un gros cryptage , à un moment donner ce sera décrypter en cas de débug.
Je contrôle avec Olly en débug comment la chaine est concatener pour voir si c'est flagrant ou pas