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
print_test_data(void)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
test_bf_ecb_raw(int n)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
test_bf_ecb(int n)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
test_bf_set_key(int n)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
test_bf_cbc(void)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
test_bf_cfb64(void)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
test_bf_ofb64(void)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
test_get_options(void)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
setup_tests(void)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