1 /* 2 * Copyright 1995-2020 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 * BF low level APIs are deprecated for public use, but still ok for internal 12 * use. 13 */ 14 #include "internal/deprecated.h" 15 16 #include <stdio.h> 17 #include <string.h> 18 #include <stdlib.h> 19 #include <openssl/opensslconf.h> /* To see if OPENSSL_NO_BF is defined */ 20 #include "testutil.h" 21 22 #include "internal/nelem.h" 23 24 #ifndef OPENSSL_NO_BF 25 # include <openssl/blowfish.h> 26 27 # ifdef CHARSET_EBCDIC 28 # include <openssl/ebcdic.h> 29 # endif 30 31 static char bf_key[2][30] = { 32 "abcdefghijklmnopqrstuvwxyz", 33 "Who is John Galt?" 34 }; 35 36 /* big endian */ 37 static BF_LONG bf_plain[2][2] = { 38 {0x424c4f57L, 0x46495348L}, 39 {0xfedcba98L, 0x76543210L} 40 }; 41 42 static BF_LONG bf_cipher[2][2] = { 43 {0x324ed0feL, 0xf413a203L}, 44 {0xcc91732bL, 0x8022f684L} 45 }; 46 47 /************/ 48 49 /* Lets use the DES test vectors :-) */ 50 # define NUM_TESTS 34 51 static unsigned char ecb_data[NUM_TESTS][8] = { 52 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 53 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 54 {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 55 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 56 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 57 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 58 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 59 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}, 60 {0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57}, 61 {0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E}, 62 {0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86}, 63 {0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E}, 64 {0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6}, 65 {0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE}, 66 {0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6}, 67 {0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE}, 68 {0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16}, 69 {0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F}, 70 {0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46}, 71 {0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E}, 72 {0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76}, 73 {0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07}, 74 {0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F}, 75 {0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7}, 76 {0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF}, 77 {0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6}, 78 {0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF}, 79 {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}, 80 {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E}, 81 {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE}, 82 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 83 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 84 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 85 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10} 86 }; 87 88 static unsigned char plain_data[NUM_TESTS][8] = { 89 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 90 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 91 {0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, 92 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 93 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 94 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 95 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 96 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 97 {0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42}, 98 {0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA}, 99 {0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72}, 100 {0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A}, 101 {0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2}, 102 {0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A}, 103 {0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2}, 104 {0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A}, 105 {0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02}, 106 {0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A}, 107 {0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32}, 108 {0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA}, 109 {0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62}, 110 {0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2}, 111 {0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA}, 112 {0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92}, 113 {0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A}, 114 {0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2}, 115 {0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A}, 116 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 117 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 118 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 119 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 120 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 121 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 122 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} 123 }; 124 125 static unsigned char cipher_data[NUM_TESTS][8] = { 126 {0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78}, 127 {0x51, 0x86, 0x6F, 0xD5, 0xB8, 0x5E, 0xCB, 0x8A}, 128 {0x7D, 0x85, 0x6F, 0x9A, 0x61, 0x30, 0x63, 0xF2}, 129 {0x24, 0x66, 0xDD, 0x87, 0x8B, 0x96, 0x3C, 0x9D}, 130 {0x61, 0xF9, 0xC3, 0x80, 0x22, 0x81, 0xB0, 0x96}, 131 {0x7D, 0x0C, 0xC6, 0x30, 0xAF, 0xDA, 0x1E, 0xC7}, 132 {0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78}, 133 {0x0A, 0xCE, 0xAB, 0x0F, 0xC6, 0xA0, 0xA2, 0x8D}, 134 {0x59, 0xC6, 0x82, 0x45, 0xEB, 0x05, 0x28, 0x2B}, 135 {0xB1, 0xB8, 0xCC, 0x0B, 0x25, 0x0F, 0x09, 0xA0}, 136 {0x17, 0x30, 0xE5, 0x77, 0x8B, 0xEA, 0x1D, 0xA4}, 137 {0xA2, 0x5E, 0x78, 0x56, 0xCF, 0x26, 0x51, 0xEB}, 138 {0x35, 0x38, 0x82, 0xB1, 0x09, 0xCE, 0x8F, 0x1A}, 139 {0x48, 0xF4, 0xD0, 0x88, 0x4C, 0x37, 0x99, 0x18}, 140 {0x43, 0x21, 0x93, 0xB7, 0x89, 0x51, 0xFC, 0x98}, 141 {0x13, 0xF0, 0x41, 0x54, 0xD6, 0x9D, 0x1A, 0xE5}, 142 {0x2E, 0xED, 0xDA, 0x93, 0xFF, 0xD3, 0x9C, 0x79}, 143 {0xD8, 0x87, 0xE0, 0x39, 0x3C, 0x2D, 0xA6, 0xE3}, 144 {0x5F, 0x99, 0xD0, 0x4F, 0x5B, 0x16, 0x39, 0x69}, 145 {0x4A, 0x05, 0x7A, 0x3B, 0x24, 0xD3, 0x97, 0x7B}, 146 {0x45, 0x20, 0x31, 0xC1, 0xE4, 0xFA, 0xDA, 0x8E}, 147 {0x75, 0x55, 0xAE, 0x39, 0xF5, 0x9B, 0x87, 0xBD}, 148 {0x53, 0xC5, 0x5F, 0x9C, 0xB4, 0x9F, 0xC0, 0x19}, 149 {0x7A, 0x8E, 0x7B, 0xFA, 0x93, 0x7E, 0x89, 0xA3}, 150 {0xCF, 0x9C, 0x5D, 0x7A, 0x49, 0x86, 0xAD, 0xB5}, 151 {0xD1, 0xAB, 0xB2, 0x90, 0x65, 0x8B, 0xC7, 0x78}, 152 {0x55, 0xCB, 0x37, 0x74, 0xD1, 0x3E, 0xF2, 0x01}, 153 {0xFA, 0x34, 0xEC, 0x48, 0x47, 0xB2, 0x68, 0xB2}, 154 {0xA7, 0x90, 0x79, 0x51, 0x08, 0xEA, 0x3C, 0xAE}, 155 {0xC3, 0x9E, 0x07, 0x2D, 0x9F, 0xAC, 0x63, 0x1D}, 156 {0x01, 0x49, 0x33, 0xE0, 0xCD, 0xAF, 0xF6, 0xE4}, 157 {0xF2, 0x1E, 0x9A, 0x77, 0xB7, 0x1C, 0x49, 0xBC}, 158 {0x24, 0x59, 0x46, 0x88, 0x57, 0x54, 0x36, 0x9A}, 159 {0x6B, 0x5C, 0x5A, 0x9C, 0x5D, 0x9E, 0x0A, 0x5A}, 160 }; 161 162 static unsigned char cbc_key[16] = { 163 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 164 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 165 }; 166 static unsigned char cbc_iv[8] = 167 { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 }; 168 static char cbc_data[40] = "7654321 Now is the time for "; 169 static unsigned char cbc_ok[32] = { 170 0x6B, 0x77, 0xB4, 0xD6, 0x30, 0x06, 0xDE, 0xE6, 171 0x05, 0xB1, 0x56, 0xE2, 0x74, 0x03, 0x97, 0x93, 172 0x58, 0xDE, 0xB9, 0xE7, 0x15, 0x46, 0x16, 0xD9, 173 0x59, 0xF1, 0x65, 0x2B, 0xD5, 0xFF, 0x92, 0xCC 174 }; 175 176 static unsigned char cfb64_ok[] = { 177 0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA, 178 0xF2, 0x6E, 0xCF, 0x6D, 0x2E, 0xB9, 0xE7, 0x6E, 179 0x3D, 0xA3, 0xDE, 0x04, 0xD1, 0x51, 0x72, 0x00, 180 0x51, 0x9D, 0x57, 0xA6, 0xC3 181 }; 182 183 static unsigned char ofb64_ok[] = { 184 0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA, 185 0x62, 0xB3, 0x43, 0xCC, 0x5B, 0x65, 0x58, 0x73, 186 0x10, 0xDD, 0x90, 0x8D, 0x0C, 0x24, 0x1B, 0x22, 187 0x63, 0xC2, 0xCF, 0x80, 0xDA 188 }; 189 190 # define KEY_TEST_NUM 25 191 static unsigned char key_test[KEY_TEST_NUM] = { 192 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87, 193 0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f, 194 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 195 0x88 196 }; 197 198 static unsigned char key_data[8] = 199 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }; 200 201 static unsigned char key_out[KEY_TEST_NUM][8] = { 202 {0xF9, 0xAD, 0x59, 0x7C, 0x49, 0xDB, 0x00, 0x5E}, 203 {0xE9, 0x1D, 0x21, 0xC1, 0xD9, 0x61, 0xA6, 0xD6}, 204 {0xE9, 0xC2, 0xB7, 0x0A, 0x1B, 0xC6, 0x5C, 0xF3}, 205 {0xBE, 0x1E, 0x63, 0x94, 0x08, 0x64, 0x0F, 0x05}, 206 {0xB3, 0x9E, 0x44, 0x48, 0x1B, 0xDB, 0x1E, 0x6E}, 207 {0x94, 0x57, 0xAA, 0x83, 0xB1, 0x92, 0x8C, 0x0D}, 208 {0x8B, 0xB7, 0x70, 0x32, 0xF9, 0x60, 0x62, 0x9D}, 209 {0xE8, 0x7A, 0x24, 0x4E, 0x2C, 0xC8, 0x5E, 0x82}, 210 {0x15, 0x75, 0x0E, 0x7A, 0x4F, 0x4E, 0xC5, 0x77}, 211 {0x12, 0x2B, 0xA7, 0x0B, 0x3A, 0xB6, 0x4A, 0xE0}, 212 {0x3A, 0x83, 0x3C, 0x9A, 0xFF, 0xC5, 0x37, 0xF6}, 213 {0x94, 0x09, 0xDA, 0x87, 0xA9, 0x0F, 0x6B, 0xF2}, 214 {0x88, 0x4F, 0x80, 0x62, 0x50, 0x60, 0xB8, 0xB4}, 215 {0x1F, 0x85, 0x03, 0x1C, 0x19, 0xE1, 0x19, 0x68}, 216 {0x79, 0xD9, 0x37, 0x3A, 0x71, 0x4C, 0xA3, 0x4F}, 217 {0x93, 0x14, 0x28, 0x87, 0xEE, 0x3B, 0xE1, 0x5C}, 218 {0x03, 0x42, 0x9E, 0x83, 0x8C, 0xE2, 0xD1, 0x4B}, 219 {0xA4, 0x29, 0x9E, 0x27, 0x46, 0x9F, 0xF6, 0x7B}, 220 {0xAF, 0xD5, 0xAE, 0xD1, 0xC1, 0xBC, 0x96, 0xA8}, 221 {0x10, 0x85, 0x1C, 0x0E, 0x38, 0x58, 0xDA, 0x9F}, 222 {0xE6, 0xF5, 0x1E, 0xD7, 0x9B, 0x9D, 0xB2, 0x1F}, 223 {0x64, 0xA6, 0xE1, 0x4A, 0xFD, 0x36, 0xB4, 0x6F}, 224 {0x80, 0xC7, 0xD7, 0xD4, 0x5A, 0x54, 0x79, 0xAD}, 225 {0x05, 0x04, 0x4B, 0x62, 0xFA, 0x52, 0xD0, 0x80}, 226 }; 227 228 static int print_test_data(void) 229 { 230 unsigned int i, j; 231 232 printf("ecb test data\n"); 233 printf("key bytes\t\tclear bytes\t\tcipher bytes\n"); 234 for (i = 0; i < NUM_TESTS; i++) { 235 for (j = 0; j < 8; j++) 236 printf("%02X", ecb_data[i][j]); 237 printf("\t"); 238 for (j = 0; j < 8; j++) 239 printf("%02X", plain_data[i][j]); 240 printf("\t"); 241 for (j = 0; j < 8; j++) 242 printf("%02X", cipher_data[i][j]); 243 printf("\n"); 244 } 245 246 printf("set_key test data\n"); 247 printf("data[8]= "); 248 for (j = 0; j < 8; j++) 249 printf("%02X", key_data[j]); 250 printf("\n"); 251 for (i = 0; i < KEY_TEST_NUM - 1; i++) { 252 printf("c="); 253 for (j = 0; j < 8; j++) 254 printf("%02X", key_out[i][j]); 255 printf(" k[%2u]=", i + 1); 256 for (j = 0; j < i + 1; j++) 257 printf("%02X", key_test[j]); 258 printf("\n"); 259 } 260 261 printf("\nchaining mode test data\n"); 262 printf("key[16] = "); 263 for (j = 0; j < 16; j++) 264 printf("%02X", cbc_key[j]); 265 printf("\niv[8] = "); 266 for (j = 0; j < 8; j++) 267 printf("%02X", cbc_iv[j]); 268 printf("\ndata[%d] = '%s'", (int)strlen(cbc_data) + 1, cbc_data); 269 printf("\ndata[%d] = ", (int)strlen(cbc_data) + 1); 270 for (j = 0; j < strlen(cbc_data) + 1; j++) 271 printf("%02X", cbc_data[j]); 272 printf("\n"); 273 printf("cbc cipher text\n"); 274 printf("cipher[%d]= ", 32); 275 for (j = 0; j < 32; j++) 276 printf("%02X", cbc_ok[j]); 277 printf("\n"); 278 279 printf("cfb64 cipher text\n"); 280 printf("cipher[%d]= ", (int)strlen(cbc_data) + 1); 281 for (j = 0; j < strlen(cbc_data) + 1; j++) 282 printf("%02X", cfb64_ok[j]); 283 printf("\n"); 284 285 printf("ofb64 cipher text\n"); 286 printf("cipher[%d]= ", (int)strlen(cbc_data) + 1); 287 for (j = 0; j < strlen(cbc_data) + 1; j++) 288 printf("%02X", ofb64_ok[j]); 289 printf("\n"); 290 return 0; 291 } 292 293 static int test_bf_ecb_raw(int n) 294 { 295 int ret = 1; 296 BF_KEY key; 297 BF_LONG data[2]; 298 299 BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]); 300 301 data[0] = bf_plain[n][0]; 302 data[1] = bf_plain[n][1]; 303 BF_encrypt(data, &key); 304 if (!TEST_mem_eq(&(bf_cipher[n][0]), BF_BLOCK, &(data[0]), BF_BLOCK)) 305 ret = 0; 306 307 BF_decrypt(&(data[0]), &key); 308 if (!TEST_mem_eq(&(bf_plain[n][0]), BF_BLOCK, &(data[0]), BF_BLOCK)) 309 ret = 0; 310 311 return ret; 312 } 313 314 static int test_bf_ecb(int n) 315 { 316 int ret = 1; 317 BF_KEY key; 318 unsigned char out[8]; 319 320 BF_set_key(&key, 8, ecb_data[n]); 321 322 BF_ecb_encrypt(&(plain_data[n][0]), out, &key, BF_ENCRYPT); 323 if (!TEST_mem_eq(&(cipher_data[n][0]), BF_BLOCK, out, BF_BLOCK)) 324 ret = 0; 325 326 BF_ecb_encrypt(out, out, &key, BF_DECRYPT); 327 if (!TEST_mem_eq(&(plain_data[n][0]), BF_BLOCK, out, BF_BLOCK)) 328 ret = 0; 329 330 return ret; 331 } 332 333 static int test_bf_set_key(int n) 334 { 335 int ret = 1; 336 BF_KEY key; 337 unsigned char out[8]; 338 339 BF_set_key(&key, n+1, key_test); 340 BF_ecb_encrypt(key_data, out, &key, BF_ENCRYPT); 341 /* mips-sgi-irix6.5-gcc vv -mabi=64 bug workaround */ 342 if (!TEST_mem_eq(out, 8, &(key_out[n][0]), 8)) 343 ret = 0; 344 345 return ret; 346 } 347 348 static int test_bf_cbc(void) 349 { 350 unsigned char cbc_in[40], cbc_out[40], iv[8]; 351 int ret = 1; 352 BF_KEY key; 353 BF_LONG len; 354 355 len = strlen(cbc_data) + 1; 356 357 BF_set_key(&key, 16, cbc_key); 358 memset(cbc_in, 0, sizeof(cbc_in)); 359 memset(cbc_out, 0, sizeof(cbc_out)); 360 memcpy(iv, cbc_iv, sizeof(iv)); 361 BF_cbc_encrypt((unsigned char *)cbc_data, cbc_out, len, 362 &key, iv, BF_ENCRYPT); 363 if (!TEST_mem_eq(cbc_out, 32, cbc_ok, 32)) 364 ret = 0; 365 366 memcpy(iv, cbc_iv, 8); 367 BF_cbc_encrypt(cbc_out, cbc_in, len, &key, iv, BF_DECRYPT); 368 if (!TEST_mem_eq(cbc_in, len, cbc_data, strlen(cbc_data) + 1)) 369 ret = 0; 370 371 return ret; 372 } 373 374 static int test_bf_cfb64(void) 375 { 376 unsigned char cbc_in[40], cbc_out[40], iv[8]; 377 int n, ret = 1; 378 BF_KEY key; 379 BF_LONG len; 380 381 len = strlen(cbc_data) + 1; 382 383 BF_set_key(&key, 16, cbc_key); 384 memset(cbc_in, 0, 40); 385 memset(cbc_out, 0, 40); 386 memcpy(iv, cbc_iv, 8); 387 n = 0; 388 BF_cfb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, 389 &key, iv, &n, BF_ENCRYPT); 390 BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]), 391 len - 13, &key, iv, &n, BF_ENCRYPT); 392 if (!TEST_mem_eq(cbc_out, (int)len, cfb64_ok, (int)len)) 393 ret = 0; 394 395 n = 0; 396 memcpy(iv, cbc_iv, 8); 397 BF_cfb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n, BF_DECRYPT); 398 BF_cfb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, 399 &key, iv, &n, BF_DECRYPT); 400 if (!TEST_mem_eq(cbc_in, (int)len, cbc_data, (int)len)) 401 ret = 0; 402 403 return ret; 404 } 405 406 static int test_bf_ofb64(void) 407 { 408 unsigned char cbc_in[40], cbc_out[40], iv[8]; 409 int n, ret = 1; 410 BF_KEY key; 411 BF_LONG len; 412 413 len = strlen(cbc_data) + 1; 414 415 BF_set_key(&key, 16, cbc_key); 416 memset(cbc_in, 0, 40); 417 memset(cbc_out, 0, 40); 418 memcpy(iv, cbc_iv, 8); 419 n = 0; 420 BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv, 421 &n); 422 BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]), 423 len - 13, &key, iv, &n); 424 if (!TEST_mem_eq(cbc_out, (int)len, ofb64_ok, (int)len)) 425 ret = 0; 426 427 n = 0; 428 memcpy(iv, cbc_iv, 8); 429 BF_ofb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n); 430 BF_ofb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, &key, iv, &n); 431 if (!TEST_mem_eq(cbc_in, (int)len, cbc_data, (int)len)) 432 ret = 0; 433 434 return ret; 435 } 436 #endif 437 438 typedef enum OPTION_choice { 439 OPT_ERR = -1, 440 OPT_EOF = 0, 441 OPT_PRINT, 442 OPT_TEST_ENUM 443 } OPTION_CHOICE; 444 445 const OPTIONS *test_get_options(void) 446 { 447 static const OPTIONS test_options[] = { 448 OPT_TEST_OPTIONS_DEFAULT_USAGE, 449 { "print", OPT_PRINT, '-', "Output test tables instead of running tests"}, 450 { NULL } 451 }; 452 return test_options; 453 } 454 455 int setup_tests(void) 456 { 457 #ifndef OPENSSL_NO_BF 458 OPTION_CHOICE o; 459 # ifdef CHARSET_EBCDIC 460 int n; 461 ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data)); 462 for (n = 0; n < 2; n++) { 463 ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n])); 464 } 465 # endif 466 467 while ((o = opt_next()) != OPT_EOF) { 468 switch(o) { 469 case OPT_PRINT: 470 print_test_data(); 471 return 1; 472 case OPT_TEST_CASES: 473 break; 474 default: 475 return 0; 476 } 477 } 478 479 ADD_ALL_TESTS(test_bf_ecb_raw, 2); 480 ADD_ALL_TESTS(test_bf_ecb, NUM_TESTS); 481 ADD_ALL_TESTS(test_bf_set_key, KEY_TEST_NUM-1); 482 ADD_TEST(test_bf_cbc); 483 ADD_TEST(test_bf_cfb64); 484 ADD_TEST(test_bf_ofb64); 485 #endif 486 return 1; 487 } 488