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