test/destest.c

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