1 /*
2 * Copyright 2016-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 #include <stdio.h>
10 #include <string.h>
11 #include <openssl/evp.h>
12 #include <openssl/bio.h>
13 #include <openssl/rand.h>
14
15 #include "testutil.h"
16
17 #define ENCRYPT 1
18 #define DECRYPT 0
19
20 #define DATA_SIZE 1024
21 #define MAX_IV 32
22 #define BUF_SIZE (DATA_SIZE + MAX_IV)
23
24 static const unsigned char KEY[] = {
25 0x51, 0x50, 0xd1, 0x77, 0x2f, 0x50, 0x83, 0x4a,
26 0x50, 0x3e, 0x06, 0x9a, 0x97, 0x3f, 0xbd, 0x7c,
27 0xe6, 0x1c, 0x43, 0x2b, 0x72, 0x0b, 0x19, 0xd1,
28 0x8e, 0xc8, 0xd8, 0x4b, 0xdc, 0x63, 0x15, 0x1b
29 };
30
31 static const unsigned char IV[] = {
32 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
33 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
34 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
35 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
36 };
37
do_bio_cipher(const EVP_CIPHER * cipher,const unsigned char * key,const unsigned char * iv)38 static int do_bio_cipher(const EVP_CIPHER* cipher, const unsigned char* key,
39 const unsigned char* iv)
40 {
41 BIO *b, *mem;
42 static unsigned char inp[BUF_SIZE] = { 0 };
43 unsigned char out[BUF_SIZE], ref[BUF_SIZE];
44 int i, lref, len, tmplen;
45
46 /* Fill buffer with non-zero data so that over steps can be detected */
47 if (!TEST_int_gt(RAND_bytes(inp, DATA_SIZE), 0))
48 return 0;
49
50 /* Encrypt tests */
51
52 /* reference output for single-chunk operation */
53 b = BIO_new(BIO_f_cipher());
54 if (!TEST_ptr(b))
55 return 0;
56 if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, ENCRYPT)))
57 goto err;
58 mem = BIO_new_mem_buf(inp, DATA_SIZE);
59 if (!TEST_ptr(mem))
60 goto err;
61 BIO_push(b, mem);
62 lref = BIO_read(b, ref, sizeof(ref));
63 BIO_free_all(b);
64
65 /* perform split operations and compare to reference */
66 for (i = 1; i < lref; i++) {
67 b = BIO_new(BIO_f_cipher());
68 if (!TEST_ptr(b))
69 return 0;
70 if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, ENCRYPT))) {
71 TEST_info("Split encrypt failed @ operation %d", i);
72 goto err;
73 }
74 mem = BIO_new_mem_buf(inp, DATA_SIZE);
75 if (!TEST_ptr(mem))
76 goto err;
77 BIO_push(b, mem);
78 memset(out, 0, sizeof(out));
79 out[i] = ~ref[i];
80 tmplen = BIO_read(b, out, i);
81 if (tmplen < 0)
82 goto err;
83 len = tmplen;
84 /* check for overstep */
85 if (!TEST_uchar_eq(out[i], (unsigned char)~ref[i])) {
86 TEST_info("Encrypt overstep check failed @ operation %d", i);
87 goto err;
88 }
89 tmplen = BIO_read(b, out + len, sizeof(out) - len);
90 if (tmplen < 0)
91 goto err;
92 len += tmplen;
93
94 BIO_free_all(b);
95
96 if (!TEST_mem_eq(out, len, ref, lref)) {
97 TEST_info("Encrypt compare failed @ operation %d", i);
98 return 0;
99 }
100 }
101
102 /* perform small-chunk operations and compare to reference */
103 for (i = 1; i < lref / 2; i++) {
104 int delta;
105
106 b = BIO_new(BIO_f_cipher());
107 if (!TEST_ptr(b))
108 return 0;
109 if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, ENCRYPT))) {
110 TEST_info("Small chunk encrypt failed @ operation %d", i);
111 goto err;
112 }
113 mem = BIO_new_mem_buf(inp, DATA_SIZE);
114 if (!TEST_ptr(mem))
115 goto err;
116 BIO_push(b, mem);
117 memset(out, 0, sizeof(out));
118 for (len = 0; (delta = BIO_read(b, out + len, i)); ) {
119 len += delta;
120 }
121 BIO_free_all(b);
122
123 if (!TEST_mem_eq(out, len, ref, lref)) {
124 TEST_info("Small chunk encrypt compare failed @ operation %d", i);
125 return 0;
126 }
127 }
128
129 /* Decrypt tests */
130
131 /* reference output for single-chunk operation */
132 b = BIO_new(BIO_f_cipher());
133 if (!TEST_ptr(b))
134 return 0;
135 if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, DECRYPT)))
136 goto err;
137 /* Use original reference output as input */
138 mem = BIO_new_mem_buf(ref, lref);
139 if (!TEST_ptr(mem))
140 goto err;
141 BIO_push(b, mem);
142 (void)BIO_flush(b);
143 memset(out, 0, sizeof(out));
144 len = BIO_read(b, out, sizeof(out));
145 BIO_free_all(b);
146
147 if (!TEST_mem_eq(inp, DATA_SIZE, out, len))
148 return 0;
149
150 /* perform split operations and compare to reference */
151 for (i = 1; i < lref; i++) {
152 b = BIO_new(BIO_f_cipher());
153 if (!TEST_ptr(b))
154 return 0;
155 if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, DECRYPT))) {
156 TEST_info("Split decrypt failed @ operation %d", i);
157 goto err;
158 }
159 mem = BIO_new_mem_buf(ref, lref);
160 if (!TEST_ptr(mem))
161 goto err;
162 BIO_push(b, mem);
163 memset(out, 0, sizeof(out));
164 out[i] = ~ref[i];
165 len = BIO_read(b, out, i);
166 /* check for overstep */
167 if (!TEST_uchar_eq(out[i], (unsigned char)~ref[i])) {
168 TEST_info("Decrypt overstep check failed @ operation %d", i);
169 goto err;
170 }
171 len += BIO_read(b, out + len, sizeof(out) - len);
172 BIO_free_all(b);
173
174 if (!TEST_mem_eq(inp, DATA_SIZE, out, len)) {
175 TEST_info("Decrypt compare failed @ operation %d", i);
176 return 0;
177 }
178 }
179
180 /* perform small-chunk operations and compare to reference */
181 for (i = 1; i < lref / 2; i++) {
182 int delta;
183
184 b = BIO_new(BIO_f_cipher());
185 if (!TEST_ptr(b))
186 return 0;
187 if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, DECRYPT))) {
188 TEST_info("Small chunk decrypt failed @ operation %d", i);
189 goto err;
190 }
191 mem = BIO_new_mem_buf(ref, lref);
192 if (!TEST_ptr(mem))
193 goto err;
194 BIO_push(b, mem);
195 memset(out, 0, sizeof(out));
196 for (len = 0; (delta = BIO_read(b, out + len, i)); ) {
197 len += delta;
198 }
199 BIO_free_all(b);
200
201 if (!TEST_mem_eq(inp, DATA_SIZE, out, len)) {
202 TEST_info("Small chunk decrypt compare failed @ operation %d", i);
203 return 0;
204 }
205 }
206
207 return 1;
208
209 err:
210 BIO_free_all(b);
211 return 0;
212 }
213
do_test_bio_cipher(const EVP_CIPHER * cipher,int idx)214 static int do_test_bio_cipher(const EVP_CIPHER* cipher, int idx)
215 {
216 switch (idx) {
217 case 0:
218 return do_bio_cipher(cipher, KEY, NULL);
219 case 1:
220 return do_bio_cipher(cipher, KEY, IV);
221 }
222 return 0;
223 }
224
test_bio_enc_aes_128_cbc(int idx)225 static int test_bio_enc_aes_128_cbc(int idx)
226 {
227 return do_test_bio_cipher(EVP_aes_128_cbc(), idx);
228 }
229
test_bio_enc_aes_128_ctr(int idx)230 static int test_bio_enc_aes_128_ctr(int idx)
231 {
232 return do_test_bio_cipher(EVP_aes_128_ctr(), idx);
233 }
234
test_bio_enc_aes_256_cfb(int idx)235 static int test_bio_enc_aes_256_cfb(int idx)
236 {
237 return do_test_bio_cipher(EVP_aes_256_cfb(), idx);
238 }
239
test_bio_enc_aes_256_ofb(int idx)240 static int test_bio_enc_aes_256_ofb(int idx)
241 {
242 return do_test_bio_cipher(EVP_aes_256_ofb(), idx);
243 }
244
245 # ifndef OPENSSL_NO_CHACHA
test_bio_enc_chacha20(int idx)246 static int test_bio_enc_chacha20(int idx)
247 {
248 return do_test_bio_cipher(EVP_chacha20(), idx);
249 }
250
251 # ifndef OPENSSL_NO_POLY1305
test_bio_enc_chacha20_poly1305(int idx)252 static int test_bio_enc_chacha20_poly1305(int idx)
253 {
254 return do_test_bio_cipher(EVP_chacha20_poly1305(), idx);
255 }
256 # endif
257 # endif
258
setup_tests(void)259 int setup_tests(void)
260 {
261 ADD_ALL_TESTS(test_bio_enc_aes_128_cbc, 2);
262 ADD_ALL_TESTS(test_bio_enc_aes_128_ctr, 2);
263 ADD_ALL_TESTS(test_bio_enc_aes_256_cfb, 2);
264 ADD_ALL_TESTS(test_bio_enc_aes_256_ofb, 2);
265 # ifndef OPENSSL_NO_CHACHA
266 ADD_ALL_TESTS(test_bio_enc_chacha20, 2);
267 # ifndef OPENSSL_NO_POLY1305
268 ADD_ALL_TESTS(test_bio_enc_chacha20_poly1305, 2);
269 # endif
270 # endif
271 return 1;
272 }
273
