cryptage Blowfish OPENSSL CBC diffère de PHP en C++

Question

Je suis en train de chiffrer et déchiffrer une communication entre une bibliothèque C++ et un serveur PHP en utilisant bibliothèque OpenSSL dans les deux d'entre eux. Je veux utiliser l'algorithme Blowfish CBC mais il semble que les résultats soient différents entre le code C++ et le code PHP. Le code C++ est pris d'ici:

Voici le code PHP:

<?php 
function strtohex($x) 
{ 
    $s=''; 
    foreach (str_split($x) as $c) $s.=sprintf("%02X",ord($c)); 
    return($s); 
} 


$encryptedMessage = openssl_encrypt("input", "BF-CBC", "123456", 0, "initvect"); 


echo $encryptedMessage; 
echo "\n"; 
echo strtohex($encryptedMessage); 

La sortie de PHP est la suivante:

x9jDa2WMwvQ= 
78396A446132574D7776513D 

C'est le C++ code:

bool do_encrypt(const char *in, unsigned char *out, int *outlen, unsigned char *key, unsigned char *iv) 
{ 
    int buflen, tmplen; 

    EVP_CIPHER_CTX ctx; 
    EVP_CIPHER_CTX_init(&ctx); 
    EVP_EncryptInit_ex(&ctx, EVP_bf_cbc(), nullptr, key, iv); 

    if (!EVP_EncryptUpdate(&ctx, out, &buflen, (unsigned char*)in,  strlen(in))) 
    { 
     return false; 
    } 

    if (!EVP_EncryptFinal_ex(&ctx, out + buflen, &tmplen)) 
    { 
     return false; 
    } 

    buflen += tmplen; 
    *outlen = buflen; 
    EVP_CIPHER_CTX_cleanup(&ctx); 

    return true; 
} 

unsigned char output[2048] = { 0 }; 
int outLen; 

auto result = do_encrypt("input", output, &outLen, (unsigned char*)"123456", (unsigned char*)"initvect"); 

BIGNUM *outputStr = BN_new(); 
BN_bin2bn(output, outLen, outputStr); 

cout << base64_encode(output, outLen) << "\n"; 
cout << BN_bn2hex(outputStr) << "\n"; 

La sortie C de est la suivante:

EfRhhWqGmSQ= 
11F461856A869924 

Quelqu'un peut-il me s'il vous plaît aider à comprendre ce que je fais mal? Toute aide sera très appréciée.

Merci!

Edit 1: j'ai réussi à fixer le code C++ après réponse JWW et il a bien fonctionné. Je manquais le EVP_CIPHER_CTX_set_key_length Cependant, je ne pouvais pas faire le code PHP retourne la même chose et, finalement, nous avons décidé de passer à AES et il fonctionne maintenant parfaitement. Merci!

Answer 1

Pour votre code OpenSSL, je crois que vous devez appeler EVP_CIPHER_CTX_set_key_length dire la bibliothèque est la clé seulement 6 octets.

Permettez-moi jeter Crypto ++ dans l'arène ci-dessous. OpenSSL et Crypto ++ convergeront sur la bonne réponse une fois que vous aurez ajouté l'appel OpenSSL EVP_CIPHER_CTX_set_key_length manquant. La bonne réponse est 32CEBA7E046431EB (en hexadécimal).

Je ne sais pas ce qui se passe avec PHP:

x9jDa2WMwvQ= 
78396A446132574D7776513D 

x Considérant est ASCII 0x78, 9 est ASCII 0x39, je devine que vous hex encodées base64 chaîne.

---

$ cat test.cxx 
#include "blowfish.h" 
#include "modes.h" 
#include "channels.h" 
#include "filters.h" 
#include "base64.h" 
#include "hex.h" 
using namespace CryptoPP; 

#include <iostream> 
#include <string> 
using namespace std; 

int main(int argc, char* argv[]) 
{ 
    const byte key[] = "123456"; // 6 
    const byte iv[] = "initvect"; // 8 
    CBC_Mode<Blowfish>::Encryption encryptor; 
    encryptor.SetKeyWithIV(key, 6, iv, 8); 

    string r1, r2; 
    ChannelSwitch chsw; 

    Base64Encoder e1(new StringSink(r1)); 
    HexEncoder e2(new StringSink(r2)); 
    chsw.AddDefaultRoute(e1); 
    chsw.AddDefaultRoute(e2); 

    string msg = "input"; 
    StringSource ss(msg, true, 
    new StreamTransformationFilter(encryptor, 
     new Redirector(chsw))); 

    cout << r1 << endl; 
    cout << r2 << endl; 

    return 0; 
} 

Les résultats du programme de test dans:

$ ./test.exe 
Ms66fgRkMes= 
32CEBA7E046431EB 

---

Voici la partie OpenSSL des choses. L'avis EVP_EncryptInit_ex est appelé deux fois. Tout d'abord, EVP_EncryptInit_ex est appelé pour définir le code de bloc EVP_bf_cbc. La longueur de la clé est définie avec EVP_CIPHER_CTX_set_key_length. Puis deuxième, EVP_EncryptInit_ex est appelé pour définir la clé et iv.

#include <openssl/evp.h> 

#include <iostream> 
#include <iomanip> 
#include <stdexcept> 
using namespace std; 

typedef unsigned char byte; 

int main() 
{ 
    EVP_CIPHER_CTX ctx; 
    EVP_CIPHER_CTX_init(&ctx); 

    int rc; 
    const byte key[] = "123456"; // 6 
    const byte iv[] = "initvect"; // 8 

    rc = EVP_EncryptInit_ex(&ctx, EVP_bf_cbc(), NULL, 0, 0); 
    if (rc != 1) 
    throw runtime_error("EVP_EncryptInit_ex failed"); 

    rc = EVP_CIPHER_CTX_set_key_length(&ctx, 6); 
    if (rc != 1) 
    throw runtime_error("EVP_CIPHER_CTX_set_key_length failed"); 

    rc = EVP_EncryptInit_ex(&ctx, NULL, NULL, key, iv); 
    if (rc != 1) 
    throw runtime_error("EVP_EncryptInit_ex failed"); 

    const byte msg[] = "input"; 
    byte buf[32]; 
    int len1 = sizeof(buf), len2 = sizeof(buf); 

    rc = EVP_EncryptUpdate(&ctx, buf, &len1, msg, 5); 
    if (rc != 1) 
    throw runtime_error("EVP_EncryptUpdate failed"); 

    rc = EVP_EncryptFinal_ex(&ctx, buf+len1, &len2); 
    if (rc != 1) 
    throw runtime_error("EVP_EncryptFinal_ex failed"); 

    for(unsigned int i=0; i<len1+len2; i++) 
     cout << std::hex << setw(2) << setfill('0') << (int)buf[i]; 
    cout << endl; 

    EVP_CIPHER_CTX_cleanup(&ctx); 
    return 0; 
}