1/* BEGIN_HEADER */ 2#include "mbedtls/blowfish.h" 3/* END_HEADER */ 4 5/* BEGIN_DEPENDENCIES 6 * depends_on:MBEDTLS_BLOWFISH_C 7 * END_DEPENDENCIES 8 */ 9 10/* BEGIN_CASE */ 11void blowfish_valid_param( ) 12{ 13 TEST_VALID_PARAM( mbedtls_blowfish_free( NULL ) ); 14} 15/* END_CASE */ 16 17/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */ 18void blowfish_invalid_param( ) 19{ 20 mbedtls_blowfish_context ctx; 21 unsigned char buf[16] = { 0 }; 22 size_t const valid_keylength = sizeof( buf ) * 8; 23 size_t valid_mode = MBEDTLS_BLOWFISH_ENCRYPT; 24 size_t invalid_mode = 42; 25 size_t off; 26 ((void) off); 27 28 TEST_INVALID_PARAM( mbedtls_blowfish_init( NULL ) ); 29 TEST_VALID_PARAM( mbedtls_blowfish_free( NULL ) ); 30 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 ) ); 39 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 ) ); 56 57#if defined(MBEDTLS_CIPHER_MODE_CBC) 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 ) ); 83#endif /* MBEDTLS_CIPHER_MODE_CBC */ 84 85#if defined(MBEDTLS_CIPHER_MODE_CFB) 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 ) ); 122#endif /* MBEDTLS_CIPHER_MODE_CFB */ 123 124#if defined(MBEDTLS_CIPHER_MODE_CTR) 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 ) ); 161#endif /* MBEDTLS_CIPHER_MODE_CTR */ 162 163exit: 164 return; 165} 166/* END_CASE */ 167 168/* BEGIN_CASE */ 169void blowfish_encrypt_ecb( data_t * key_str, data_t * src_str, 170 data_t * dst, int setkey_result ) 171{ 172 unsigned char output[100]; 173 mbedtls_blowfish_context ctx; 174 175 memset(output, 0x00, 100); 176 mbedtls_blowfish_init( &ctx ); 177 178 179 TEST_ASSERT( mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 ) == setkey_result ); 180 if( setkey_result == 0 ) 181 { 182 TEST_ASSERT( mbedtls_blowfish_crypt_ecb( &ctx, MBEDTLS_BLOWFISH_ENCRYPT, src_str->x, output ) == 0 ); 183 184 TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 8, dst->len ) == 0 ); 185 } 186 187exit: 188 mbedtls_blowfish_free( &ctx ); 189} 190/* END_CASE */ 191 192/* BEGIN_CASE */ 193void blowfish_decrypt_ecb( data_t * key_str, data_t * src_str, 194 data_t * dst, int setkey_result ) 195{ 196 unsigned char output[100]; 197 mbedtls_blowfish_context ctx; 198 199 memset(output, 0x00, 100); 200 mbedtls_blowfish_init( &ctx ); 201 202 203 TEST_ASSERT( mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 ) == setkey_result ); 204 if( setkey_result == 0 ) 205 { 206 TEST_ASSERT( mbedtls_blowfish_crypt_ecb( &ctx, MBEDTLS_BLOWFISH_DECRYPT, src_str->x, output ) == 0 ); 207 208 TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 8, dst->len ) == 0 ); 209 } 210 211exit: 212 mbedtls_blowfish_free( &ctx ); 213} 214/* END_CASE */ 215 216/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */ 217void blowfish_encrypt_cbc( data_t * key_str, data_t * iv_str, 218 data_t * src_str, data_t * dst, 219 int cbc_result ) 220{ 221 unsigned char output[100]; 222 mbedtls_blowfish_context ctx; 223 224 memset(output, 0x00, 100); 225 mbedtls_blowfish_init( &ctx ); 226 227 228 mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 ); 229 230 TEST_ASSERT( mbedtls_blowfish_crypt_cbc( &ctx, MBEDTLS_BLOWFISH_ENCRYPT, src_str->len , iv_str->x, src_str->x, output ) == cbc_result ); 231 if( cbc_result == 0 ) 232 { 233 234 TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 235 src_str->len, dst->len ) == 0 ); 236 } 237 238exit: 239 mbedtls_blowfish_free( &ctx ); 240} 241/* END_CASE */ 242 243/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */ 244void blowfish_decrypt_cbc( data_t * key_str, data_t * iv_str, 245 data_t * src_str, data_t * dst, 246 int cbc_result ) 247{ 248 unsigned char output[100]; 249 mbedtls_blowfish_context ctx; 250 251 memset(output, 0x00, 100); 252 mbedtls_blowfish_init( &ctx ); 253 254 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, src_str->x, output ) == cbc_result ); 257 if( cbc_result == 0) 258 { 259 260 TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, src_str->len, 261 dst->len ) == 0 ); 262 } 263 264exit: 265 mbedtls_blowfish_free( &ctx ); 266} 267/* END_CASE */ 268 269/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */ 270void blowfish_encrypt_cfb64( data_t * key_str, data_t * iv_str, 271 data_t * src_str, data_t * dst ) 272{ 273 unsigned char output[100]; 274 mbedtls_blowfish_context ctx; 275 size_t iv_offset = 0; 276 277 memset(output, 0x00, 100); 278 mbedtls_blowfish_init( &ctx ); 279 280 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, &iv_offset, iv_str->x, src_str->x, output ) == 0 ); 283 284 TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, src_str->len, 285 dst->len ) == 0 ); 286 287exit: 288 mbedtls_blowfish_free( &ctx ); 289} 290/* END_CASE */ 291 292/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */ 293void blowfish_decrypt_cfb64( data_t * key_str, data_t * iv_str, 294 data_t * src_str, data_t * dst ) 295{ 296 unsigned char output[100]; 297 mbedtls_blowfish_context ctx; 298 size_t iv_offset = 0; 299 300 memset(output, 0x00, 100); 301 mbedtls_blowfish_init( &ctx ); 302 303 304 mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 ); 305 TEST_ASSERT( mbedtls_blowfish_crypt_cfb64( &ctx, MBEDTLS_BLOWFISH_DECRYPT, src_str->len, &iv_offset, iv_str->x, src_str->x, output ) == 0 ); 306 307 TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, src_str->len, 308 dst->len ) == 0 ); 309 310exit: 311 mbedtls_blowfish_free( &ctx ); 312} 313/* END_CASE */ 314 315/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CTR */ 316void blowfish_encrypt_ctr( data_t * key_str, data_t * iv_str, 317 data_t * src_str, data_t * dst ) 318{ 319 unsigned char stream_str[100]; 320 unsigned char output[100]; 321 mbedtls_blowfish_context ctx; 322 size_t iv_offset = 0; 323 324 memset(stream_str, 0x00, 100); 325 memset(output, 0x00, 100); 326 mbedtls_blowfish_init( &ctx ); 327 328 329 mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 ); 330 TEST_ASSERT( mbedtls_blowfish_crypt_ctr( &ctx, src_str->len, &iv_offset, iv_str->x, stream_str, src_str->x, output ) == 0 ); 331 332 TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, src_str->len, 333 dst->len ) == 0 ); 334 335exit: 336 mbedtls_blowfish_free( &ctx ); 337} 338/* END_CASE */ 339