Bonjour,

Je suis en train de faire un module de cryptage / décryptage en utilisant libcrypto et les fonctions blowfish.

Pour le moment j'ai ça :

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
51
52
53
54
55
56
57
58
 
void TestCryptage2()
{
	char* data = "test avec un bloc de taille un peu plus important"; // à passer en entrée sous unsigned char*
	const size_t size = strlen(data) + 1; // + 1 car là c'est du texte, à passer en entrée
 
	std::string strPass = "pass";
 
	BF_KEY* key = new BF_KEY;
	memset(key, 0, sizeof(BF_KEY));
	BF_set_key(key, strPass.size(), (unsigned char*)strPass.c_str());
 
	const size_t blocksize = 8;
 
	// 1er 8 octets devraient être la taille de la data entrante (puis ramené à %8 == 0)
	char* crypted = new char[size + (blocksize - (size % blocksize))];
 
	size_t index = 0;
	while (index < size) {
 
		unsigned char plaintext[blocksize + 1];
		unsigned char cyphertext[blocksize + 1];
 
		memset(plaintext, 0, blocksize);
		memset(cyphertext, 0, blocksize);
 
		size_t shunkSize = std::min(blocksize, (size - index));
		memcpy(plaintext, data + index, shunkSize);
		BF_ecb_encrypt(plaintext, cyphertext, key, BF_ENCRYPT);
		memcpy(crypted + index, cyphertext, blocksize);
 
		index += shunkSize;
	}
 
	std::cout << "encrypted = " << crypted;
 
	// Lire les premiers 8 octets pour connaitre a taille attendu 
	char* decrypted = new char[size];
	index = 0;
	while (index < size) {
 
		unsigned char plaintext[blocksize + 1];
		unsigned char cyphertext[blocksize + 1];
 
		memset(plaintext, 0, blocksize);
		memset(cyphertext, 0, blocksize);
 
		size_t shunkSize = std::min(blocksize, (size - index));
		memcpy(cyphertext, crypted + index, blocksize);
		BF_ecb_encrypt(cyphertext, plaintext, key, BF_DECRYPT);
		memcpy(decrypted + index, plaintext, shunkSize);
 
		index += shunkSize;
	}
 
	//BF_ecb_encrypt(cyphertext, plaintext, key, BF_DECRYPT);
	std::cout << "encrypted = " << decrypted;
}
C'est un premier test, un peu porc mais au moins ça valide l'utilisation de la bibliothèque.

Il se trouve que lorsque l'on encrypte 8 octets, on obtient 8 octets cryptés, et inversement évidemment, du coup je pensais pouvoir remplacer la data passée en entrée et faire proposer une utilisation de ce style :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
 
unsigned char data[] = ...;
encryptData(data);
decryptData(data);
Mais il y a un loup, parce que le blowfish n'accepte de crypter que par blocs de 8 octets. Du coup je dois ramener la data en entrée à un multiple de 8 octets et faire une allocation supplémentaire dont je ne saurais plus être responsable par la suite (le crypté partira peut-être sur du réseau ou je ne sais pas et n'ai pas à le savoir).

Comment on gère ce genre de truc habituellement ?

Dans quelques exemples sur la fonction "BF_ecb_encrypt", j'ai vu qu'ils couplaient ça avec du base64 mais n'ai pas vraiment compris l'intérêt.

Merci pour vos lumières,

A bientôt