test/destest.c

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