NOM

       SSL_CTX_use_certificate, SSL_CTX_use_certificate_ASN1, SSL_CTX_use_certificate_file,
       SSL_use_certificate, SSL_use_certificate_ASN1, SSL_use_certificate_file,
       SSL_CTX_use_certificate_chain_file, SSL_CTX_use_PrivateKey, SSL_CTX_use_PrivateKey_ASN1,
       SSL_CTX_use_PrivateKey_file, SSL_CTX_use_RSAPrivateKey, SSL_CTX_use_RSAPrivateKey_ASN1,
       SSL_CTX_use_RSAPrivateKey_file, SSL_use_PrivateKey_file, SSL_use_PrivateKey_ASN1,
       SSL_use_PrivateKey, SSL_use_RSAPrivateKey, SSL_use_RSAPrivateKey_ASN1,
       SSL_use_RSAPrivateKey_file, SSL_CTX_check_private_key, SSL_check_private_key - Charger les
       données de certificat et de clé

SYNOPSIS

        #include <openssl/ssl.h>

        int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x);
        int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len, unsigned char *d);
        int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, int type);
        int SSL_use_certificate(SSL *ssl, X509 *x);
        int SSL_use_certificate_ASN1(SSL *ssl, unsigned char *d, int len);
        int SSL_use_certificate_file(SSL *ssl, const char *file, int type);

        int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file);

        int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey);
        int SSL_CTX_use_PrivateKey_ASN1(int pk, SSL_CTX *ctx, unsigned char *d,
                                        long len);
        int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type);
        int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa);
        int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, unsigned char *d, long len);
        int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file, int type);
        int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey);
        int SSL_use_PrivateKey_ASN1(int pk,SSL *ssl, unsigned char *d, long len);
        int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type);
        int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa);
        int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, unsigned char *d, long len);
        int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type);

        int SSL_CTX_check_private_key(const SSL_CTX *ctx);
        int SSL_check_private_key(const SSL *ssl);

DESCRIPTION

       Ces fonctions chargent les certificats et les clés privés dans l'objet SSL_CTX et l'objet
       SSL, respectivement.

       La classe de fonctions SSL_CTX_* charge les certificats et les clés dans l'objet SSL_CTX,
       ctx. L'information est passée aux objets SSL ssl créés à partir de ctx avec SSL_new(3) par
       copie, ainsi les changements portés à ctx ne se propagent pas à des objets SSL déjà
       existants.

       La classe de fonctions SSL_* charge seulement les certificats et les clés dans un objet
       SSL particulier. L'information particulière est conservée lorsque SSL_clear(3) est appelée
       pour cet objet SSL.

       SSL_CTX_use_certificate() charge le certificat x dans ctx, SSL_use_certificate() charge x
       dans ssl. Le reste des certificats nécessaires pour former la chaîne complète de
       certificats peut être spécifié avec la fonction SSL_CTX_add_extra_chain_cert(3).

       SSL_CTX_use_certificate_ASN1() charge le certificat codé en ASN1 à partir de l'emplacement
       de mémoire d (de longueur len) dans ctx, SSL_use_certificate_ASN1() charge le certificat
       codé en ASN1 dans ssl.

       SSL_CTX_use_certificate_file() charge le premier certificat stocké dans file dans ctx. Le
       format type du certificat peut être précisé à partir des types connus SSL_FILETYPE_PEM,
       SSL_FILETYPE_ASN1. SSL_use_certificate_file() charge le certificat de file dans ssl. Voir
       dans la partie NOTES pourquoi SSL_CTX_use_certificate_chain_file() devrait être préférée.

       SSL_CTX_use_certificate_chain_file() charge une chaîne de certificats de file dans ctx.
       Les certificats peuvent être au format PEM et peuvent être triés d'abord en certificat du
       sujet (certificat du client ou du serveur réel), puis en certificats d'autorité de
       certification intermédiaires, le cas échéant, et pour finir en autorité de certification
       de plus haut niveau (racine). Il n'y a pas de fonction correspondante fonctionnant avec un
       objet SSL simple.

       SSL_CTX_use_PrivateKey() ajoute pkey comme clé privée à ctx. SSL_CTX_use_RSAPrivateKey()
       ajoute la clé privée rsa de type RSA à ctx. SSL_use_PrivateKey() ajoute pkey comme clé
       privée à ssl ; SSL_use_RSAPrivateKey() ajoute rsa comme clé privée de type RSA à ssl. Si
       un certificat a déjà été configuré et que la clé privée n'appartient pas au certificat,
       une erreur est renvoyée. Pour changer un certificat, apparier la clé privée, le nouveau
       certificat doit être configuré avec SSL_use_certificate() ou SSL_CTX_use_certificate()
       avant de configurer la clé privée avec SSL_CTX_use_PrivateKey() ou SSL_use_PrivateKey().

       SSL_CTX_use_PrivateKey_ASN1() ajoute la clé privée de type pk stockée à l'emplacement de
       mémoire d (de longueur len) à ctx. SSL_CTX_use_RSAPrivateKey_ASN1() ajoute la clé privée
       de type RSA stockée à l'emplacement de mémoire d (de longueur len) à ctx.
       SSL_use_PrivateKey_ASN1() et SSL_use_RSAPrivateKey_ASN1() ajoute la clé privée à ssl.

       SSL_CTX_use_PrivateKey_file() ajoute la première clé privée trouvée dans file à ctx. Le
       type du format du certificat doit être indiqué à partir des types connus SSL_FILETYPE_PEM,
       SSL_FILETYPE_ASN1.SSL_CTX_use_RSAPrivateKey_file() ajoute la première clé privée RSA
       trouvée dans file à ctx. SSL_use_PrivateKey_file() ajoute la première clé privée trouvée
       dans file à ssl ; SSL_use_RSAPrivateKey_file() ajoute la première clé privée RSA trouvée à
       ssl.

       SSL_CTX_check_private_key() vérifie la cohérence d'une clé privée avec le certificat
       correspondant chargé dans ctx. Si plus d'une paire clé/certificat (RSA/DSA) est installée,
       le dernier objet installé sera vérifié. Si, par exemple, le dernier objet est un
       certificat ou une clé RSA, la paire clé/certificat RSA sera vérifiée.
       SSL_check_private_key() exécute la même vérification pour ssl. Si aucune clé ou certificat
       n'ont été explicitement ajoutés pour ce ssl, le dernier objet ajouté dans ctx sera
       vérifié.

