NOM

       X509_VERIFY_PARAM_set_flags, X509_VERIFY_PARAM_clear_flags, X509_VERIFY_PARAM_get_flags,
       X509_VERIFY_PARAM_set_purpose, X509_VERIFY_PARAM_set_trust, X509_VERIFY_PARAM_set_depth,
       X509_VERIFY_PARAM_get_depth, X509_VERIFY_PARAM_set_time, X509_VERIFY_PARAM_add0_policy,
       X509_VERIFY_PARAM_set1_policies, X509_VERIFY_PARAM_set1_host, X509_VERIFY_PARAM_add1_host,
       X509_VERIFY_PARAM_set_hostflags, X509_VERIFY_PARAM_get0_peername, X509_VERIFY_PARAM_set1_email,
       X509_VERIFY_PARAM_set1_ip, X509_VERIFY_PARAM_set1_ip_asc - Paramètres de vérifications X509

SYNOPSIS

        #include <openssl/x509_vfy.h>

        int X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param, unsigned long drapeaux);
        int X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param,                                    unsigned
       long drapeaux);
        unsigned long X509_VERIFY_PARAM_get_flags(X509_VERIFY_PARAM *param);

        int X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int but);
        int X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int confiance);

        void X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t);

        int X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param,                               ASN1_OBJECT
       *politique);
        int X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param,
                                STACK_OF(ASN1_OBJECT) *politiques);

        void X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int profondeur);
        int X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param);

        int X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param,                      const char *name, size_t
       namelen);
        int X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param,
                                        const char *name, size_t namelen);
        void X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM *param,                           unsigned int
       flags);
        char *X509_VERIFY_PARAM_get0_peername(X509_VERIFY_PARAM *param);
        int X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param,                      const char *email,
       size_t emaillen);
        int X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param,                       const unsigned char *ip,
       size_t iplen);
        int X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param, const char *ipasc);

DESCRIPTION

       Ces fonctions manipulent la structure X509_VERIFY_PARAM associée à une opération de vérification du
       certificat.

       La fonction X509_VERIFY_PARAM_set_flags() définit les drapeaux de param en les comparant par OU logique
       avec drapeaux. Voir la section DRAPEAUX DE VÉRIFICATION pour une description complète des valeurs que le
       paramètre drapeaux peut prendre.

       X509_VERIFY_PARAM_get_flags() renvoie les drapeaux dans param.

       X509_VERIFY_PARAM_clear_flags() efface les drapeaux drapeaux dans param.

       X509_VERIFY_PARAM_set_purpose() fixe l'objectif de vérification de param à but. Cela détermine le but
       acceptable de la chaîne de certificats, par exemple pour un client ou un serveur SSL.

       X509_VERIFY_PARAM_set_trust() définit le paramètre de confiance de param à confiance.

       X509_VERIFY_PARAM_set_time() fixe le moment de vérification de param à t. Normalement, l'heure actuelle
       est utilisée.

       X509_VERIFY_PARAM_add0_policy() permet le contrôle de la politique (elle est désactivée par défaut) et
       ajoute politique à l'ensemble des politiques acceptables.

       X509_VERIFY_PARAM_set1_policies() permet la vérification de politique (elle est désactivée par défaut) et
       définit l'ensemble des politiques à politiques. Toutes les politiques existantes sont effacées. Le
       paramètre politiques peut être NULL pour effacer un ensemble de règles existant.

       X509_VERIFY_PARAM_set_depth() définit la profondeur de vérification maximum à profondeur. C'est le nombre
       maximal de certificats de CA non fiables qui peuvent apparaître dans une chaîne.

       X509_VERIFY_PARAM_set1_host() définit le nom de domaine DNS à name en effaçant les valeurs indiquées
       auparavant. Si name est NULL ou vide, la liste des noms de domaine est effacée et les vérifications des
       noms ne sont pas effectuées sur le certificat du pair. Si name est une chaîne terminée par NULL, namelen
       peut être zéro, autrement namelen doit être défini à la longueur de name. Lorsqu'un nom de domaine est
       indiqué, la vérification du certificat appelle la fonction X509_check_host(3) avec les drapeaux définis
       par l'argument flags donné à la fonction X509_VERIFY_PARAM_set_hostflags() (0 par défaut). Les
       applications sont vivement encouragées à utiliser cette interface plutôt que d'appeler directement
       X509_check_host(3) car les vérifications de noms de domaine ne sont plus requises avec l'utilisation des
       certificats DANE-EE(3), et les vérifications internes seront supprimées lorsque la prise en charge de
       DANE sera ajoutée à OpenSSL.

       X509_VERIFY_PARAM_add1_host() ajoute name comme identifiant de référence supplémentaire qui peut
       correspondre au certificat du pair. Les valeurs précédentes de name définies avec
       X509_VERIFY_PARAM_set1_host() ou X509_VERIFY_PARAM_add1_host() sont conservées, et aucun changement n'est
       effectué si name est NULL ou vide. Si plusieurs noms sont définis, le pair est considéré correspondant si
       au moins une des valeurs correspond.

       X509_VERIFY_PARAM_get0_peername() renvoie le nom de domaine DNS ou le nom commun du sujet du certificat
       du pair qui correspond à un des identifiants de référence. Si la correspondance par joker n'est pas
       désactivée, ou si un identifiant de référence indique un domaine parent (qui commence par « . ») plutôt
       qu'un nom de domaine, alors le nom du pair peut être respectivement un joker ou un sous-domaine de
       l'identifiant de référence. La chaîne de retour est allouée par la bibliothèque et n'est plus vide une
       fois que l'argument param associé est libéré. Les applications ne doivent pas libérer la valeur de
       retour.

       X509_VERIFY_PARAM_set1_email() définit l'adresse courriel, au format de la RFC 822, à email. Si email est
       une chaîne terminée par un caractère NULL, emaillen peut être zéro, sinon emaillen doit être défini à la
       longueur de la chaîne email. Si une adresse courriel est indiquée, la vérification du certificat appelle
       X509_check_email(3).

       X509_VERIFY_PARAM_set1_ip() définit l'adresse IP à ip. L'argument ip est au format binaire, dans l'ordre
       des octets du réseau et iplen doit être défini à 4 pour IPv4 et 16 pour IPv6. Si une adresse IP est
       indiquée, la vérification du certificat appelle X509_check_ip(3).

       X509_VERIFY_PARAM_set1_ip_asc() définit l'adresse IP à ipasc. L'argument ipasc est une chaîne terminée
       par le caractère NULL : quatre nombre décimaux séparés par des points pour IPv4, et huit hexadécimaux
       séparés par des deux-points pour IPv6. La notation abrégée « :: » est acceptée pour les adresses IPv6.

