test/destest.c

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