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
31static char bf_key[2][30] = {
32    "abcdefghijklmnopqrstuvwxyz",
33    "Who is John Galt?"
34};
35
36/* big endian */
37static BF_LONG bf_plain[2][2] = {
38    {0x424c4f57L, 0x46495348L},
39    {0xfedcba98L, 0x76543210L}
40};
41
42static 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
51static 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
88static 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
125static 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
162static unsigned char cbc_key[16] = {
163    0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
164    0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87
165};
166static unsigned char cbc_iv[8] =
167    { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
168static char cbc_data[40] = "7654321 Now is the time for ";
169static 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
176static 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
183static 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
191static 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
198static unsigned char key_data[8] =
199    { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
200
201static 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
228static 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
293static 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
314static 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
333static 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
348static 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
374static 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
406static 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
438typedef enum OPTION_choice {
439    OPT_ERR = -1,
440    OPT_EOF = 0,
441    OPT_PRINT,
442    OPT_TEST_ENUM
443} OPTION_CHOICE;
444
445const 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
455int 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