Removed temporary KW functions and corrected ut and style

Mika Leppänen · Mika Leppänen · commit 2f4e0996864a · 2019-01-22T08:49:47.000+02:00
diff --git a/source/Security/protocols/fwh_sec_prot/supp_fwh_sec_prot.c b/source/Security/protocols/fwh_sec_prot/supp_fwh_sec_prot.c
@@ -499,8 +499,7 @@ static int8_t supp_fwh_kde_handle(sec_prot_t *prot)
     }
 
     switch (data->recv_msg) {
-        case FWH_MESSAGE_1:
-            {
+        case FWH_MESSAGE_1: {
             uint8_t recv_pmkid[PMKID_LEN];
             uint8_t calc_pmkid[PMKID_LEN];
             if (kde_pmkid_read(kde, kde_len, recv_pmkid) < 0) {
@@ -512,8 +511,8 @@ static int8_t supp_fwh_kde_handle(sec_prot_t *prot)
             if (memcmp(recv_pmkid, calc_pmkid, PMKID_LEN) != 0) {
                 goto error;
             }
-            }
-            break;
+        }
+        break;
 
         case FWH_MESSAGE_3:
             // If a valid new GTK value present, insert it
diff --git a/source/Security/protocols/gkh_sec_prot/auth_gkh_sec_prot.c b/source/Security/protocols/gkh_sec_prot/auth_gkh_sec_prot.c
@@ -201,8 +201,7 @@ static int8_t auth_gkh_sec_prot_message_send(sec_prot_t *prot, gkh_sec_prot_msg_
     uint8_t *kde_end = kde_start;
 
     switch (msg) {
-        case GKH_MESSAGE_1:
-            {
+        case GKH_MESSAGE_1: {
             int8_t gtk_set_index = prot->sec_keys->gtk_set_index;
             sec_prot_gtk_keys_t *gtks = prot->sec_keys->gtks;
             if (gtk_set_index >= 0 && gtks->gtk[gtk_set_index].set && gtks->gtk[gtk_set_index].live) {
@@ -211,8 +210,8 @@ static int8_t auth_gkh_sec_prot_message_send(sec_prot_t *prot, gkh_sec_prot_msg_
             kde_end = kde_lifetime_write(kde_end, GTK_DEFAULT_LIFETIME);
             kde_end = kde_gtkl_write(kde_end, gtks->gtk[0].live, gtks->gtk[1].live, gtks->gtk[2].live, gtks->gtk[3].live);
             kde_padding_write(kde_end, kde_start + kde_len);
-            }
-            break;
+        }
+        break;
         default:
             break;
     }
diff --git a/source/Security/protocols/gkh_sec_prot/supp_gkh_sec_prot.c b/source/Security/protocols/gkh_sec_prot/supp_gkh_sec_prot.c
@@ -310,7 +310,7 @@ static int8_t supp_gkh_kde_handle(sec_prot_t *prot)
     if (ret < 0 || prot->sec_keys->gtk_set_index < 0) {
         return -1;
     } else {
-       return 0;
+        return 0;
     }
 }
 
diff --git a/source/Security/protocols/sec_prot_lib.c b/source/Security/protocols/sec_prot_lib.c
@@ -364,7 +364,7 @@ int8_t sec_prot_lib_gtk_read(uint8_t *kde, uint16_t kde_len, sec_prot_gtk_keys_t
             *gtk_set_index = key_id; // Insert
         }
         uint32_t lifetime;
-        if (kde_lifetime_read(kde, kde_len, &lifetime) >=0 ) {
+        if (kde_lifetime_read(kde, kde_len, &lifetime) >= 0) {
             if (gtks->gtk[key_id].set) {
                 gtks->gtk[key_id].lifetime = lifetime;
             }
diff --git a/source/Service_Libs/nist_aes_kw/nist_aes_kw.c b/source/Service_Libs/nist_aes_kw/nist_aes_kw.c
@@ -23,7 +23,7 @@
 #include "mbedtls/nist_kw.h"
 #include "Service_Libs/nist_aes_kw/nist_aes_kw.h"
 
-#ifdef HAVE_WS
+#if defined(HAVE_WS) && (defined(HAVE_PAE_SUPP) || defined(HAVE_PAE_AUTH))
 
 #define TRACE_GROUP "naes"
 
@@ -99,58 +99,4 @@ int8_t nist_aes_key_wrap(uint8_t is_wrap, const uint8_t *key, int16_t key_bits,
     return ret_val;
 }
 
-#if !defined(MBEDTLS_NIST_KW_C)
-
-// Temporal implementation until MBEDTLS_NIST_KW_C is enabled on all platforms
-
-void mbedtls_nist_kw_init(mbedtls_nist_kw_context *ctx)
-{
-    (void) ctx;
-}
-
-int mbedtls_nist_kw_setkey(mbedtls_nist_kw_context *ctx,
-                           mbedtls_cipher_id_t cipher,
-                           const unsigned char *key,
-                           unsigned int keybits,
-                           const int is_wrap)
-{
-    (void) ctx;
-    (void) cipher;
-    (void) key;
-    (void) keybits;
-    (void) is_wrap;
-    return 0;
-}
-
-int mbedtls_nist_kw_wrap(mbedtls_nist_kw_context *ctx, mbedtls_nist_kw_mode_t mode,
-                         const unsigned char *input, size_t in_len,
-                         unsigned char *output, size_t *out_len, size_t out_size)
-{
-    (void) ctx;
-    (void) mode;
-    memset(output, 0, out_size);
-    memcpy(output, input, in_len);
-    *out_len = in_len + 8;
-    return 0;
-}
-
-int mbedtls_nist_kw_unwrap(mbedtls_nist_kw_context *ctx, mbedtls_nist_kw_mode_t mode,
-                           const unsigned char *input, size_t in_len,
-                           unsigned char *output, size_t *out_len, size_t out_size)
-{
-    (void) ctx;
-    (void) mode;
-    *out_len = in_len - 8;
-    memset(output, 0, out_size);
-    memcpy(output, input, *out_len);
-    return 0;
-}
-
-void mbedtls_nist_kw_free(mbedtls_nist_kw_context *ctx)
-{
-    (void) ctx;
-}
-
-#endif
-
 #endif
diff --git a/test/nanostack/unittest/service_libs/nist_aes_kw/test_nist_aes_kw.c b/test/nanostack/unittest/service_libs/nist_aes_kw/test_nist_aes_kw.c
@@ -25,6 +25,8 @@
 #include "mbedtls_stub.h"
 #include "test_nist_aes_kw.h"
 
+#if defined(HAVE_WS) && (defined(HAVE_PAE_SUPP) || defined(HAVE_PAE_AUTH))
+
 static const uint8_t key[] = {"1234567890123456"};
 static const uint8_t key_len = sizeof(key) - 1;
 
@@ -66,28 +68,28 @@ bool test_nist_aes_key_wrap_1()
         return false;
     }
     if (mbedtls_stub.kw.keybits != 128) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.is_wrap != 1) {
-       return false;
+        return false;
     }
     if (!mbedtls_stub.kw.wrap_called) {
         return false;
     }
-    if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW ) {
-       return false;
+    if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW) {
+        return false;
     }
     if (memcmp(mbedtls_stub.kw.input, data, data_len) != 0) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.in_len != data_len) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.out_len != out_len) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.out_size != out_len) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.free_ctx == 0) {
         return false;
@@ -127,28 +129,28 @@ bool test_nist_aes_key_wrap_2()
         return false;
     }
     if (mbedtls_stub.kw.keybits != 128) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.is_wrap != 0) {
-       return false;
+        return false;
     }
     if (!mbedtls_stub.kw.unwrap_called) {
         return false;
     }