VALEURS DE RETOUR

       X509_VERIFY_PARAM_set_flags(), X509_VERIFY_PARAM_clear_flags(), X509_VERIFY_PARAM_set_purpose(),
       X509_VERIFY_PARAM_set_trust(), X509_VERIFY_PARAM_add0_policy() X509_VERIFY_PARAM_set1_policies(),
       X509_VERIFY_PARAM_set1_host(), X509_VERIFY_PARAM_set_hostflags(), X509_VERIFY_PARAM_set1_email(),
       X509_VERIFY_PARAM_set1_ip() et X509_VERIFY_PARAM_set1_ip_asc() renvoient 1 si elles réussissent ou 0 en
       cas d’échec.

       X509_VERIFY_PARAM_get_flags() renvoie les drapeaux de vérification actuels.

       X509_VERIFY_PARAM_set_time() et X509_VERIFY_PARAM_set_depth() ne renvoient pas de valeurs.

       X509_VERIFY_PARAM_get_depth() renvoie la profondeur de vérification en cours.

DRAPEAUX DE VÉRIFICATION

       Les drapeaux de vérification se composent de zéro ou plusieurs des drapeaux disjonctifs (chaînage OU
       logique).

       X509_V_FLAG_CRL_CHECK permet la vérification de la CRL pour la chaîne de certificats terminale. Une
       erreur se produit si une CRL appropriée ne peut être trouvée.

       X509_V_FLAG_CRL_CHECK_ALL permet la vérification de la CRL pour l'ensemble de la chaîne de certificats.

       X509_V_FLAG_IGNORE_CRITICAL désactive le contrôle d'extension critique. Par défaut, des extensions
       critiques non prises en charge dans les certificats ou les CRL (si vérifiées) conduisent à une erreur
       fatale. Si ce drapeau est activé, les extensions critiques non prises en charge sont ignorées.
       AVERTISSEMENT : paramétrer cette option pour autre chose que pour le débogage peut être un risque de
       sécurité. Un contrôle plus fin des extensions prises en charge peut être réalisé dans le rappel de
       vérification.

       Le drapeau X509_V_FLAG_X509_STRICT désactive les contournements pour les certificats cassés et impose à
       la vérification d'appliquer strictement les règles X509.

       X509_V_FLAG_ALLOW_PROXY_CERTS permet la vérification du certificat proxy.

       X509_V_FLAG_POLICY_CHECK permet la vérification de politique de certificat, par défaut aucun contrôle de
       la politique n'est réalisé. Des informations supplémentaires sont envoyées au rappel de vérification
       relatif au contrôle des politiques.

       X509_V_FLAG_EXPLICIT_POLICY, X509_V_FLAG_INHIBIT_ANY et X509_V_FLAG_INHIBIT_MAP activent respectivement
       les drapeaux require explicit policy, inhibit any policy et inhibit policy mapping, tels que définis dans
       la RFC3280. Le contrôle de la politique est automatiquement activé si l'un de ces drapeaux est activé.

       Si X509_V_FLAG_NOTIFY_POLICY est activé et le contrôle de la politique est un succès, un code d'état
       spécifique est activé sur la fonction de rappel de vérification. Cela lui permet d'examiner l'arbre de
       politique valable et d'effectuer des contrôles supplémentaires, ou tout simplement l'enregistrer à des
       fins de débogage.

       Par défaut, certaines fonctionnalités supplémentaires telles que les CRL indirectes et les CRL signées
       par différentes clés sont désactivées. Si X509_V_FLAG_EXTENDED_CRL_SUPPORT est activé, elles sont
       activées.

       Si X509_V_FLAG_USE_DELTAS est activé, les deltas de CRL (le cas échéant) sont utilisés pour déterminer le
       statut du certificat. Sinon, les deltas sont ignorés.

       B <X509_V_FLAG_CHECK_SS_SIGNATURE> permet un contrôle de la signature du certificat autosigné de la CA
       racine. Par défaut, cette vérification est désactivée car elle n'ajoute pas de sécurité supplémentaire,
       mais dans certains cas, les applications pourraient vouloir vérifier la signature de toute façon. Un
       effet secondaire de l'absence de vérification de la signature de la CA racine est que les condensés de
       message non pris en charge ou désactivés de la CA racine ne sont pas traités comme des erreurs fatales.

       Le drapeau X509_V_FLAG_CB_ISSUER_CHECK permet le débogage du contrôle de certificat de l'émetteur. Il
       n'est pas nécessaire à moins que vous n'enregistriez la vérification du certificat. Si cette option est
       activée, des codes d'état supplémentaires seront envoyés au rappel de vérification qui doit être prêt à
       traiter de tels cas sans supposer que ce sont des erreurs.

       Le drapeau X509_V_FLAG_NO_ALT_CHAINS désactive la vérification des chaînes alternatives. Par défaut, lors
       de la construction d'une chaîne de certificats, si la première chaîne trouvée n'est pas de confiance,
       OpenSSL continuera à chercher si une autre chaîne de confiance existe. Avec ce drapeau, le comportement
       sera celui des versions de OpenSSL antérieures à 1.0.2b.

