1 /*
2 * Copyright 1995-2024 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 };
169 static char cbc_data[40] = "7654321 Now is the time for ";
170 static unsigned char cbc_ok[32] = {
171 0x6B, 0x77, 0xB4, 0xD6, 0x30, 0x06, 0xDE, 0xE6,
172 0x05, 0xB1, 0x56, 0xE2, 0x74, 0x03, 0x97, 0x93,
173 0x58, 0xDE, 0xB9, 0xE7, 0x15, 0x46, 0x16, 0xD9,
174 0x59, 0xF1, 0x65, 0x2B, 0xD5, 0xFF, 0x92, 0xCC
175 };
176
177 static unsigned char cfb64_ok[] = {
178 0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
179 0xF2, 0x6E, 0xCF, 0x6D, 0x2E, 0xB9, 0xE7, 0x6E,
180 0x3D, 0xA3, 0xDE, 0x04, 0xD1, 0x51, 0x72, 0x00,
181 0x51, 0x9D, 0x57, 0xA6, 0xC3
182 };
183
184 static unsigned char ofb64_ok[] = {
185 0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
186 0x62, 0xB3, 0x43, 0xCC, 0x5B, 0x65, 0x58, 0x73,
187 0x10, 0xDD, 0x90, 0x8D, 0x0C, 0x24, 0x1B, 0x22,
188 0x63, 0xC2, 0xCF, 0x80, 0xDA
189 };
190
191 # define KEY_TEST_NUM 25
192 static unsigned char key_test[KEY_TEST_NUM] = {
193 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
194 0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
195 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
196 0x88
197 };
198
199 static unsigned char key_data[8] = {
200 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10
201 };
202
203 static unsigned char key_out[KEY_TEST_NUM][8] = {
204 {0xF9, 0xAD, 0x59, 0x7C, 0x49, 0xDB, 0x00, 0x5E},
205 {0xE9, 0x1D, 0x21, 0xC1, 0xD9, 0x61, 0xA6, 0xD6},
206 {0xE9, 0xC2, 0xB7, 0x0A, 0x1B, 0xC6, 0x5C, 0xF3},
207 {0xBE, 0x1E, 0x63, 0x94, 0x08, 0x64, 0x0F, 0x05},
208 {0xB3, 0x9E, 0x44, 0x48, 0x1B, 0xDB, 0x1E, 0x6E},
209 {0x94, 0x57, 0xAA, 0x83, 0xB1, 0x92, 0x8C, 0x0D},
210 {0x8B, 0xB7, 0x70, 0x32, 0xF9, 0x60, 0x62, 0x9D},
211 {0xE8, 0x7A, 0x24, 0x4E, 0x2C, 0xC8, 0x5E, 0x82},
212 {0x15, 0x75, 0x0E, 0x7A, 0x4F, 0x4E, 0xC5, 0x77},
213 {0x12, 0x2B, 0xA7, 0x0B, 0x3A, 0xB6, 0x4A, 0xE0},
214 {0x3A, 0x83, 0x3C, 0x9A, 0xFF, 0xC5, 0x37, 0xF6},
215 {0x94, 0x09, 0xDA, 0x87, 0xA9, 0x0F, 0x6B, 0xF2},
216 {0x88, 0x4F, 0x80, 0x62, 0x50, 0x60, 0xB8, 0xB4},
217 {0x1F, 0x85, 0x03, 0x1C, 0x19, 0xE1, 0x19, 0x68},
218 {0x79, 0xD9, 0x37, 0x3A, 0x71, 0x4C, 0xA3, 0x4F},
219 {0x93, 0x14, 0x28, 0x87, 0xEE, 0x3B, 0xE1, 0x5C},
220 {0x03, 0x42, 0x9E, 0x83, 0x8C, 0xE2, 0xD1, 0x4B},
221 {0xA4, 0x29, 0x9E, 0x27, 0x46, 0x9F, 0xF6, 0x7B},
222 {0xAF, 0xD5, 0xAE, 0xD1, 0xC1, 0xBC, 0x96, 0xA8},
223 {0x10, 0x85, 0x1C, 0x0E, 0x38, 0x58, 0xDA, 0x9F},
224 {0xE6, 0xF5, 0x1E, 0xD7, 0x9B, 0x9D, 0xB2, 0x1F},
225 {0x64, 0xA6, 0xE1, 0x4A, 0xFD, 0x36, 0xB4, 0x6F},
226 {0x80, 0xC7, 0xD7, 0xD4, 0x5A, 0x54, 0x79, 0xAD},
227 {0x05, 0x04, 0x4B, 0x62, 0xFA, 0x52, 0xD0, 0x80},
228 };
229
print_test_data(void)230 static int print_test_data(void)
231 {
232 unsigned int i, j;
233
234 printf("ecb test data\n");
235 printf("key bytes\t\tclear bytes\t\tcipher bytes\n");
236 for (i = 0; i < NUM_TESTS; i++) {
237 for (j = 0; j < 8; j++)
238 printf("%02X", ecb_data[i][j]);
239 printf("\t");
240 for (j = 0; j < 8; j++)
241 printf("%02X", plain_data[i][j]);
242 printf("\t");
243 for (j = 0; j < 8; j++)
244 printf("%02X", cipher_data[i][j]);
245 printf("\n");
246 }
247
248 printf("set_key test data\n");
249 printf("data[8]= ");
250 for (j = 0; j < 8; j++)
251 printf("%02X", key_data[j]);
252 printf("\n");
253 for (i = 0; i < KEY_TEST_NUM - 1; i++) {
254 printf("c=");
255 for (j = 0; j < 8; j++)
256 printf("%02X", key_out[i][j]);
257 printf(" k[%2u]=", i + 1);
258 for (j = 0; j < i + 1; j++)
259 printf("%02X", key_test[j]);
260 printf("\n");
261 }
262
263 printf("\nchaining mode test data\n");
264 printf("key[16] = ");
265 for (j = 0; j < 16; j++)
266 printf("%02X", cbc_key[j]);
267 printf("\niv[8] = ");
268 for (j = 0; j < 8; j++)
269 printf("%02X", cbc_iv[j]);
270 printf("\ndata[%d] = '%s'", (int)strlen(cbc_data) + 1, cbc_data);
271 printf("\ndata[%d] = ", (int)strlen(cbc_data) + 1);
272 for (j = 0; j < strlen(cbc_data) + 1; j++)
273 printf("%02X", cbc_data[j]);
274 printf("\n");
275 printf("cbc cipher text\n");
276 printf("cipher[%d]= ", 32);
277 for (j = 0; j < 32; j++)
278 printf("%02X", cbc_ok[j]);
279 printf("\n");
280
281 printf("cfb64 cipher text\n");
282 printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
283 for (j = 0; j < strlen(cbc_data) + 1; j++)
284 printf("%02X", cfb64_ok[j]);
285 printf("\n");
286
287 printf("ofb64 cipher text\n");
288 printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
289 for (j = 0; j < strlen(cbc_data) + 1; j++)
290 printf("%02X", ofb64_ok[j]);
291 printf("\n");
292 return 0;
293 }
294
test_bf_ecb_raw(int n)295 static int test_bf_ecb_raw(int n)
296 {
297 int ret = 1;
298 BF_KEY key;
299 BF_LONG data[2];
300
301 BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
302
303 data[0] = bf_plain[n][0];
304 data[1] = bf_plain[n][1];
305 BF_encrypt(data, &key);
306 if (!TEST_mem_eq(&(bf_cipher[n][0]), BF_BLOCK, &(data[0]), BF_BLOCK))
307 ret = 0;
308
309 BF_decrypt(&(data[0]), &key);
310 if (!TEST_mem_eq(&(bf_plain[n][0]), BF_BLOCK, &(data[0]), BF_BLOCK))
311 ret = 0;
312
313 return ret;
314 }
315
test_bf_ecb(int n)316 static int test_bf_ecb(int n)
317 {
318 int ret = 1;
319 BF_KEY key;
320 unsigned char out[8];
321
322 BF_set_key(&key, 8, ecb_data[n]);
323
324 BF_ecb_encrypt(&(plain_data[n][0]), out, &key, BF_ENCRYPT);
325 if (!TEST_mem_eq(&(cipher_data[n][0]), BF_BLOCK, out, BF_BLOCK))
326 ret = 0;
327
328 BF_ecb_encrypt(out, out, &key, BF_DECRYPT);
329 if (!TEST_mem_eq(&(plain_data[n][0]), BF_BLOCK, out, BF_BLOCK))
330 ret = 0;
331
332 return ret;
333 }
334
test_bf_set_key(int n)335 static int test_bf_set_key(int n)
336 {
337 int ret = 1;
338 BF_KEY key;
339 unsigned char out[8];
340
341 BF_set_key(&key, n+1, key_test);
342 BF_ecb_encrypt(key_data, out, &key, BF_ENCRYPT);
343 /* mips-sgi-irix6.5-gcc vv -mabi=64 bug workaround */
344 if (!TEST_mem_eq(out, 8, &(key_out[n][0]), 8))
345 ret = 0;
346
347 return ret;
348 }
349
test_bf_cbc(void)350 static int test_bf_cbc(void)
351 {
352 unsigned char cbc_in[40], cbc_out[40], iv[8];
353 int ret = 1;
354 BF_KEY key;
355 BF_LONG len;
356
357 len = strlen(cbc_data) + 1;
358
359 BF_set_key(&key, 16, cbc_key);
360 memset(cbc_in, 0, sizeof(cbc_in));
361 memset(cbc_out, 0, sizeof(cbc_out));
362 memcpy(iv, cbc_iv, sizeof(iv));
363 BF_cbc_encrypt((unsigned char *)cbc_data, cbc_out, len,
364 &key, iv, BF_ENCRYPT);
365 if (!TEST_mem_eq(cbc_out, 32, cbc_ok, 32))
366 ret = 0;
367
368 memcpy(iv, cbc_iv, 8);
369 BF_cbc_encrypt(cbc_out, cbc_in, len, &key, iv, BF_DECRYPT);
370 if (!TEST_mem_eq(cbc_in, len, cbc_data, strlen(cbc_data) + 1))
371 ret = 0;
372
373 return ret;
374 }
375
test_bf_cfb64(void)376 static int test_bf_cfb64(void)
377 {
378 unsigned char cbc_in[40], cbc_out[40], iv[8];
379 int n, ret = 1;
380 BF_KEY key;
381 BF_LONG len;
382
383 len = strlen(cbc_data) + 1;
384
385 BF_set_key(&key, 16, cbc_key);
386 memset(cbc_in, 0, 40);
387 memset(cbc_out, 0, 40);
388 memcpy(iv, cbc_iv, 8);
389 n = 0;
390 BF_cfb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13,
391 &key, iv, &n, BF_ENCRYPT);
392 BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
393 len - 13, &key, iv, &n, BF_ENCRYPT);
394 if (!TEST_mem_eq(cbc_out, (int)len, cfb64_ok, (int)len))
395 ret = 0;
396
397 n = 0;
398 memcpy(iv, cbc_iv, 8);
399 BF_cfb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n, BF_DECRYPT);
400 BF_cfb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17,
401 &key, iv, &n, BF_DECRYPT);
402 if (!TEST_mem_eq(cbc_in, (int)len, cbc_data, (int)len))
403 ret = 0;
404
405 return ret;
406 }
407
test_bf_ofb64(void)408 static int test_bf_ofb64(void)
409 {
410 unsigned char cbc_in[40], cbc_out[40], iv[8];
411 int n, ret = 1;
412 BF_KEY key;
413 BF_LONG len;
414
415 len = strlen(cbc_data) + 1;
416
417 BF_set_key(&key, 16, cbc_key);
418 memset(cbc_in, 0, 40);
419 memset(cbc_out, 0, 40);
420 memcpy(iv, cbc_iv, 8);
421 n = 0;
422 BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
423 &n);
424 BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
425 len - 13, &key, iv, &n);
426 if (!TEST_mem_eq(cbc_out, (int)len, ofb64_ok, (int)len))
427 ret = 0;
428
429 n = 0;
430 memcpy(iv, cbc_iv, 8);
431 BF_ofb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n);
432 BF_ofb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, &key, iv, &n);
433 if (!TEST_mem_eq(cbc_in, (int)len, cbc_data, (int)len))
434 ret = 0;
435
436 return ret;
437 }
438 #endif
439
440 typedef enum OPTION_choice {
441 OPT_ERR = -1,
442 OPT_EOF = 0,
443 OPT_PRINT,
444 OPT_TEST_ENUM
445 } OPTION_CHOICE;
446
test_get_options(void)447 const OPTIONS *test_get_options(void)
448 {
449 static const OPTIONS test_options[] = {
450 OPT_TEST_OPTIONS_DEFAULT_USAGE,
451 { "print", OPT_PRINT, '-', "Output test tables instead of running tests"},
452 { NULL }
453 };
454 return test_options;
455 }
456
setup_tests(void)457 int setup_tests(void)
458 {
459 #ifndef OPENSSL_NO_BF
460 OPTION_CHOICE o;
461 # ifdef CHARSET_EBCDIC
462 int n;
463 ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
464 for (n = 0; n < 2; n++) {
465 ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
466 }
467 # endif
468
469 while ((o = opt_next()) != OPT_EOF) {
470 switch (o) {
471 case OPT_PRINT:
472 print_test_data();
473 return 1;
474 case OPT_TEST_CASES:
475 break;
476 default:
477 return 0;
478 }
479 }
480
481 ADD_ALL_TESTS(test_bf_ecb_raw, 2);
482 ADD_ALL_TESTS(test_bf_ecb, NUM_TESTS);
483 ADD_ALL_TESTS(test_bf_set_key, KEY_TEST_NUM-1);
484 ADD_TEST(test_bf_cbc);
485 ADD_TEST(test_bf_cfb64);
486 ADD_TEST(test_bf_ofb64);
487 #endif
488 return 1;
489 }
490
