Provided by: manpages-fr-extra_20140201_all bug

NOM

       DSA_set_default_method, DSA_get_default_method, DSA_set_method, DSA_new_method,
       DSA_OpenSSL - Sélectionner la méthode DSA

SYNOPSIS

        #include <openssl/dsa.h>
        #include <openssl/engine.h>

        void DSA_set_default_method(const DSA_METHOD *meth);

        const DSA_METHOD *DSA_get_default_method(void);

        int DSA_set_method(DSA *dsa, const DSA_METHOD *meth);

        DSA *DSA_new_method(ENGINE *engine);

        DSA_METHOD *DSA_OpenSSL(void);

DESCRIPTION

       Une DSA_METHOD indique les fonctions qu’OpenSSL utilise pour les opérations DSA. En
       modifiant la méthode, les implémentations alternatives comme les accélérateurs matériels
       pourraient être utilisés. Important : consultez la section NOTES qui contient des
       renseignements importants sur la façon dont ces fonctions d’interface de programmation DSA
       sont concernées par l’utilisation des appels d’interface de programmation ENGINE.

       Initialement, la DSA_METHOD par défaut est l’implémentation interne d’OpenSSL, telle que
       renvoyée par DSA_OpenSSL().

       DSA_set_default_method() fait de meth la méthode par défaut pour toutes les structures DSA
       créées ensuite. Remarque : ce n’est vrai que tant qu’aucun ENGINE n’a été défini par
       défaut pour DSA, donc cette fonction n’est plus recommandée.

       DSA_get_default_method() renvoie un pointeur vers la DSA_METHOD par défaut actuelle.
       Cependant, la signification de ce résultat dépend de l’utilisation ou non de l’interface
       de programmation ENGINE, donc cette fonction n’est plus recommandée.

       DSA_set_method() sélectionne meth pour réaliser toutes les opérations utilisant la clef
       dsa. Cela remplacera la DSA_METHOD utilisée par la clef DSA et, si la méthode précédente a
       été fournie par un ENGINE, le traitement par cet ENGINE sera abandonné pendant la
       modification. Certaines clefs pourraient ne fonctionner qu’avec certaines implémentations
       de DSA_METHOD (par exemple à partir d’un module ENGINE qui prend en charge les clefs
       protégées matériellement) et, dans ces cas, essayer de modifier la DSA_METHOD pour la clef
       peut avoir des résultats inattendus.

       DSA_new_method() alloue et initialise une structure DSA de telle sorte qu’engine sera
       utilisé pour les opérations DSA. Si engine est NULL, l’ENGINE par défaut pour les
       opérations DSA est utilisé, et si aucun ENGINE par défaut n’est défini, la DSA_METHOD
       contrôlée par DSA_set_default_method() est utilisée.

LA STRUCTURE DSA_METHOD

       struct
        {
            /* nom de l’implémentation */
               const char *name;

            /* signer */
               DSA_SIG *(*dsa_do_sign)(const unsigned char *dgst, int dlen,
                                        DSA *dsa);

            /* précalculer k^-1 et r */
               int (*dsa_sign_setup)(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp,
                                        BIGNUM **rp);

            /* vérifier */
               int (*dsa_do_verify)(const unsigned char *dgst, int dgst_len,
                                        DSA_SIG *sig, DSA *dsa);

            /* calculer rr = a1^p1 * a2^p2 mod m (pourrait être NULL pour
                                                  certaines implémentations) */
               int (*dsa_mod_exp)(DSA *dsa, BIGNUM *rr, BIGNUM *a1, BIGNUM *p1,
                                        BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
                                        BN_CTX *ctx, BN_MONT_CTX *in_mont);

            /* calculer r = a ^ p mod m (pourrait être NULL pour
                                         certaines implémentations) */
               int (*bn_mod_exp)(DSA *dsa, BIGNUM *r, BIGNUM *a,
                                        const BIGNUM *p, const BIGNUM *m,
                                        BN_CTX *ctx, BN_MONT_CTX *m_ctx);

            /* appelée à DSA_new */
               int (*init)(DSA *DSA);

            /* appelée à DSA_free */
               int (*finish)(DSA *DSA);

               int flags;

               char *app_data; /* ? */

        } DSA_METHOD;

VALEURS DE RETOUR

       DSA_OpenSSL() et DSA_get_default_method() renvoient des pointeurs vers les DSA_METHOD
       respectives.

       DSA_set_default_method() ne renvoie rien.

       DSA_set_method() renvoie une valeur non nulle si la meth a été définie correctement comme
       la méthode pour dsa (y compris le déchargement du traitement de l’ENGINE si la méthode
       précédente était fournie par un ENGINE).

       DSA_new_method() renvoie NULL et positionne un code d'erreur qui peut être récupéré avec
       ERR_get_error(3) si l'allocation échoue. Sinon, elle renvoie un pointeur vers la structure
       nouvellement allouée.

NOTES

       Depuis la version 0.9.7, les implémentations DSA_METHOD sont regroupées avec d’autres
       interfaces de programmation algorithmiques (par exemple RSA_METHOD, EVP_CIPHER, etc.) dans
       les modules ENGINE. Si un ENGINE par défaut est indiqué pour la fonctionnalité DSA
       utilisant une fonction d’interface de programmation ENGINE, cela remplacera tous les DSA
       par défaut définis en utilisant l’interface de programmation DSA (c’est-à-dire
       DSA_set_default_method()). Pour cette raison, l’interface de programmation ENGINE est la
       façon recommandée de contrôler les implémentations par défaut à utiliser dans les
       algorithmes cryptographiques DSA et autres.

VOIR AUSSI

       dsa(3), DSA_new(3)

HISTORIQUE

       DSA_set_default_method(), DSA_get_default_method(), DSA_set_method(), DSA_new_method() et
       DSA_OpenSSL() ont été ajoutées dans OpenSSL 0.9.4.

       DSA_set_default_openssl_method() et DSA_get_default_openssl_method() ont respectivement
       remplacé DSA_set_default_method() et DSA_get_default_method(), et DSA_set_method() et
       DSA_new_method() ont été modifiées pour utiliser des ENGINE plutôt que des DSA_METHOD
       pendant le développement de la version ENGINE d’OpenSSL 0.9.6. Pour 0.9.7, le traitement
       des valeurs par défaut dans l’interface de programmation ENGINE a été restructuré en
       revenant sur cette modification, pour que le comportement des autres fonctions ressemble
       plus au comportement précédent. Le comportement des valeurs par défaut dans l’interface de
       programmation ENGINE remplace maintenant de façon transparente le comportement des valeurs
       par défaut dans l’interface de programmation DSA sans modification nécessaire de ces
       prototypes de fonctions.

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.