-    if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW ) {
-       return false;
+    if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW) {
+        return false;
     }
     if (memcmp(mbedtls_stub.kw.input, data, data_len) != 0) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.in_len != data_len) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.out_len != out_len) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.out_size != out_len) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.free_ctx == 0) {
         return false;
@@ -185,10 +187,10 @@ bool test_nist_aes_key_wrap_3()
         return false;
     }
     if (mbedtls_stub.kw.keybits != 128) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.is_wrap != 1) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.wrap_called || mbedtls_stub.kw.unwrap_called) {
         return false;
@@ -231,28 +233,28 @@ bool test_nist_aes_key_wrap_4()
         return false;
     }
     if (mbedtls_stub.kw.keybits != 128) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.is_wrap != 1) {
-       return false;
+        return false;
     }
     if (!mbedtls_stub.kw.wrap_called) {
         return false;
     }
-    if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW ) {
-       return false;
+    if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW) {
+        return false;
     }
     if (memcmp(mbedtls_stub.kw.input, data, data_len) != 0) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.in_len != data_len) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.out_len != out_len) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.out_size != out_len) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.free_ctx == 0) {
         return false;
@@ -292,31 +294,60 @@ bool test_nist_aes_key_wrap_5()
         return false;
     }
     if (mbedtls_stub.kw.keybits != 128) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.is_wrap != 0) {
-       return false;
+        return false;
     }
     if (!mbedtls_stub.kw.unwrap_called) {
         return false;
     }
