diff --git a/crypto/DeFeo_Scheme/P768_internal.h b/crypto/DeFeo_Scheme/P768_internal.h
index 16d1089d5313b75f0ec7e66a45480c44a4090bbe..08d35d55db7915f02416f86a1c0b4e45d9e3d5ff 100644
--- a/crypto/DeFeo_Scheme/P768_internal.h
+++ b/crypto/DeFeo_Scheme/P768_internal.h
@@ -44,9 +44,9 @@
 #define CRYPTO_BYTES               24
 #define CRYPTO_CIPHERTEXTBYTES    596    // CRYPTO_PUBLICKEYBYTES + MSG_BYTES bytes
 
-#define DEFEO_SECRETKEYBYTES      48
-#define DEFEO_PUBLICKEYBYTES     564
-#define DEFEO_BYTES              188
+#define DEFEO_SECRET_KEY_LEN      48
+#define DEFEO_PUBLICK_KEY_LEN     564
+#define DEFEO_SHARED_KEY_LEN      188
 
 
 // SIDH's basic element definitions and point representations
diff --git a/crypto/DeFeo_Scheme/defeo_kex.c b/crypto/DeFeo_Scheme/defeo_kex.c
index 2bcba773fc62ae9021be195217de9192bc982e20..7b876c8bf4e3306c2274cbf975a9d522a08c0222 100644
--- a/crypto/DeFeo_Scheme/defeo_kex.c
+++ b/crypto/DeFeo_Scheme/defeo_kex.c
@@ -1368,9 +1368,9 @@ int EphemeralSecretAgreement_B(const unsigned char* PrivateKeyB, const unsigned
 int cryptotest_kex()
 {
     // Testing key exchange
-    unsigned char PrivateKeyA[DEFEO_SECRETKEYBYTES], PrivateKeyB[DEFEO_SECRETKEYBYTES];
-    unsigned char PublicKeyA[DEFEO_PUBLICKEYBYTES], PublicKeyB[DEFEO_PUBLICKEYBYTES];
-    unsigned char SharedSecretA[DEFEO_BYTES], SharedSecretB[DEFEO_BYTES];
+    unsigned char PrivateKeyA[DEFEO_SECRET_KEY_LEN], PrivateKeyB[DEFEO_SECRET_KEY_LEN];
+    unsigned char PublicKeyA[DEFEO_PUBLICK_KEY_LEN], PublicKeyB[DEFEO_PUBLICK_KEY_LEN];
+    unsigned char SharedSecretA[DEFEO_SHARED_KEY_LEN], SharedSecretB[DEFEO_SHARED_KEY_LEN];
     bool passed = true;
 
     random_mod_order_A(PrivateKeyA);
@@ -1382,7 +1382,7 @@ int cryptotest_kex()
     EphemeralSecretAgreement_A(PrivateKeyA, PublicKeyB, SharedSecretA);           // Alice computes her shared secret using Bob's public key
     EphemeralSecretAgreement_B(PrivateKeyB, PublicKeyA, SharedSecretB);           // Bob computes his shared secret using Alice's public key
 
-    if (memcmp(SharedSecretA, SharedSecretB, DEFEO_BYTES) != 0)
+    if (memcmp(SharedSecretA, SharedSecretB, DEFEO_SHARED_KEY_LEN) != 0)
     {
         passed = false;        
     }
diff --git a/crypto/dap_enc_defeo.c b/crypto/dap_enc_defeo.c
index b0e66283338276d0d1117a4a8f1c228acb0c4a1d..c33b0476f62d0e3076abb50d13ed88993891587a 100644
--- a/crypto/dap_enc_defeo.c
+++ b/crypto/dap_enc_defeo.c
@@ -39,15 +39,15 @@ void dap_enc_defeo_key_new_generate(struct dap_enc_key * a_key, const void *kex_
 
     dap_enc_defeo_key_new(a_key);
 
-    a_key->pub_key_data = malloc(DEFEO_PUBLICKEYBYTES);
-    a_key->pub_key_data_size = DEFEO_PUBLICKEYBYTES;
+    a_key->pub_key_data = malloc(DEFEO_PUBLICK_KEY_LEN);
+    a_key->pub_key_data_size = DEFEO_PUBLICK_KEY_LEN;
     if(a_key->pub_key_data == NULL) {
         log_it(L_CRITICAL, "Error malloc");
         return;
     }
 
-    a_key->priv_key_data = malloc(DEFEO_SECRETKEYBYTES);
-    a_key->priv_key_data_size = DEFEO_SECRETKEYBYTES;
+    a_key->priv_key_data = malloc(DEFEO_SECRET_KEY_LEN);
+    a_key->priv_key_data_size = DEFEO_SECRET_KEY_LEN;
 
     // generate A key pair
     random_mod_order_A((unsigned char *) a_key->priv_key_data);
@@ -78,23 +78,23 @@ size_t dap_enc_defeo_encode(struct dap_enc_key *b_key, const void *a_pub,
 
     *b_pub = NULL;
 
-    if(a_pub_size != DEFEO_PUBLICKEYBYTES) {
+    if(a_pub_size != DEFEO_PUBLICK_KEY_LEN) {
         return 1;
     }
 
-    *b_pub = malloc(DEFEO_PUBLICKEYBYTES);
+    *b_pub = malloc(DEFEO_PUBLICK_KEY_LEN);
     if(b_pub == NULL) {
         log_it(L_CRITICAL, "Error malloc");
         return 2;
     }
 
-    b_key->priv_key_data = malloc(DEFEO_BYTES);
+    b_key->priv_key_data = malloc(DEFEO_SHARED_KEY_LEN);
     if(b_key->priv_key_data == NULL) {
         log_it(L_CRITICAL, "Error malloc");
         return 3;
     }
 
-    uint8_t *bob_priv = malloc(DEFEO_SECRETKEYBYTES);
+    uint8_t *bob_priv = malloc(DEFEO_SECRET_KEY_LEN);
 
     // generate Bob's key pair
     random_mod_order_B((unsigned char *)bob_priv);
@@ -111,8 +111,8 @@ size_t dap_enc_defeo_encode(struct dap_enc_key *b_key, const void *a_pub,
     }
 
     free(bob_priv);
-    b_key->priv_key_data_size = DEFEO_BYTES;
-    b_key->pub_key_data_size = DEFEO_PUBLICKEYBYTES;
+    b_key->priv_key_data_size = DEFEO_SHARED_KEY_LEN;
+    b_key->pub_key_data_size = DEFEO_PUBLICK_KEY_LEN;
 
     return 0;
 }
@@ -127,12 +127,12 @@ size_t dap_enc_defeo_encode(struct dap_enc_key *b_key, const void *a_pub,
 // a_key_len --- shared key length
 size_t dap_enc_defeo_decode(struct dap_enc_key *a_key, const void *a_priv, size_t b_pub_size, unsigned char *b_pub)
 {
-    if(b_pub_size != DEFEO_PUBLICKEYBYTES) {
+    if(b_pub_size != DEFEO_PUBLICK_KEY_LEN) {
         log_it(L_ERROR, "public key size not equal DEFEO_PUBLICKEYBYTES");
         return 1;
     }
 
-    a_key->priv_key_data = malloc(DEFEO_BYTES);
+    a_key->priv_key_data = malloc(DEFEO_SHARED_KEY_LEN);
     if(a_key->priv_key_data == NULL) {
         log_it(L_CRITICAL, "Error malloc");
         return 2;
@@ -144,7 +144,7 @@ size_t dap_enc_defeo_decode(struct dap_enc_key *a_key, const void *a_priv, size_
         return 3;
     }
 
-    a_key->priv_key_data_size = DEFEO_BYTES;
+    a_key->priv_key_data_size = DEFEO_SHARED_KEY_LEN;
 
     return 0;
 }