Comprendre l'initialisation du moteur dans OpenSSL

Le problème avec votre suggestion est, comme Martin l'a dit, que vous avez besoin de l'initialiser le MOTEUR. Le problème avec votre code a été modifié de ce que vous faisiez ENGINE_new, qui est de vous obtenir un tout nouveau MOTEUR de votre propre, vous devez alors fournir avec des méthodes de chiffrement, recueil des méthodes, etc. En fait, pour ce que vous voulez (et ce que tout le monde ou presque veut), tout en ignorant complètement tous les MOTEUR de choses est le bon choix.

Certains filiale de problèmes:

• vos chaînes ont été hexagonale, mais vous avez besoin d'un \x par caractère à réellement obtenir que hex octet à cette position dans la chaîne, ce qui je pense a été ce que tu voulais.
• vous essayiez de hachage de 40 octets à partir de "données", ce qui n'était pas si longtemps (l'effet réel: vous finirais partie de hachage votre chaîne de résultat)
• votre résultat attendu a été (autant que je puis dire) d'une mauvaise
• vous imprimer des caractères aléatoires pour le terminal, depuis le HMAC fonction produit de 32 octets de l'aléatoire des données binaires, non imprimable choses.

Le code suivant compile, travaille et réussit le test. C'est un peu différent de l'exemple de code que vous avez trouvé (car il utilise toujours l'individu HMAC_* fonctions utiles si vous voulez faire votre hachage peu à peu à l'aide de HMAC_Update):

#include <openssl/engine.h>
#include <openssl/hmac.h>
#include <openssl/evp.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>


int main(void)
{
        unsigned char* key = (unsigned char*) "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b";
        unsigned char* data = (unsigned char*) "\x48\x69\x20\x54\x68\x65\x72\x65";
        unsigned char* expected = (unsigned char*) "\x49\x2c\xe0\x20\xfe\x25\x34\xa5\x78\x9d\xc3\x84\x88\x06\xc7\x8f\x4f\x67\x11\x39\x7f\x08\xe7\xe7\xa1\x2c\xa5\xa4\x48\x3c\x8a\xa6";
        unsigned char* result;
        unsigned int result_len = 32;
        int i;
        HMAC_CTX ctx;

        result = (unsigned char*) malloc(sizeof(char) * result_len);

        ENGINE_load_builtin_engines();
        ENGINE_register_all_complete();

        HMAC_CTX_init(&ctx);
        HMAC_Init_ex(&ctx, key, 16, EVP_sha256(), NULL);
        HMAC_Update(&ctx, data, 8);
        HMAC_Final(&ctx, result, &result_len);
        HMAC_CTX_cleanup(&ctx);

        for (i=0; i!=result_len; i++)
        {
                if (expected[i]!=result[i])
                {
                        printf("Got %02X instead of %02X at byte %d!\n", result[i], expected[i], i);
                        break;
                }
        }
        if (i==result_len)
        {
                printf("Test ok!\n");
        }
        return 0;
}

Évidemment, ce n'est pas la réponse à votre question initiale sur la façon d'initialiser les Moteurs, mais il n'y a vraiment pas de bonne réponse à cela sans avoir plus de contexte, lequel s'avère ne pas être pertinents à votre situation...

Il semble que rien n'est de l'allocation d'un moteur, de sorte que la première utilisation de e est segfaulting. Je pense que vous devez appeler ENGINE *ENGINE_new(void) premier.

(Notez que j'ai utilisé OpenSSL, mais je n'ai pas utilisé le ENGINE fonctions avant.)

Mise à jour: je ne suis pas vraiment heureux avec ma propre réponse (j'ai dû dash off pour le thé, avant). Afin de poursuivre mes notes sont:

1. J'ai eu un peu d'un coup d'oeil à la (longue) page de man pour la ENGINE fonctions, et je ne suis pas sûr que l'appel ENGINE_new est suffisant.

2. Je n'avais pas remarqué que les appels à la HMAC_CTX_* fonctions prenaient un pointeur non initialisé, plutôt que d'un pointeur alloué à la structure. HMAC_CTX_init vais essayer d'écrire à la mémoire pointée par son ctx paramètre, ce qui permettra d'erreur de segmentation. Vous devez déclarer et utiliser ctx comme ceci:

   HMAC_CTX ctx;
   HMAC_CTX_init(&ctx);
   HMAC_Init_ex(&ctx, key, 40, EVP_sha256(), e);
   ...

   De cette façon, vous êtes l'allocation de la structure sur la pile, puis en passant un pointeur.

3. La HMAC fonction ne prend pas un pointeur vers un CTX à tous, donc à part globale ou locale de thread de stockage, je ne suis pas sûr de ce que c'est la connexion à la CTX est. Je pense que vous pouvez ignorer que, en appelant HMAC_Update une ou plusieurs fois, suivi par HMAC_Final pour obtenir le résultat. Vous auriez besoin d'allouer de l'espace pour cette raison, donc, quelque chose comme ce qui suit serait travailler pour que:

   unsigned int len;
   HMAC_Final(&ctx, result, &len);