third_party/mbedtls/repo/tests/suites/test_suite_shax.function

   1 /* BEGIN_HEADER */
   2 #include "mbedtls/sha1.h"
   3 #include "mbedtls/sha256.h"
   4 #include "mbedtls/sha512.h"
   5 /* END_HEADER */
   6
   7 /* BEGIN_CASE depends_on:MBEDTLS_SHA1_C */
   8 void sha1_valid_param( )
   9 {
  10     TEST_VALID_PARAM( mbedtls_sha1_free( NULL ) );
  11 }
  12 /* END_CASE */
  13
  14 /* BEGIN_CASE depends_on:MBEDTLS_SHA1_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
  15 void sha1_invalid_param( )
  16 {
  17     mbedtls_sha1_context ctx;
  18     unsigned char buf[64] = { 0 };
  19     size_t const buflen = sizeof( buf );
  20
  21     TEST_INVALID_PARAM( mbedtls_sha1_init( NULL ) );
  22
  23     TEST_INVALID_PARAM( mbedtls_sha1_clone( NULL, &ctx ) );
  24     TEST_INVALID_PARAM( mbedtls_sha1_clone( &ctx, NULL ) );
  25
  26     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
  27                             mbedtls_sha1_starts_ret( NULL ) );
  28
  29     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
  30                             mbedtls_sha1_update_ret( NULL, buf, buflen ) );
  31     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
  32                             mbedtls_sha1_update_ret( &ctx, NULL, buflen ) );
  33
  34     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
  35                             mbedtls_sha1_finish_ret( NULL, buf ) );
  36     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
  37                             mbedtls_sha1_finish_ret( &ctx, NULL ) );
  38
  39     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
  40                             mbedtls_internal_sha1_process( NULL, buf ) );
  41     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
  42                             mbedtls_internal_sha1_process( &ctx, NULL ) );
  43
  44     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
  45                             mbedtls_sha1_ret( NULL, buflen, buf ) );
  46     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
  47                             mbedtls_sha1_ret( buf, buflen, NULL ) );
  48
  49 exit:
  50     return;
  51 }
  52 /* END_CASE */
  53
  54 /* BEGIN_CASE depends_on:MBEDTLS_SHA1_C */
  55 void mbedtls_sha1( data_t * src_str, data_t * hex_hash_string )
  56 {
  57     unsigned char output[41];
  58
  59     memset(output, 0x00, 41);
  60
  61
  62     TEST_ASSERT( mbedtls_sha1_ret( src_str->x, src_str->len, output ) == 0 );
  63
  64     TEST_ASSERT( hexcmp( output, hex_hash_string->x, 20, hex_hash_string->len ) == 0 );
  65 }
  66 /* END_CASE */
  67
  68 /* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
  69 void sha256_valid_param( )
  70 {
  71     TEST_VALID_PARAM( mbedtls_sha256_free( NULL ) );
  72 }
  73 /* END_CASE */
  74
  75 /* BEGIN_CASE depends_on:MBEDTLS_SHA256_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
  76 void sha256_invalid_param( )
  77 {
  78     mbedtls_sha256_context ctx;
  79     unsigned char buf[64] = { 0 };
  80     size_t const buflen = sizeof( buf );
  81     int valid_type = 0;
  82     int invalid_type = 42;
  83
  84     TEST_INVALID_PARAM( mbedtls_sha256_init( NULL ) );
  85
  86     TEST_INVALID_PARAM( mbedtls_sha256_clone( NULL, &ctx ) );
  87     TEST_INVALID_PARAM( mbedtls_sha256_clone( &ctx, NULL ) );
  88
  89     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
  90                             mbedtls_sha256_starts_ret( NULL, valid_type ) );
  91     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
  92                             mbedtls_sha256_starts_ret( &ctx, invalid_type ) );
  93
  94     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
  95                             mbedtls_sha256_update_ret( NULL, buf, buflen ) );
  96     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
  97                             mbedtls_sha256_update_ret( &ctx, NULL, buflen ) );
  98
  99     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
 100                             mbedtls_sha256_finish_ret( NULL, buf ) );
 101     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
 102                             mbedtls_sha256_finish_ret( &ctx, NULL ) );
 103
 104     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
 105                             mbedtls_internal_sha256_process( NULL, buf ) );
 106     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
 107                             mbedtls_internal_sha256_process( &ctx, NULL ) );
 108
 109     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
 110                             mbedtls_sha256_ret( NULL, buflen,
 111                                                 buf, valid_type ) );
 112     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
 113                             mbedtls_sha256_ret( buf, buflen,
 114                                                 NULL, valid_type ) );
 115     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
 116                             mbedtls_sha256_ret( buf, buflen,
 117                                                 buf, invalid_type ) );
 118
 119 exit:
 120     return;
 121 }
 122 /* END_CASE */
 123
 124 /* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
 125 void sha224( data_t * src_str, data_t * hex_hash_string )
 126 {
 127     unsigned char output[57];
 128
 129     memset(output, 0x00, 57);
 130
 131
 132     TEST_ASSERT( mbedtls_sha256_ret( src_str->x, src_str->len, output, 1 ) == 0 );
 133
 134     TEST_ASSERT( hexcmp( output, hex_hash_string->x, 28, hex_hash_string->len ) == 0 );
 135 }
 136 /* END_CASE */
 137
 138 /* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
 139 void mbedtls_sha256( data_t * src_str, data_t * hex_hash_string )
 140 {
 141     unsigned char output[65];
 142
 143     memset(output, 0x00, 65);
 144
 145
 146     TEST_ASSERT( mbedtls_sha256_ret( src_str->x, src_str->len, output, 0 ) == 0 );
 147
 148     TEST_ASSERT( hexcmp( output, hex_hash_string->x, 32, hex_hash_string->len ) == 0 );
 149 }
 150 /* END_CASE */
 151
 152 /* BEGIN_CASE depends_on:MBEDTLS_SHA512_C */
 153 void sha512_valid_param( )
 154 {
 155     TEST_VALID_PARAM( mbedtls_sha512_free( NULL ) );
 156 }
 157 /* END_CASE */
 158
 159 /* BEGIN_CASE depends_on:MBEDTLS_SHA512_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
 160 void sha512_invalid_param( )
 161 {
 162     mbedtls_sha512_context ctx;
 163     unsigned char buf[64] = { 0 };
 164     size_t const buflen = sizeof( buf );
 165     int valid_type = 0;
 166     int invalid_type = 42;
 167
 168     TEST_INVALID_PARAM( mbedtls_sha512_init( NULL ) );
 169
 170     TEST_INVALID_PARAM( mbedtls_sha512_clone( NULL, &ctx ) );
 171     TEST_INVALID_PARAM( mbedtls_sha512_clone( &ctx, NULL ) );
 172
 173     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
 174                             mbedtls_sha512_starts_ret( NULL, valid_type ) );
 175     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
 176                             mbedtls_sha512_starts_ret( &ctx, invalid_type ) );
 177
 178     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
 179                             mbedtls_sha512_update_ret( NULL, buf, buflen ) );
 180     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
 181                             mbedtls_sha512_update_ret( &ctx, NULL, buflen ) );
 182
 183     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
 184                             mbedtls_sha512_finish_ret( NULL, buf ) );
 185     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
 186                             mbedtls_sha512_finish_ret( &ctx, NULL ) );
 187
 188     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
 189                             mbedtls_internal_sha512_process( NULL, buf ) );
 190     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
 191                             mbedtls_internal_sha512_process( &ctx, NULL ) );
 192
 193     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
 194                             mbedtls_sha512_ret( NULL, buflen,
 195                                                 buf, valid_type ) );
 196     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
 197                             mbedtls_sha512_ret( buf, buflen,
 198                                                 NULL, valid_type ) );
 199     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
 200                             mbedtls_sha512_ret( buf, buflen,
 201                                                 buf, invalid_type ) );
 202
 203 exit:
 204     return;
 205 }
 206 /* END_CASE */
 207
 208 /* BEGIN_CASE depends_on:MBEDTLS_SHA512_C */
 209 void sha384( data_t * src_str, data_t * hex_hash_string )
 210 {
 211     unsigned char output[97];
 212
 213     memset(output, 0x00, 97);
 214
 215
 216     TEST_ASSERT( mbedtls_sha512_ret( src_str->x, src_str->len, output, 1 ) == 0 );
 217
 218     TEST_ASSERT( hexcmp( output, hex_hash_string->x, 48, hex_hash_string->len ) == 0 );
 219 }
 220 /* END_CASE */
 221
 222 /* BEGIN_CASE depends_on:MBEDTLS_SHA512_C */
 223 void mbedtls_sha512( data_t * src_str, data_t * hex_hash_string )
 224 {
 225     unsigned char output[129];
 226
 227     memset(output, 0x00, 129);
 228
 229
 230     TEST_ASSERT( mbedtls_sha512_ret( src_str->x, src_str->len, output, 0 ) == 0 );
 231
 232     TEST_ASSERT( hexcmp( output, hex_hash_string->x, 64, hex_hash_string->len ) == 0 );
 233 }
 234 /* END_CASE */
 235
 236 /* BEGIN_CASE depends_on:MBEDTLS_SHA1_C:MBEDTLS_SELF_TEST */
 237 void sha1_selftest(  )
 238 {
 239     TEST_ASSERT( mbedtls_sha1_self_test( 1 ) == 0 );
 240 }
 241 /* END_CASE */
 242
 243 /* BEGIN_CASE depends_on:MBEDTLS_SHA256_C:MBEDTLS_SELF_TEST */
 244 void sha256_selftest(  )
 245 {
 246     TEST_ASSERT( mbedtls_sha256_self_test( 1 ) == 0 );
 247 }
 248 /* END_CASE */
 249
 250 /* BEGIN_CASE depends_on:MBEDTLS_SHA512_C:MBEDTLS_SELF_TEST */
 251 void sha512_selftest(  )
 252 {
 253     TEST_ASSERT( mbedtls_sha512_self_test( 1 ) == 0 );
 254 }
 255 /* END_CASE */