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 * hex_dst_string, 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( hexcmp( output, hex_dst_string->x, 8, hex_dst_string->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 * hex_dst_string, 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( hexcmp( output, hex_dst_string->x, 8, hex_dst_string->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 * hex_dst_string, 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( hexcmp( output, hex_dst_string->x, src_str->len, hex_dst_string->len ) == 0 ); 235 } 236 237exit: 238 mbedtls_blowfish_free( &ctx ); 239} 240/* END_CASE */ 241 242/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */ 243void blowfish_decrypt_cbc( data_t * key_str, data_t * iv_str, 244 data_t * src_str, data_t * hex_dst_string, 245 int cbc_result ) 246{ 247 unsigned char output[100]; 248 mbedtls_blowfish_context ctx; 249 250 memset(output, 0x00, 100); 251 mbedtls_blowfish_init( &ctx ); 252 253 254 mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 ); 255 TEST_ASSERT( mbedtls_blowfish_crypt_cbc( &ctx, MBEDTLS_BLOWFISH_DECRYPT, src_str->len , iv_str->x, src_str->x, output ) == cbc_result ); 256 if( cbc_result == 0) 257 { 258 259 TEST_ASSERT( hexcmp( output, hex_dst_string->x, src_str->len, hex_dst_string->len ) == 0 ); 260 } 261 262exit: 263 mbedtls_blowfish_free( &ctx ); 264} 265/* END_CASE */ 266 267/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */ 268void blowfish_encrypt_cfb64( data_t * key_str, data_t * iv_str, 269 data_t * src_str, data_t * hex_dst_string 270 ) 271{ 272 unsigned char output[100]; 273 mbedtls_blowfish_context ctx; 274 size_t iv_offset = 0; 275 276 memset(output, 0x00, 100); 277 mbedtls_blowfish_init( &ctx ); 278 279 280 mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 ); 281 TEST_ASSERT( mbedtls_blowfish_crypt_cfb64( &ctx, MBEDTLS_BLOWFISH_ENCRYPT, src_str->len, &iv_offset, iv_str->x, src_str->x, output ) == 0 ); 282 283 TEST_ASSERT( hexcmp( output, hex_dst_string->x, src_str->len, hex_dst_string->len ) == 0 ); 284 285exit: 286 mbedtls_blowfish_free( &ctx ); 287} 288/* END_CASE */ 289 290/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */ 291void blowfish_decrypt_cfb64( data_t * key_str, data_t * iv_str, 292 data_t * src_str, data_t * hex_dst_string 293 ) 294{ 295 unsigned char output[100]; 296 mbedtls_blowfish_context ctx; 297 size_t iv_offset = 0; 298 299 memset(output, 0x00, 100); 300 mbedtls_blowfish_init( &ctx ); 301 302 303 mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 ); 304 TEST_ASSERT( mbedtls_blowfish_crypt_cfb64( &ctx, MBEDTLS_BLOWFISH_DECRYPT, src_str->len, &iv_offset, iv_str->x, src_str->x, output ) == 0 ); 305 306 TEST_ASSERT( hexcmp( output, hex_dst_string->x, src_str->len, hex_dst_string->len ) == 0 ); 307 308exit: 309 mbedtls_blowfish_free( &ctx ); 310} 311/* END_CASE */ 312 313/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CTR */ 314void blowfish_encrypt_ctr( data_t * key_str, data_t * iv_str, 315 data_t * src_str, data_t * hex_dst_string ) 316{ 317 unsigned char stream_str[100]; 318 unsigned char output[100]; 319 mbedtls_blowfish_context ctx; 320 size_t iv_offset = 0; 321 322 memset(stream_str, 0x00, 100); 323 memset(output, 0x00, 100); 324 mbedtls_blowfish_init( &ctx ); 325 326 327 mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 ); 328 TEST_ASSERT( mbedtls_blowfish_crypt_ctr( &ctx, src_str->len, &iv_offset, iv_str->x, stream_str, src_str->x, output ) == 0 ); 329 330 TEST_ASSERT( hexcmp( output, hex_dst_string->x, src_str->len, hex_dst_string->len ) == 0 ); 331 332exit: 333 mbedtls_blowfish_free( &ctx ); 334} 335/* END_CASE */ 336