NOTES

       Les fonctions ci-dessus doivent être utilisées pour manipuler les paramètres de vérification au lieu des
       fonctions traditionnelles qui travaillent dans des structures spécifiques, telles que
       X509_STORE_CTX_set_flags().

BOGUES

       La vérification des delta de la CRL est actuellement simpliste. Un seul delta peut être utilisé et (en
       partie en raison des limitations de X509_STORE) les CRL construites ne sont pas maintenues.

       Si la vérification des CRL est activée, les CRL devraient être disponibles dans la structure X509_STORE
       correspondante. Aucune tentative n'est faite pour télécharger des CRL depuis l'extension des points de
       distribution.

EXEMPLE

       Activer la vérification de la CRL lors de la vérification du certificat pendant des connexions SSL
       associées à une structure ctx SSL_CTX :

         X509_VERIFY_PARAM *param;
         param = X509_VERIFY_PARAM_new();
         X509_VERIFY_PARAM_set_flags(param, X509_V_FLAG_CRL_CHECK);
         SSL_CTX_set1_param(ctx, param);
         X509_VERIFY_PARAM_free(param);

VOIR AUSSI

       X509_verify_cert(3), X509_check_host(3), X509_check_email(3), X509_check_ip(3)

HISTORIQUE

       Le drapeau X509_V_FLAG_NO_ALT_CHAINS a été ajouté dans OpenSSL 1.0.2b

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_VERIFY_PARAM_set_flags(3SSL)