Branch data     Line data    Source code

       1                 :             : #include <edhoc.h>
       2                 :             : #include <zephyr/ztest.h>
       3                 :             : #include <zephyr/debug/thread_analyzer.h>
       4                 :             : #include "edhoc_test_vectors_exporter_v15.h"
       5                 :             : 
       6                 :           1 : void test_exporter(void)
       7                 :             : {
       8                 :           1 :         enum err err;
       9                 :             : 
      10                 :           1 :         uint8_t prk_exporter_buf[32];
      11                 :           1 :         struct byte_array prk_exporter = { .ptr = prk_exporter_buf,
      12                 :             :                                            .len = sizeof(prk_exporter_buf) };
      13                 :             : 
      14                 :           1 :         uint8_t prk_out_new_buf[32];
      15                 :           1 :         struct byte_array prk_out_new = { .ptr = prk_out_new_buf,
      16                 :             :                                           .len = sizeof(prk_out_new_buf) };
      17                 :             : 
      18                 :           1 :         uint8_t master_secret_buf[16];
      19                 :           1 :         struct byte_array master_secret = { .ptr = master_secret_buf,
      20                 :             :                                             .len = sizeof(master_secret_buf) };
      21                 :             : 
      22                 :           1 :         uint8_t master_salt_buf[8];
      23                 :           1 :         struct byte_array master_salt = { .ptr = master_salt_buf,
      24                 :             :                                           .len = sizeof(master_salt_buf) };
      25                 :             : 
      26                 :           1 :         struct byte_array prk_out = { .ptr = T1_PRK_OUT,
      27                 :             :                                       .len = sizeof(T1_PRK_OUT) };
      28                 :           1 :         struct byte_array context = { .ptr = T1_KEY_UPDATE_CONTEXT,
      29                 :             :                                       .len = sizeof(T1_KEY_UPDATE_CONTEXT) };
      30                 :             :         /***/
      31                 :             :         /***/
      32                 :           1 :         err = prk_out_update(SHA_256, &prk_out, &context, &prk_out_new);
      33                 :             : 
      34                 :           1 :         zassert_true(err == 0, "prk_out_update failed");
      35                 :           1 :         zassert_mem_equal__(T1_PRK_OUT_NEW, prk_out_new.ptr, prk_out_new.len,
      36                 :             :                             "wrong prk_out_new");
      37                 :             :         /***/
      38                 :             :         /***/
      39                 :           1 :         err = prk_out2exporter(SHA_256, &prk_out, &prk_exporter);
      40                 :             : 
      41                 :           1 :         zassert_true(err == 0, "prk_out2exporter failed");
      42                 :           1 :         zassert_mem_equal__(T1_PRK_EXPORTER, prk_exporter.ptr, prk_exporter.len,
      43                 :             :                             "wrong prk_exporter");
      44                 :             :         /***/
      45                 :             :         /***/
      46                 :           1 :         err = edhoc_exporter(SHA_256, OSCORE_MASTER_SECRET, &prk_exporter,
      47                 :             :                              &master_secret);
      48                 :           1 :         zassert_true(err == 0, "edhoc_exporter failed");
      49                 :           1 :         zassert_mem_equal__(T1_OSCORE_MASTER_SECRET, master_secret.ptr,
      50                 :             :                             master_secret.len, "wrong master_secret");
      51                 :             :         /***/
      52                 :             :         /***/
      53                 :           1 :         err = edhoc_exporter(SHA_256, OSCORE_MASTER_SALT, &prk_exporter,
      54                 :             :                              &master_salt);
      55                 :           1 :         zassert_true(err == 0, "edhoc_exporter failed");
      56                 :           1 :         zassert_mem_equal__(T1_OSCORE_MASTER_SALT, master_salt.ptr,
      57                 :             :                             master_salt.len, "wrong master_salt");
      58                 :             : 
      59                 :             : #ifdef REPORT_STACK_USAGE
      60                 :             :         thread_analyzer_print();
      61                 :             : #endif
      62                 :           1 : }