Provided by: manpages-fr-extra_20151231_all 
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.
1.0.2a 1.0.2c 2015-12-31 fr::crypto::des(3SSL)