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