NOTES

       Le stockage de certificats interne d'OpenSSL peut garder plusieurs paires de clefs ou de
       certificats à la fois. Le certificat utilisé dépend du chiffrement choisi, Consultez aussi
       SSL_CTX_set_cipher_list(3).

       Lors de la lecture des certificats et des clés privés à partir d'un fichier, les fichiers
       de type SSL_FILETYPE_ASN1 (connu aussi sous le nom DER, codé en binaire) peuvent seulement
       contenir un certificat ou une clé privée, en conséquence
       SSL_CTX_use_certificate_chain_file() est seulement applicable au format PEM. Les fichiers
       de type SSL_FILETYPE_PEM peuvent contenir plus d'un objet.

       SSL_CTX_use_certificate_chain_file() ajoute le premier certificat trouvé dans le fichier
       au stockage de certificats. Les autres certificats sont ajoutés au stockage de certificats
       de chaîne utilisant SSL_CTX_add_extra_chain_cert(3). Note : les versions d'OpenSSL
       antérieures à 1.0.2 ont seulement un seul stockage de chaînes de certificats pour tous les
       types de certificat. OpenSSL 1.0.2 et suivantes ont un stockage de chaînes séparé pour
       chaque type. SSL_CTX_use_certificate_chain_file() devrait être utilisée plutôt que la
       fonction SSL_CTX_use_certificate_file() afin de permettre l'utilisation de chaînes
       complètes de certificats même quand un stockage d'autorités de certification non sûr est
       utilisé ou quand l'autorité de certification qui émet le certificat ne pourra pas être
       ajoutée au stockage d'autorités de certification de confiance.

       Si des certificats supplémentaires sont nécessaires pour terminer la chaîne complète de
       certificats lors de la négociation TLS, des certificats d'autorité de certification sont
       aussi recherchés dans les emplacements des certificats d'autorité de certification de
       confiance, voir SSL_CTX_load_verify_locations(3).

       Les clés privées chargées d'un fichier peuvent être chiffrées. Afin de charger avec succès
       des clés chiffrées, une fonction qui renvoie la phrase secrète peut avoir été fournie,
       voir SSL_CTX_set_default_passwd_cb(3). (Les fichiers de certificats pourraient aussi bien
       être chiffrés d'un point de vue technique, toutefois, ce n'est pas logique dans la mesure
       où les données contenues par le certificat sont considérées comme publiques de toute
       façon.)

VALEURS DE RETOUR

       En cas de réussite, les fonctions renvoient 1. Vérifiez la pile d'erreur pour découvrir la
       raison de l'échec sinon.

VOIR AUSSI

       ssl(3), SSL_new(3), SSL_clear(3), SSL_CTX_load_verify_locations(3),
       SSL_CTX_set_default_passwd_cb(3), SSL_CTX_set_cipher_list(3),
       SSL_CTX_set_client_cert_cb(3), SSL_CTX_add_extra_chain_cert(3)

HISTORIQUE

       La gestion des clés privées à chiffrement DER (SSL_FILETYPE_ASN1) dans
       SL_CTX_use_PrivateKey_file() et SSL_use_PrivateKey_file() a été ajoutée dans la
       version 0.9.8 .

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.