Partage
  • Partager sur Facebook
  • Partager sur Twitter

problème affichage

Crypto next generation

    19 mars 2019 à 14:17:05

    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);
        }
    
    }
     

    ce que j'obtiens : \BW-|?W??
    • Partager sur Facebook
    • Partager sur Twitter
      19 mars 2019 à 15:23:31

      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

      • Partager sur Facebook
      • Partager sur Twitter
      Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.
        19 mars 2019 à 15:32:35

        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 

        • Partager sur Facebook
        • Partager sur Twitter
          19 mars 2019 à 16:01:25

          Ligne 115, où initialisez vous le contenu de "pbhash" avant le l'afficher ?
          • Partager sur Facebook
          • Partager sur Twitter
          Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.

          problème affichage

          × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
          • Editeur
          • Markdown