Provided by: manpages-fr-extra_20151231_all bug

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-fr::crypto::X509_VERIFY_PARAM_set_flags(3SSL)