C89 compliance

3 files changed, 50 insertions, 34 deletions

diff --git a/gost_grasshopper_cipher.c b/gost_grasshopper_cipher.c
index 6adc380..24e389a 100644
--- a/gost_grasshopper_cipher.c
+++ b/gost_grasshopper_cipher.c
@@ -104,7 +104,8 @@ static struct GRASSHOPPER_CIPHER_PARAMS gost_cipher_params[5] = {
 
 /* Set 256 bit  key into context */
 static GRASSHOPPER_INLINE void gost_grasshopper_cipher_key(gost_grasshopper_cipher_ctx* c, const uint8_t* k) {
-    for (int i = 0; i < 2; i++) {
+		int i;
+    for (i = 0; i < 2; i++) {
         grasshopper_copy128(&c->key.k.k[i], (const grasshopper_w128_t*) (k + i * 16));
     }
     grasshopper_set_encrypt_key(&c->encrypt_round_keys, &c->key);
@@ -113,13 +114,14 @@ static GRASSHOPPER_INLINE void gost_grasshopper_cipher_key(gost_grasshopper_ciph
 
 /* Cleans up key from context */
 static GRASSHOPPER_INLINE void gost_grasshopper_cipher_destroy(gost_grasshopper_cipher_ctx* c) {
-    for (int i = 0; i < 2; i++) {
+		int i;
+    for (i = 0; i < 2; i++) {
         grasshopper_zero128(&c->key.k.k[i]);
     }
-    for (int i = 0; i < GRASSHOPPER_ROUND_KEYS_COUNT; i++) {
+    for (i = 0; i < GRASSHOPPER_ROUND_KEYS_COUNT; i++) {
         grasshopper_zero128(&c->encrypt_round_keys.k[i]);
     }
-    for (int i = 0; i < GRASSHOPPER_ROUND_KEYS_COUNT; i++) {
+    for (i = 0; i < GRASSHOPPER_ROUND_KEYS_COUNT; i++) {
         grasshopper_zero128(&c->decrypt_round_keys.k[i]);
     }
     grasshopper_zero128(&c->buffer);
@@ -142,10 +144,10 @@ static GRASSHOPPER_INLINE void gost_grasshopper_cipher_destroy_ctr(gost_grasshop
 
 static int gost_grasshopper_cipher_init(EVP_CIPHER_CTX* ctx, const unsigned char* key,
                                         const unsigned char* iv, int enc) {
-    gost_grasshopper_cipher_ctx* c = EVP_CIPHER_CTX_cipher_data(ctx);
+    gost_grasshopper_cipher_ctx* c = EVP_CIPHER_CTX_get_cipher_data(ctx);
 
     if (EVP_CIPHER_CTX_get_app_data(ctx) == NULL) {
-        EVP_CIPHER_CTX_set_app_data(ctx, EVP_CIPHER_CTX_cipher_data(ctx));
+        EVP_CIPHER_CTX_set_app_data(ctx, EVP_CIPHER_CTX_get_cipher_data(ctx));
     }
 
     if (key != NULL) {
@@ -169,7 +171,7 @@ static int gost_grasshopper_cipher_init(EVP_CIPHER_CTX* ctx, const unsigned char
 static GRASSHOPPER_INLINE int gost_grasshopper_cipher_init_ecb(EVP_CIPHER_CTX* ctx, const unsigned char* key,
                                                                const unsigned char* iv,
                                                                int enc) {
-    gost_grasshopper_cipher_ctx* c = EVP_CIPHER_CTX_cipher_data(ctx);
+    gost_grasshopper_cipher_ctx* c = EVP_CIPHER_CTX_get_cipher_data(ctx);
     c->type = GRASSHOPPER_CIPHER_ECB;
     return gost_grasshopper_cipher_init(ctx, key, iv, enc);
 }
@@ -177,7 +179,7 @@ static GRASSHOPPER_INLINE int gost_grasshopper_cipher_init_ecb(EVP_CIPHER_CTX* c
 static GRASSHOPPER_INLINE int gost_grasshopper_cipher_init_cbc(EVP_CIPHER_CTX* ctx, const unsigned char* key,
                                                                const unsigned char* iv,
                                                                int enc) {
-    gost_grasshopper_cipher_ctx* c = EVP_CIPHER_CTX_cipher_data(ctx);
+    gost_grasshopper_cipher_ctx* c = EVP_CIPHER_CTX_get_cipher_data(ctx);
     c->type = GRASSHOPPER_CIPHER_CBC;
     return gost_grasshopper_cipher_init(ctx, key, iv, enc);
 }
@@ -185,7 +187,7 @@ static GRASSHOPPER_INLINE int gost_grasshopper_cipher_init_cbc(EVP_CIPHER_CTX* c
 static GRASSHOPPER_INLINE int gost_grasshopper_cipher_init_ofb(EVP_CIPHER_CTX* ctx, const unsigned char* key,
                                                                const unsigned char* iv,
                                                                int enc) {
-    gost_grasshopper_cipher_ctx_ofb* c = EVP_CIPHER_CTX_cipher_data(ctx);
+    gost_grasshopper_cipher_ctx_ofb* c = EVP_CIPHER_CTX_get_cipher_data(ctx);
 
     c->c.type = GRASSHOPPER_CIPHER_OFB;
 
@@ -197,7 +199,7 @@ static GRASSHOPPER_INLINE int gost_grasshopper_cipher_init_ofb(EVP_CIPHER_CTX* c
 static GRASSHOPPER_INLINE int gost_grasshopper_cipher_init_cfb(EVP_CIPHER_CTX* ctx, const unsigned char* key,
                                                                const unsigned char* iv,
                                                                int enc) {
-    gost_grasshopper_cipher_ctx* c = EVP_CIPHER_CTX_cipher_data(ctx);
+    gost_grasshopper_cipher_ctx* c = EVP_CIPHER_CTX_get_cipher_data(ctx);
     c->type = GRASSHOPPER_CIPHER_CFB;
     return gost_grasshopper_cipher_init(ctx, key, iv, enc);
 }
@@ -205,7 +207,7 @@ static GRASSHOPPER_INLINE int gost_grasshopper_cipher_init_cfb(EVP_CIPHER_CTX* c
 static GRASSHOPPER_INLINE int gost_grasshopper_cipher_init_ctr(EVP_CIPHER_CTX* ctx, const unsigned char* key,
                                                                const unsigned char* iv,
                                                                int enc) {
-    gost_grasshopper_cipher_ctx_ctr* c = EVP_CIPHER_CTX_cipher_data(ctx);
+    gost_grasshopper_cipher_ctx_ctr* c = EVP_CIPHER_CTX_get_cipher_data(ctx);
 
     c->c.type = GRASSHOPPER_CIPHER_CTR;
 
@@ -219,7 +221,7 @@ static GRASSHOPPER_INLINE int gost_grasshopper_cipher_init_ctr(EVP_CIPHER_CTX* c
 
 static GRASSHOPPER_INLINE int gost_grasshopper_cipher_do(EVP_CIPHER_CTX* ctx, unsigned char* out,
                                                          const unsigned char* in, size_t inl) {
-    gost_grasshopper_cipher_ctx* c = (gost_grasshopper_cipher_ctx*) EVP_CIPHER_CTX_cipher_data(ctx);
+    gost_grasshopper_cipher_ctx* c = (gost_grasshopper_cipher_ctx*) EVP_CIPHER_CTX_get_cipher_data(ctx);
     struct GRASSHOPPER_CIPHER_PARAMS* params = &gost_cipher_params[c->type];
 
     return params->do_cipher(ctx, out, in, inl);
@@ -227,7 +229,7 @@ static GRASSHOPPER_INLINE int gost_grasshopper_cipher_do(EVP_CIPHER_CTX* ctx, un
 
 static int gost_grasshopper_cipher_do_ecb(EVP_CIPHER_CTX* ctx, unsigned char* out,
                                           const unsigned char* in, size_t inl) {
-    gost_grasshopper_cipher_ctx* c = (gost_grasshopper_cipher_ctx*) EVP_CIPHER_CTX_cipher_data(ctx);
+    gost_grasshopper_cipher_ctx* c = (gost_grasshopper_cipher_ctx*) EVP_CIPHER_CTX_get_cipher_data(ctx);
     bool encrypting = (bool) EVP_CIPHER_CTX_encrypting(ctx);
     const unsigned char* current_in = in;
     unsigned char* current_out = out;
@@ -251,7 +253,7 @@ static int gost_grasshopper_cipher_do_ecb(EVP_CIPHER_CTX* ctx, unsigned char* ou
 
 static int gost_grasshopper_cipher_do_cbc(EVP_CIPHER_CTX* ctx, unsigned char* out,
                                           const unsigned char* in, size_t inl) {
-    gost_grasshopper_cipher_ctx* c = (gost_grasshopper_cipher_ctx*) EVP_CIPHER_CTX_cipher_data(ctx);
+    gost_grasshopper_cipher_ctx* c = (gost_grasshopper_cipher_ctx*) EVP_CIPHER_CTX_get_cipher_data(ctx);
     unsigned char* iv = EVP_CIPHER_CTX_iv_noconst(ctx);
     bool encrypting = (bool) EVP_CIPHER_CTX_encrypting(ctx);
     const unsigned char* current_in = in;
@@ -283,7 +285,7 @@ static int gost_grasshopper_cipher_do_cbc(EVP_CIPHER_CTX* ctx, unsigned char* ou
 
 static int gost_grasshopper_cipher_do_ctr(EVP_CIPHER_CTX* ctx, unsigned char* out,
                                           const unsigned char* in, size_t inl) {
-    gost_grasshopper_cipher_ctx_ctr* c = (gost_grasshopper_cipher_ctx_ctr*) EVP_CIPHER_CTX_cipher_data(ctx);
+    gost_grasshopper_cipher_ctx_ctr* c = (gost_grasshopper_cipher_ctx_ctr*) EVP_CIPHER_CTX_get_cipher_data(ctx);
     unsigned char* iv = EVP_CIPHER_CTX_iv_noconst(ctx);
     const unsigned char* current_in = in;
     unsigned char* current_out = out;
@@ -291,11 +293,12 @@ static int gost_grasshopper_cipher_do_ctr(EVP_CIPHER_CTX* ctx, unsigned char* ou
     grasshopper_w128_t* currentInputBlock;
     grasshopper_w128_t* currentOutputBlock;
     size_t lasted;
+		size_t i;
 
     memcpy(&c->iv_buffer, iv, 8);
 
     // full parts
-    for (size_t i = 0; i < blocks; i++, current_in += GRASSHOPPER_BLOCK_SIZE, current_out += GRASSHOPPER_BLOCK_SIZE) {
+    for (i = 0; i < blocks; i++, current_in += GRASSHOPPER_BLOCK_SIZE, current_out += GRASSHOPPER_BLOCK_SIZE) {
         currentInputBlock = (grasshopper_w128_t*) current_in;
         currentOutputBlock = (grasshopper_w128_t*) current_out;
         memcpy(c->iv_buffer.b + 8, &c->counter, 8);
@@ -311,7 +314,7 @@ static int gost_grasshopper_cipher_do_ctr(EVP_CIPHER_CTX* ctx, unsigned char* ou
         currentOutputBlock = (grasshopper_w128_t*) current_out;
         memcpy(c->iv_buffer.b + 8, &c->counter, 8);
         grasshopper_encrypt_block(&c->c.encrypt_round_keys, &c->iv_buffer, &c->partial_buffer, &c->c.buffer);
-        for (size_t i = 0; i < lasted; i++) {
+        for (i = 0; i < lasted; i++) {
             currentOutputBlock->b[i] = c->partial_buffer.b[i] ^ currentInputBlock->b[i];
         }
         c->counter += 1;
@@ -369,7 +372,7 @@ static void gost_grasshopper_cnt_next(gost_grasshopper_cipher_ctx_ofb* ctx, gras
 
 static int gost_grasshopper_cipher_do_ofb(EVP_CIPHER_CTX* ctx, unsigned char* out,
                                           const unsigned char* in, size_t inl) {
-    gost_grasshopper_cipher_ctx_ofb* c = (gost_grasshopper_cipher_ctx_ofb*) EVP_CIPHER_CTX_cipher_data(ctx);
+    gost_grasshopper_cipher_ctx_ofb* c = (gost_grasshopper_cipher_ctx_ofb*) EVP_CIPHER_CTX_get_cipher_data(ctx);
     const unsigned char* in_ptr = in;
     unsigned char* out_ptr = out;
     unsigned char* buf = EVP_CIPHER_CTX_buf_noconst(ctx);
@@ -427,7 +430,7 @@ static int gost_grasshopper_cipher_do_ofb(EVP_CIPHER_CTX* ctx, unsigned char* ou
 
 static int gost_grasshopper_cipher_do_cfb(EVP_CIPHER_CTX* ctx, unsigned char* out,
                                           const unsigned char* in, size_t inl) {
-    gost_grasshopper_cipher_ctx* c = (gost_grasshopper_cipher_ctx*) EVP_CIPHER_CTX_cipher_data(ctx);
+    gost_grasshopper_cipher_ctx* c = (gost_grasshopper_cipher_ctx*) EVP_CIPHER_CTX_get_cipher_data(ctx);
     const unsigned char* in_ptr = in;
     unsigned char* out_ptr = out;
     unsigned char* buf = EVP_CIPHER_CTX_buf_noconst(ctx);
@@ -505,7 +508,7 @@ static int gost_grasshopper_cipher_do_cfb(EVP_CIPHER_CTX* ctx, unsigned char* ou
 }
 
 static int gost_grasshopper_cipher_cleanup(EVP_CIPHER_CTX* ctx) {
-    gost_grasshopper_cipher_ctx* c = (gost_grasshopper_cipher_ctx*) EVP_CIPHER_CTX_cipher_data(ctx);
+    gost_grasshopper_cipher_ctx* c = (gost_grasshopper_cipher_ctx*) EVP_CIPHER_CTX_get_cipher_data(ctx);
     struct GRASSHOPPER_CIPHER_PARAMS* params = &gost_cipher_params[c->type];
 
     gost_grasshopper_cipher_destroy(c);
diff --git a/gost_grasshopper_core.c b/gost_grasshopper_core.c
index 6eb7490..83bcbc6 100644
--- a/gost_grasshopper_core.c
+++ b/gost_grasshopper_core.c
@@ -14,14 +14,16 @@ extern "C" {
 
 static GRASSHOPPER_INLINE void grasshopper_l(grasshopper_w128_t* w) {
     uint8_t x;
+		unsigned int j;
+		int i;
 
     // 16 rounds
-    for (unsigned int j = 0; j < sizeof(grasshopper_lvec) / sizeof(grasshopper_lvec[0]); j++) {
+    for (j = 0; j < sizeof(grasshopper_lvec) / sizeof(grasshopper_lvec[0]); j++) {
 
         // An LFSR with 16 elements from GF(2^8)
         x = w->b[15];    // since lvec[15] = 1
 
-        for (int i = 14; i >= 0; i--) {
+        for (i = 14; i >= 0; i--) {
             w->b[i + 1] = w->b[i];
             x ^= grasshopper_galois_mul(w->b[i], grasshopper_lvec[i]);
         }
@@ -31,12 +33,14 @@ static GRASSHOPPER_INLINE void grasshopper_l(grasshopper_w128_t* w) {
 
 static GRASSHOPPER_INLINE void grasshopper_l_inv(grasshopper_w128_t* w) {
     uint8_t x;
+		unsigned int j;
+		int i;
 
     // 16 rounds
-    for (unsigned int j = 0; j < sizeof(grasshopper_lvec) / sizeof(grasshopper_lvec[0]); j++) {
+    for (j = 0; j < sizeof(grasshopper_lvec) / sizeof(grasshopper_lvec[0]); j++) {
 
         x = w->b[0];
-        for (int i = 0; i < 15; i++) {
+        for (i = 0; i < 15; i++) {
             w->b[i] = w->b[i + 1];
             x ^= grasshopper_galois_mul(w->b[i], grasshopper_lvec[i]);
         }
@@ -48,8 +52,9 @@ static GRASSHOPPER_INLINE void grasshopper_l_inv(grasshopper_w128_t* w) {
 
 void grasshopper_set_encrypt_key(grasshopper_round_keys_t* subkeys, const grasshopper_key_t* key) {
     grasshopper_w128_t c, x, y, z;
+		int i;
 
-    for (int i = 0; i < 16; i++) {
+    for (i = 0; i < 16; i++) {
         // this will be have to changed for little-endian systems
         x.b[i] = key->k.b[i];
         y.b[i] = key->k.b[i + 16];
@@ -58,7 +63,7 @@ void grasshopper_set_encrypt_key(grasshopper_round_keys_t* subkeys, const grassh
     grasshopper_copy128(&subkeys->k[0], &x);
     grasshopper_copy128(&subkeys->k[1], &y);
 
-    for (int i = 1; i <= 32; i++) {
+    for (i = 1; i <= 32; i++) {
 
         // C Value
         grasshopper_zero128(&c);
@@ -88,18 +93,20 @@ void grasshopper_set_encrypt_key(grasshopper_round_keys_t* subkeys, const grassh
 }
 
 void grasshopper_set_decrypt_key(grasshopper_round_keys_t* subkeys, const grasshopper_key_t* key) {
+		int i;
     grasshopper_set_encrypt_key(subkeys, key);
 
-    for (int i = 1; i < 10; i++) {
+    for (i = 1; i < 10; i++) {
         grasshopper_l_inv(&subkeys->k[i]);
     }
 }
 
 void grasshopper_encrypt_block(grasshopper_round_keys_t* subkeys, grasshopper_w128_t* source,
                                grasshopper_w128_t* target, grasshopper_w128_t* buffer) {
+		int i;
     grasshopper_copy128(target, source);
 
-    for (int i = 0; i < 9; i++) {
+    for (i = 0; i < 9; i++) {
         grasshopper_append128(target, &subkeys->k[i]);
         grasshopper_append128multi(buffer, target, grasshopper_pil_enc128);
     }
@@ -116,11 +123,12 @@ void grasshopper_encrypt_block2(grasshopper_round_keys_t* subkeys, grasshopper_w
 
 void grasshopper_decrypt_block(grasshopper_round_keys_t* subkeys, grasshopper_w128_t* source,
                                grasshopper_w128_t* target, grasshopper_w128_t* buffer) {
+		int i;
     grasshopper_copy128(target, source);
 
     grasshopper_append128multi(buffer, target, grasshopper_l_dec128);
 
-    for (int i = 9; i > 1; i--) {
+    for (i = 9; i > 1; i--) {
         grasshopper_append128(target, &subkeys->k[i]);
         grasshopper_append128multi(buffer, target, grasshopper_pil_dec128);
     }
diff --git a/gost_grasshopper_math.h b/gost_grasshopper_math.h
index fb42606..176d16a 100644
--- a/gost_grasshopper_math.h
+++ b/gost_grasshopper_math.h
@@ -57,7 +57,8 @@ static GRASSHOPPER_INLINE void grasshopper_zero128(grasshopper_w128_t* x) {
 #if(GRASSHOPPER_BITS == 8 || GRASSHOPPER_BITS == 16)
     memset(&x, 0, sizeof(x));
 #else
-    for (int i = 0; i < GRASSHOPPER_BIT_PARTS; i++) {
+		int i;
+    for (i = 0; i < GRASSHOPPER_BIT_PARTS; i++) {
         GRASSHOPPER_ACCESS_128_VALUE(*x, i) = 0;
     }
 #endif
@@ -67,14 +68,16 @@ static GRASSHOPPER_INLINE void grasshopper_copy128(grasshopper_w128_t* to, const
 #if(GRASSHOPPER_BITS == 8 || GRASSHOPPER_BITS == 16)
     __builtin_memcpy(&to, &from, sizeof(w128_t));
 #else
-    for (int i = 0; i < GRASSHOPPER_BIT_PARTS; i++) {
+		int i;
+    for (i = 0; i < GRASSHOPPER_BIT_PARTS; i++) {
         GRASSHOPPER_ACCESS_128_VALUE(*to, i) = GRASSHOPPER_ACCESS_128_VALUE(*from, i);
     }
 #endif
 }
 
 static GRASSHOPPER_INLINE void grasshopper_append128(grasshopper_w128_t* x, const grasshopper_w128_t* y) {
-    for (int i = 0; i < GRASSHOPPER_BIT_PARTS; i++) {
+		int i;
+    for (i = 0; i < GRASSHOPPER_BIT_PARTS; i++) {
         GRASSHOPPER_ACCESS_128_VALUE(*x, i) ^= GRASSHOPPER_ACCESS_128_VALUE(*y, i);
     }
 }
@@ -88,8 +91,9 @@ static GRASSHOPPER_INLINE void grasshopper_plus128(grasshopper_w128_t* result, c
 // result & x must be different
 static GRASSHOPPER_INLINE void grasshopper_plus128multi(grasshopper_w128_t* result, const grasshopper_w128_t* x,
                                                     const grasshopper_w128_t array[][256]) {
+		int i;
     grasshopper_zero128(result);
-    for (int i = 0; i < GRASSHOPPER_MAX_BIT_PARTS; i++) {
+    for (i = 0; i < GRASSHOPPER_MAX_BIT_PARTS; i++) {
         grasshopper_append128(result, &array[i][GRASSHOPPER_ACCESS_128_VALUE_8(*x, i)]);
     }
 }
@@ -101,7 +105,8 @@ static GRASSHOPPER_INLINE void grasshopper_append128multi(grasshopper_w128_t* re
 }
 
 static GRASSHOPPER_INLINE void grasshopper_convert128(grasshopper_w128_t* x, const uint8_t* array) {
-    for (int i = 0; i < GRASSHOPPER_MAX_BIT_PARTS; i++) {
+		int i;
+    for (i = 0; i < GRASSHOPPER_MAX_BIT_PARTS; i++) {
         GRASSHOPPER_ACCESS_128_VALUE_8(*x, i) = array[GRASSHOPPER_ACCESS_128_VALUE_8(*x, i)];
     }
 }