Bonjour je souhaiterais visualiser la valeur de mon hash generer grace à la librairie bcrypt/ncrypt, mais j'ai un probleme lors de l'affichage, je ne comprends pas d'ou ca vient, je vous partage le code, et ce que je recois en console :

#include <windows.h>
#include <stdio.h>
#include <bcrypt.h>
#include <iostream> 
#include <string>


#define NT_SUCCESS(Status)          (((NTSTATUS)(Status)) >= 0)

#define STATUS_UNSUCCESSFUL         ((NTSTATUS)0xC0000001L)


static const BYTE rgbMsg[] = 
{
"bonsoir "
};


void __cdecl wmain(
                   int                      argc, 
                   __in_ecount(argc) LPWSTR *wargv)
{

    BCRYPT_ALG_HANDLE       hAlg            = NULL;
    BCRYPT_HASH_HANDLE      hHash           = NULL;
    NTSTATUS                status          = STATUS_UNSUCCESSFUL;
    DWORD                   cbData          = 0,
                            cbHash          = 0,
                            cbHashObject    = 0;
    PBYTE                   pbHashObject    = NULL;
    PBYTE                   pbHash          = NULL;

    UNREFERENCED_PARAMETER(argc);
    UNREFERENCED_PARAMETER(wargv);

    //open an algorithm handle
    if(!NT_SUCCESS(status = BCryptOpenAlgorithmProvider(
                                                &hAlg,
                                                BCRYPT_SHA256_ALGORITHM,
                                                NULL,
                                                0)))
    {
        wprintf(L"**** Error 0x%x returned by BCryptOpenAlgorithmProvider\n", status);
        goto Cleanup;
    }

    //calculate the size of the buffer to hold the hash object
    if(!NT_SUCCESS(status = BCryptGetProperty(
                                        hAlg, 
                                        BCRYPT_OBJECT_LENGTH, 
                                        (PBYTE)&cbHashObject, 
                                        sizeof(DWORD), 
                                        &cbData, 
                                        0)))
    {
        wprintf(L"**** Error 0x%x returned by BCryptGetProperty\n", status);
        goto Cleanup;
    }

    //allocate the hash object on the heap
    pbHashObject = (PBYTE)HeapAlloc (GetProcessHeap (), 0, cbHashObject);
    if(NULL == pbHashObject)
    {
        wprintf(L"**** memory allocation failed\n");
        goto Cleanup;
    }

   //calculate the length of the hash
    if(!NT_SUCCESS(status = BCryptGetProperty(
                                        hAlg, 
                                        BCRYPT_HASH_LENGTH, 
                                        (PBYTE)&cbHash, 
                                        sizeof(DWORD), 
                                        &cbData, 
                                        0)))
    {
        wprintf(L"**** Error 0x%x returned by BCryptGetProperty\n", status);
        goto Cleanup;
    }

    //allocate the hash buffer on the heap
    pbHash = (PBYTE)HeapAlloc (GetProcessHeap (), 0, cbHash);
    if(NULL == pbHash)
    {
        wprintf(L"**** memory allocation failed\n");
        goto Cleanup;
    }

    //create a hash
    if(!NT_SUCCESS(status = BCryptCreateHash(
                                        hAlg, 
                                        &hHash, 
                                        pbHashObject, 
                                        cbHashObject, 
                                        NULL, 
                                        0, 
                                        0)))
    {
        wprintf(L"**** Error 0x%x returned by BCryptCreateHash\n", status);
        goto Cleanup;
    }
    

    //hash some data
    if(!NT_SUCCESS(status = BCryptHashData(
                                        hHash,
                                        (PBYTE)rgbMsg,
                                        sizeof(rgbMsg),
                                        0)))
    {
        wprintf(L"**** Error 0x%x returned by BCryptHashData\n", status);
        goto Cleanup;
    }

std :: cout <<"pbhash"<< pbhash<<endl; 
    
    //close the hash
    if(!NT_SUCCESS(status = BCryptFinishHash(
                                        hHash, 
                                        pbHash, 
                                        cbHash, 
                                        0)))
    {
        wprintf(L"**** Error 0x%x returned by BCryptFinishHash\n", status);
        goto Cleanup;
    }

    wprintf(L"Success!\n");

Cleanup:

    if(hAlg)
    {
        BCryptCloseAlgorithmProvider(hAlg,0);
    }

    if (hHash)    
    {
        BCryptDestroyHash(hHash);
    }

    if(pbHashObject)
    {
        HeapFree(GetProcessHeap(), 0, pbHashObject);
    }

    if(pbHash)
    {
        HeapFree(GetProcessHeap(), 0, pbHash);
    }

}

Votre code, c'est du C des années 70 (goto, HeapAlloc, etc...), alors le "Crypto Next Generatio" du sous-titre, comment dire.

Vous avez des pointeurs sur des "bytes", par des char gentiment remplis de caractère, en ASCII avec votre std::out ASCII perdu dans un océan de chaine UNICODE à grand coup de "L".

En plus vous l'affichez avant de vous en servir, de "pbhash", c'est donc du bruit en mémoire que vous affichez.

Pour l'affichage UNICODE, http://www.cplusplus.com/reference/iostream/wcout/

Mais bon, sans une police de caractère ayant une représentation graphique de toute les combinaisons de 16 bits, il y aura plein de "?" dans tous les quoi.

Si la fonction de hash est bien faite, le résultat est indiscernable du bruit, donc le problème d’affichage sera le même avant ou après utilisation des variables.

Convertissez ces bytes en caractère imprimable, comme en hexadécimale :

https://stackoverflow.com/questions/14050452/how-to-convert-byte-array-to-hex-string-in-visual-c

Merci pour votre réponse, je pensais que c'était une petite chose à changer ahaha, et il y a quelque chose je comprends pas

"En plus vous l'affichez avant de vous en servir, de "pbhash", c'est donc du bruit en mémoire que vous affichez.", qu'est ce que vous voulez dire ? Parce que je l'utilise la fonction et ensuite je demande l'affichage