test/destest.c

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