• 0. Selon la norme gmt0018, comment appeler les interfaces pour obtenir la valeur SM3 de votre numéro d'étudiant et nom ? (5 points)
• 1. Utiliser OpenSSL pour implémenter les interfaces de hachage de l'interface SDF, en supportant au moins l'algorithme SM3, et intégrer les fonctions pertinentes dans sdf.c du dossier src (5 points)
• 2. Dans main.c du dossier test, appeler pour effectuer des tests, en testant au moins le calcul de la valeur SM3 de votre numéro d'étudiant (numérique) et de votre numéro d'étudiant (chaîne de caractères) (5 points)
• 3. **Suomettre le code (ou le lien du code) et les captures d'écran des résultats d'exécution**

Code

main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sdf.h"

int main() {
    unsigned char resultat_hash[32]; // Tampon pour stocker le résultat du hachage, SM3 a une longueur de 256 bits, soit 32 octets
    const char *identifiant_etudiant_texte = "12345678"; // Identifiant de l'étudiant sous forme de texte
    const unsigned char identifiant_etudiant_octets[] = {0x12, 0x34, 0x56, 0x78}; // Identifiant de l'étudiant sous forme de tableau d'octets

    // Calculer le hachage de l'identifiant de l'étudiant (texte)
    if (calculer_sm3((const unsigned char *)identifiant_etudiant_texte, strlen(identifiant_etudiant_texte), resultat_hash) == 0) {
        printf("Hachage SM3 de l'identifiant de l'étudiant (texte): ");
        for (int i = 0; i < 32; i++) {
            printf("%02x", resultat_hash[i]);
        }
        printf("\n");
    } else {
        printf("Échec du calcul du hachage SM3 de l'identifiant de l'étudiant (texte).\n");
    }

    // Calculer le hachage de l'identifiant de l'étudiant (octets)
    if (calculer_sm3(identifiant_etudiant_octets, sizeof(identifiant_etudiant_octets), resultat_hash) == 0) {
        printf("Hachage SM3 de l'identifiant de l'étudiant (octets): ");
        for (int i = 0; i < 32; i++) {
            printf("%02x", resultat_hash[i]);
        }
        printf("\n");
    } else {
        printf("Échec du calcul du hachage SM3 de l'identifiant de l'étudiant (octets).\n");
    }

    return 0;
}

sdf.c

#include <openssl/evp.h>
#include "sdf.h"

int calculer_sm3(const unsigned char *donnees, size_t longueur_donnees, unsigned char *hash_resultat) {
    EVP_MD_CTX *contexte_md;
    const EVP_MD *algorithme_md;
    unsigned int longueur_hash;

    algorithme_md = EVP_sm3(); // Utiliser l'algorithme SM3
    contexte_md = EVP_MD_CTX_new();
    if (contexte_md == NULL) {
        return -1; // Échec de l'initialisation
    }

    if (1 != EVP_DigestInit_ex(contexte_md, algorithme_md, NULL)) {
        EVP_MD_CTX_free(contexte_md);
        return -1; // Échec de l'initialisation du contexte de hachage
    }

    if (1 != EVP_DigestUpdate(contexte_md, donnees, longueur_donnees)) {
        EVP_MD_CTX_free(contexte_md);
        return -1; // Échec de la mise à jour du hachage
    }

    if (1 != EVP_DigestFinal_ex(contexte_md, hash_resultat, &longueur_hash)) {
        EVP_MD_CTX_free(contexte_md);
        return -1; // Échec du calcul du hachage
    }

    EVP_MD_CTX_free(contexte_md);
    return 0; // Succès du calcul du hachage
}

sdf.h

#ifndef SDF_H
#define SDF_H

/**
 * Calcule le hachage SM3 des données fournies
 * @param donnees Les données à hacher
 * @param longueur_donnees La longueur des données en octets
 * @param hash_resultat Le tampon où stocker le résultat du hachage
 * @return 0 en cas de succès, -1 en cas d'erreur
 */
int calculer_sm3(const unsigned char *donnees, size_t longueur_donnees, unsigned char *hash_resultat);

#endif /* SDF_H */

Captures d'écran