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().
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.