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