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