NOM¶

DES_random_key, DES_set_key, DES_key_sched, DES_set_key_checked, DES_set_key_unchecked, DES_set_odd_parity, DES_is_weak_key, DES_ecb_encrypt, DES_ecb2_encrypt, DES_ecb3_encrypt, DES_ncbc_encrypt, DES_cfb_encrypt, DES_ofb_encrypt, DES_pcbc_encrypt, DES_cfb64_encrypt, DES_ofb64_encrypt, DES_xcbc_encrypt, DES_ede2_cbc_encrypt, DES_ede2_cfb64_encrypt, DES_ede2_ofb64_encrypt, DES_ede3_cbc_encrypt, DES_ede3_cbcm_encrypt, DES_ede3_cfb64_encrypt, DES_ede3_ofb64_encrypt, DES_cbc_cksum, DES_quad_cksum, DES_string_to_key, DES_string_to_2keys, DES_fcrypt, DES_crypt, DES_enc_read, DES_enc_write - Chiffrement DES

SYNOPSIS¶

 #include <openssl/des.h>
 void DES_random_key(DES_cblock *ret);
 int DES_set_key(const_DES_cblock *key, DES_key_schedule *schedule);
 int DES_key_sched(const_DES_cblock *key, DES_key_schedule *schedule);
 int DES_set_key_checked(const_DES_cblock *key,
        DES_key_schedule *schedule);
 void DES_set_key_unchecked(const_DES_cblock *key,
        DES_key_schedule *schedule);
 void DES_set_odd_parity(DES_cblock *key);
 int DES_is_weak_key(const_DES_cblock *key);
 void DES_ecb_encrypt(const_DES_cblock *input, DES_cblock *output, 
        DES_key_schedule *ks, int enc);
 void DES_ecb2_encrypt(const_DES_cblock *input, DES_cblock *output, 
        DES_key_schedule *ks1, DES_key_schedule *ks2, int enc);
 void DES_ecb3_encrypt(const_DES_cblock *input, DES_cblock *output, 
        DES_key_schedule *ks1, DES_key_schedule *ks2, 
        DES_key_schedule *ks3, int enc);
 void DES_ncbc_encrypt(const unsigned char *input, unsigned char *output, 
        long length, DES_key_schedule *schedule, DES_cblock *ivec, 
        int enc);
 void DES_cfb_encrypt(const unsigned char *in, unsigned char *out,
        int numbits, long length, DES_key_schedule *schedule,
        DES_cblock *ivec, int enc);
 void DES_ofb_encrypt(const unsigned char *in, unsigned char *out,
        int numbits, long length, DES_key_schedule *schedule,
        DES_cblock *ivec);
 void DES_pcbc_encrypt(const unsigned char *input, unsigned char *output, 
        long length, DES_key_schedule *schedule, DES_cblock *ivec, 
        int enc);
 void DES_cfb64_encrypt(const unsigned char *in, unsigned char *out,
        long length, DES_key_schedule *schedule, DES_cblock *ivec,
        int *num, int enc);
 void DES_ofb64_encrypt(const unsigned char *in, unsigned char *out,
        long length, DES_key_schedule *schedule, DES_cblock *ivec,
        int *num);
 void DES_xcbc_encrypt(const unsigned char *input, unsigned char *output, 
        long length, DES_key_schedule *schedule, DES_cblock *ivec, 
        const_DES_cblock *inw, const_DES_cblock *outw, int enc);
 void DES_ede2_cbc_encrypt(const unsigned char *input,
        unsigned char *output, long length, DES_key_schedule *ks1,
        DES_key_schedule *ks2, DES_cblock *ivec, int enc);
 void DES_ede2_cfb64_encrypt(const unsigned char *in,
        unsigned char *out, long length, DES_key_schedule *ks1,
        DES_key_schedule *ks2, DES_cblock *ivec, int *num, int enc);
 void DES_ede2_ofb64_encrypt(const unsigned char *in,
        unsigned char *out, long length, DES_key_schedule *ks1,
        DES_key_schedule *ks2, DES_cblock *ivec, int *num);
 void DES_ede3_cbc_encrypt(const unsigned char *input,
        unsigned char *output, long length, DES_key_schedule *ks1,
        DES_key_schedule *ks2, DES_key_schedule *ks3, DES_cblock *ivec,
        int enc);
 void DES_ede3_cbcm_encrypt(const unsigned char *in, unsigned char *out, 
        long length, DES_key_schedule *ks1, DES_key_schedule *ks2, 
        DES_key_schedule *ks3, DES_cblock *ivec1, DES_cblock *ivec2, 
        int enc);
 void DES_ede3_cfb64_encrypt(const unsigned char *in, unsigned char *out, 
        long length, DES_key_schedule *ks1, DES_key_schedule *ks2,
        DES_key_schedule *ks3, DES_cblock *ivec, int *num, int enc);
 void DES_ede3_ofb64_encrypt(const unsigned char *in, unsigned char *out, 
        long length, DES_key_schedule *ks1, 
        DES_key_schedule *ks2, DES_key_schedule *ks3, 
        DES_cblock *ivec, int *num);
 DES_LONG DES_cbc_cksum(const unsigned char *input, DES_cblock *output, 
        long length, DES_key_schedule *schedule, 
        const_DES_cblock *ivec);
 DES_LONG DES_quad_cksum(const unsigned char *input, DES_cblock output[], 
        long length, int out_count, DES_cblock *seed);
 void DES_string_to_key(const char *str, DES_cblock *key);
 void DES_string_to_2keys(const char *str, DES_cblock *key1,
        DES_cblock *key2);
 char *DES_fcrypt(const char *buf, const char *salt, char *ret);
 char *DES_crypt(const char *buf, const char *salt);
 int DES_enc_read(int fd, void *buf, int len, DES_key_schedule *sched,
        DES_cblock *iv);
 int DES_enc_write(int fd, const void *buf, int len,
        DES_key_schedule *sched, DES_cblock *iv);

