TrustedFirmware Git Browser
Code Review Sign In
review.trustedfirmware.org / mirror / mbed-tls / ae59c5232274df36b1b58dd52eb74cb153829a1a / . / tests / suites / test_suite_blowfish.function
blob: 95417113dd8be5ec54213373968cc5ce1b8153dd [file] [log] [blame]
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]1/* BEGIN_HEADER */
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +0000[diff] [blame]2#include "mbedtls/blowfish.h"
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]3/* END_HEADER */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]4
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]5/* BEGIN_DEPENDENCIES
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]6 * depends_on:MBEDTLS_BLOWFISH_C
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]7 * END_DEPENDENCIES
8 */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]9
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]10/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]11void blowfish_valid_param()
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500[diff] [blame]12{
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]13 TEST_VALID_PARAM(mbedtls_blowfish_free(NULL));
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500[diff] [blame]14}
15/* END_CASE */
16
17/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]18void blowfish_invalid_param()
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500[diff] [blame]19{
20 mbedtls_blowfish_context ctx;
21 unsigned char buf[16] = { 0 };
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]22 size_t const valid_keylength = sizeof(buf) * 8;
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500[diff] [blame]23 size_t valid_mode = MBEDTLS_BLOWFISH_ENCRYPT;
24 size_t invalid_mode = 42;
25 size_t off;
26 ((void) off);
27
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]28 TEST_INVALID_PARAM(mbedtls_blowfish_init(NULL));
29 TEST_VALID_PARAM(mbedtls_blowfish_free(NULL));
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500[diff] [blame]30
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]31 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
32 mbedtls_blowfish_setkey(NULL,
33 buf,
34 valid_keylength));
35 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
36 mbedtls_blowfish_setkey(&ctx,
37 NULL,
38 valid_keylength));
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500[diff] [blame]39
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]40 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
41 mbedtls_blowfish_crypt_ecb(NULL,
42 valid_mode,
43 buf, buf));
44 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
45 mbedtls_blowfish_crypt_ecb(&ctx,
46 invalid_mode,
47 buf, buf));
48 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
49 mbedtls_blowfish_crypt_ecb(&ctx,
50 valid_mode,
51 NULL, buf));
52 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
53 mbedtls_blowfish_crypt_ecb(&ctx,
54 valid_mode,
55 buf, NULL));
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500[diff] [blame]56
57#if defined(MBEDTLS_CIPHER_MODE_CBC)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]58 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
59 mbedtls_blowfish_crypt_cbc(NULL,
60 valid_mode,
61 sizeof(buf),
62 buf, buf, buf));
63 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
64 mbedtls_blowfish_crypt_cbc(&ctx,
65 invalid_mode,
66 sizeof(buf),
67 buf, buf, buf));
68 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
69 mbedtls_blowfish_crypt_cbc(&ctx,
70 valid_mode,
71 sizeof(buf),
72 NULL, buf, buf));
73 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
74 mbedtls_blowfish_crypt_cbc(&ctx,
75 valid_mode,
76 sizeof(buf),
77 buf, NULL, buf));
78 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
79 mbedtls_blowfish_crypt_cbc(&ctx,
80 valid_mode,
81 sizeof(buf),
82 buf, buf, NULL));
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500[diff] [blame]83#endif /* MBEDTLS_CIPHER_MODE_CBC */
84
85#if defined(MBEDTLS_CIPHER_MODE_CFB)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]86 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
87 mbedtls_blowfish_crypt_cfb64(NULL,
88 valid_mode,
89 sizeof(buf),
90 &off, buf,
91 buf, buf));
92 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
93 mbedtls_blowfish_crypt_cfb64(&ctx,
94 invalid_mode,
95 sizeof(buf),
96 &off, buf,
97 buf, buf));
98 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
99 mbedtls_blowfish_crypt_cfb64(&ctx,
100 valid_mode,
101 sizeof(buf),
102 NULL, buf,
103 buf, buf));
104 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
105 mbedtls_blowfish_crypt_cfb64(&ctx,
106 valid_mode,
107 sizeof(buf),
108 &off, NULL,
109 buf, buf));
110 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
111 mbedtls_blowfish_crypt_cfb64(&ctx,
112 valid_mode,
113 sizeof(buf),
114 &off, buf,
115 NULL, buf));
116 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
117 mbedtls_blowfish_crypt_cfb64(&ctx,
118 valid_mode,
119 sizeof(buf),
120 &off, buf,
121 buf, NULL));
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500[diff] [blame]122#endif /* MBEDTLS_CIPHER_MODE_CFB */
123
124#if defined(MBEDTLS_CIPHER_MODE_CTR)
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]125 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
126 mbedtls_blowfish_crypt_ctr(NULL,
127 sizeof(buf),
128 &off,
129 buf, buf,
130 buf, buf));
131 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
132 mbedtls_blowfish_crypt_ctr(&ctx,
133 sizeof(buf),
134 NULL,
135 buf, buf,
136 buf, buf));
137 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
138 mbedtls_blowfish_crypt_ctr(&ctx,
139 sizeof(buf),
140 &off,
141 NULL, buf,
142 buf, buf));
143 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
144 mbedtls_blowfish_crypt_ctr(&ctx,
145 sizeof(buf),
146 &off,
147 buf, NULL,
148 buf, buf));
149 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
150 mbedtls_blowfish_crypt_ctr(&ctx,
151 sizeof(buf),
152 &off,
153 buf, buf,
154 NULL, buf));
155 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
156 mbedtls_blowfish_crypt_ctr(&ctx,
157 sizeof(buf),
158 &off,
159 buf, buf,
160 buf, NULL));
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500[diff] [blame]161#endif /* MBEDTLS_CIPHER_MODE_CTR */
162
163exit:
164 return;
165}
166/* END_CASE */
167
168/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]169void blowfish_encrypt_ecb(data_t *key_str, data_t *src_str,
170 data_t *dst, int setkey_result)
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]171{
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]172 unsigned char output[100];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]173 mbedtls_blowfish_context ctx;
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]174
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]175 memset(output, 0x00, 100);
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]176 mbedtls_blowfish_init(&ctx);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]177
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]178
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]179 TEST_ASSERT(mbedtls_blowfish_setkey(&ctx, key_str->x, key_str->len * 8) == setkey_result);
180 if (setkey_result == 0) {
181 TEST_ASSERT(mbedtls_blowfish_crypt_ecb(&ctx, MBEDTLS_BLOWFISH_ENCRYPT, src_str->x,
182 output) == 0);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]183
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]184 TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 8, dst->len) == 0);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]185 }
Paul Bakker8cfd9d82014-06-18 11:16:11 +0200[diff] [blame]186
Paul Bakkerbd51b262014-07-10 15:26:12 +0200[diff] [blame]187exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]188 mbedtls_blowfish_free(&ctx);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]189}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]190/* END_CASE */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]191
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]192/* BEGIN_CASE */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]193void blowfish_decrypt_ecb(data_t *key_str, data_t *src_str,
194 data_t *dst, int setkey_result)
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]195{
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]196 unsigned char output[100];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]197 mbedtls_blowfish_context ctx;
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]198
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]199 memset(output, 0x00, 100);
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]200 mbedtls_blowfish_init(&ctx);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]201
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]202
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]203 TEST_ASSERT(mbedtls_blowfish_setkey(&ctx, key_str->x, key_str->len * 8) == setkey_result);
204 if (setkey_result == 0) {
205 TEST_ASSERT(mbedtls_blowfish_crypt_ecb(&ctx, MBEDTLS_BLOWFISH_DECRYPT, src_str->x,
206 output) == 0);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]207
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]208 TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 8, dst->len) == 0);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]209 }
Paul Bakker8cfd9d82014-06-18 11:16:11 +0200[diff] [blame]210
Paul Bakkerbd51b262014-07-10 15:26:12 +0200[diff] [blame]211exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]212 mbedtls_blowfish_free(&ctx);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]213}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]214/* END_CASE */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]215
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]216/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]217void blowfish_encrypt_cbc(data_t *key_str, data_t *iv_str,
218 data_t *src_str, data_t *dst,
219 int cbc_result)
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]220{
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]221 unsigned char output[100];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]222 mbedtls_blowfish_context ctx;
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]223
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]224 memset(output, 0x00, 100);
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]225 mbedtls_blowfish_init(&ctx);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]226
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]227
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]228 mbedtls_blowfish_setkey(&ctx, key_str->x, key_str->len * 8);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]229
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]230 TEST_ASSERT(mbedtls_blowfish_crypt_cbc(&ctx, MBEDTLS_BLOWFISH_ENCRYPT, src_str->len, iv_str->x,
231 src_str->x, output) == cbc_result);
232 if (cbc_result == 0) {
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]233
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]234 TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
235 src_str->len, dst->len) == 0);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]236 }
Paul Bakker8cfd9d82014-06-18 11:16:11 +0200[diff] [blame]237
Paul Bakkerbd51b262014-07-10 15:26:12 +0200[diff] [blame]238exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]239 mbedtls_blowfish_free(&ctx);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]240}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]241/* END_CASE */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]242
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]243/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]244void blowfish_decrypt_cbc(data_t *key_str, data_t *iv_str,
245 data_t *src_str, data_t *dst,
246 int cbc_result)
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]247{
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]248 unsigned char output[100];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]249 mbedtls_blowfish_context ctx;
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]250
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]251 memset(output, 0x00, 100);
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]252 mbedtls_blowfish_init(&ctx);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]253
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]254
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]255 mbedtls_blowfish_setkey(&ctx, key_str->x, key_str->len * 8);
256 TEST_ASSERT(mbedtls_blowfish_crypt_cbc(&ctx, MBEDTLS_BLOWFISH_DECRYPT, src_str->len, iv_str->x,
257 src_str->x, output) == cbc_result);
258 if (cbc_result == 0) {
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]259
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]260 TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, src_str->len,
261 dst->len) == 0);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]262 }
Paul Bakker8cfd9d82014-06-18 11:16:11 +0200[diff] [blame]263
Paul Bakkerbd51b262014-07-10 15:26:12 +0200[diff] [blame]264exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]265 mbedtls_blowfish_free(&ctx);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]266}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]267/* END_CASE */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]268
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]269/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]270void blowfish_encrypt_cfb64(data_t *key_str, data_t *iv_str,
271 data_t *src_str, data_t *dst)
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]272{
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]273 unsigned char output[100];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]274 mbedtls_blowfish_context ctx;
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]275 size_t iv_offset = 0;
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]276
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]277 memset(output, 0x00, 100);
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]278 mbedtls_blowfish_init(&ctx);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]279
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]280
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]281 mbedtls_blowfish_setkey(&ctx, key_str->x, key_str->len * 8);
282 TEST_ASSERT(mbedtls_blowfish_crypt_cfb64(&ctx, MBEDTLS_BLOWFISH_ENCRYPT, src_str->len,
283 &iv_offset, iv_str->x, src_str->x, output) == 0);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]284
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]285 TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, src_str->len,
286 dst->len) == 0);
Paul Bakker8cfd9d82014-06-18 11:16:11 +0200[diff] [blame]287
Paul Bakkerbd51b262014-07-10 15:26:12 +0200[diff] [blame]288exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]289 mbedtls_blowfish_free(&ctx);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]290}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]291/* END_CASE */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]292
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]293/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]294void blowfish_decrypt_cfb64(data_t *key_str, data_t *iv_str,
295 data_t *src_str, data_t *dst)
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]296{
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]297 unsigned char output[100];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]298 mbedtls_blowfish_context ctx;
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]299 size_t iv_offset = 0;
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]300
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]301 memset(output, 0x00, 100);
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]302 mbedtls_blowfish_init(&ctx);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]303
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]304
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]305 mbedtls_blowfish_setkey(&ctx, key_str->x, key_str->len * 8);
306 TEST_ASSERT(mbedtls_blowfish_crypt_cfb64(&ctx, MBEDTLS_BLOWFISH_DECRYPT, src_str->len,
307 &iv_offset, iv_str->x, src_str->x, output) == 0);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]308
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]309 TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, src_str->len,
310 dst->len) == 0);
Paul Bakker8cfd9d82014-06-18 11:16:11 +0200[diff] [blame]311
Paul Bakkerbd51b262014-07-10 15:26:12 +0200[diff] [blame]312exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]313 mbedtls_blowfish_free(&ctx);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]314}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]315/* END_CASE */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]316
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]317/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CTR */
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]318void blowfish_encrypt_ctr(data_t *key_str, data_t *iv_str,
319 data_t *src_str, data_t *dst)
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]320{
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]321 unsigned char stream_str[100];
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]322 unsigned char output[100];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]323 mbedtls_blowfish_context ctx;
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]324 size_t iv_offset = 0;
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]325
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]326 memset(stream_str, 0x00, 100);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]327 memset(output, 0x00, 100);
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]328 mbedtls_blowfish_init(&ctx);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]329
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]330
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]331 mbedtls_blowfish_setkey(&ctx, key_str->x, key_str->len * 8);
332 TEST_ASSERT(mbedtls_blowfish_crypt_ctr(&ctx, src_str->len, &iv_offset, iv_str->x, stream_str,
333 src_str->x, output) == 0);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]334
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]335 TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, src_str->len,
336 dst->len) == 0);
Paul Bakker8cfd9d82014-06-18 11:16:11 +0200[diff] [blame]337
Paul Bakkerbd51b262014-07-10 15:26:12 +0200[diff] [blame]338exit:
Gilles Peskine1b6c09a2023-01-11 14:52:35 +0100[diff] [blame]339 mbedtls_blowfish_free(&ctx);
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]340}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]341/* END_CASE */