accéder aux champs d'une structure pointé

Bonjour comment accéder au champs d’une structure dont on ne connait pas le nom des champs ? yaurais t-il pas une fonction qui permet d’accéder directement a la premier valeur de la structure ? EVP_PKEY ppkey; je shouhaite accéder au donnée EVP_KEY en passant par le pointeur ppkey, normalement je devrais faire ppkey->nomduchamp; mais je ne connais pas le nom des champs. Alors comment y accéder sans nom de champs ? Où peut-on trouver le détaille de la structure EVP_PKEY ?
merci de vos futur réponse.

Salut,

Comment tu sais que tu cherches tes données dans cette structure si tu ne connais pas les champs x)

Quoi qu’il en soit, regarde sa doc, sinon regarde sa déclaration, et tu trouveras les noms des champs. Un bon editeur te les propose en auto-completion aussi normalement.

De manière propre, tu ne peux pas. Il te faut connaitre, l’ordre de trs prétendus champs, l’alignement mémoire … et le type de chaques champs.

Il y a deux possibilités. (1) La structure est visible dans le header (evp.h ou récursivement dans tous les includes) et dans ce cas, pas de probème ! (2)La structure n’est pas dispo , dans ce cas , tu es obligé de passer par des fonctions pour définir/modifier/utiliser les éléments de ta variable structure (EVP_PKEY)

Et c’est le (2) ici.

Comment définir une variable de type EVP_PKEY ? (EVP_PKEY_new) https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_new.html

Comme toute allocation, il faudra penser à libérer la mémoire. (EVP_PKEY_free) https://www.openssl.org/docs/manmaster/man3/EVP_PKEY_free.html

Et il faudra passer par des fonctions pour modifier la variable.

 int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, RSA *key);
 int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, DSA *key);
 int EVP_PKEY_set1_DH(EVP_PKEY *pkey, DH *key);
 int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, EC_KEY *key);

il y a aussi avec "assign" au lieu de set…

et pour obtenir le contenu de tes variables

 const unsigned char *EVP_PKEY_get0_hmac(const EVP_PKEY *pkey, size_t *len);
 RSA *EVP_PKEY_get0_RSA(EVP_PKEY *pkey);
 DSA *EVP_PKEY_get0_DSA(EVP_PKEY *pkey);
 DH *EVP_PKEY_get0_DH(EVP_PKEY *pkey);
 EC_KEY *EVP_PKEY_get0_EC_KEY(EVP_PKEY *pkey);

par exemple. Attention à leur utilisation.

Parce que d’après ce que j’ai compris en lisant la doc, la clée est stocker dans la structure EVP_PKEY et accesible par ppkey.

J’utlise une EC, donc la fonction qui m’intésse doit être EVP_PKEY_get0_EC_KEY(); et je l’utilise comme ça :

EVP_PKEY_get0_EC_KEY(*pkey)

Le probléme et que le programme ne compile pas à cause d’une erreur, que voici :

error: cannot convert 'EVP_PKEY' {aka 'evp_pkey_st'} to 'EVP_PKEY*' {aka 'evp_pkey_st*'}|

il compile uniquement que quand je fais

EVP_PKEY_get0_EC_KEY(pkey)

Mais se n’est pas pour autant que j’obtiens le contenue de la variable, ce qui est logique en mon sens puisque "pkey" est juste l’addresse de la variable. voici mon code en entier :

 EVP_PKEY_CTX *ctx = NULL;
     if(!EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx, NID_secp256k1))
     {
          std::cout << "error 1 " << std::endl;
     }
     else
     {
          EVP_PKEY *pkey = NULL;
         ENGINE *e = NULL;
        if(EVP_PKEY_get0_EC_KEY(*pkey) != NULL)
         {
           if(!(ctx = EVP_PKEY_CTX_new(pkey, e)))
           {
               std::cout << "bien 1" << std::endl;
           }
         }
          else
         {
            if(!(ctx = EVP_PKEY_CTX_new_id(NID_secp256k1, e)))
            {
                std::cout << "bien 2" << std::endl;
            }
         }

        EVP_PKEY *ppkey = NULL;
         if (1 != EVP_PKEY_keygen(ctx, &ppkey))
         {
            std::cout << "error 2" << std::endl;
         }
         else
         {
               std::cout << EVP_PKEY_get0_EC_KEY(*ppkey) << std::endl;
         }
     }

A la ligne 19 je ne sais pas quel parametre mettre avec le parametre "e" car dans la doc le parametre doit être "int id" mais je ne sais pas à quoi correspond le id. Excusez moi j’ai du mal à comprendre les doc.

J’aurais tendance a dire que si tu n’arrives pas à trouver cette info par toi même, c’est que tu fais probablement des choses qui te dépassent et ça va tout faire peter.

EVP_PKEY est un typedef de evp_pkey_st et cette structure est définie dans evp.h.

Hors sujet : c’est du C, pas du C++.

Normalement on peut utliser openssl pour des programmes C++ et c’est pour cette raison que j’ai choisi openssl. Quelle serait la bibliothéque la plus adapter pour coder en C++ ?

OpenSSL. Mais ca reste une question C. Mais c’est un detail.

J’ai trouver différentes fonctions pour décoder des clée : X509_PUBKEY_get0(), X509_PUBKEY_set() et EVP_PKEY_asn1_add0 ( 3) qui font parti des methodes EVP_PKEY_ASN1_METHOD d’aprés ce que j’ai compris, voici le lien pour ces methodes : https://www.openssl.org/docs/man1.1.1/man3/EVP_PKEY_asn1_copy.html j’ai aussi trouver la structure EVP_PKEY le voici :

struct evp_pkey_st {
    /* == Legacy attributes == */
    int type;
    int save_type;
    const EVP_PKEY_ASN1_METHOD *ameth;
    ENGINE *engine;
    ENGINE *pmeth_engine; /* If not NULL public key ENGINE to use */
    union {
        void *ptr;
# ifndef OPENSSL_NO_RSA
        struct rsa_st *rsa;     /* RSA */
# endif
# ifndef OPENSSL_NO_DSA
        struct dsa_st *dsa;     /* DSA */
# endif
# ifndef OPENSSL_NO_DH
        struct dh_st *dh;       /* DH */
# endif
# ifndef OPENSSL_NO_EC
        struct ec_key_st *ec;   /* ECC */
        ECX_KEY *ecx;           /* X25519, X448, Ed25519, Ed448 */
# endif
    } pkey;

et normalement je devrais pouvoir y accéder de 2 façon différentes :

(*ppkey).ameth
ppkey->ameth

mais ce n’est pas le cas sauf si pour accéder à EVP_PKEY_ASN1_METHOD je devais faire *ppkey.(fonction de EVP_PKEY_ASN1_METHOD)

Les EVP* sont des interfaces privées, tu ne peux pas accéder aux champs, il faut passer par l’API public -> les fonctions. C’est ainsi pour de bonne raison lié à la compatibilité binaire sur les mises à jour.

Je ne sais pas d’où te vient l’idée de faire *ppkey.(fonction de EVP_PKEY_ASN1_METHOD), mais cela montre clairement qu’il te manque les bases. Tu devrais d’abord lire un cours.