DESCRIPTION¶

Cette bibliothèque contient une implémentation rapide de l'algorithme de chiffrement DES.

Il y a deux phases dans l'utilisation du chiffrement DES. La première consiste à générer un DES_key_schedule à partir d'une clé, la seconde est le chiffrement réel. Une clé DES est du type DES_cblock. Ce type consiste en 8 octets de parité impaire. Le bit de poids le plus faible dans chaque octet est le bit de parité. La préparation de clés « key schedule » est une forme étendue de la clé ; elle est utilisée pour accélérer le processus.

DES_random_key() génère une clé aléatoire. Le PRNG doit être initialisé avant d'utiliser cette fonction (voir rand(3)). Si le PRNG n'a pu générer une clé sécurisée, le code de retour est 0.

Avant qu'une clé DES puisse être utilisée, elle doit être convertie en une DES_key_schedule dépendant de l’architecture à l’aide de la fonction DES_set_key_checked() ou DES_set_key_unchecked().

DES_set_key_checked() vérifiera que la clé est de parité impaire et n'est pas une clé faible ou partiellement faible. Si la parité est mauvaise, alors -1 sera renvoyé. Si la clé est faible, alors -2 sera renvoyé. Si une erreur est renvoyée, alors la préparation de clés ne sera pas faite.

DES_set_key() fonctionne comme DES_set_key_checked() si le drapeau DES_check_key n'est pas 0, sinon elle fonctionne comme DES_set_key_unchecked(). Ces fonctions sont disponibles pour la compatibilité ; il est recommandé d'utiliser une fonction qui ne dépend pas d'une variable globale.

DES_set_odd_parity() change la parité de key à impaire.

DES_is_weak_key() renvoie 1 si la clé passée est faible, 0 si elle est forte.

Les routines suivantes opèrent sur un flux d'entrée ou de sortie des DES_cblock.

