crypto/des/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
 349 # if 0
 350 static DES_LONG cbc_cksum_ret = 0xB462FEF7L;
 351 # else
 352 static DES_LONG cbc_cksum_ret = 0xF7FE62B4L;
 353 # endif
 354 static unsigned char cbc_cksum_data[8] =
 355     { 0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 };
 356
 357 static char *pt(unsigned char *p);
 358 static int cfb_test(int bits, unsigned char *cfb_cipher);
 359 static int cfb64_test(unsigned char *cfb_cipher);
 360 static int ede_cfb64_test(unsigned char *cfb_cipher);
 361 int main(int argc, char *argv[])
 362 {
 363     int j, err = 0;
 364     unsigned int i;
 365     des_cblock in, out, outin, iv3;
 366     des_key_schedule ks, ks2, ks3;
 367     unsigned char cbc_in[40];
 368     unsigned char cbc_out[40];
 369     DES_LONG cs;
 370     unsigned char cret[8];
 371     DES_LONG lqret[4];
 372     int num;
 373     char *str;
 374
 375     printf("Doing ecb\n");
 376     for (i = 0; i < NUM_TESTS; i++) {
 377         DES_set_key_unchecked(&key_data[i], &ks);
 378         memcpy(in, plain_data[i], 8);
 379         memset(out, 0, 8);
 380         memset(outin, 0, 8);
 381         des_ecb_encrypt(&in, &out, ks, DES_ENCRYPT);
 382         des_ecb_encrypt(&out, &outin, ks, DES_DECRYPT);
 383
 384         if (memcmp(out, cipher_data[i], 8) != 0) {
 385             printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
 386                    i + 1, pt(key_data[i]), pt(in), pt(cipher_data[i]),
 387                    pt(out));
 388             err = 1;
 389         }
 390         if (memcmp(in, outin, 8) != 0) {
 391             printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
 392                    i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
 393             err = 1;
 394         }
 395     }
 396
 397 # ifndef LIBDES_LIT
 398     printf("Doing ede ecb\n");
 399     for (i = 0; i < (NUM_TESTS - 2); i++) {
 400         DES_set_key_unchecked(&key_data[i], &ks);
 401         DES_set_key_unchecked(&key_data[i + 1], &ks2);
 402         DES_set_key_unchecked(&key_data[i + 2], &ks3);
 403         memcpy(in, plain_data[i], 8);
 404         memset(out, 0, 8);
 405         memset(outin, 0, 8);
 406         des_ecb2_encrypt(&in, &out, ks, ks2, DES_ENCRYPT);
 407         des_ecb2_encrypt(&out, &outin, ks, ks2, DES_DECRYPT);
 408
 409         if (memcmp(out, cipher_ecb2[i], 8) != 0) {
 410             printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
 411                    i + 1, pt(key_data[i]), pt(in), pt(cipher_ecb2[i]),
 412                    pt(out));
 413             err = 1;
 414         }
 415         if (memcmp(in, outin, 8) != 0) {
 416             printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
 417                    i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
 418             err = 1;
 419         }
 420     }
 421 # endif
 422
 423     printf("Doing cbc\n");
 424     if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
 425         printf("Key error %d\n", j);
 426         err = 1;
 427     }
 428     memset(cbc_out, 0, 40);
 429     memset(cbc_in, 0, 40);
 430     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
 431     des_ncbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, ks,
 432                      &iv3, DES_ENCRYPT);
 433     if (memcmp(cbc_out, cbc_ok, 32) != 0) {
 434         printf("cbc_encrypt encrypt error\n");
 435         err = 1;
 436     }
 437
 438     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
 439     des_ncbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, ks,
 440                      &iv3, DES_DECRYPT);
 441     if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data)) != 0) {
 442         printf("cbc_encrypt decrypt error\n");
 443         err = 1;
 444     }
 445 # ifndef LIBDES_LIT
 446     printf("Doing desx cbc\n");
 447     if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
 448         printf("Key error %d\n", j);
 449         err = 1;
 450     }
 451     memset(cbc_out, 0, 40);
 452     memset(cbc_in, 0, 40);
 453     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
 454     des_xcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, ks,
 455                      &iv3, &cbc2_key, &cbc3_key, DES_ENCRYPT);
 456     if (memcmp(cbc_out, xcbc_ok, 32) != 0) {
 457         printf("des_xcbc_encrypt encrypt error\n");
 458         err = 1;
 459     }
 460     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
 461     des_xcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, ks,
 462                      &iv3, &cbc2_key, &cbc3_key, DES_DECRYPT);
 463     if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
 464         printf("des_xcbc_encrypt decrypt error\n");
 465         err = 1;
 466     }
 467 # endif
 468
 469     printf("Doing ede cbc\n");
 470     if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
 471         printf("Key error %d\n", j);
 472         err = 1;
 473     }
 474     if ((j = DES_set_key_checked(&cbc2_key, &ks2)) != 0) {
 475         printf("Key error %d\n", j);
 476         err = 1;
 477     }
 478     if ((j = DES_set_key_checked(&cbc3_key, &ks3)) != 0) {
 479         printf("Key error %d\n", j);
 480         err = 1;
 481     }
 482     memset(cbc_out, 0, 40);
 483     memset(cbc_in, 0, 40);
 484     i = strlen((char *)cbc_data) + 1;
 485     /* i=((i+7)/8)*8; */
 486     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
 487
 488     des_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, ks, ks2, ks3, &iv3,
 489                          DES_ENCRYPT);
 490     des_ede3_cbc_encrypt(&(cbc_data[16]), &(cbc_out[16]), i - 16, ks, ks2,
 491                          ks3, &iv3, DES_ENCRYPT);
 492     if (memcmp
 493         (cbc_out, cbc3_ok,
 494          (unsigned int)(strlen((char *)cbc_data) + 1 + 7) / 8 * 8) != 0) {
 495         unsigned int n;
 496
 497         printf("des_ede3_cbc_encrypt encrypt error\n");
 498         for (n = 0; n < i; ++n)
 499             printf(" %02x", cbc_out[n]);
 500         printf("\n");
 501         for (n = 0; n < i; ++n)
 502             printf(" %02x", cbc3_ok[n]);
 503         printf("\n");
 504         err = 1;
 505     }
 506
 507     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
 508     des_ede3_cbc_encrypt(cbc_out, cbc_in, i, ks, ks2, ks3, &iv3, DES_DECRYPT);
 509     if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
 510         unsigned int n;
 511
 512         printf("des_ede3_cbc_encrypt decrypt error\n");
 513         for (n = 0; n < i; ++n)
 514             printf(" %02x", cbc_data[n]);
 515         printf("\n");
 516         for (n = 0; n < i; ++n)
 517             printf(" %02x", cbc_in[n]);
 518         printf("\n");
 519         err = 1;
 520     }
 521 # ifndef LIBDES_LIT
 522     printf("Doing pcbc\n");
 523     if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
 524         printf("Key error %d\n", j);
 525         err = 1;
 526     }
 527     memset(cbc_out, 0, 40);
 528     memset(cbc_in, 0, 40);
 529     des_pcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, ks,
 530                      &cbc_iv, DES_ENCRYPT);
 531     if (memcmp(cbc_out, pcbc_ok, 32) != 0) {
 532         printf("pcbc_encrypt encrypt error\n");
 533         err = 1;
 534     }
 535     des_pcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, ks,
 536                      &cbc_iv, DES_DECRYPT);
 537     if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
 538         printf("pcbc_encrypt decrypt error\n");
 539         err = 1;
 540     }
 541
 542     printf("Doing ");
 543     printf("cfb8 ");
 544     err += cfb_test(8, cfb_cipher8);
 545     printf("cfb16 ");
 546     err += cfb_test(16, cfb_cipher16);
 547     printf("cfb32 ");
 548     err += cfb_test(32, cfb_cipher32);
 549     printf("cfb48 ");
 550     err += cfb_test(48, cfb_cipher48);
 551     printf("cfb64 ");
 552     err += cfb_test(64, cfb_cipher64);
 553
 554     printf("cfb64() ");
 555     err += cfb64_test(cfb_cipher64);
 556
 557     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 558     for (i = 0; i < sizeof(plain); i++)
 559         des_cfb_encrypt(&(plain[i]), &(cfb_buf1[i]),
 560                         8, 1, ks, &cfb_tmp, DES_ENCRYPT);
 561     if (memcmp(cfb_cipher8, cfb_buf1, sizeof(plain)) != 0) {
 562         printf("cfb_encrypt small encrypt error\n");
 563         err = 1;
 564     }
 565
 566     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 567     for (i = 0; i < sizeof(plain); i++)
 568         des_cfb_encrypt(&(cfb_buf1[i]), &(cfb_buf2[i]),
 569                         8, 1, ks, &cfb_tmp, DES_DECRYPT);
 570     if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
 571         printf("cfb_encrypt small decrypt error\n");
 572         err = 1;
 573     }
 574
 575     printf("ede_cfb64() ");
 576     err += ede_cfb64_test(cfb_cipher64);
 577
 578     printf("done\n");
 579
 580     printf("Doing ofb\n");
 581     DES_set_key_checked(&ofb_key, &ks);
 582     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
 583     des_ofb_encrypt(plain, ofb_buf1, 64, sizeof(plain) / 8, ks, &ofb_tmp);
 584     if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
 585         printf("ofb_encrypt encrypt error\n");
 586         printf("%02X %02X %02X %02X %02X %02X %02X %02X\n",
 587                ofb_buf1[8 + 0], ofb_buf1[8 + 1], ofb_buf1[8 + 2],
 588                ofb_buf1[8 + 3], ofb_buf1[8 + 4], ofb_buf1[8 + 5],
 589                ofb_buf1[8 + 6], ofb_buf1[8 + 7]);
 590         printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", ofb_buf1[8 + 0],
 591                ofb_cipher[8 + 1], ofb_cipher[8 + 2], ofb_cipher[8 + 3],
 592                ofb_buf1[8 + 4], ofb_cipher[8 + 5], ofb_cipher[8 + 6],
 593                ofb_cipher[8 + 7]);
 594         err = 1;
 595     }
 596     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
 597     des_ofb_encrypt(ofb_buf1, ofb_buf2, 64, sizeof(ofb_buf1) / 8, ks,
 598                     &ofb_tmp);
 599     if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
 600         printf("ofb_encrypt decrypt error\n");
 601         printf("%02X %02X %02X %02X %02X %02X %02X %02X\n",
 602                ofb_buf2[8 + 0], ofb_buf2[8 + 1], ofb_buf2[8 + 2],
 603                ofb_buf2[8 + 3], ofb_buf2[8 + 4], ofb_buf2[8 + 5],
 604                ofb_buf2[8 + 6], ofb_buf2[8 + 7]);
 605         printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", plain[8 + 0],
 606                plain[8 + 1], plain[8 + 2], plain[8 + 3], plain[8 + 4],
 607                plain[8 + 5], plain[8 + 6], plain[8 + 7]);
 608         err = 1;
 609     }
 610
 611     printf("Doing ofb64\n");
 612     DES_set_key_checked(&ofb_key, &ks);
 613     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
 614     memset(ofb_buf1, 0, sizeof(ofb_buf1));
 615     memset(ofb_buf2, 0, sizeof(ofb_buf1));
 616     num = 0;
 617     for (i = 0; i < sizeof(plain); i++) {
 618         des_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, ks, &ofb_tmp, &num);
 619     }
 620     if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
 621         printf("ofb64_encrypt encrypt error\n");
 622         err = 1;
 623     }
 624     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
 625     num = 0;
 626     des_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), ks, &ofb_tmp,
 627                       &num);
 628     if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
 629         printf("ofb64_encrypt decrypt error\n");
 630         err = 1;
 631     }
 632
 633     printf("Doing ede_ofb64\n");
 634     DES_set_key_checked(&ofb_key, &ks);
 635     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
 636     memset(ofb_buf1, 0, sizeof(ofb_buf1));
 637     memset(ofb_buf2, 0, sizeof(ofb_buf1));
 638     num = 0;
 639     for (i = 0; i < sizeof(plain); i++) {
 640         des_ede3_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, ks, ks,
 641                                ks, &ofb_tmp, &num);
 642     }
 643     if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
 644         printf("ede_ofb64_encrypt encrypt error\n");
 645         err = 1;
 646     }
 647     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
 648     num = 0;
 649     des_ede3_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), ks, ks, ks,
 650                            &ofb_tmp, &num);
 651     if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
 652         printf("ede_ofb64_encrypt decrypt error\n");
 653         err = 1;
 654     }
 655
 656     printf("Doing cbc_cksum\n");
 657     DES_set_key_checked(&cbc_key, &ks);
 658     cs = des_cbc_cksum(cbc_data, &cret, strlen((char *)cbc_data), ks,
 659                        &cbc_iv);
 660     if (cs != cbc_cksum_ret) {
 661         printf("bad return value (%08lX), should be %08lX\n",
 662                (unsigned long)cs, (unsigned long)cbc_cksum_ret);
 663         err = 1;
 664     }
 665     if (memcmp(cret, cbc_cksum_data, 8) != 0) {
 666         printf("bad cbc_cksum block returned\n");
 667         err = 1;
 668     }
 669
 670     printf("Doing quad_cksum\n");
 671     cs = des_quad_cksum(cbc_data, (des_cblock *)lqret,
 672                         (long)strlen((char *)cbc_data), 2,
 673                         (des_cblock *)cbc_iv);
 674     if (cs != 0x70d7a63aL) {
 675         printf("quad_cksum error, ret %08lx should be 70d7a63a\n",
 676                (unsigned long)cs);
 677         err = 1;
 678     }
 679     if (lqret[0] != 0x327eba8dL) {
 680         printf("quad_cksum error, out[0] %08lx is not %08lx\n",
 681                (unsigned long)lqret[0], 0x327eba8dUL);
 682         err = 1;
 683     }
 684     if (lqret[1] != 0x201a49ccL) {
 685         printf("quad_cksum error, out[1] %08lx is not %08lx\n",
 686                (unsigned long)lqret[1], 0x201a49ccUL);
 687         err = 1;
 688     }
 689     if (lqret[2] != 0x70d7a63aL) {
 690         printf("quad_cksum error, out[2] %08lx is not %08lx\n",
 691                (unsigned long)lqret[2], 0x70d7a63aUL);
 692         err = 1;
 693     }
 694     if (lqret[3] != 0x501c2c26L) {
 695         printf("quad_cksum error, out[3] %08lx is not %08lx\n",
 696                (unsigned long)lqret[3], 0x501c2c26UL);
 697         err = 1;
 698     }
 699 # endif
 700
 701     printf("input word alignment test");
 702     for (i = 0; i < 4; i++) {
 703         printf(" %d", i);
 704         des_ncbc_encrypt(&(cbc_out[i]), cbc_in,
 705                          strlen((char *)cbc_data) + 1, ks,
 706                          &cbc_iv, DES_ENCRYPT);
 707     }
 708     printf("\noutput word alignment test");
 709     for (i = 0; i < 4; i++) {
 710         printf(" %d", i);
 711         des_ncbc_encrypt(cbc_out, &(cbc_in[i]),
 712                          strlen((char *)cbc_data) + 1, ks,
 713                          &cbc_iv, DES_ENCRYPT);
 714     }
 715     printf("\n");
 716     printf("fast crypt test ");
 717     str = crypt("testing", "ef");
 718     if (strcmp("efGnQx2725bI2", str) != 0) {
 719         printf("fast crypt error, %s should be efGnQx2725bI2\n", str);
 720         err = 1;
 721     }
 722     str = crypt("bca76;23", "yA");
 723     if (strcmp("yA1Rp/1hZXIJk", str) != 0) {
 724         printf("fast crypt error, %s should be yA1Rp/1hZXIJk\n", str);
 725         err = 1;
 726     }
 727 # ifdef OPENSSL_SYS_NETWARE
 728     if (err)
 729         printf("ERROR: %d\n", err);
 730 # endif
 731     printf("\n");
 732     return (err);
 733 }
 734
 735 static char *pt(unsigned char *p)
 736 {
 737     static char bufs[10][20];
 738     static int bnum = 0;
 739     char *ret;
 740     int i;
 741     static char *f = "0123456789ABCDEF";
 742
 743     ret = &(bufs[bnum++][0]);
 744     bnum %= 10;
 745     for (i = 0; i < 8; i++) {
 746         ret[i * 2] = f[(p[i] >> 4) & 0xf];
 747         ret[i * 2 + 1] = f[p[i] & 0xf];
 748     }
 749     ret[16] = '\0';
 750     return (ret);
 751 }
 752
 753 # ifndef LIBDES_LIT
 754
 755 static int cfb_test(int bits, unsigned char *cfb_cipher)
 756 {
 757     des_key_schedule ks;
 758     int i, err = 0;
 759
 760     DES_set_key_checked(&cfb_key, &ks);
 761     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 762     des_cfb_encrypt(plain, cfb_buf1, bits, sizeof(plain), ks, &cfb_tmp,
 763                     DES_ENCRYPT);
 764     if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
 765         err = 1;
 766         printf("cfb_encrypt encrypt error\n");
 767         for (i = 0; i < 24; i += 8)
 768             printf("%s\n", pt(&(cfb_buf1[i])));
 769     }
 770     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 771     des_cfb_encrypt(cfb_buf1, cfb_buf2, bits, sizeof(plain), ks, &cfb_tmp,
 772                     DES_DECRYPT);
 773     if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
 774         err = 1;
 775         printf("cfb_encrypt decrypt error\n");
 776         for (i = 0; i < 24; i += 8)
 777             printf("%s\n", pt(&(cfb_buf1[i])));
 778     }
 779     return (err);
 780 }
 781
 782 static int cfb64_test(unsigned char *cfb_cipher)
 783 {
 784     des_key_schedule ks;
 785     int err = 0, i, n;
 786
 787     DES_set_key_checked(&cfb_key, &ks);
 788     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 789     n = 0;
 790     des_cfb64_encrypt(plain, cfb_buf1, 12, ks, &cfb_tmp, &n, DES_ENCRYPT);
 791     des_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]), sizeof(plain) - 12, ks,
 792                       &cfb_tmp, &n, DES_ENCRYPT);
 793     if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
 794         err = 1;
 795         printf("cfb_encrypt encrypt error\n");
 796         for (i = 0; i < 24; i += 8)
 797             printf("%s\n", pt(&(cfb_buf1[i])));
 798     }
 799     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 800     n = 0;
 801     des_cfb64_encrypt(cfb_buf1, cfb_buf2, 17, ks, &cfb_tmp, &n, DES_DECRYPT);
 802     des_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
 803                       sizeof(plain) - 17, ks, &cfb_tmp, &n, DES_DECRYPT);
 804     if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
 805         err = 1;
 806         printf("cfb_encrypt decrypt error\n");
 807         for (i = 0; i < 24; i += 8)
 808             printf("%s\n", pt(&(cfb_buf2[i])));
 809     }
 810     return (err);
 811 }
 812
 813 static int ede_cfb64_test(unsigned char *cfb_cipher)
 814 {
 815     des_key_schedule ks;
 816     int err = 0, i, n;
 817
 818     DES_set_key_checked(&cfb_key, &ks);
 819     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 820     n = 0;
 821     des_ede3_cfb64_encrypt(plain, cfb_buf1, 12, ks, ks, ks, &cfb_tmp, &n,
 822                            DES_ENCRYPT);
 823     des_ede3_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]),
 824                            sizeof(plain) - 12, ks, ks, ks,
 825                            &cfb_tmp, &n, DES_ENCRYPT);
 826     if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
 827         err = 1;
 828         printf("ede_cfb_encrypt encrypt error\n");
 829         for (i = 0; i < 24; i += 8)
 830             printf("%s\n", pt(&(cfb_buf1[i])));
 831     }
 832     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
 833     n = 0;
 834     des_ede3_cfb64_encrypt(cfb_buf1, cfb_buf2, (long)17, ks, ks, ks,
 835                            &cfb_tmp, &n, DES_DECRYPT);
 836     des_ede3_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
 837                            sizeof(plain) - 17, ks, ks, ks,
 838                            &cfb_tmp, &n, DES_DECRYPT);
 839     if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
 840         err = 1;
 841         printf("ede_cfb_encrypt decrypt error\n");
 842         for (i = 0; i < 24; i += 8)
 843             printf("%s\n", pt(&(cfb_buf2[i])));
 844     }
 845     return (err);
 846 }
 847
 848 # endif
 849 #endif