Provided by: manpages-fr-extra_20151231_all bug

NOM

       X509_STORE_CTX_set_verify_cb - Définir un rappel de vérification

SYNOPSIS

        #include <openssl/x509_vfy.h>

        void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,                     int (*verify_cb)(int ok,
       X509_STORE_CTX *ctx));

DESCRIPTION

       X509_STORE_CTX_set_verify_cb() définit le rappel de vérification de ctx à verify_cb en écrasant tout
       rappel existant.

       Le rappel de vérification peut être utilisé pour personnaliser l'opération de vérification de certificat,
       soit en écrasant les conditions d'erreur, soit en journalisant les erreurs dans un but de débogage.

       Cependant, un rappel de vérification n'est pas essentiel, et l'opération par défaut est souvent
       suffisante.

       Le paramètre ok du rappel indique la valeur que le rappel devrait retourner pour conserver le
       comportement par défaut. Si c'est zéro, alors un état d'erreur est indiqué. Si c'est 1, alors aucune
       erreur n'est arrivée. Si le drapeau X509_V_FLAG_NOTIFY_POLICY est activé, alors ok est mis à 2 pour
       indiquer que la vérification de politique est terminée.

       Le paramètre ctx du rappel est la structure X509_STORE_CTX qui réalise l'opération de vérification. Un
       rappel peut examiner cette structure et recevoir des informations supplémentaires sur l'erreur, par
       exemple en appelant X509_STORE_CTX_get_current_cert(). Des données d'application supplémentaires peuvent
       être passées au rappel par le mécanisme ex_data.

AVERTISSEMENT

       En général, un rappel de vérification ne devrait pas renvoyer 1 sans condition en toutes circonstances,
       parce que cela permettrait à la vérification de réussir quelque soit l'erreur. Cela retire effectivement
       toute la sécurité de l'application parce que tous les certificats (y compris ceux générés qui ne sont pas
       de confiance) seront acceptés.

NOTES

       Le rappel de vérification peut être défini et hérité de la structure mère réalisant l'opération. Dans
       certains cas (comme une vérification S/MIME), la structure X509_STORE_CTX est créée et détruite en
       interne et la seule façon de définir un rappel de vérification personnalisé est par héritage de la
       structure X509_STORE associée.

VALEURS DE RETOUR

       X509_STORE_CTX_set_verify_cb() ne renvoie aucune valeur.

EXEMPLES

       Opération de rappel par défaut :

        int verify_callback(int ok, X509_STORE_CTX *ctx)
               {
               return ok;
               }

       Exemple simple, supposez qu'un certificat de la chaîne soit expiré, et que le but est de continuer après
       cette erreur :

        int verify_callback(int ok, X509_STORE_CTX *ctx)
               {
               /* Tolérer l'expiration de certificat */
               if (X509_STORE_CTX_get_error(ctx) == X509_V_ERR_CERT_HAS_EXPIRED)
                               return 1;
               /* Sinon ne rien écraser */
               return ok;
               }

       Exemple plus compliqué, où le but est de ne pas continuer après n'importe quel certificat expiré, mais
       seulement dans un cas particulier :

        int verify_callback(int ok, X509_STORE_CTX *ctx)
               {
               int err = X509_STORE_CTX_get_error(ctx);
               X509 *err_cert = X509_STORE_CTX_get_current_cert(ctx);
               if (err == X509_V_ERR_CERT_HAS_EXPIRED)
                       {
                       if (check_is_acceptable_expired_cert(err_cert)
                               return 1;
                       }
               return ok;
               }

       Rappel avec journalisation complète. Dans ce cas, le bio_err est supposé être un BIO de journalisation
       globale, une alternative serait de conserver un BIO dans ctx en utilisant ex_data.

        int verify_callback(int ok, X509_STORE_CTX *ctx)
               {
               X509 *err_cert;
               int err,depth;

               err_cert = X509_STORE_CTX_get_current_cert(ctx);
               err =   X509_STORE_CTX_get_error(ctx);
               depth = X509_STORE_CTX_get_error_depth(ctx);

               BIO_printf(bio_err,"depth=%d ",depth);
               if (err_cert)
                       {
                       X509_NAME_print_ex(bio_err, X509_get_subject_name(err_cert),
                                               0, XN_FLAG_ONELINE);
                       BIO_puts(bio_err, "\n");
                       }
               else
                       BIO_puts(bio_err, "<no cert>\n");
               if S<( !ok)>
                       BIO_printf(bio_err,"verify error:num=%d:%s\n",err,
                               X509_verify_cert_error_string(err));
               switch (err)
                       {
               case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
                       BIO_puts(bio_err,"issuer= ");
                       X509_NAME_print_ex(bio_err, X509_get_issuer_name(err_cert),
                                               0, XN_FLAG_ONELINE);
                       BIO_puts(bio_err, "\n");
                       break;
               case X509_V_ERR_CERT_NOT_YET_VALID:
               case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
                       BIO_printf(bio_err,"notBefore=");
                       ASN1_TIME_print(bio_err,X509_get_notBefore(err_cert));
                       BIO_printf(bio_err,"\n");
                       break;
               case X509_V_ERR_CERT_HAS_EXPIRED:
               case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
                       BIO_printf(bio_err,"notAfter=");
                       ASN1_TIME_print(bio_err,X509_get_notAfter(err_cert));
                       BIO_printf(bio_err,"\n");
                       break;
               case X509_V_ERR_NO_EXPLICIT_POLICY:
                       policies_print(bio_err, ctx);
                       break;
                       }
               if (err == X509_V_OK && ok == 2)
                       /* afficher les politiques */

               BIO_printf(bio_err,"verify return:%d\n",ok);
               return(ok);
               }

VOIR AUSSI

       X509_STORE_CTX_get_error(3), X509_STORE_CTX_get_ex_new_index(3)(3)>, X509_STORE_set_verify_cb_func(3)

HISTORIQUE

       X509_STORE_CTX_set_verify_cb() est disponible dans toutes les versions de SSLeay et d'OpenSSL.

TRADUCTION

       La traduction de cette page de manuel est maintenue par les membres de la liste <debian-l10n-french AT
       lists DOT debian DOT org>. Veuillez signaler toute erreur de traduction par un rapport de bogue sur le
       paquet manpages-fr-extra.

1.0.2a 1.0.2c                                      2015-12-31     fr::crypto::X509_STORE_CTX_set_verify_cb(3SSL)