web-dev-qa-db-fra.com

Générer SHA hachage en C ++ à l'aide de la bibliothèque OpenSSL

Comment puis-je générer des hachages SHA1 ou SHA2 en utilisant la bibliothèque OpenSSL ?

J'ai cherché sur Google et je n'ai trouvé aucune fonction ou exemple de code.

c++cryptography
68
Jon Duwok

Depuis la ligne de commande, c'est simplement:

printf "compute sha1" | openssl sha1

Vous pouvez appeler la bibliothèque comme ceci:

#include <stdio.h>
#include <string.h>
#include <openssl/sha.h>

int main()
{
    unsigned char ibuf[] = "compute sha1";
    unsigned char obuf[20];

    SHA1(ibuf, strlen(ibuf), obuf);

    int i;
    for (i = 0; i < 20; i++) {
        printf("%02x ", obuf[i]);
    }
    printf("\n");

    return 0;
}
74
brianegge

OpenSSL a un horrible documentation sans exemples de code, mais vous êtes ici:

#include <openssl/sha.h>

bool simpleSHA256(void* input, unsigned long length, unsigned char* md)
{
    SHA256_CTX context;
    if(!SHA256_Init(&context))
        return false;

    if(!SHA256_Update(&context, (unsigned char*)input, length))
        return false;

    if(!SHA256_Final(md, &context))
        return false;

    return true;
}

Usage:

unsigned char md[SHA256_DIGEST_LENGTH]; // 32 bytes
if(!simpleSHA256(<data buffer>, <data length>, md))
{
    // handle error
}

Par la suite, md contiendra le résumé binaire du message SHA-256. Un code similaire peut être utilisé pour les autres membres de la famille SHA, il suffit de remplacer "256" dans le code.

Si vous avez des données plus volumineuses, vous devez bien sûr alimenter des blocs de données à mesure qu'ils arrivent (plusieurs SHA256_Update appels).

53
AndiDog

la syntaxe correcte sur la ligne de commande doit être

echo -n "compute sha1" | openssl sha1

sinon, vous hacherez également le caractère de fin de ligne.

2
mecano

Voici OpenSSL exemple de calcul sha-1 digérer en utilisant BIO :

#include <openssl/bio.h>
#include <openssl/evp.h>

std::string sha1(const std::string &input)
{
    BIO * p_bio_md  = nullptr;
    BIO * p_bio_mem = nullptr;

    try
    {
        // make chain: p_bio_md <-> p_bio_mem
        p_bio_md = BIO_new(BIO_f_md());
        if (!p_bio_md) throw std::bad_alloc();
        BIO_set_md(p_bio_md, EVP_sha1());

        p_bio_mem = BIO_new_mem_buf((void*)input.c_str(), input.length());
        if (!p_bio_mem) throw std::bad_alloc();
        BIO_Push(p_bio_md, p_bio_mem);

        // read through p_bio_md
        // read sequence: buf <<-- p_bio_md <<-- p_bio_mem
        std::vector<char> buf(input.size());
        for (;;)
        {
            auto nread = BIO_read(p_bio_md, buf.data(), buf.size());
            if (nread  < 0) { throw std::runtime_error("BIO_read failed"); }
            if (nread == 0) { break; } // eof
        }

        // get result
        char md_buf[EVP_MAX_MD_SIZE];
        auto md_len = BIO_gets(p_bio_md, md_buf, sizeof(md_buf));
        if (md_len <= 0) { throw std::runtime_error("BIO_gets failed"); }

        std::string result(md_buf, md_len);

        // clean
        BIO_free_all(p_bio_md);

        return result;
    }
    catch (...)
    {
        if (p_bio_md) { BIO_free_all(p_bio_md); }
        throw;
    }
}

Bien qu'il soit plus long que d'appeler simplement SHA1 fonction de OpenSSL, mais il est plus universel et peut être retravaillé pour être utilisé avec des flux de fichiers (traitant ainsi des données de n'importe quelle longueur).

1
anton_rh

Adaptation de la version @AndiDog pour gros fichier:

static const int K_READ_BUF_SIZE{ 1024 * 16 };

std::optional<std::string> CalcSha256(std::string filename)
{
    // Initialize openssl
    SHA256_CTX context;
    if(!SHA256_Init(&context))
    {
        return std::nullopt;
    }

    // Read file and update calculated SHA
    char buf[K_READ_BUF_SIZE];
    std::ifstream file(filename, std::ifstream::binary);
    while (file.good())
    {
        file.read(buf, sizeof(buf));
        if(!SHA256_Update(&context, buf, file.gcount()))
        {
            return std::nullopt;
        }
    }

    // Get Final SHA
    unsigned char result[SHA256_DIGEST_LENGTH];
    if(!SHA256_Final(result, &context))
    {
        return std::nullopt;
    }

    // Transform byte-array to string
    std::stringstream shastr;
    shastr << std::hex << std::setfill('0');
    for (const auto &byte: result)
    {
        shastr << std::setw(2) << (int)byte;
    }
    return shastr.str();
}
1
Nayfe