DES_ecb_encrypt() est la routine DES de base qui chiffre ou déchiffre séparément des DES_cblock de 8 octets dans le mode electronic code book (ECB). Elle transforme toujours les données d’entrée, pointées par input, dans les données de sortie, pointées par l'argument output. Si l'argument encrypt est différent de 0 (DES_ENCRYPT), input (texte clair) est chiffré dans output (texte chiffré) en utilisant le key_schedule spécifié par l'argument schedule, préalablement initialisé par DES_set_key. Si encrypt est 0 (DES_DECRYPT), input (maintenant texte chiffré) est déchiffré dans output (maintenant texte clair). L'entrée et la sortie peuvent se recouvrir. DES_ecb_encrypt() ne renvoie pas de valeur.

DES_ecb3_encrypt() chiffre ou déchiffre le bloc input en utilisant un chiffrement Triple-DES à trois clés dans le mode ECB. Cela implique de chiffrer l'entrée avec ks1, de déchiffrer avec ks2 et ensuite de chiffrer avec ks3. Cette routine réduit grandement les risques de cassede DES par force brute et elle a l’avantage que si ks1, ks2 et ks3 sont les mêmes, cela est équivalent au mode de chiffrement ECB avec ks1 comme clé.

La macro DES_ecb2_encrypt() permet d'exécuter un chiffrement Triple-DES à deux clés à l'aide de ks1 pour le chiffrement final.

DES_ncbc_encrypt() chiffre ou déchiffre en utilisant le mode cipher-block-chaining (CBC) de DES. Si l'argument encrypt est différent de 0, la routine CBC chiffre les données pointées par l'argument input dans le texte chiffré pointé par l'argument output, en utilisant la préparation des clés fournie par l'argument schedule et le vecteur d'initialisation fourni par l'argument ivec. Si la longueur length de l'argument n'est pas un entier multiple de 8 octets, le dernier bloc est copié dans une zone temporaire et rempli de 0. La sortie est toujours un entier multiple de 8 octets.