-    if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW ) {
-       return false;
+    if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW) {
+        return false;
     }
     if (memcmp(mbedtls_stub.kw.input, data, data_len) != 0) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.in_len != data_len) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.out_len != out_len) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.out_size != out_len) {
-       return false;
+        return false;
     }
     if (mbedtls_stub.kw.free_ctx == 0) {
         return false;
     }
     return true;
 }
+
+#else
+
+bool test_nist_aes_key_wrap_1()
+{
+    return true;
+}
+
+bool test_nist_aes_key_wrap_2()
+{
+    return true;
+}
+
+bool test_nist_aes_key_wrap_3()
+{
+    return true;
+}
+
+bool test_nist_aes_key_wrap_4()
+{
+    return true;
+}
+
+bool test_nist_aes_key_wrap_5()
+{
+    return true;
+}
+
+#endif
diff --git a/test/nanostack/unittest/stub/mbedtls_stub.c b/test/nanostack/unittest/stub/mbedtls_stub.c
@@ -403,7 +403,7 @@ void mbedtls_nist_kw_init(mbedtls_nist_kw_context *ctx)
     mbedtls_stub.kw.ctx = ctx;
 }
 
-int mbedtls_nist_kw_setkey(mbedtls_nist_kw_context *ctx, mbedtls_cipher_id_t cipher, const unsigned char *key, unsigned int keybits, const int is_wrap )
+int mbedtls_nist_kw_setkey(mbedtls_nist_kw_context *ctx, mbedtls_cipher_id_t cipher, const unsigned char *key, unsigned int keybits, const int is_wrap)
 {
     if (mbedtls_stub.kw.ctx == ctx) {
         mbedtls_stub.kw.cipher = cipher;

Original file line number	Diff line number	Diff line change
`@@ -310,7 +310,7 @@ static int8_t supp_gkh_kde_handle(sec_prot_t *prot)`
`310`	`310`	`if (ret < 0 \|\| prot->sec_keys->gtk_set_index < 0) {`
`311`	`311`	`return -1;`
`312`	`312`	`} else {`
`313`		`- return 0;`
	`313`	`+ return 0;`
`314`	`314`	`}`
`315`	`315`	`}`
`316`	`316`
Original file line number	Diff line number	Diff line change
`@@ -364,7 +364,7 @@ int8_t sec_prot_lib_gtk_read(uint8_t *kde, uint16_t kde_len, sec_prot_gtk_keys_t`
`364`	`364`	`*gtk_set_index = key_id; // Insert`
`365`	`365`	`}`
`366`	`366`	`uint32_t lifetime;`
`367`		`- if (kde_lifetime_read(kde, kde_len, &lifetime) >=0 ) {`
	`367`	`+ if (kde_lifetime_read(kde, kde_len, &lifetime) >= 0) {`
`368`	`368`	`if (gtks->gtk[key_id].set) {`
`369`	`369`	`gtks->gtk[key_id].lifetime = lifetime;`
`370`	`370`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,8 @@`
`25`	`25`	`#include "mbedtls_stub.h"`
`26`	`26`	`#include "test_nist_aes_kw.h"`
`27`	`27`
	`28`	`+#if defined(HAVE_WS) && (defined(HAVE_PAE_SUPP) \|\| defined(HAVE_PAE_AUTH))`
	`29`	`+`
`28`	`30`	`static const uint8_t key[] = {"1234567890123456"};`
`29`	`31`	`static const uint8_t key_len = sizeof(key) - 1;`
`30`	`32`
`@@ -66,28 +68,28 @@ bool test_nist_aes_key_wrap_1()`
`66`	`68`	`return false;`
`67`	`69`	`}`
`68`	`70`	`if (mbedtls_stub.kw.keybits != 128) {`
`69`		`- return false;`
	`71`	`+ return false;`
`70`	`72`	`}`
`71`	`73`	`if (mbedtls_stub.kw.is_wrap != 1) {`
`72`		`- return false;`
	`74`	`+ return false;`
`73`	`75`	`}`
`74`	`76`	`if (!mbedtls_stub.kw.wrap_called) {`
`75`	`77`	`return false;`
`76`	`78`	`}`
`77`		`- if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW ) {`
`78`		`- return false;`
	`79`	`+ if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW) {`
	`80`	`+ return false;`
`79`	`81`	`}`
`80`	`82`	`if (memcmp(mbedtls_stub.kw.input, data, data_len) != 0) {`
`81`		`- return false;`
	`83`	`+ return false;`
`82`	`84`	`}`
`83`	`85`	`if (mbedtls_stub.kw.in_len != data_len) {`
`84`		`- return false;`
	`86`	`+ return false;`
`85`	`87`	`}`
`86`	`88`	`if (mbedtls_stub.kw.out_len != out_len) {`
`87`		`- return false;`
	`89`	`+ return false;`
`88`	`90`	`}`
`89`	`91`	`if (mbedtls_stub.kw.out_size != out_len) {`
`90`		`- return false;`
	`92`	`+ return false;`
`91`	`93`	`}`
`92`	`94`	`if (mbedtls_stub.kw.free_ctx == 0) {`
`93`	`95`	`return false;`
`@@ -127,28 +129,28 @@ bool test_nist_aes_key_wrap_2()`
`127`	`129`	`return false;`
`128`	`130`	`}`
`129`	`131`	`if (mbedtls_stub.kw.keybits != 128) {`
`130`		`- return false;`
	`132`	`+ return false;`
`131`	`133`	`}`
`132`	`134`	`if (mbedtls_stub.kw.is_wrap != 0) {`
`133`		`- return false;`
	`135`	`+ return false;`
`134`	`136`	`}`
`135`	`137`	`if (!mbedtls_stub.kw.unwrap_called) {`
`136`	`138`	`return false;`
`137`	`139`	`}`
`138`		`- if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW ) {`
`139`		`- return false;`
	`140`	`+ if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW) {`
	`141`	`+ return false;`
`140`	`142`	`}`
`141`	`143`	`if (memcmp(mbedtls_stub.kw.input, data, data_len) != 0) {`
`142`		`- return false;`
	`144`	`+ return false;`
`143`	`145`	`}`
`144`	`146`	`if (mbedtls_stub.kw.in_len != data_len) {`
`145`		`- return false;`
	`147`	`+ return false;`
`146`	`148`	`}`
`147`	`149`	`if (mbedtls_stub.kw.out_len != out_len) {`
`148`		`- return false;`
	`150`	`+ return false;`
`149`	`151`	`}`
`150`	`152`	`if (mbedtls_stub.kw.out_size != out_len) {`
`151`		`- return false;`
	`153`	`+ return false;`
`152`	`154`	`}`
`153`	`155`	`if (mbedtls_stub.kw.free_ctx == 0) {`
`154`	`156`	`return false;`
`@@ -185,10 +187,10 @@ bool test_nist_aes_key_wrap_3()`
`185`	`187`	`return false;`
`186`	`188`	`}`
`187`	`189`	`if (mbedtls_stub.kw.keybits != 128) {`
`188`		`- return false;`
	`190`	`+ return false;`
`189`	`191`	`}`
`190`	`192`	`if (mbedtls_stub.kw.is_wrap != 1) {`
`191`		`- return false;`
	`193`	`+ return false;`
`192`	`194`	`}`
`193`	`195`	`if (mbedtls_stub.kw.wrap_called \|\| mbedtls_stub.kw.unwrap_called) {`
`194`	`196`	`return false;`
`@@ -231,28 +233,28 @@ bool test_nist_aes_key_wrap_4()`
`231`	`233`	`return false;`
`232`	`234`	`}`
`233`	`235`	`if (mbedtls_stub.kw.keybits != 128) {`
`234`		`- return false;`
	`236`	`+ return false;`
`235`	`237`	`}`
`236`	`238`	`if (mbedtls_stub.kw.is_wrap != 1) {`
`237`		`- return false;`
	`239`	`+ return false;`
`238`	`240`	`}`
`239`	`241`	`if (!mbedtls_stub.kw.wrap_called) {`
`240`	`242`	`return false;`
`241`	`243`	`}`
`242`		`- if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW ) {`
`243`		`- return false;`
	`244`	`+ if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW) {`
	`245`	`+ return false;`
`244`	`246`	`}`
`245`	`247`	`if (memcmp(mbedtls_stub.kw.input, data, data_len) != 0) {`
`246`		`- return false;`
	`248`	`+ return false;`
`247`	`249`	`}`
`248`	`250`	`if (mbedtls_stub.kw.in_len != data_len) {`
`249`		`- return false;`
	`251`	`+ return false;`
`250`	`252`	`}`
`251`	`253`	`if (mbedtls_stub.kw.out_len != out_len) {`
`252`		`- return false;`
	`254`	`+ return false;`
`253`	`255`	`}`
`254`	`256`	`if (mbedtls_stub.kw.out_size != out_len) {`
`255`		`- return false;`
	`257`	`+ return false;`
`256`	`258`	`}`
`257`	`259`	`if (mbedtls_stub.kw.free_ctx == 0) {`
`258`	`260`	`return false;`
`@@ -292,31 +294,60 @@ bool test_nist_aes_key_wrap_5()`
`292`	`294`	`return false;`
`293`	`295`	`}`
`294`	`296`	`if (mbedtls_stub.kw.keybits != 128) {`
`295`		`- return false;`
	`297`	`+ return false;`
`296`	`298`	`}`
`297`	`299`	`if (mbedtls_stub.kw.is_wrap != 0) {`
`298`		`- return false;`
	`300`	`+ return false;`
`299`	`301`	`}`
`300`	`302`	`if (!mbedtls_stub.kw.unwrap_called) {`
`301`	`303`	`return false;`
`302`	`304`	`}`
`303`		`- if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW ) {`
`304`		`- return false;`
	`305`	`+ if (mbedtls_stub.kw.mode != MBEDTLS_KW_MODE_KW) {`
	`306`	`+ return false;`
`305`	`307`	`}`
`306`	`308`	`if (memcmp(mbedtls_stub.kw.input, data, data_len) != 0) {`
`307`		`- return false;`
	`309`	`+ return false;`
`308`	`310`	`}`
`309`	`311`	`if (mbedtls_stub.kw.in_len != data_len) {`
`310`		`- return false;`
	`312`	`+ return false;`
`311`	`313`	`}`
`312`	`314`	`if (mbedtls_stub.kw.out_len != out_len) {`
`313`		`- return false;`
	`315`	`+ return false;`
`314`	`316`	`}`
`315`	`317`	`if (mbedtls_stub.kw.out_size != out_len) {`
`316`		`- return false;`
	`318`	`+ return false;`
`317`	`319`	`}`
`318`	`320`	`if (mbedtls_stub.kw.free_ctx == 0) {`
`319`	`321`	`return false;`
`320`	`322`	`}`
`321`	`323`	`return true;`
`322`	`324`	`}`
	`325`	`+`
	`326`	`+#else`
	`327`	`+`
	`328`	`+bool test_nist_aes_key_wrap_1()`
	`329`	`+{`
	`330`	`+ return true;`
	`331`	`+}`
	`332`	`+`
	`333`	`+bool test_nist_aes_key_wrap_2()`
	`334`	`+{`
	`335`	`+ return true;`
	`336`	`+}`
	`337`	`+`
	`338`	`+bool test_nist_aes_key_wrap_3()`
	`339`	`+{`
	`340`	`+ return true;`
	`341`	`+}`
	`342`	`+`
	`343`	`+bool test_nist_aes_key_wrap_4()`
	`344`	`+{`
	`345`	`+ return true;`
	`346`	`+}`
	`347`	`+`
	`348`	`+bool test_nist_aes_key_wrap_5()`
	`349`	`+{`
	`350`	`+ return true;`
	`351`	`+}`
	`352`	`+`
	`353`	`+#endif`
Original file line number	Diff line number	Diff line change
`@@ -403,7 +403,7 @@ void mbedtls_nist_kw_init(mbedtls_nist_kw_context *ctx)`
`403`	`403`	`mbedtls_stub.kw.ctx = ctx;`
`404`	`404`	`}`
`405`	`405`
`406`		`-int mbedtls_nist_kw_setkey(mbedtls_nist_kw_context ctx, mbedtls_cipher_id_t cipher, const unsigned char key, unsigned int keybits, const int is_wrap )`
	`406`	`+int mbedtls_nist_kw_setkey(mbedtls_nist_kw_context ctx, mbedtls_cipher_id_t cipher, const unsigned char key, unsigned int keybits, const int is_wrap)`
`407`	`407`	`{`
`408`	`408`	`if (mbedtls_stub.kw.ctx == ctx) {`
`409`	`409`	`mbedtls_stub.kw.cipher = cipher;`