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