From 395df2fe306764e0d6909d423cd390ee2e841392 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ulf=20M=C3=B6ller?= Date: Sun, 19 Mar 2000 02:09:37 +0000 Subject: [PATCH] libdes manpage. This may still contain a few errors from the old documentation, but most of it should make sense. --- crypto/des/des_crypt.pod | 261 --------------------------- doc/crypto/des.pod | 376 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 376 insertions(+), 261 deletions(-) delete mode 100644 crypto/des/des_crypt.pod create mode 100644 doc/crypto/des.pod diff --git a/crypto/des/des_crypt.pod b/crypto/des/des_crypt.pod deleted file mode 100644 index 673215f758..0000000000 --- a/crypto/des/des_crypt.pod +++ /dev/null @@ -1,261 +0,0 @@ -=pod - -=head1 NAME - -des_read_password, des_read_2password, des_string_to_key, -des_string_to_2key, des_read_pw_string, des_random_key, des_set_key, -des_key_sched, des_ecb_encrypt, des_ecb3_encrypt, des_cbc_encrypt, -des_3cbc_encrypt, des_pcbc_encrypt, des_cfb_encrypt, des_ofb_encrypt, -des_cbc_cksum, des_quad_cksum, des_enc_read, des_enc_write, -des_set_odd_parity, des_is_weak_key, crypt - (non USA) DES encryption - -=head1 SYNOPSIS - - #include - - int des_read_password(des_cblock *key, char *prompt, int verify); - - int des_read_2password(des_cblock *key1, des_cblock *key2, char *prompt, - int verify); - - int des_string_to_key(char *str, des_cblock *key); - - int des_string_to_2keys(char *str, des_cblock *key1, des_cblock *key2); - - int des_read_pw_string(char *buf, int length, char *prompt, int verify); - - int des_random_key(des_cblock *key); - - int des_set_key(des_cblock *key, des_key_schedule schedule); - - int des_key_sched(des_cblock *key, des_key_schedule schedule); - - int des_ecb_encrypt(des_cblock *input, des_cblock *output, - des_key_schedule schedule, int encrypt); - - int des_ecb3_encrypt(des_cblock *input, des_cblock *output, - des_key_schedule ks1, des_key_schedule ks2, int encrypt); - - int des_cbc_encrypt(des_cblock *input, des_cblock *output, - long length, des_key_schedule schedule, des_cblock *ivec, - int encrypt); - - int des_3cbc_encrypt(des_cblock *input, des_cblock *output, - long length, des_key_schedule sk1, des_key_schedule sk2, - des_cblock *ivec1, des_cblock *ivec2, int encrypt); - - int des_pcbc_encrypt(des_cblock *input, des_cblock *output, - long length, des_key_schedule schedule, des_cblock *ivec, - int encrypt); - - int des_cfb_encrypt(unsigned char *input, unsigned char *output, - int numbits, long length, des_key_schedule schedule, - des_cblock *ivec, int encrypt); - - int des_ofb_encrypt(unsigned char *input, unsigned char *output, - int numbits, long length, des_key_schedule schedule, - des_cblock *ivec); - - unsigned long des_cbc_cksum(des_cblock *input, des_cblock *output, - long length, des_key_schedule schedule, des_cblock *ivec); - - unsigned long des_quad_cksum(des_cblock *input, des_cblock *output, - long length, int out_count, des_cblock *seed); - - int des_check_key; - - int des_enc_read(int fd, char *buf, int len, des_key_schedule sched, - des_cblock *iv); - - int des_enc_write(int fd, char *buf, int len, des_key_schedule sched, - des_cblock *iv); - - extern int des_rw_mode; - - void des_set_odd_parity(des_cblock *key); - - int des_is_weak_key(des_cblock *key); - - char *crypt(char *passwd, char *salt); - -=head1 DESCRIPTION - -This library contains a fast implementation of the DES encryption -algorithm. - -There are two phases to the use of DES encryption. The first is the -generation of a I from a key, the second is the -actual encryption. A des key is of type I. This type is -made from 8 characters with odd parity. The least significant bit in -the character is the parity bit. The key schedule is an expanded form -of the key; it is used to speed the encryption process. - -I writes the string specified by prompt to the -standard output, turns off echo and reads an input string from -standard input until terminated with a newline. If verify is -non-zero, it prompts and reads the input again and verifies that both -entered passwords are the same. The entered string is converted into -a des key by using the I routine. The new key is -placed in the I that was passed (by reference) to the -routine. If there were no errors, I returns 0, -1 -is returned if there was a terminal error and 1 is returned for any -other error. - -I operates in the same way as I -except that it generates two keys by using the I -function. - -I is called by I to read and -verify a string from a terminal device. The string is returned in -I. The size of I is passed to the routine via the I -parameter. - -I converts a string into a valid des key. - -I converts a string into two valid des keys. This -routine is best suited for used to generate keys for use with -I. - -I returns a random key that is made of a combination -of process id, time and an increasing counter. - -Before a des key can be used, it is converted into a -I via the I routine. If the -I flag is non-zero, I will check that the -key passed is of odd parity and is not a week or semi-weak key. If -the parity is wrong, then -1 is returned. If the key is a weak key, -then -2 is returned. If an error is returned, the key schedule is not -generated. - -I is another name for the I function. - -The following routines mostly operate on an input and output stream of -I's. - -I is the basic DES encryption routine that encrypts -or decrypts a single 8-byte I in I -mode. It always transforms the input data, pointed to by I, -into the output data, pointed to by the I argument. If the -I argument is non-zero (DES_ENCRYPT), the I -(cleartext) is encrypted in to the I (ciphertext) using the -key_schedule specified by the I argument, previously set via -I. If I is zero (DES_DECRYPT), the I (now -ciphertext) is decrypted into the I (now cleartext). Input -and output may overlap. No meaningful value is returned. - -I encrypts/decrypts the I block by using -triple ecb DES encryption. This involves encrypting the input with -I, decryption with the key schedule I, and then encryption -with the first again. This routine greatly reduces the chances of -brute force breaking of DES and has the advantage of if I and -I are the same, it is equivalent to just encryption using ecb -mode and I as the key. - -I encrypts/decrypts using the -I mode of DES. If the I argument is -non-zero, the routine cipher-block-chain encrypts the cleartext data -pointed to by the I argument into the ciphertext pointed to by -the I argument, using the key schedule provided by the -I argument, and initialization vector provided by the -I argument. If the I argument is not an integral -multiple of eight bytes, the last block is copied to a temporary area -and zero filled. The output is always an integral multiple of eight -bytes. To make multiple cbc encrypt calls on a large amount of data -appear to be one I call, the I of subsequent -calls should be the last 8 bytes of the output. - -I encrypts/decrypts the I block by using -triple cbc DES encryption. This involves encrypting the input with -key schedule I, decryption with the key schedule I, and then -encryption with the first again. Two initialization vectors are -required, I and I. Unlike I, these -initialization vectors are modified by the subroutine. This routine -greatly reduces the chances of brute force breaking of DES and has the -advantage of if I and I are the same, it is equivalent to -just encryption using cbc mode and I as the key. - -I encrypt/decrypts using a modified block chaining -mode. It provides better error propagation characteristics than cbc -encryption. - -I encrypt/decrypts using cipher feedback mode. This -method takes an array of characters as input and outputs and array of -characters. It does not require any padding to 8 character groups. -Note: the ivec variable is changed and the new changed value needs to -be passed to the next call to this function. Since this function runs -a complete DES ecb encryption per numbits, this function is only -suggested for use when sending small numbers of characters. - -I encrypt using output feedback mode. This method -takes an array of characters as input and outputs and array of -characters. It does not require any padding to 8 character groups. -Note: the ivec variable is changed and the new changed value needs to -be passed to the next call to this function. Since this function runs -a complete DES ecb encryption per numbits, this function is only -suggested for use when sending small numbers of characters. - -I produces an 8 byte checksum based on the input stream -(via cbc encryption). The last 4 bytes of the checksum is returned -and the complete 8 bytes is placed in I. - -I returns a 4 byte checksum from the input bytes. The -algorithm can be iterated over the input, depending on I, -1, 2, 3 or 4 times. If I is non-NULL, the 8 bytes generated -by each pass are written into I. - -I is used to write I bytes to file descriptor -I from buffer I. The data is encrypted via I -(default) using I for the key and I as a starting vector. -The actual data send down I consists of 4 bytes (in network byte -order) containing the length of the following encrypted data. The -encrypted data then follows, padded with random data out to a multiple -of 8 bytes. - -I is used to read I bytes from file descriptor -I into buffer I. The data being read from I is assumed to -have come from I and is decrypted using I for -the key schedule and I for the initial vector. The -I pair can be used to read/write to files, -pipes and sockets. I have used them in implementing a version of -rlogin in which all data is encrypted. - -I is used to specify the encryption mode to use with -I and I. If set to I (the -default), des_pcbc_encrypt is used. If set to I -des_cbc_encrypt is used. These two routines and the variable are not -part of the normal MIT library. - -I sets the parity of the passed I to odd. -This routine is not part of the standard MIT library. - -I returns 1 is the passed key is a weak key (pick -again :-), 0 if it is ok. This routine is not part of the standard -MIT library. - -I is a replacement for the normal system crypt. It is much -faster than the system crypt. - -=head1 BUGS - -I and I operates on input of 8 bits. -What this means is that if you set numbits to 12, and length to 2, the -first 12 bits will come from the 1st input byte and the low half of -the second input byte. The second 12 bits will have the low 8 bits -taken from the 3rd input byte and the top 4 bits taken from the 4th -input byte. The same holds for output. This function has been -implemented this way because most people will be using a multiple of 8 -and because once you get into pulling bytes input bytes apart things -get ugly! - -I is the most machine/OS dependent function and -normally generates the most problems when porting this code. - -I is probably different from the MIT version since -there are lots of fun ways to implement one-way encryption of a text -string. - -=head1 AUTHOR - -Eric Young (eay@cryptsoft.com) - -=cut diff --git a/doc/crypto/des.pod b/doc/crypto/des.pod new file mode 100644 index 0000000000..c553210ef2 --- /dev/null +++ b/doc/crypto/des.pod @@ -0,0 +1,376 @@ +=pod + +=head1 NAME + +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_read_password, des_read_2passwords, des_read_pw_string, +des_cbc_cksum, des_quad_cksum, des_string_to_key, des_string_to_2keys, +des_fcrypt, des_crypt, des_enc_read, des_enc_write - DES encryption + +=head1 SYNOPSIS + + #include + + 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); + + int des_read_password(des_cblock *key, const char *prompt, int verify); + int des_read_2passwords(des_cblock *key1, des_cblock *key2, + const char *prompt, int verify); + int des_read_pw_string(char *buf, int length, const char *prompt, + int verify); + + 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); + char *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); + +=head1 DESCRIPTION + +This library contains a fast implementation of the DES encryption +algorithm. + +There are two phases to the use of DES encryption. The first is the +generation of a I from a key, the second is the +actual encryption. A DES key is of type I. This type is +consists of 8 bytes with odd parity. The least significant bit in +each byte is the parity bit. The key schedule is an expanded form of +the key; it is used to speed the encryption process. + +des_random_key() generates a random key. The PRNG must be seeded +prior to using this function (see L; for backward +compatibility the function des_random_seed() is available as well). +If the PRNG could not generate a secure key, 0 is returned. In +earlier versions of the library, des_random_key() did not generate +secure keys. + +Before a DES key can be used, it must be converted into the +architecture dependant I via the +des_set_key_checked() or des_set_key_unchecked() function. + +des_set_key_checked() will check that the key passed is of odd parity +and is not a week or semi-weak key. If the parity is wrong, then -1 +is returned. If the key is a weak key, then -2 is returned. If an +error is returned, the key schedule is not generated. + +des_set_key() (called des_key_sched() in the MIT library) works like +des_set_key_checked() if the I flag is non-zero, +otherwise like des_set_key_unchecked(). These functions are available +for compatibility; it is recommended to use a function that does not +depend on a global variable. + +des_set_odd_parity() (called des_fixup_key_parity() in the MIT +library) sets the parity of the passed I to odd. + +des_is_weak_key() returns 1 is the passed key is a weak key, 0 if it +is ok. The probability that a randomly generated key is weak is +1/2^52, so it is not really worth checking for them. + +The following routines mostly operate on an input and output stream of +Is. + +des_ecb_encrypt() is the basic DES encryption routine that encrypts or +decrypts a single 8-byte I in I +(ECB) mode. It always transforms the input data, pointed to by +I, into the output data, pointed to by the I argument. +If the I argument is non-zero (DES_ENCRYPT), the I +(cleartext) is encrypted in to the I (ciphertext) using the +key_schedule specified by the I argument, previously set via +I. If I is zero (DES_DECRYPT), the I (now +ciphertext) is decrypted into the I (now cleartext). Input +and output may overlap. des_ecb_encrypt() does not return a value. + +des_ecb3_encrypt() encrypts/decrypts the I block by using +three-key Triple-DES encryption in ECB mode. This involves encrypting +the input with I, decrypting with the key schedule I, and +then encrypting with I. This routine greatly reduces the chances +of brute force breaking of DES and has the advantage of if I, +I and I are the same, it is equivalent to just encryption +using ECB mode and I as the key. + +The macro des_ecb2_encrypt() is provided to perform two-key Triple-DES +encryption by using I for the final encryption. + +des_ncbc_encrypt() encrypts/decrypts using the I +(CBC) mode of DES. If the I argument is non-zero, the +routine cipher-block-chain encrypts the cleartext data pointed to by +the I argument into the ciphertext pointed to by the I +argument, using the key schedule provided by the I argument, +and initialization vector provided by the I argument. If the +I argument is not an integral multiple of eight bytes, the +last block is copied to a temporary area and zero filled. The output +is always an integral multiple of eight bytes. + +des_xcbc_encrypt() is RSA's DESX mode of DES. It uses I and +I to 'whiten' the encryption. I and I are secret +(unlike the iv) and are as such, part of the key. So the key is sort +of 24 bytes. This is much better than CBC DES. + +des_ede3_cbc_encrypt() implements outer triple CBC DES encryption with +three keys. This means that each DES operation inside the CBC mode is +really an C. This mode is used by SSL. + +The des_ede2_cbc_encrypt() macro implements two-key Triple-DES by +reusing I for the final encryption. C. +This form of Triple-DES is used by the RSAREF library. + +des_pcbc_encrypt() encrypt/decrypts using the propagating cipher block +chaing mode used by Kerberos v4. Its parameters are the same as +des_ncbc_encrypt(). + +des_cfb_encrypt() encrypt/decrypts using cipher feedback mode. This +method takes an array of characters as input and outputs and array of +characters. It does not require any padding to 8 character groups. +Note: the I variable is changed and the new changed value needs to +be passed to the next call to this function. Since this function runs +a complete DES ECB encryption per I, this function is only +suggested for use when sending small numbers of characters. + +des_cfb64_encrypt() +implements CFB mode of DES with 64bit feedback. Why is this +useful you ask? Because this routine will allow you to encrypt an +arbitrary number of bytes, no 8 byte padding. Each call to this +routine will encrypt the input bytes to output and then update ivec +and num. num contains 'how far' we are though ivec. If this does +not make much sense, read more about cfb mode of DES :-). + +des_ede3_cfb64_encrypt() and des_ede2_cfb64_encrypt() is the same as +des_cfb64_encrypt() except that Triple-DES is used. + +des_ofb_encrypt() encrypts using output feedback mode. This method +takes an array of characters as input and outputs and array of +characters. It does not require any padding to 8 character groups. +Note: the I variable is changed and the new changed value needs to +be passed to the next call to this function. Since this function runs +a complete DES ECB encryption per numbits, this function is only +suggested for use when sending small numbers of characters. + +des_ofb64_encrypt() is the same as des_cfb64_encrypt() using Output +Feed Back mode. + +des_ede3_ofb64_encrypt() and des_ede2_ofb64_encrypt() is the same as +des_ofb64_encrypt(), using Triple-DES. + +The following functions are included in the DES library for +compatibility with the MIT Kerberos library. des_read_pw_string() +is also available under the name EVP_read_pw_string(). + +des_read_pw_string() writes the string specified by I to +standarf output, turns echo off and reads in input string from the +terminal. The string is returned in I, which must have space for +at least I bytes. If I is set, the user is asked for +the password twice and unless the two copies match, an error is +returned. A return code of -1 indicates a system error, 1 failure due +to use interaction, and 0 is success. + +des_read_password() does the same and converts the password to a DES +key by calling des_string_to_key(); des_read_2password() operates in +the same way as des_read_password() except that it generates two keys +by using the des_string_to_2key() function. des_string_to_key() is +available for backward compatibility with the MIT library. New +applications should use a cryptographic hash function. The same +applies for des_string_to_2key(). + +des_cbc_cksum() produces an 8 byte checksum based on the input stream +(via CBC encryption). The last 4 bytes of the checksum are returned +and the complete 8 bytes are placed in I. This function is +used by Kerberos v4. Other applications should use +L etc. instead. + +des_quad_cksum() is a Kerberos v4 function. It returns a 4 byte +checksum from the input bytes. The algorithm can be iterated over the +input, depending on I, 1, 2, 3 or 4 times. If I is +non-NULL, the 8 bytes generated by each pass are written into +I. + +The following are DES-based tranformations: + +des_fcrypt() is a fast version of the unix crypt(3) function. This +version takes only a small amount of space relative to other fast +crypt() implementations. This is different to the normal crypt in +that the third parameter is the buffer that the return value is +written into. It needs to be at least 14 bytes long. This function +is thread safe, unlike the normal crypt. + +des_crypt() is a faster replacement for the normal system crypt(). +This function calls des_fcrypt() with a static array passed as the +third parameter. This emulates the normal non-thread safe semantics +of crypt(3). + +des_enc_write() writes I bytes to file descriptor I from +buffer I. The data is encrypted via I (default) +using I for the key and I as a starting vector. The actual +data send down I consists of 4 bytes (in network byte order) +containing the length of the following encrypted data. The encrypted +data then follows, padded with random data out to a multiple of 8 +bytes. + +des_enc_read() is used to read I bytes from file descriptor +I into buffer I. The data being read from I is assumed to +have come from des_enc_write() and is decrypted using I for +the key schedule and I for the initial vector. + +B The data format used by des_enc_write() and des_enc_read() +has a cryptographic weakness: When asked to write more than MAXWRITE +bytes, des_enc_write() will split the data into several chunks that +are all encrypted using the same IV. So don't use these functions +unless you are sure you know what you do (in which case you might not +want to use them anyway). They cannot handle non-blocking sockets. +des_enc_read() uses an internal state and thus cannot be used on +multiple files. + +I is used to specify the encryption mode to use with +des_enc_read() and des_end_write(). If set to I (the +default), des_pcbc_encrypt is used. If set to I +des_cbc_encrypt is used. + +=head1 NOTES + +Single-key DES is insecure due to its short key size. ECB mode is +not suitable for most applications; see L. + +The L library provides higher-level encryption functions. + +=head1 BUGS + +des_3cbc_encrypt() is flawed and must not be used in applications. + +des_cbc_encrypt() does not modify B; use des_ncbc_encrypt() +instead. + +des_cfb_encrypt() and des_ofb_encrypt() operates on input of 8 bits. +What this means is that if you set numbits to 12, and length to 2, the +first 12 bits will come from the 1st input byte and the low half of +the second input byte. The second 12 bits will have the low 8 bits +taken from the 3rd input byte and the top 4 bits taken from the 4th +input byte. The same holds for output. This function has been +implemented this way because most people will be using a multiple of 8 +and because once you get into pulling bytes input bytes apart things +get ugly! + +des_read_pw_string() is the most machine/OS dependent function and +normally generates the most problems when porting this code. + +=head1 CONFORMING TO + +ANSI X3.106 + +The B library was written to be source code compatible with +the MIT Kerberos library. + +=head1 SEE ALSO + +crypt(3), L, L, L + +=head1 HISTORY + +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(), des_read_password() and +des_string_to_key() are available in the MIT Kerberos library; +des_check_key_parity(), des_fixup_key_parity() and des_is_weak_key() +are available in newer versions of that library. + +des_set_key_checked() and des_set_key_unchecked() were added in +OpenSSL 0.9.5. + +des_generate_random_block(), des_init_random_number_generator(), +des_new_random_key(), des_set_random_generator_seed() and +des_set_sequence_number() and des_rand_data() are used in newer +versions of Kerberos but are not implemented here. + +des_random_key() generated cryptographically weak random data in +SSLeay and in OpenSSL prior version 0.9.5, as well as in the original +MIT library. + +=head1 AUTHOR + +Eric Young (eay@cryptsoft.com). Modified for the OpenSSL project +(http://www.openssl.org). + +=cut -- GitLab