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.