test/destest.c

   1 /* crypto/des/destest.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58
  59 #include <stdio.h>
  60 #include <stdlib.h>
  61
  62 #include <openssl/e_os2.h>
  63 #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WINDOWS)
  64 # ifndef OPENSSL_SYS_MSDOS
  65 #  define OPENSSL_SYS_MSDOS
  66 # endif
  67 #endif
  68
  69 #ifndef OPENSSL_SYS_MSDOS
  70 # if !defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_VMS_DECC)
  71 #  include OPENSSL_UNISTD
  72 # endif
  73 #else
  74 # include <io.h>
  75 #endif
  76 #include <string.h>
  77
  78 #ifdef OPENSSL_NO_DES
  79 int main(int argc, char *argv[])
  80 {
  81     printf("No DES support\n");
  82     return (0);
  83 }
  84 #else
  85 # include <openssl/des.h>
  86
  87 # define crypt(c,s) (DES_crypt((c),(s)))
  88
  89 /* tisk tisk - the test keys don't all have odd parity :-( */
  90 /* test data */
  91 # define NUM_TESTS 34
  92 static unsigned char key_data[NUM_TESTS][8] = {
  93     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  94     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
  95     {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  96     {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
  97     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
  98     {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
  99     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 100     {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10},
 101     {0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57},
 102     {0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E},
 103     {0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86},
 104     {0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E},
 105     {0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6},
 106     {0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE},
 107     {0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6},
 108     {0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE},
 109     {0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16},
 110     {0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F},
 111     {0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46},
 112     {0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E},
 113     {0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76},
 114     {0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07},
 115     {0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F},
 116     {0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7},
 117     {0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF},
 118     {0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6},
 119     {0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF},
 120     {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 121     {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E},
 122     {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE},
 123     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 124     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
 125     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
 126     {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}
 127 };
 128
 129 static unsigned char plain_data[NUM_TESTS][8] = {
 130     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 131     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
 132     {0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
 133     {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
 134     {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
 135     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
 136     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 137     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
 138     {0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42},
 139     {0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA},
 140     {0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72},
 141     {0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A},
 142     {0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2},
 143     {0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A},
 144     {0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2},
 145     {0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A},
 146     {0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02},
 147     {0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A},
 148     {0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32},
 149     {0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA},
 150     {0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62},
 151     {0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2},
 152     {0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA},
 153     {0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92},
 154     {0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A},
 155     {0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2},
 156     {0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A},
 157     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
 158     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
 159     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
 160     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
 161     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 162     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 163     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
 164 };
 165
 166 static unsigned char cipher_data[NUM_TESTS][8] = {
 167     {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7},
 168     {0x73, 0x59, 0xB2, 0x16, 0x3E, 0x4E, 0xDC, 0x58},
 169     {0x95, 0x8E, 0x6E, 0x62, 0x7A, 0x05, 0x55, 0x7B},
 170     {0xF4, 0x03, 0x79, 0xAB, 0x9E, 0x0E, 0xC5, 0x33},
 171     {0x17, 0x66, 0x8D, 0xFC, 0x72, 0x92, 0x53, 0x2D},
 172     {0x8A, 0x5A, 0xE1, 0xF8, 0x1A, 0xB8, 0xF2, 0xDD},
 173     {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7},
 174     {0xED, 0x39, 0xD9, 0x50, 0xFA, 0x74, 0xBC, 0xC4},
 175     {0x69, 0x0F, 0x5B, 0x0D, 0x9A, 0x26, 0x93, 0x9B},
 176     {0x7A, 0x38, 0x9D, 0x10, 0x35, 0x4B, 0xD2, 0x71},
 177     {0x86, 0x8E, 0xBB, 0x51, 0xCA, 0xB4, 0x59, 0x9A},
 178     {0x71, 0x78, 0x87, 0x6E, 0x01, 0xF1, 0x9B, 0x2A},
 179     {0xAF, 0x37, 0xFB, 0x42, 0x1F, 0x8C, 0x40, 0x95},
 180     {0x86, 0xA5, 0x60, 0xF1, 0x0E, 0xC6, 0xD8, 0x5B},
 181     {0x0C, 0xD3, 0xDA, 0x02, 0x00, 0x21, 0xDC, 0x09},
 182     {0xEA, 0x67, 0x6B, 0x2C, 0xB7, 0xDB, 0x2B, 0x7A},
 183     {0xDF, 0xD6, 0x4A, 0x81, 0x5C, 0xAF, 0x1A, 0x0F},
 184     {0x5C, 0x51, 0x3C, 0x9C, 0x48, 0x86, 0xC0, 0x88},
 185     {0x0A, 0x2A, 0xEE, 0xAE, 0x3F, 0xF4, 0xAB, 0x77},
 186     {0xEF, 0x1B, 0xF0, 0x3E, 0x5D, 0xFA, 0x57, 0x5A},
 187     {0x88, 0xBF, 0x0D, 0xB6, 0xD7, 0x0D, 0xEE, 0x56},
 188     {0xA1, 0xF9, 0x91, 0x55, 0x41, 0x02, 0x0B, 0x56},
 189     {0x6F, 0xBF, 0x1C, 0xAF, 0xCF, 0xFD, 0x05, 0x56},
 190     {0x2F, 0x22, 0xE4, 0x9B, 0xAB, 0x7C, 0xA1, 0xAC},
 191     {0x5A, 0x6B, 0x61, 0x2C, 0xC2, 0x6C, 0xCE, 0x4A},
 192     {0x5F, 0x4C, 0x03, 0x8E, 0xD1, 0x2B, 0x2E, 0x41},
 193     {0x63, 0xFA, 0xC0, 0xD0, 0x34, 0xD9, 0xF7, 0x93},
 194     {0x61, 0x7B, 0x3A, 0x0C, 0xE8, 0xF0, 0x71, 0x00},
 195     {0xDB, 0x95, 0x86, 0x05, 0xF8, 0xC8, 0xC6, 0x06},
 196     {0xED, 0xBF, 0xD1, 0xC6, 0x6C, 0x29, 0xCC, 0xC7},
 197     {0x35, 0x55, 0x50, 0xB2, 0x15, 0x0E, 0x24, 0x51},
 198     {0xCA, 0xAA, 0xAF, 0x4D, 0xEA, 0xF1, 0xDB, 0xAE},
 199     {0xD5, 0xD4, 0x4F, 0xF7, 0x20, 0x68, 0x3D, 0x0D},
 200     {0x2A, 0x2B, 0xB0, 0x08, 0xDF, 0x97, 0xC2, 0xF2}
 201 };
 202
 203 static unsigned char cipher_ecb2[NUM_TESTS - 1][8] = {
 204     {0x92, 0x95, 0xB5, 0x9B, 0xB3, 0x84, 0x73, 0x6E},
 205     {0x19, 0x9E, 0x9D, 0x6D, 0xF3, 0x9A, 0xA8, 0x16},
 206     {0x2A, 0x4B, 0x4D, 0x24, 0x52, 0x43, 0x84, 0x27},
 207     {0x35, 0x84, 0x3C, 0x01, 0x9D, 0x18, 0xC5, 0xB6},
 208     {0x4A, 0x5B, 0x2F, 0x42, 0xAA, 0x77, 0x19, 0x25},
 209     {0xA0, 0x6B, 0xA9, 0xB8, 0xCA, 0x5B, 0x17, 0x8A},
 210     {0xAB, 0x9D, 0xB7, 0xFB, 0xED, 0x95, 0xF2, 0x74},
 211     {0x3D, 0x25, 0x6C, 0x23, 0xA7, 0x25, 0x2F, 0xD6},
 212     {0xB7, 0x6F, 0xAB, 0x4F, 0xBD, 0xBD, 0xB7, 0x67},
 213     {0x8F, 0x68, 0x27, 0xD6, 0x9C, 0xF4, 0x1A, 0x10},
 214     {0x82, 0x57, 0xA1, 0xD6, 0x50, 0x5E, 0x81, 0x85},
 215     {0xA2, 0x0F, 0x0A, 0xCD, 0x80, 0x89, 0x7D, 0xFA},
 216     {0xCD, 0x2A, 0x53, 0x3A, 0xDB, 0x0D, 0x7E, 0xF3},
 217     {0xD2, 0xC2, 0xBE, 0x27, 0xE8, 0x1B, 0x68, 0xE3},
 218     {0xE9, 0x24, 0xCF, 0x4F, 0x89, 0x3C, 0x5B, 0x0A},
 219     {0xA7, 0x18, 0xC3, 0x9F, 0xFA, 0x9F, 0xD7, 0x69},
 220     {0x77, 0x2C, 0x79, 0xB1, 0xD2, 0x31, 0x7E, 0xB1},
 221     {0x49, 0xAB, 0x92, 0x7F, 0xD0, 0x22, 0x00, 0xB7},
 222     {0xCE, 0x1C, 0x6C, 0x7D, 0x85, 0xE3, 0x4A, 0x6F},
 223     {0xBE, 0x91, 0xD6, 0xE1, 0x27, 0xB2, 0xE9, 0x87},
 224     {0x70, 0x28, 0xAE, 0x8F, 0xD1, 0xF5, 0x74, 0x1A},
 225     {0xAA, 0x37, 0x80, 0xBB, 0xF3, 0x22, 0x1D, 0xDE},
 226     {0xA6, 0xC4, 0xD2, 0x5E, 0x28, 0x93, 0xAC, 0xB3},
 227     {0x22, 0x07, 0x81, 0x5A, 0xE4, 0xB7, 0x1A, 0xAD},
 228     {0xDC, 0xCE, 0x05, 0xE7, 0x07, 0xBD, 0xF5, 0x84},
 229     {0x26, 0x1D, 0x39, 0x2C, 0xB3, 0xBA, 0xA5, 0x85},
 230     {0xB4, 0xF7, 0x0F, 0x72, 0xFB, 0x04, 0xF0, 0xDC},
 231     {0x95, 0xBA, 0xA9, 0x4E, 0x87, 0x36, 0xF2, 0x89},
 232     {0xD4, 0x07, 0x3A, 0xF1, 0x5A, 0x17, 0x82, 0x0E},
 233     {0xEF, 0x6F, 0xAF, 0xA7, 0x66, 0x1A, 0x7E, 0x89},
 234     {0xC1, 0x97, 0xF5, 0x58, 0x74, 0x8A, 0x20, 0xE7},
 235     {0x43, 0x34, 0xCF, 0xDA, 0x22, 0xC4, 0x86, 0xC8},
 236     {0x08, 0xD7, 0xB4, 0xFB, 0x62, 0x9D, 0x08, 0x85}
 237 };
 238
 239 static unsigned char cbc_key[8] =
 240     { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
 241 static unsigned char cbc2_key[8] =
 242     { 0xf1, 0xe0, 0xd3, 0xc2, 0xb5, 0xa4, 0x97, 0x86 };
 243 static unsigned char cbc3_key[8] =
 244     { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
 245 static unsigned char cbc_iv[8] =
 246     { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
 247 /*
 248  * Changed the following text constant to binary so it will work on ebcdic
 249  * machines :-)
 250  */
 251 /* static char cbc_data[40]="7654321 Now is the time for \0001"; */
 252 static unsigned char cbc_data[40] = {
 253     0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
 254     0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
 255     0x68, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20,
 256     0x66, 0x6F, 0x72, 0x20, 0x00, 0x31, 0x00, 0x00,
 257     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 258 };
 259
 260 static unsigned char cbc_ok[32] = {
 261     0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
 262     0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb,
 263     0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68,
 264     0x1d, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4
 265 };
 266
 267 # ifdef SCREW_THE_PARITY
 268 #  error "SCREW_THE_PARITY is not ment to be defined."
 269 #  error "Original vectors are preserved for reference only."
 270 static unsigned char cbc2_key[8] =
 271     { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 };
 272 static unsigned char xcbc_ok[32] = {
 273     0x86, 0x74, 0x81, 0x0D, 0x61, 0xA4, 0xA5, 0x48,
 274     0xB9, 0x93, 0x03, 0xE1, 0xB8, 0xBB, 0xBD, 0xBD,
 275     0x64, 0x30, 0x0B, 0xB9, 0x06, 0x65, 0x81, 0x76,
 276     0x04, 0x1D, 0x77, 0x62, 0x17, 0xCA, 0x2B, 0xD2,
 277 };
 278 # else
 279 static unsigned char xcbc_ok[32] = {
 280     0x84, 0x6B, 0x29, 0x14, 0x85, 0x1E, 0x9A, 0x29,
 281     0x54, 0x73, 0x2F, 0x8A, 0xA0, 0xA6, 0x11, 0xC1,
 282     0x15, 0xCD, 0xC2, 0xD7, 0x95, 0x1B, 0x10, 0x53,
 283     0xA6, 0x3C, 0x5E, 0x03, 0xB2, 0x1A, 0xA3, 0xC4,
 284 };
 285 # endif
 286
 287 static unsigned char cbc3_ok[32] = {
 288     0x3F, 0xE3, 0x01, 0xC9, 0x62, 0xAC, 0x01, 0xD0,
 289     0x22, 0x13, 0x76, 0x3C, 0x1C, 0xBD, 0x4C, 0xDC,
 290     0x79, 0x96, 0x57, 0xC0, 0x64, 0xEC, 0xF5, 0xD4,
 291     0x1C, 0x67, 0x38, 0x12, 0xCF, 0xDE, 0x96, 0x75
 292 };
 293
 294 static unsigned char pcbc_ok[32] = {
 295     0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
 296     0x6d, 0xec, 0xb4, 0x70, 0xa0, 0xe5, 0x6b, 0x15,
 297     0xae, 0xa6, 0xbf, 0x61, 0xed, 0x7d, 0x9c, 0x9f,
 298     0xf7, 0x17, 0x46, 0x3b, 0x8a, 0xb3, 0xcc, 0x88
 299 };
 300
 301 static unsigned char cfb_key[8] =
 302     { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
 303 static unsigned char cfb_iv[8] =
 304     { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
 305 static unsigned char cfb_buf1[40], cfb_buf2[40], cfb_tmp[8];
 306 static unsigned char plain[24] = {
 307     0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73,
 308     0x20, 0x74, 0x68, 0x65, 0x20, 0x74,
 309     0x69, 0x6d, 0x65, 0x20, 0x66, 0x6f,
 310     0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20
 311 };
 312
 313 static unsigned char cfb_cipher8[24] = {
 314     0xf3, 0x1f, 0xda, 0x07, 0x01, 0x14, 0x62, 0xee, 0x18, 0x7f, 0x43, 0xd8,
 315     0x0a, 0x7c, 0xd9, 0xb5, 0xb0, 0xd2, 0x90, 0xda, 0x6e, 0x5b, 0x9a, 0x87
 316 };
 317
 318 static unsigned char cfb_cipher16[24] = {
 319     0xF3, 0x09, 0x87, 0x87, 0x7F, 0x57, 0xF7, 0x3C, 0x36, 0xB6, 0xDB, 0x70,
 320     0xD8, 0xD5, 0x34, 0x19, 0xD3, 0x86, 0xB2, 0x23, 0xB7, 0xB2, 0xAD, 0x1B
 321 };
 322
 323 static unsigned char cfb_cipher32[24] = {
 324     0xF3, 0x09, 0x62, 0x49, 0xA4, 0xDF, 0xA4, 0x9F, 0x33, 0xDC, 0x7B, 0xAD,
 325     0x4C, 0xC8, 0x9F, 0x64, 0xE4, 0x53, 0xE5, 0xEC, 0x67, 0x20, 0xDA, 0xB6
 326 };
 327
 328 static unsigned char cfb_cipher48[24] = {
 329     0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x30, 0xB5, 0x15, 0xEC, 0xBB, 0x85,
 330     0x97, 0x5A, 0x13, 0x8C, 0x68, 0x60, 0xE2, 0x38, 0x34, 0x3C, 0xDC, 0x1F
 331 };
 332
 333 static unsigned char cfb_cipher64[24] = {
 334     0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x6E, 0x51, 0xA6, 0x9E, 0x83, 0x9B,
 335     0x1A, 0x92, 0xF7, 0x84, 0x03, 0x46, 0x71, 0x33, 0x89, 0x8E, 0xA6, 0x22
 336 };
 337
 338 static unsigned char ofb_key[8] =
 339     { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
 340 static unsigned char ofb_iv[8] =
 341     { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
 342 static unsigned char ofb_buf1[24], ofb_buf2[24], ofb_tmp[8];
 343 static unsigned char ofb_cipher[24] = {
 344     0xf3, 0x09, 0x62, 0x49, 0xc7, 0xf4, 0x6e, 0x51,
 345     0x35, 0xf2, 0x4a, 0x24, 0x2e, 0xeb, 0x3d, 0x3f,
 346     0x3d, 0x6d, 0x5b, 0xe3, 0x25, 0x5a, 0xf8, 0xc3
 347 };
 348 static DES_LONG cbc_cksum_ret = 0xF7FE62B4L;
 349 static unsigned char cbc_cksum_data[8] =
 350     { 0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 };
 351
 352 static char *pt(unsigned char *p);
 353 static int cfb_test(int bits, unsigned char *cfb_cipher);
 354 static int cfb64_test(unsigned char *cfb_cipher);
 355 static int ede_cfb64_test(unsigned char *cfb_cipher);
 356 int main(int argc, char *argv[])
 357 {
 358     int j, err = 0;
 359     unsigned int i;
 360     DES_cblock in, out, outin, iv3;
 361     DES_key_schedule ks, ks2, ks3;
 362     unsigned char cbc_in[40];
 363     unsigned char cbc_out[40];
 364     DES_LONG cs;
 365     unsigned char cret[8];
 366     DES_LONG lqret[4];
 367     int num;
 368     char *str;
 369
 370     printf("Doing ecb\n");
 371     for (i = 0; i < NUM_TESTS; i++) {
 372         DES_set_key_unchecked(&key_data[i], &ks);
 373         memcpy(in, plain_data[i], 8);
 374         memset(out, 0, 8);
 375         memset(outin, 0, 8);
 376         DES_ecb_encrypt(&in, &out, &ks, DES_ENCRYPT);
 377         DES_ecb_encrypt(&out, &outin, &ks, DES_DECRYPT);
 378
 379         if (memcmp(out, cipher_data[i], 8) != 0) {
 380             printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
 381                    i + 1, pt(key_data[i]), pt(in), pt(cipher_data[i]),
 382                    pt(out));
 383             err = 1;
 384         }
 385         if (memcmp(in, outin, 8) != 0) {
 386             printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
 387                    i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
 388             err = 1;
 389         }
 390     }
 391
 392 # ifndef LIBDES_LIT
 393     printf("Doing ede ecb\n");
 394     for (i = 0; i < (NUM_TESTS - 2); i++) {
 395         DES_set_key_unchecked(&key_data[i], &ks);
 396         DES_set_key_unchecked(&key_data[i + 1], &ks2);
 397         DES_set_key_unchecked(&key_data[i + 2], &ks3);
 398         memcpy(in, plain_data[i], 8);
 399         memset(out, 0, 8);
 400         memset(outin, 0, 8);
 401         DES_ecb3_encrypt(&in,&out,&ks,&ks2,&ks,DES_ENCRYPT);
 402         DES_ecb3_encrypt(&out,&outin,&ks,&ks2,&ks,DES_DECRYPT);
 403
 404         if (memcmp(out, cipher_ecb2[i], 8) != 0) {
 405             printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
 406                    i + 1, pt(key_data[i]), pt(in), pt(cipher_ecb2[i]),
 407                    pt(out));
 408             err = 1;
 409         }
 410         if (memcmp(in, outin, 8) != 0) {
 411             printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
 412                    i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
 413             err = 1;
 414         }
 415     }
 416 # endif
 417
 418     printf("Doing cbc\n");
 419     if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
 420         printf("Key error %d\n", j);
 421         err = 1;
 422     }
 423     memset(cbc_out, 0, 40);
 424     memset(cbc_in, 0, 40);
 425     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
 426     DES_ncbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, &ks,
 427                      &iv3, DES_ENCRYPT);
 428     if (memcmp(cbc_out, cbc_ok, 32) != 0) {
 429         printf("cbc_encrypt encrypt error\n");
 430         err = 1;
 431     }
 432
 433     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
 434     DES_ncbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, &ks,
 435                      &iv3, DES_DECRYPT);
 436     if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data)) != 0) {
 437         printf("cbc_encrypt decrypt error\n");
 438         err = 1;
 439     }
 440 # ifndef LIBDES_LIT
 441     printf("Doing desx cbc\n");
 442     if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
 443         printf("Key error %d\n", j);
 444         err = 1;
 445     }
 446     memset(cbc_out, 0, 40);
 447     memset(cbc_in, 0, 40);
 448     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
 449     DES_xcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, &ks,
 450                      &iv3, &cbc2_key, &cbc3_key, DES_ENCRYPT);
 451     if (memcmp(cbc_out, xcbc_ok, 32) != 0) {
 452         printf("des_xcbc_encrypt encrypt error\n");
 453         err = 1;
 454     }
 455     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
 456     DES_xcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, &ks,
 457                      &iv3, &cbc2_key, &cbc3_key, DES_DECRYPT);
 458     if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
 459         printf("des_xcbc_encrypt decrypt error\n");
 460         err = 1;
 461     }
 462 # endif
 463
 464     printf("Doing ede cbc\n");
 465     if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
 466         printf("Key error %d\n", j);
 467         err = 1;
 468     }
 469     if ((j = DES_set_key_checked(&cbc2_key, &ks2)) != 0) {
 470         printf("Key error %d\n", j);
 471         err = 1;
 472     }
 473     if ((j = DES_set_key_checked(&cbc3_key, &ks3)) != 0) {
 474         printf("Key error %d\n", j);
 475         err = 1;
 476     }
 477     memset(cbc_out, 0, 40);
 478     memset(cbc_in, 0, 40);
 479     i = strlen((char *)cbc_data) + 1;
 480     /* i=((i+7)/8)*8; */
 481     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
 482
 483     DES_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, &ks, &ks2, &ks3, &iv3,
 484                          DES_ENCRYPT);
 485     DES_ede3_cbc_encrypt(&(cbc_data[16]), &(cbc_out[16]), i - 16, &ks, &ks2,
 486                          &ks3, &iv3, DES_ENCRYPT);
 487     if (memcmp
 488         (cbc_out, cbc3_ok,
 489          (unsigned int)(strlen((char *)cbc_data) + 1 + 7) / 8 * 8) != 0) {
 490         unsigned int n;
 491
 492         printf("des_ede3_cbc_encrypt encrypt error\n");
 493         for (n = 0; n < i; ++n)
 494             printf(" %02x", cbc_out[n]);
 495         printf("\n");
 496         for (n = 0; n < i; ++n)
 497             printf(" %02x", cbc3_ok[n]);
 498         printf("\n");
 499         err = 1;
 500     }
 501
 502     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
 503     DES_ede3_cbc_encrypt(cbc_out, cbc_in, i, &ks, &ks2, &ks3, &iv3, DES_DECRYPT);
 504     if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
 505         unsigned int n;
 506
 507         printf("DES_ede3_cbc_encrypt decrypt error\n");
 508         for (n = 0; n < i; ++n)
 509             printf(" %02x", cbc_data[n]);
 510         printf("\n");
 511         for (n = 0; n < i; ++n)
 512             printf(" %02x", cbc_in[n]);
 513         printf("\n");
 514         err = 1;
 515     }
 516 # ifndef LIBDES_LIT
 517     printf("Doing pcbc\n");
 518     if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
 519         printf("Key error %d\n", j);
 520         err = 1;
 521     }
 522     memset(cbc_out, 0, 40);
 523     memset(cbc_in, 0, 40);
 524     DES_pcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, &ks,
 525                      &cbc_iv, DES_ENCRYPT);
 526     if (memcmp(cbc_out, pcbc_ok, 32) != 0) {
 527         printf("pcbc_encrypt encrypt error\n");
 528         err = 1;
 529     }
 530     DES_pcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, &ks,
 531                      &cbc_iv, DES_DECRYPT);
 532     if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
 533         printf("pcbc_encrypt decrypt error\n");
 534         err = 1;
 535     }
 536
 537     printf("Doing ");
 538     printf("cfb8 ");
 539     err += cfb_test(8, cfb_cipher8);
 540     printf("cfb16 ");
 541     err += cfb_test(16, cfb_cipher16);
 542     printf("cfb32 ");
 543     err += cfb_test(32, cfb_cipher32);
 544     printf("cfb48 ");
 545     err += cfb_test(48, cfb_cipher48);
 546     printf("cfb64 ");
 547     err += cfb_test(64, cfb_cipher64);
 548
 549     printf("cfb64() ");
 550     err += cfb64_test(cfb_cipher64);
 551
 552     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 553     for (i = 0; i < sizeof(plain); i++)
 554         DES_cfb_encrypt(&(plain[i]), &(cfb_buf1[i]),
 555                         8, 1, &ks, &cfb_tmp, DES_ENCRYPT);
 556     if (memcmp(cfb_cipher8, cfb_buf1, sizeof(plain)) != 0) {
 557         printf("cfb_encrypt small encrypt error\n");
 558         err = 1;
 559     }
 560
 561     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 562     for (i = 0; i < sizeof(plain); i++)
 563         DES_cfb_encrypt(&(cfb_buf1[i]), &(cfb_buf2[i]),
 564                         8, 1, &ks, &cfb_tmp, DES_DECRYPT);
 565     if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
 566         printf("cfb_encrypt small decrypt error\n");
 567         err = 1;
 568     }
 569
 570     printf("ede_cfb64() ");
 571     err += ede_cfb64_test(cfb_cipher64);
 572
 573     printf("done\n");
 574
 575     printf("Doing ofb\n");
 576     DES_set_key_checked(&ofb_key, &ks);
 577     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
 578     DES_ofb_encrypt(plain, ofb_buf1, 64, sizeof(plain) / 8, &ks, &ofb_tmp);
 579     if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
 580         printf("ofb_encrypt encrypt error\n");
 581         printf("%02X %02X %02X %02X %02X %02X %02X %02X\n",
 582                ofb_buf1[8 + 0], ofb_buf1[8 + 1], ofb_buf1[8 + 2],
 583                ofb_buf1[8 + 3], ofb_buf1[8 + 4], ofb_buf1[8 + 5],
 584                ofb_buf1[8 + 6], ofb_buf1[8 + 7]);
 585         printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", ofb_buf1[8 + 0],
 586                ofb_cipher[8 + 1], ofb_cipher[8 + 2], ofb_cipher[8 + 3],
 587                ofb_buf1[8 + 4], ofb_cipher[8 + 5], ofb_cipher[8 + 6],
 588                ofb_cipher[8 + 7]);
 589         err = 1;
 590     }
 591     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
 592     DES_ofb_encrypt(ofb_buf1, ofb_buf2, 64, sizeof(ofb_buf1) / 8, &ks,
 593                     &ofb_tmp);
 594     if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
 595         printf("ofb_encrypt decrypt error\n");
 596         printf("%02X %02X %02X %02X %02X %02X %02X %02X\n",
 597                ofb_buf2[8 + 0], ofb_buf2[8 + 1], ofb_buf2[8 + 2],
 598                ofb_buf2[8 + 3], ofb_buf2[8 + 4], ofb_buf2[8 + 5],
 599                ofb_buf2[8 + 6], ofb_buf2[8 + 7]);
 600         printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", plain[8 + 0],
 601                plain[8 + 1], plain[8 + 2], plain[8 + 3], plain[8 + 4],
 602                plain[8 + 5], plain[8 + 6], plain[8 + 7]);
 603         err = 1;
 604     }
 605
 606     printf("Doing ofb64\n");
 607     DES_set_key_checked(&ofb_key, &ks);
 608     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
 609     memset(ofb_buf1, 0, sizeof(ofb_buf1));
 610     memset(ofb_buf2, 0, sizeof(ofb_buf1));
 611     num = 0;
 612     for (i = 0; i < sizeof(plain); i++) {
 613         DES_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, &ks, &ofb_tmp, &num);
 614     }
 615     if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
 616         printf("ofb64_encrypt encrypt error\n");
 617         err = 1;
 618     }
 619     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
 620     num = 0;
 621     DES_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ofb_tmp,
 622                       &num);
 623     if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
 624         printf("ofb64_encrypt decrypt error\n");
 625         err = 1;
 626     }
 627
 628     printf("Doing ede_ofb64\n");
 629     DES_set_key_checked(&ofb_key, &ks);
 630     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
 631     memset(ofb_buf1, 0, sizeof(ofb_buf1));
 632     memset(ofb_buf2, 0, sizeof(ofb_buf1));
 633     num = 0;
 634     for (i = 0; i < sizeof(plain); i++) {
 635         DES_ede3_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, &ks, &ks,
 636                                &ks, &ofb_tmp, &num);
 637     }
 638     if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
 639         printf("ede_ofb64_encrypt encrypt error\n");
 640         err = 1;
 641     }
 642     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
 643     num = 0;
 644     DES_ede3_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ks, &ks,
 645                            &ofb_tmp, &num);
 646     if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
 647         printf("ede_ofb64_encrypt decrypt error\n");
 648         err = 1;
 649     }
 650
 651     printf("Doing cbc_cksum\n");
 652     DES_set_key_checked(&cbc_key, &ks);
 653     cs = DES_cbc_cksum(cbc_data, &cret, strlen((char *)cbc_data), &ks,
 654                        &cbc_iv);
 655     if (cs != cbc_cksum_ret) {
 656         printf("bad return value (%08lX), should be %08lX\n",
 657                (unsigned long)cs, (unsigned long)cbc_cksum_ret);
 658         err = 1;
 659     }
 660     if (memcmp(cret, cbc_cksum_data, 8) != 0) {
 661         printf("bad cbc_cksum block returned\n");
 662         err = 1;
 663     }
 664
 665     printf("Doing quad_cksum\n");
 666     cs = DES_quad_cksum(cbc_data, (DES_cblock *)lqret,
 667                         (long)strlen((char *)cbc_data), 2,
 668                         (DES_cblock *)cbc_iv);
 669     if (cs != 0x70d7a63aL) {
 670         printf("quad_cksum error, ret %08lx should be 70d7a63a\n",
 671                (unsigned long)cs);
 672         err = 1;
 673     }
 674     if (lqret[0] != 0x327eba8dL) {
 675         printf("quad_cksum error, out[0] %08lx is not %08lx\n",
 676                (unsigned long)lqret[0], 0x327eba8dUL);
 677         err = 1;
 678     }
 679     if (lqret[1] != 0x201a49ccL) {
 680         printf("quad_cksum error, out[1] %08lx is not %08lx\n",
 681                (unsigned long)lqret[1], 0x201a49ccUL);
 682         err = 1;
 683     }
 684     if (lqret[2] != 0x70d7a63aL) {
 685         printf("quad_cksum error, out[2] %08lx is not %08lx\n",
 686                (unsigned long)lqret[2], 0x70d7a63aUL);
 687         err = 1;
 688     }
 689     if (lqret[3] != 0x501c2c26L) {
 690         printf("quad_cksum error, out[3] %08lx is not %08lx\n",
 691                (unsigned long)lqret[3], 0x501c2c26UL);
 692         err = 1;
 693     }
 694 # endif
 695
 696     printf("input word alignment test");
 697     for (i = 0; i < 4; i++) {
 698         printf(" %d", i);
 699         DES_ncbc_encrypt(&(cbc_out[i]), cbc_in,
 700                          strlen((char *)cbc_data) + 1, &ks,
 701                          &cbc_iv, DES_ENCRYPT);
 702     }
 703     printf("\noutput word alignment test");
 704     for (i = 0; i < 4; i++) {
 705         printf(" %d", i);
 706         DES_ncbc_encrypt(cbc_out, &(cbc_in[i]),
 707                          strlen((char *)cbc_data) + 1, &ks,
 708                          &cbc_iv, DES_ENCRYPT);
 709     }
 710     printf("\n");
 711     printf("fast crypt test ");
 712     str = crypt("testing", "ef");
 713     if (strcmp("efGnQx2725bI2", str) != 0) {
 714         printf("fast crypt error, %s should be efGnQx2725bI2\n", str);
 715         err = 1;
 716     }
 717     str = crypt("bca76;23", "yA");
 718     if (strcmp("yA1Rp/1hZXIJk", str) != 0) {
 719         printf("fast crypt error, %s should be yA1Rp/1hZXIJk\n", str);
 720         err = 1;
 721     }
 722 # ifdef OPENSSL_SYS_NETWARE
 723     if (err)
 724         printf("ERROR: %d\n", err);
 725 # endif
 726     printf("\n");
 727     return (err);
 728 }
 729
 730 static char *pt(unsigned char *p)
 731 {
 732     static char bufs[10][20];
 733     static int bnum = 0;
 734     char *ret;
 735     int i;
 736     static char *f = "0123456789ABCDEF";
 737
 738     ret = &(bufs[bnum++][0]);
 739     bnum %= 10;
 740     for (i = 0; i < 8; i++) {
 741         ret[i * 2] = f[(p[i] >> 4) & 0xf];
 742         ret[i * 2 + 1] = f[p[i] & 0xf];
 743     }
 744     ret[16] = '\0';
 745     return (ret);
 746 }
 747
 748 # ifndef LIBDES_LIT
 749
 750 static int cfb_test(int bits, unsigned char *cfb_cipher)
 751 {
 752     DES_key_schedule ks;
 753     int i, err = 0;
 754
 755     DES_set_key_checked(&cfb_key, &ks);
 756     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 757     DES_cfb_encrypt(plain, cfb_buf1, bits, sizeof(plain), &ks, &cfb_tmp,
 758                     DES_ENCRYPT);
 759     if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
 760         err = 1;
 761         printf("cfb_encrypt encrypt error\n");
 762         for (i = 0; i < 24; i += 8)
 763             printf("%s\n", pt(&(cfb_buf1[i])));
 764     }
 765     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 766     DES_cfb_encrypt(cfb_buf1, cfb_buf2, bits, sizeof(plain), &ks, &cfb_tmp,
 767                     DES_DECRYPT);
 768     if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
 769         err = 1;
 770         printf("cfb_encrypt decrypt error\n");
 771         for (i = 0; i < 24; i += 8)
 772             printf("%s\n", pt(&(cfb_buf1[i])));
 773     }
 774     return (err);
 775 }
 776
 777 static int cfb64_test(unsigned char *cfb_cipher)
 778 {
 779     DES_key_schedule ks;
 780     int err = 0, i, n;
 781
 782     DES_set_key_checked(&cfb_key, &ks);
 783     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 784     n = 0;
 785     DES_cfb64_encrypt(plain, cfb_buf1, 12, &ks, &cfb_tmp, &n, DES_ENCRYPT);
 786     DES_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]), sizeof(plain) - 12, &ks,
 787                       &cfb_tmp, &n, DES_ENCRYPT);
 788     if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
 789         err = 1;
 790         printf("cfb_encrypt encrypt error\n");
 791         for (i = 0; i < 24; i += 8)
 792             printf("%s\n", pt(&(cfb_buf1[i])));
 793     }
 794     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 795     n = 0;
 796     DES_cfb64_encrypt(cfb_buf1, cfb_buf2, 17, &ks, &cfb_tmp, &n, DES_DECRYPT);
 797     DES_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
 798                       sizeof(plain) - 17, &ks, &cfb_tmp, &n, DES_DECRYPT);
 799     if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
 800         err = 1;
 801         printf("cfb_encrypt decrypt error\n");
 802         for (i = 0; i < 24; i += 8)
 803             printf("%s\n", pt(&(cfb_buf2[i])));
 804     }
 805     return (err);
 806 }
 807
 808 static int ede_cfb64_test(unsigned char *cfb_cipher)
 809 {
 810     DES_key_schedule ks;
 811     int err = 0, i, n;
 812
 813     DES_set_key_checked(&cfb_key, &ks);
 814     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 815     n = 0;
 816     DES_ede3_cfb64_encrypt(plain, cfb_buf1, 12, &ks, &ks, &ks, &cfb_tmp, &n,
 817                            DES_ENCRYPT);
 818     DES_ede3_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]),
 819                            sizeof(plain) - 12, &ks, &ks, &ks,
 820                            &cfb_tmp, &n, DES_ENCRYPT);
 821     if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
 822         err = 1;
 823         printf("ede_cfb_encrypt encrypt error\n");
 824         for (i = 0; i < 24; i += 8)
 825             printf("%s\n", pt(&(cfb_buf1[i])));
 826     }
 827     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 828     n = 0;
 829     DES_ede3_cfb64_encrypt(cfb_buf1, cfb_buf2, (long)17, &ks, &ks, &ks,
 830                            &cfb_tmp, &n, DES_DECRYPT);
 831     DES_ede3_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
 832                            sizeof(plain) - 17, &ks, &ks, &ks,
 833                            &cfb_tmp, &n, DES_DECRYPT);
 834     if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
 835         err = 1;
 836         printf("ede_cfb_encrypt decrypt error\n");
 837         for (i = 0; i < 24; i += 8)
 838             printf("%s\n", pt(&(cfb_buf2[i])));
 839     }
 840     return (err);
 841 }
 842
 843 # endif
 844 #endif