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