DES_xcbc_encrypt() est le mode DESX de RSA de DES. Elle utilise inw et outw pour durcir le chiffrement. inw et outw sont secrets (à l'opposé de iv) et font, de ce fait, partie de la clé. Donc, la clé est une sorte de clé de 24 octets. Cela est bien mieux que CBC DES.

DES_ede3_cbc_encrypt() implémente le chiffrement CBC DES triple externe avec trois clés. Cela veut dire que chaque opération DES à l'intérieur du mode CBC est un "C=E(ks3,D(ks2,E(ks1,M)))". Ce mode est utilisé par SSL.

La macro DES_ede2_cbc_encrypt() implémente Triple-DES avec deux clés en réutilisant ks1 pour le chiffrement final "C=E(ks1,D(ks2,E(ks1,M)))" Cette forme de Triple-DES est utilisée par la bibliothèque RSAREF.

DES_pcbc_encrypt() chiffre ou déchiffre en utilisant le mode de propagation CBC utilisé par Kerberos v4. Ses paramètres sont identiques à DES_ncbc_encrypt().

DES_cfb_encrypt() chiffre ou déchiffre en utilisant un mode de chiffrement à rétroaction. Cette méthode prend un tableau de caractères comme entrée et produit un tableau de caractères. Elle ne nécessite pas de formatage pour les groupes de 8 caractères. Note : la variable ivec est modifiée et la nouvelle valeur à besoin d'être passée au prochain appel de cette fonction. Comme cette fonction utilise un chiffrement DES ECB complet par numbits, cette fonction est suggérée uniquement lors de l'envoi de petits nombres de caractères.

DES_cfb64_encrypt() implémente le mode CFB de DES avec une rétroaction de 64 bits. Pourquoi est-ce que cela est utile dites-vous ? Parce que cette routine autorise à chiffrer un nombre arbitraire d'octets, sans formatage à 8 octets. Chaque appel à cette routine chiffrera les octets d'entrée vers la sortie puis mettra à jour ivec et num. num contient « la distance » par rapport à ivec. Si cela n'a aucun sens, référez-vous à la documentation du mode CFB de DES :-).

DES_ede3_cfb64_encrypt() et DES_ede2_cfb64_encrypt() sont identiques à DES_cfb64_encrypt() sauf que Triple-DES est utilisé.

DES_ofb_encrypt() chiffre en utilisant le mode de chiffrement à rétroaction. Cette méthode prend un tableau de caractères comme entrée et produit un tableau de caractères. Elle ne nécessite pas de formatage pour les groupes de 8 caractères. Note : la variable ivec est modifiée et la nouvelle valeur a besoin d'être passée au prochain appel de cette fonction. Comme cette fonction utilise un chiffrement DES ECB complet par numbits, cette fonction est suggérée uniquement lors de l'envoi de petits nombres de caractères.

DES_ofb64_encrypt() est identique à DES_cfb64_encrypt() en utilisant le mode de chiffrement à rétroaction de sortie.

DES_ede3_ofb64_encrypt() et DES_ede2_ofb64_encrypt() sont identiques à DES_ofb64_encrypt(), en utilisant Triple-DES.

Les instructions suivantes sont incluses dans la bibliothèque DES pour compatibilité avec la bibliothèque Kerberos du MIT.

DES_cbc_cksum() produit une empreinte de 8 octets en se basant sur le flux d'entrée (avec un chiffrement CBC). Les 4 derniers octets de l'empreinte sont renvoyés et les 8 octets totaux sont placés dans output. Cette fonction est utilisée par Kerberos v4. Les autres applications devraient à la place utiliser EVP_DigestInit(3), etc.

DES_quad_cksum() est une fonction de Kerberos v4. Elle renvoie une empreinte de 4 octets à partir des octets d'entrée. Il est possible d'itérer sur l’entrée, selon out_count, 1, 2, 3 ou 4 fois. Si output n'est pas NULL, les 8 octets générés par chaque passage sont écrits dans output.

Les transformations suivantes sont basées sur DES :

DES_fcrypt() est une version plus rapide de la fonction Unix crypt(3). Cette version n’utilise qu'une petite quantité d'espace par rapport aux autres implémentations crypt() rapides. Cela est différent du crypt normal dans le fait que le troisième paramètre est le tampon dans lequel la valeur de retour est écrite. Elle a besoin d'avoir au moins 14 octets de long. Cette fonction est à fil sécurisé (« thread-safe ») contrairement à la fonction crypt normale.

DES_crypt() est un remplacement plus rapide pour le système normal crypt(). Cette fonction appelle DES_fcrypt() avec un tableau statique passé comme troisième paramètre. Cela émule les sémantiques normales, pour les fils non sécurisés, de crypt(3).

DES_enc_write() écrit len octets dans un descripteur de fichier fd provenant du tampon buf. Les données sont chiffrées à l’aide de pcbc_encrypt (par défaut) utilisant sched comme clé et iv comme vecteur de début. Les données envoyées à fd consistent en 4 octets (en ordre d'octets du réseau) contenant la longueur des données chiffrées suivantes. Les données chiffrées suivent, formatées avec des données aléatoires basées sur un multiple de 8 octets.

DES_enc_read() est utilisé pour lire len octets d'un descripteur de fichier fd dans un tampon buf. On suppose que les données lues dans fd proviennent de DES_enc_write() et sont déchiffrées en utilisant sched comme préparation de clés et iv comme vecteur initial.

Attention : Le format des données utilisées par DES_enc_write() et DES_enc_read() a une faiblesse cryptographique : lorsqu'il y a une demande d'écriture de plus de MAXWRITE octets, DES_enc_write() découpera les données en plusieurs morceaux qui utilisent tous le même IV (vecteur d’initialisation). N'utilisez donc pas ces fonctions sauf si vous êtes sûr de savoir ce que vous faites (et même dans ce cas il n'est pas recommandé de s'en servir). Elles ne peuvent pas gérer les sockets non bloquantes. DES_enc_read() utilise un état interne, et de ce fait ne peut être utilisé sur de multiples fichiers.

DES_rw_mode est utilisé pour spécifier le mode de chiffrement à utiliser avec DES_enc_read() et DES_end_write(). Si défini à DES_PCBC_MODE (mode par défaut), DES_pcbc_encrypt est utilisé. Si défini à DES_CBC_MODE alors DES_cbc_encrypt est utilisé.

NOTES¶

DES avec une seule clé n'est pas sécurisé à cause de la taille de la clé qui est trop courte. Le mode ECB n'est pas approprié pour la plupart des applications ; voir des_modes(7).

La bibliothèque evp(3) fournit des fonctions de chiffrement de plus haut niveau.

BOGUES¶

DES_3cbc_encrypt() présente des défauts et ne doit pas être utilisée dans une application.

DES_cbc_encrypt() ne modifie pas ivec ; à la place utilisez DES_ncbc_encrypt().

DES_cfb_encrypt() et DES_ofb_encrypt() opèrent sur une entrée de 8 bits. Cela veut dire que si vous mettez numbits à 12, et la longueur à 2, les premiers 12 bits viendront du premier octet d'entrée et la deuxième moitié du deuxième octet d’entrée. Les 12 bits de la deuxième moitié auront leurs 8 derniers bits pris du 3ème octet d’entrée et leurs 4 premiers bits pris du 4ème octet d'entrée. De même pour la sortie. Cette fonction a été implémentée de cette façon parce que la plupart des gens utilisent un multiple de 8 et parce que lorsque qu’il faut séparer récupération et envoi des octets, les choses deviennent délicates !

DES_string_to_key() est disponible pour une compatibilité ascendante avec la bibliothèque du MIT. Les nouvelles applications devraient utiliser une fonction de hachage cryptographique. Il en va de même pour DES_string_to_2key().

MISE EN CONFORMITɶ

ANSI X3.106

La bibliothèque des a été écrite pour être compatible d'un point de vue du code source avec la bibliothèque Kerberos du MIT.

VOIR AUSSI¶

crypt(3), des_modes(7), evp(3), rand(3)

HISTORIQUE¶

Dans OpenSSL 0.9.7, toutes les fonctions des_ ont été renommées en DES_ pour éviter tous conflits avec les anciennes versions de libdes. La compatibilité des fonctions des_ est fournie pendant une courte période, il en va de même pour crypt(). Les déclarations pour celles-ci sont dans <openssl/des_old.h>. Il n'y a pas de variante DES_ pour des_random_seed(). La même chose se produira si d'autres fonctions sont jugées redondantes (des_random_seed() fait juste un appel à RAND_seed() et est uniquement présente pour raisons de compatibilité), boguées ou prévues d'être retirées.

des_cbc_cksum(), des_cbc_encrypt(), des_ecb_encrypt(), des_is_weak_key(), des_key_sched(), des_pcbc_encrypt(), des_quad_cksum(), des_random_key() et des_string_to_key() sont disponibles dans la bibliothèque Kerberos du MIT ; des_check_key_parity(), des_fixup_key_parity() et des_is_weak_key() sont disponibles dans les versions plus récentes de cette bibliothèque.

des_set_key_checked() et des_set_key_unchecked() ont été ajoutées dans OpenSSL 0.9.5.

des_generate_random_block(), des_init_random_number_generator(), des_new_random_key(), des_set_random_generator_seed(), des_set_sequence_number() et des_rand_data() sont utilisées dans les versions plus récentes de Kerberos mais ne sont pas implémentées ici.

des_random_key() générait des données aléatoires cryptographiquement faibles dans SSLeay et dans OpenSSL avant la version 0.9.5, de même pour la bibliothèque MIT d'origine.

AUTEUR¶

Eric Young (eay@cryptsoft.com). Modifications pour le projet OpenSSL (http://www.openssl.org).

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.