]> wagner.pp.ru Git - openssl-gost/engine.git/commitdiff
Formatting
authorDmitry Belyavskiy <beldmit@gmail.com>
Tue, 11 Sep 2018 09:27:19 +0000 (12:27 +0300)
committerDmitry Belyavskiy <beldmit@gmail.com>
Tue, 11 Sep 2018 09:27:19 +0000 (12:27 +0300)
gost_grasshopper_cipher.c

index a482a39cf0728ea2bf75746109cfe8aa85708293..d641bcb114ee2a60ac44bc3a1eb0ea39f7f291aa 100644 (file)
@@ -20,751 +20,849 @@ extern "C" {
 #include "gost_lcl.h"
 #include "e_gost_err.h"
 
-enum GRASSHOPPER_CIPHER_TYPE {
-    GRASSHOPPER_CIPHER_ECB = 0,
-    GRASSHOPPER_CIPHER_CBC,
-    GRASSHOPPER_CIPHER_OFB,
-    GRASSHOPPER_CIPHER_CFB,
-    GRASSHOPPER_CIPHER_CTR,
-    GRASSHOPPER_CIPHER_CTRACPKM,
-};
-
-static EVP_CIPHER* gost_grasshopper_ciphers[6] = {
+    enum GRASSHOPPER_CIPHER_TYPE {
+        GRASSHOPPER_CIPHER_ECB = 0,
+        GRASSHOPPER_CIPHER_CBC,
+        GRASSHOPPER_CIPHER_OFB,
+        GRASSHOPPER_CIPHER_CFB,
+        GRASSHOPPER_CIPHER_CTR,
+        GRASSHOPPER_CIPHER_CTRACPKM,
+    };
+
+    static EVP_CIPHER *gost_grasshopper_ciphers[6] = {
         [GRASSHOPPER_CIPHER_ECB] = NULL,
         [GRASSHOPPER_CIPHER_CBC] = NULL,
         [GRASSHOPPER_CIPHER_OFB] = NULL,
         [GRASSHOPPER_CIPHER_CFB] = NULL,
         [GRASSHOPPER_CIPHER_CTR] = NULL,
         [GRASSHOPPER_CIPHER_CTRACPKM] = NULL,
-};
-
-static GRASSHOPPER_INLINE void gost_grasshopper_cipher_destroy_ofb(gost_grasshopper_cipher_ctx* c);
-static GRASSHOPPER_INLINE void gost_grasshopper_cipher_destroy_ctr(gost_grasshopper_cipher_ctx* c);
-
-struct GRASSHOPPER_CIPHER_PARAMS {
-    int nid;
-    grasshopper_init_cipher_func init_cipher;
-    grasshopper_do_cipher_func do_cipher;
-    grasshopper_destroy_cipher_func destroy_cipher;
-    int block_size;
-    int ctx_size;
-    int iv_size;
-    bool padding;
-};
-
-static struct GRASSHOPPER_CIPHER_PARAMS gost_cipher_params[6] = {
+    };
+
+    static GRASSHOPPER_INLINE void
+        gost_grasshopper_cipher_destroy_ofb(gost_grasshopper_cipher_ctx * c);
+    static GRASSHOPPER_INLINE void
+        gost_grasshopper_cipher_destroy_ctr(gost_grasshopper_cipher_ctx * c);
+
+    struct GRASSHOPPER_CIPHER_PARAMS {
+        int nid;
+        grasshopper_init_cipher_func init_cipher;
+        grasshopper_do_cipher_func do_cipher;
+        grasshopper_destroy_cipher_func destroy_cipher;
+        int block_size;
+        int ctx_size;
+        int iv_size;
+        bool padding;
+    };
+
+    static struct GRASSHOPPER_CIPHER_PARAMS gost_cipher_params[6] = {
         [GRASSHOPPER_CIPHER_ECB] = {
-                NID_grasshopper_ecb,
-                gost_grasshopper_cipher_init_ecb,
-                gost_grasshopper_cipher_do_ecb,
-                NULL,
-                16,
-                sizeof(gost_grasshopper_cipher_ctx),
-                0,
-                true
-        },
+                                    NID_grasshopper_ecb,
+                                    gost_grasshopper_cipher_init_ecb,
+                                    gost_grasshopper_cipher_do_ecb,
+                                    NULL,
+                                    16,
+                                    sizeof(gost_grasshopper_cipher_ctx),
+                                    0,
+                                    true}
+        ,
         [GRASSHOPPER_CIPHER_CBC] = {
-                NID_grasshopper_cbc,
-                gost_grasshopper_cipher_init_cbc,
-                gost_grasshopper_cipher_do_cbc,
-                NULL,
-                16,
-                sizeof(gost_grasshopper_cipher_ctx),
-                16,
-                true
-        },
+                                    NID_grasshopper_cbc,
+                                    gost_grasshopper_cipher_init_cbc,
+                                    gost_grasshopper_cipher_do_cbc,
+                                    NULL,
+                                    16,
+                                    sizeof(gost_grasshopper_cipher_ctx),
+                                    16,
+                                    true}
+        ,
         [GRASSHOPPER_CIPHER_OFB] = {
-                NID_grasshopper_ofb,
-                gost_grasshopper_cipher_init_ofb,
-                gost_grasshopper_cipher_do_ofb,
-                gost_grasshopper_cipher_destroy_ofb,
-                1,
-                sizeof(gost_grasshopper_cipher_ctx_ofb),
-                16,
-                false
-        },
+                                    NID_grasshopper_ofb,
+                                    gost_grasshopper_cipher_init_ofb,
+                                    gost_grasshopper_cipher_do_ofb,
+                                    gost_grasshopper_cipher_destroy_ofb,
+                                    1,
+                                    sizeof(gost_grasshopper_cipher_ctx_ofb),
+                                    16,
+                                    false}
+        ,
         [GRASSHOPPER_CIPHER_CFB] = {
-                NID_grasshopper_cfb,
-                gost_grasshopper_cipher_init_cfb,
-                gost_grasshopper_cipher_do_cfb,
-                NULL,
-                1,
-                sizeof(gost_grasshopper_cipher_ctx),
-                16,
-                false
-        },
+                                    NID_grasshopper_cfb,
+                                    gost_grasshopper_cipher_init_cfb,
+                                    gost_grasshopper_cipher_do_cfb,
+                                    NULL,
+                                    1,
+                                    sizeof(gost_grasshopper_cipher_ctx),
+                                    16,
+                                    false}
+        ,
         [GRASSHOPPER_CIPHER_CTR] = {
-                NID_grasshopper_ctr,
-                gost_grasshopper_cipher_init_ctr,
-                gost_grasshopper_cipher_do_ctr,
-                gost_grasshopper_cipher_destroy_ctr,
-                1,
-                sizeof(gost_grasshopper_cipher_ctx_ctr),
-               /* IV size is set to match full block, to make it responsibility of
-                * user to assign correct values (IV || 0), and to make naive context
-                * copy possible (for software such as openssh) */
-                16,
-                false
-        },
+                                    NID_grasshopper_ctr,
+                                    gost_grasshopper_cipher_init_ctr,
+                                    gost_grasshopper_cipher_do_ctr,
+                                    gost_grasshopper_cipher_destroy_ctr,
+                                    1,
+                                    sizeof(gost_grasshopper_cipher_ctx_ctr),
+                                    /* IV size is set to match full block, to make it responsibility of
+                                     * user to assign correct values (IV || 0), and to make naive context
+                                     * copy possible (for software such as openssh) */
+                                    16,
+                                    false}
+        ,
         [GRASSHOPPER_CIPHER_CTRACPKM] = {
-                NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm,
-                gost_grasshopper_cipher_init_ctracpkm,
-                gost_grasshopper_cipher_do_ctracpkm,
-                gost_grasshopper_cipher_destroy_ctr,
-                1,
-                sizeof(gost_grasshopper_cipher_ctx_ctr),
-                16,
-                false
-        },
-};
+                                         NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm,
+                                         gost_grasshopper_cipher_init_ctracpkm,
+                                         gost_grasshopper_cipher_do_ctracpkm,
+                                         gost_grasshopper_cipher_destroy_ctr,
+                                         1,
+                                         sizeof
+                                         (gost_grasshopper_cipher_ctx_ctr),
+                                         16,
+                                         false}
+        ,
+    };
 
 /* first 256 bit of D from draft-irtf-cfrg-re-keying-12 */
-static const unsigned char ACPKM_D_2018[] = {
-    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, /*  64 bit */
-    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, /* 128 bit */
-    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
-    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, /* 256 bit */
-};
-
-static void acpkm_next(gost_grasshopper_cipher_ctx *c)
-{
-    unsigned char newkey[GRASSHOPPER_KEY_SIZE];
-    const int J = GRASSHOPPER_KEY_SIZE / GRASSHOPPER_BLOCK_SIZE;
-    int n;
-
-    for (n = 0; n < J; n++) {
-        const unsigned char *D_n = &ACPKM_D_2018[n * GRASSHOPPER_BLOCK_SIZE];
-
-        grasshopper_encrypt_block(&c->encrypt_round_keys,
-            (grasshopper_w128_t *)D_n,
-            (grasshopper_w128_t *)&newkey[n * GRASSHOPPER_BLOCK_SIZE],
-            &c->buffer);
-    }
-    gost_grasshopper_cipher_key(c, newkey);
-}
+    static const unsigned char ACPKM_D_2018[] = {
+        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, /*  64 bit */
+        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, /* 128 bit */
+        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+        0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, /* 256 bit */
+    };
+
+    static void acpkm_next(gost_grasshopper_cipher_ctx * c) {
+        unsigned char newkey[GRASSHOPPER_KEY_SIZE];
+        const int J = GRASSHOPPER_KEY_SIZE / GRASSHOPPER_BLOCK_SIZE;
+        int n;
+
+        for (n = 0; n < J; n++) {
+            const unsigned char *D_n =
+                &ACPKM_D_2018[n * GRASSHOPPER_BLOCK_SIZE];
+
+            grasshopper_encrypt_block(&c->encrypt_round_keys,
+                                      (grasshopper_w128_t *) D_n,
+                                      (grasshopper_w128_t *) & newkey[n *
+                                                                      GRASSHOPPER_BLOCK_SIZE],
+                                      &c->buffer);
+        }
+        gost_grasshopper_cipher_key(c, newkey);
+    }
 
 /* Set 256 bit  key into context */
-GRASSHOPPER_INLINE void gost_grasshopper_cipher_key(gost_grasshopper_cipher_ctx* c, const uint8_t* k) {
-               int i;
-    for (i = 0; i < 2; i++) {
-        grasshopper_copy128(&c->key.k.k[i], (const grasshopper_w128_t*) (k + i * 16));
+    GRASSHOPPER_INLINE void
+        gost_grasshopper_cipher_key(gost_grasshopper_cipher_ctx * c,
+                                    const uint8_t *k) {
+        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);
+        grasshopper_set_decrypt_key(&c->decrypt_round_keys, &c->key);
     }
-    grasshopper_set_encrypt_key(&c->encrypt_round_keys, &c->key);
-    grasshopper_set_decrypt_key(&c->decrypt_round_keys, &c->key);
-}
 
 /* Cleans up key from context */
-GRASSHOPPER_INLINE void gost_grasshopper_cipher_destroy(gost_grasshopper_cipher_ctx* c) {
-               int i;
-    for (i = 0; i < 2; i++) {
-        grasshopper_zero128(&c->key.k.k[i]);
-    }
-    for (i = 0; i < GRASSHOPPER_ROUND_KEYS_COUNT; i++) {
-        grasshopper_zero128(&c->encrypt_round_keys.k[i]);
-    }
-    for (i = 0; i < GRASSHOPPER_ROUND_KEYS_COUNT; i++) {
-        grasshopper_zero128(&c->decrypt_round_keys.k[i]);
+    GRASSHOPPER_INLINE void
+        gost_grasshopper_cipher_destroy(gost_grasshopper_cipher_ctx * c) {
+        int i;
+        for (i = 0; i < 2; i++) {
+            grasshopper_zero128(&c->key.k.k[i]);
+        }
+        for (i = 0; i < GRASSHOPPER_ROUND_KEYS_COUNT; i++) {
+            grasshopper_zero128(&c->encrypt_round_keys.k[i]);
+        }
+        for (i = 0; i < GRASSHOPPER_ROUND_KEYS_COUNT; i++) {
+            grasshopper_zero128(&c->decrypt_round_keys.k[i]);
+        }
+        grasshopper_zero128(&c->buffer);
     }
-    grasshopper_zero128(&c->buffer);
-}
-
-static GRASSHOPPER_INLINE void gost_grasshopper_cipher_destroy_ofb(gost_grasshopper_cipher_ctx* c) {
-    gost_grasshopper_cipher_ctx_ofb* ctx = (gost_grasshopper_cipher_ctx_ofb*) c;
-
-    grasshopper_zero128(&ctx->buffer1);
-}
-
-static GRASSHOPPER_INLINE void gost_grasshopper_cipher_destroy_ctr(gost_grasshopper_cipher_ctx* c) {
-    gost_grasshopper_cipher_ctx_ctr* ctx = (gost_grasshopper_cipher_ctx_ctr*) c;
 
-    grasshopper_zero128(&ctx->partial_buffer);
-}
+    static GRASSHOPPER_INLINE void
+        gost_grasshopper_cipher_destroy_ofb(gost_grasshopper_cipher_ctx * c) {
+        gost_grasshopper_cipher_ctx_ofb *ctx =
+            (gost_grasshopper_cipher_ctx_ofb *) c;
 
-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_get_cipher_data(ctx);
-
-    if (EVP_CIPHER_CTX_get_app_data(ctx) == NULL) {
-        EVP_CIPHER_CTX_set_app_data(ctx, EVP_CIPHER_CTX_get_cipher_data(ctx));
+        grasshopper_zero128(&ctx->buffer1);
     }
 
-    if (key != NULL) {
-        gost_grasshopper_cipher_key(c, key);
-    }
+    static GRASSHOPPER_INLINE void
+        gost_grasshopper_cipher_destroy_ctr(gost_grasshopper_cipher_ctx * c) {
+        gost_grasshopper_cipher_ctx_ctr *ctx =
+            (gost_grasshopper_cipher_ctx_ctr *) c;
 
-    if (iv != NULL) {
-        memcpy((unsigned char*) EVP_CIPHER_CTX_original_iv(ctx), iv,
-               EVP_CIPHER_CTX_iv_length(ctx));
+        grasshopper_zero128(&ctx->partial_buffer);
     }
 
-    memcpy(EVP_CIPHER_CTX_iv_noconst(ctx),
-           EVP_CIPHER_CTX_original_iv(ctx),
-           EVP_CIPHER_CTX_iv_length(ctx));
+    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_get_cipher_data(ctx);
 
-    grasshopper_zero128(&c->buffer);
+        if (EVP_CIPHER_CTX_get_app_data(ctx) == NULL) {
+            EVP_CIPHER_CTX_set_app_data(ctx,
+                                        EVP_CIPHER_CTX_get_cipher_data(ctx));
+        }
 
-    return 1;
-}
+        if (key != NULL) {
+            gost_grasshopper_cipher_key(c, key);
+        }
 
-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_get_cipher_data(ctx);
-    c->type = GRASSHOPPER_CIPHER_ECB;
-    return gost_grasshopper_cipher_init(ctx, key, iv, enc);
-}
+        if (iv != NULL) {
+            memcpy((unsigned char *)EVP_CIPHER_CTX_original_iv(ctx), iv,
+                   EVP_CIPHER_CTX_iv_length(ctx));
+        }
 
-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_get_cipher_data(ctx);
-    c->type = GRASSHOPPER_CIPHER_CBC;
-    return gost_grasshopper_cipher_init(ctx, key, iv, enc);
-}
+        memcpy(EVP_CIPHER_CTX_iv_noconst(ctx),
+               EVP_CIPHER_CTX_original_iv(ctx), EVP_CIPHER_CTX_iv_length(ctx));
 
-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_get_cipher_data(ctx);
+        grasshopper_zero128(&c->buffer);
 
-    c->c.type = GRASSHOPPER_CIPHER_OFB;
+        return 1;
+    }
 
-    grasshopper_zero128(&c->buffer1);
+    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_get_cipher_data(ctx);
+        c->type = GRASSHOPPER_CIPHER_ECB;
+        return gost_grasshopper_cipher_init(ctx, key, iv, enc);
+    }
 
-    return gost_grasshopper_cipher_init(ctx, key, iv, enc);
-}
+    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_get_cipher_data(ctx);
+        c->type = GRASSHOPPER_CIPHER_CBC;
+        return gost_grasshopper_cipher_init(ctx, key, iv, enc);
+    }
 
-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_get_cipher_data(ctx);
-    c->type = GRASSHOPPER_CIPHER_CFB;
-    return gost_grasshopper_cipher_init(ctx, key, iv, enc);
-}
+    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_get_cipher_data(ctx);
 
-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_get_cipher_data(ctx);
+        c->c.type = GRASSHOPPER_CIPHER_OFB;
 
-    c->c.type = GRASSHOPPER_CIPHER_CTR;
-    EVP_CIPHER_CTX_set_num(ctx, 0);
+        grasshopper_zero128(&c->buffer1);
 
-    grasshopper_zero128(&c->partial_buffer);
+        return gost_grasshopper_cipher_init(ctx, key, iv, enc);
+    }
 
-    return gost_grasshopper_cipher_init(ctx, key, iv, enc);
-}
+    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_get_cipher_data(ctx);
+        c->type = GRASSHOPPER_CIPHER_CFB;
+        return gost_grasshopper_cipher_init(ctx, key, iv, enc);
+    }
 
-GRASSHOPPER_INLINE int gost_grasshopper_cipher_init_ctracpkm(EVP_CIPHER_CTX *ctx, const unsigned char *key,
-                                                               const unsigned char *iv,
-                                                               int enc) {
-    gost_grasshopper_cipher_ctx_ctr *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
+    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_get_cipher_data(ctx);
 
-    /* NB: setting type makes EVP do_cipher callback useless */
-    c->c.type = GRASSHOPPER_CIPHER_CTRACPKM;
-    EVP_CIPHER_CTX_set_num(ctx, 0);
-    c->section_size  = 4096;
+        c->c.type = GRASSHOPPER_CIPHER_CTR;
+        EVP_CIPHER_CTX_set_num(ctx, 0);
 
-    return gost_grasshopper_cipher_init(ctx, key, iv, enc);
-}
+        grasshopper_zero128(&c->partial_buffer);
 
-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_get_cipher_data(ctx);
-    struct GRASSHOPPER_CIPHER_PARAMS* params = &gost_cipher_params[c->type];
+        return gost_grasshopper_cipher_init(ctx, key, iv, enc);
+    }
 
-    return params->do_cipher(ctx, out, in, inl);
-}
+    GRASSHOPPER_INLINE int gost_grasshopper_cipher_init_ctracpkm(EVP_CIPHER_CTX
+                                                                 *ctx,
+                                                                 const unsigned
+                                                                 char *key,
+                                                                 const unsigned
+                                                                 char *iv,
+                                                                 int enc) {
+        gost_grasshopper_cipher_ctx_ctr *c =
+            EVP_CIPHER_CTX_get_cipher_data(ctx);
+
+        /* NB: setting type makes EVP do_cipher callback useless */
+        c->c.type = GRASSHOPPER_CIPHER_CTRACPKM;
+        EVP_CIPHER_CTX_set_num(ctx, 0);
+        c->section_size = 4096;
 
-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_get_cipher_data(ctx);
-    bool encrypting = (bool) EVP_CIPHER_CTX_encrypting(ctx);
-    const unsigned char* current_in = in;
-    unsigned char* current_out = out;
-    size_t blocks = inl / GRASSHOPPER_BLOCK_SIZE;
-    size_t i;
-
-    for (i = 0; i < blocks; i++, current_in += GRASSHOPPER_BLOCK_SIZE, current_out += GRASSHOPPER_BLOCK_SIZE) {
-        if (encrypting) {
-            grasshopper_encrypt_block(&c->encrypt_round_keys, (grasshopper_w128_t*) current_in,
-                                      (grasshopper_w128_t*) current_out,
-                                      &c->buffer);
-        } else {
-            grasshopper_decrypt_block(&c->decrypt_round_keys, (grasshopper_w128_t*) current_in,
-                                      (grasshopper_w128_t*) current_out,
-                                      &c->buffer);
-        }
+        return gost_grasshopper_cipher_init(ctx, key, iv, enc);
     }
 
-    return 1;
-}
+    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_get_cipher_data(ctx);
+        struct GRASSHOPPER_CIPHER_PARAMS *params = &gost_cipher_params[c->type];
 
-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_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;
-    unsigned char* current_out = out;
-    grasshopper_w128_t* currentInputBlock;
-    grasshopper_w128_t* currentOutputBlock;
-    size_t blocks = inl / GRASSHOPPER_BLOCK_SIZE;
-    size_t i;
-    grasshopper_w128_t* currentBlock;
-
-    currentBlock = (grasshopper_w128_t*) iv;
-
-    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;
-        if (encrypting) {
-            grasshopper_append128(currentBlock, currentInputBlock);
-            grasshopper_encrypt_block(&c->encrypt_round_keys, currentBlock, currentOutputBlock, &c->buffer);
-            grasshopper_copy128(currentBlock, currentOutputBlock);
-        } else {
-            grasshopper_decrypt_block(&c->decrypt_round_keys, currentInputBlock, currentOutputBlock, &c->buffer);
-            grasshopper_append128(currentOutputBlock, currentBlock);
-            grasshopper_copy128(currentBlock, currentInputBlock);
+        return params->do_cipher(ctx, out, in, inl);
+    }
+
+    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_get_cipher_data(ctx);
+        bool encrypting = (bool) EVP_CIPHER_CTX_encrypting(ctx);
+        const unsigned char *current_in = in;
+        unsigned char *current_out = out;
+        size_t blocks = inl / GRASSHOPPER_BLOCK_SIZE;
+        size_t i;
+
+        for (i = 0; i < blocks;
+             i++, current_in += GRASSHOPPER_BLOCK_SIZE, current_out +=
+             GRASSHOPPER_BLOCK_SIZE) {
+            if (encrypting) {
+                grasshopper_encrypt_block(&c->encrypt_round_keys,
+                                          (grasshopper_w128_t *) current_in,
+                                          (grasshopper_w128_t *) current_out,
+                                          &c->buffer);
+            } else {
+                grasshopper_decrypt_block(&c->decrypt_round_keys,
+                                          (grasshopper_w128_t *) current_in,
+                                          (grasshopper_w128_t *) current_out,
+                                          &c->buffer);
+            }
         }
+
+        return 1;
     }
 
-    return 1;
-}
+    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_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;
+        unsigned char *current_out = out;
+        grasshopper_w128_t *currentInputBlock;
+        grasshopper_w128_t *currentOutputBlock;
+        size_t blocks = inl / GRASSHOPPER_BLOCK_SIZE;
+        size_t i;
+        grasshopper_w128_t *currentBlock;
+
+        currentBlock = (grasshopper_w128_t *) iv;
+
+        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;
+            if (encrypting) {
+                grasshopper_append128(currentBlock, currentInputBlock);
+                grasshopper_encrypt_block(&c->encrypt_round_keys, currentBlock,
+                                          currentOutputBlock, &c->buffer);
+                grasshopper_copy128(currentBlock, currentOutputBlock);
+            } else {
+                grasshopper_decrypt_block(&c->decrypt_round_keys,
+                                          currentInputBlock, currentOutputBlock,
+                                          &c->buffer);
+                grasshopper_append128(currentOutputBlock, currentBlock);
+                grasshopper_copy128(currentBlock, currentInputBlock);
+            }
+        }
 
-void inc_counter(unsigned char* counter, size_t counter_bytes)
-{
-    unsigned char c;
-    unsigned int n = counter_bytes;
-
-    do {
-        --n;
-        c = counter[n];
-        ++c;
-        counter[n] = c;
-        if (c) return;
-    } while (n);
-}
+        return 1;
+    }
+
+    void inc_counter(unsigned char *counter, size_t counter_bytes) {
+        unsigned char c;
+        unsigned int n = counter_bytes;
+
+        do {
+            --n;
+            c = counter[n];
+            ++c;
+            counter[n] = c;
+            if (c)
+                return;
+        } while (n);
+    }
 
 /* increment counter (128-bit int) by 1 */
-static void ctr128_inc(unsigned char *counter)
-{
-       inc_counter(counter, 16);
-}
+    static void ctr128_inc(unsigned char *counter) {
+        inc_counter(counter, 16);
+    }
 
-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_get_cipher_data(ctx);
-    unsigned char* iv = EVP_CIPHER_CTX_iv_noconst(ctx);
-    const unsigned char* current_in = in;
-    unsigned char* current_out = out;
-    grasshopper_w128_t* currentInputBlock;
-    grasshopper_w128_t* currentOutputBlock;
-    unsigned int n = EVP_CIPHER_CTX_num(ctx);
-    size_t lasted;
-    size_t i;
-
-    while (n && inl) {
-       *(current_out++) = *(current_in++) ^ c->partial_buffer.b[n];
-       --inl;
-       n = (n + 1) % GRASSHOPPER_BLOCK_SIZE;
-    }
-    EVP_CIPHER_CTX_set_num(ctx, n);
-    size_t blocks = inl / GRASSHOPPER_BLOCK_SIZE;
-
-    grasshopper_w128_t* iv_buffer = (grasshopper_w128_t*) iv;
-
-    // full parts
-    for (i = 0; i < blocks; i++) {
-        currentInputBlock = (grasshopper_w128_t*) current_in;
-        currentOutputBlock = (grasshopper_w128_t*) current_out;
-        grasshopper_encrypt_block(&c->c.encrypt_round_keys, iv_buffer, currentOutputBlock, &c->c.buffer);
-        grasshopper_append128(currentOutputBlock, currentInputBlock);
-        ctr128_inc(iv_buffer->b);
-        current_in += GRASSHOPPER_BLOCK_SIZE;
-        current_out += GRASSHOPPER_BLOCK_SIZE;
-    }
-
-    // last part
-    lasted = inl - blocks * GRASSHOPPER_BLOCK_SIZE;
-    if (lasted > 0) {
-        currentInputBlock = (grasshopper_w128_t*) current_in;
-        currentOutputBlock = (grasshopper_w128_t*) current_out;
-        grasshopper_encrypt_block(&c->c.encrypt_round_keys, iv_buffer, &c->partial_buffer, &c->c.buffer);
-        for (i = 0; i < lasted; i++) {
-            currentOutputBlock->b[i] = c->partial_buffer.b[i] ^ currentInputBlock->b[i];
+    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_get_cipher_data(ctx);
+        unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx);
+        const unsigned char *current_in = in;
+        unsigned char *current_out = out;
+        grasshopper_w128_t *currentInputBlock;
+        grasshopper_w128_t *currentOutputBlock;
+        unsigned int n = EVP_CIPHER_CTX_num(ctx);
+        size_t lasted;
+        size_t i;
+
+        while (n && inl) {
+            *(current_out++) = *(current_in++) ^ c->partial_buffer.b[n];
+            --inl;
+            n = (n + 1) % GRASSHOPPER_BLOCK_SIZE;
+        }
+        EVP_CIPHER_CTX_set_num(ctx, n);
+        size_t blocks = inl / GRASSHOPPER_BLOCK_SIZE;
+
+        grasshopper_w128_t *iv_buffer = (grasshopper_w128_t *) iv;
+
+        // full parts
+        for (i = 0; i < blocks; i++) {
+            currentInputBlock = (grasshopper_w128_t *) current_in;
+            currentOutputBlock = (grasshopper_w128_t *) current_out;
+            grasshopper_encrypt_block(&c->c.encrypt_round_keys, iv_buffer,
+                                      currentOutputBlock, &c->c.buffer);
+            grasshopper_append128(currentOutputBlock, currentInputBlock);
+            ctr128_inc(iv_buffer->b);
+            current_in += GRASSHOPPER_BLOCK_SIZE;
+            current_out += GRASSHOPPER_BLOCK_SIZE;
         }
-       EVP_CIPHER_CTX_set_num(ctx, i);
-        ctr128_inc(iv_buffer->b);
-    }
 
-    return 1;
-}
+        // last part
+        lasted = inl - blocks * GRASSHOPPER_BLOCK_SIZE;
+        if (lasted > 0) {
+            currentInputBlock = (grasshopper_w128_t *) current_in;
+            currentOutputBlock = (grasshopper_w128_t *) current_out;
+            grasshopper_encrypt_block(&c->c.encrypt_round_keys, iv_buffer,
+                                      &c->partial_buffer, &c->c.buffer);
+            for (i = 0; i < lasted; i++) {
+                currentOutputBlock->b[i] =
+                    c->partial_buffer.b[i] ^ currentInputBlock->b[i];
+            }
+            EVP_CIPHER_CTX_set_num(ctx, i);
+            ctr128_inc(iv_buffer->b);
+        }
+
+        return 1;
+    }
 
 #define GRASSHOPPER_BLOCK_MASK (GRASSHOPPER_BLOCK_SIZE - 1)
-static inline void apply_acpkm_grasshopper(gost_grasshopper_cipher_ctx_ctr *ctx, unsigned int *num)
-{
-    if (!ctx->section_size ||
-        (*num < ctx->section_size))
-        return;
-    acpkm_next(&ctx->c);
-    *num &= GRASSHOPPER_BLOCK_MASK;
-}
+    static inline void apply_acpkm_grasshopper(gost_grasshopper_cipher_ctx_ctr *
+                                               ctx, unsigned int *num) {
+        if (!ctx->section_size || (*num < ctx->section_size))
+            return;
+        acpkm_next(&ctx->c);
+        *num &= GRASSHOPPER_BLOCK_MASK;
+    }
 
 /* If meshing is not configured via ctrl (setting section_size)
  * this function works exactly like plain ctr */
-int gost_grasshopper_cipher_do_ctracpkm(EVP_CIPHER_CTX *ctx, unsigned char *out,
-    const unsigned char *in, size_t inl) {
-    gost_grasshopper_cipher_ctx_ctr *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
-    unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx);
-    unsigned int num = EVP_CIPHER_CTX_num(ctx);
-
-    while ((num & GRASSHOPPER_BLOCK_MASK) && inl) {
-        *out++ = *in++ ^ c->partial_buffer.b[num & GRASSHOPPER_BLOCK_MASK];
-        --inl;
-        num++;
-    }
-    size_t blocks = inl / GRASSHOPPER_BLOCK_SIZE;
-    size_t i;
-
-    // full parts
-    for (i = 0; i < blocks; i++) {
-        apply_acpkm_grasshopper(c, &num);
-        grasshopper_encrypt_block(&c->c.encrypt_round_keys,
-            (grasshopper_w128_t *)iv, (grasshopper_w128_t *)out, &c->c.buffer);
-        grasshopper_append128((grasshopper_w128_t *)out, (grasshopper_w128_t *)in);
-        ctr128_inc(iv);
-        in  += GRASSHOPPER_BLOCK_SIZE;
-        out += GRASSHOPPER_BLOCK_SIZE;
-        num += GRASSHOPPER_BLOCK_SIZE;
-    }
-
-    // last part
-    size_t lasted = inl - blocks * GRASSHOPPER_BLOCK_SIZE;
-    if (lasted > 0) {
-        apply_acpkm_grasshopper(c, &num);
-        grasshopper_encrypt_block(&c->c.encrypt_round_keys,
-            (grasshopper_w128_t *)iv, &c->partial_buffer, &c->c.buffer);
-        for (i = 0; i < lasted; i++)
-            out[i] = c->partial_buffer.b[i] ^ in[i];
-        ctr128_inc(iv);
-        num += lasted;
-    }
-    EVP_CIPHER_CTX_set_num(ctx, num);
-
-    return 1;
-}
+    int gost_grasshopper_cipher_do_ctracpkm(EVP_CIPHER_CTX *ctx,
+                                            unsigned char *out,
+                                            const unsigned char *in,
+                                            size_t inl) {
+        gost_grasshopper_cipher_ctx_ctr *c =
+            EVP_CIPHER_CTX_get_cipher_data(ctx);
+        unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx);
+        unsigned int num = EVP_CIPHER_CTX_num(ctx);
+
+        while ((num & GRASSHOPPER_BLOCK_MASK) && inl) {
+            *out++ = *in++ ^ c->partial_buffer.b[num & GRASSHOPPER_BLOCK_MASK];
+            --inl;
+            num++;
+        }
+        size_t blocks = inl / GRASSHOPPER_BLOCK_SIZE;
+        size_t i;
+
+        // full parts
+        for (i = 0; i < blocks; i++) {
+            apply_acpkm_grasshopper(c, &num);
+            grasshopper_encrypt_block(&c->c.encrypt_round_keys,
+                                      (grasshopper_w128_t *) iv,
+                                      (grasshopper_w128_t *) out, &c->c.buffer);
+            grasshopper_append128((grasshopper_w128_t *) out,
+                                  (grasshopper_w128_t *) in);
+            ctr128_inc(iv);
+            in += GRASSHOPPER_BLOCK_SIZE;
+            out += GRASSHOPPER_BLOCK_SIZE;
+            num += GRASSHOPPER_BLOCK_SIZE;
+        }
+
+        // last part
+        size_t lasted = inl - blocks * GRASSHOPPER_BLOCK_SIZE;
+        if (lasted > 0) {
+            apply_acpkm_grasshopper(c, &num);
+            grasshopper_encrypt_block(&c->c.encrypt_round_keys,
+                                      (grasshopper_w128_t *) iv,
+                                      &c->partial_buffer, &c->c.buffer);
+            for (i = 0; i < lasted; i++)
+                out[i] = c->partial_buffer.b[i] ^ in[i];
+            ctr128_inc(iv);
+            num += lasted;
+        }
+        EVP_CIPHER_CTX_set_num(ctx, num);
+
+        return 1;
+    }
 
 /*
  * Fixed 128-bit IV implementation make shift regiser redundant.
  */
-static void gost_grasshopper_cnt_next(gost_grasshopper_cipher_ctx_ofb* ctx, grasshopper_w128_t* iv,
-                                      grasshopper_w128_t* buf) {
-    memcpy(&ctx->buffer1, iv, 16);
-    grasshopper_encrypt_block(&ctx->c.encrypt_round_keys, &ctx->buffer1, buf, &ctx->c.buffer);
-    memcpy(iv, buf, 16);
-}
+    static void gost_grasshopper_cnt_next(gost_grasshopper_cipher_ctx_ofb * ctx,
+                                          grasshopper_w128_t * iv,
+                                          grasshopper_w128_t * buf) {
+        memcpy(&ctx->buffer1, iv, 16);
+        grasshopper_encrypt_block(&ctx->c.encrypt_round_keys, &ctx->buffer1,
+                                  buf, &ctx->c.buffer);
+        memcpy(iv, buf, 16);
+    }
 
-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_get_cipher_data(ctx);
-    const unsigned char* in_ptr = in;
-    unsigned char* out_ptr = out;
-    unsigned char* buf = EVP_CIPHER_CTX_buf_noconst(ctx);
-    unsigned char* iv = EVP_CIPHER_CTX_iv_noconst(ctx);
-    int num = EVP_CIPHER_CTX_num(ctx);
-    size_t i = 0;
-    size_t j;
-
-    /* process partial block if any */
-    if (num > 0) {
-        for (j = (size_t) num, i = 0; j < GRASSHOPPER_BLOCK_SIZE && i < inl;
-             j++, i++, in_ptr++, out_ptr++) {
-            *out_ptr = buf[j] ^ (*in_ptr);
-        }
-        if (j == GRASSHOPPER_BLOCK_SIZE) {
-            EVP_CIPHER_CTX_set_num(ctx, 0);
-        } else {
-            EVP_CIPHER_CTX_set_num(ctx, (int) j);
-            return 1;
+    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_get_cipher_data(ctx);
+        const unsigned char *in_ptr = in;
+        unsigned char *out_ptr = out;
+        unsigned char *buf = EVP_CIPHER_CTX_buf_noconst(ctx);
+        unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx);
+        int num = EVP_CIPHER_CTX_num(ctx);
+        size_t i = 0;
+        size_t j;
+
+        /* process partial block if any */
+        if (num > 0) {
+            for (j = (size_t)num, i = 0; j < GRASSHOPPER_BLOCK_SIZE && i < inl;
+                 j++, i++, in_ptr++, out_ptr++) {
+                *out_ptr = buf[j] ^ (*in_ptr);
+            }
+            if (j == GRASSHOPPER_BLOCK_SIZE) {
+                EVP_CIPHER_CTX_set_num(ctx, 0);
+            } else {
+                EVP_CIPHER_CTX_set_num(ctx, (int)j);
+                return 1;
+            }
         }
-    }
 
-    for (; i + GRASSHOPPER_BLOCK_SIZE <
-           inl; i += GRASSHOPPER_BLOCK_SIZE, in_ptr += GRASSHOPPER_BLOCK_SIZE, out_ptr += GRASSHOPPER_BLOCK_SIZE) {
-        /*
-         * block cipher current iv
-         */
-        /* Encrypt */
-        gost_grasshopper_cnt_next(c, (grasshopper_w128_t*) iv, (grasshopper_w128_t*) buf);
-
-        /*
-         * xor next block of input text with it and output it
-         */
-        /*
-         * output this block
-         */
-        for (j = 0; j < GRASSHOPPER_BLOCK_SIZE; j++) {
-            out_ptr[j] = buf[j] ^ in_ptr[j];
+        for (; i + GRASSHOPPER_BLOCK_SIZE <
+             inl;
+             i += GRASSHOPPER_BLOCK_SIZE, in_ptr +=
+             GRASSHOPPER_BLOCK_SIZE, out_ptr += GRASSHOPPER_BLOCK_SIZE) {
+            /*
+             * block cipher current iv
+             */
+            /* Encrypt */
+            gost_grasshopper_cnt_next(c, (grasshopper_w128_t *) iv,
+                                      (grasshopper_w128_t *) buf);
+
+            /*
+             * xor next block of input text with it and output it
+             */
+            /*
+             * output this block
+             */
+            for (j = 0; j < GRASSHOPPER_BLOCK_SIZE; j++) {
+                out_ptr[j] = buf[j] ^ in_ptr[j];
+            }
         }
-    }
 
-    /* Process rest of buffer */
-    if (i < inl) {
-        gost_grasshopper_cnt_next(c, (grasshopper_w128_t*) iv, (grasshopper_w128_t*) buf);
-        for (j = 0; i < inl; j++, i++) {
-            out_ptr[j] = buf[j] ^ in_ptr[j];
+        /* Process rest of buffer */
+        if (i < inl) {
+            gost_grasshopper_cnt_next(c, (grasshopper_w128_t *) iv,
+                                      (grasshopper_w128_t *) buf);
+            for (j = 0; i < inl; j++, i++) {
+                out_ptr[j] = buf[j] ^ in_ptr[j];
+            }
+            EVP_CIPHER_CTX_set_num(ctx, (int)j);
+        } else {
+            EVP_CIPHER_CTX_set_num(ctx, 0);
         }
-        EVP_CIPHER_CTX_set_num(ctx, (int) j);
-    } else {
-        EVP_CIPHER_CTX_set_num(ctx, 0);
+
+        return 1;
     }
 
-    return 1;
-}
+    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_get_cipher_data(ctx);
+        const unsigned char *in_ptr = in;
+        unsigned char *out_ptr = out;
+        unsigned char *buf = EVP_CIPHER_CTX_buf_noconst(ctx);
+        unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx);
+        bool encrypting = (bool) EVP_CIPHER_CTX_encrypting(ctx);
+        int num = EVP_CIPHER_CTX_num(ctx);
+        size_t i = 0;
+        size_t j = 0;
+
+        /* process partial block if any */
+        if (num > 0) {
+            for (j = (size_t)num, i = 0; j < GRASSHOPPER_BLOCK_SIZE && i < inl;
+                 j++, i++, in_ptr++, out_ptr++) {
+                if (!encrypting) {
+                    buf[j + GRASSHOPPER_BLOCK_SIZE] = *in_ptr;
+                }
+                *out_ptr = buf[j] ^ (*in_ptr);
+                if (encrypting) {
+                    buf[j + GRASSHOPPER_BLOCK_SIZE] = *out_ptr;
+                }
+            }
+            if (j == GRASSHOPPER_BLOCK_SIZE) {
+                memcpy(iv, buf + GRASSHOPPER_BLOCK_SIZE,
+                       GRASSHOPPER_BLOCK_SIZE);
+                EVP_CIPHER_CTX_set_num(ctx, 0);
+            } else {
+                EVP_CIPHER_CTX_set_num(ctx, (int)j);
+                return 1;
+            }
+        }
 
-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_get_cipher_data(ctx);
-    const unsigned char* in_ptr = in;
-    unsigned char* out_ptr = out;
-    unsigned char* buf = EVP_CIPHER_CTX_buf_noconst(ctx);
-    unsigned char* iv = EVP_CIPHER_CTX_iv_noconst(ctx);
-    bool encrypting = (bool) EVP_CIPHER_CTX_encrypting(ctx);
-    int num = EVP_CIPHER_CTX_num(ctx);
-    size_t i = 0;
-    size_t j = 0;
-
-    /* process partial block if any */
-    if (num > 0) {
-        for (j = (size_t) num, i = 0; j < GRASSHOPPER_BLOCK_SIZE && i < inl; j++, i++, in_ptr++, out_ptr++) {
+        for (; i + GRASSHOPPER_BLOCK_SIZE <
+             inl;
+             i += GRASSHOPPER_BLOCK_SIZE, in_ptr +=
+             GRASSHOPPER_BLOCK_SIZE, out_ptr += GRASSHOPPER_BLOCK_SIZE) {
+            /*
+             * block cipher current iv
+             */
+            grasshopper_encrypt_block(&c->encrypt_round_keys,
+                                      (grasshopper_w128_t *) iv,
+                                      (grasshopper_w128_t *) buf, &c->buffer);
+            /*
+             * xor next block of input text with it and output it
+             */
+            /*
+             * output this block
+             */
             if (!encrypting) {
-                buf[j + GRASSHOPPER_BLOCK_SIZE] = *in_ptr;
+                memcpy(iv, in_ptr, GRASSHOPPER_BLOCK_SIZE);
             }
-            *out_ptr = buf[j] ^ (*in_ptr);
+            for (j = 0; j < GRASSHOPPER_BLOCK_SIZE; j++) {
+                out_ptr[j] = buf[j] ^ in_ptr[j];
+            }
+            /* Encrypt */
+            /* Next iv is next block of cipher text */
             if (encrypting) {
-                buf[j + GRASSHOPPER_BLOCK_SIZE] = *out_ptr;
+                memcpy(iv, out_ptr, GRASSHOPPER_BLOCK_SIZE);
             }
         }
-        if (j == GRASSHOPPER_BLOCK_SIZE) {
-            memcpy(iv, buf + GRASSHOPPER_BLOCK_SIZE, GRASSHOPPER_BLOCK_SIZE);
-            EVP_CIPHER_CTX_set_num(ctx, 0);
+
+        /* Process rest of buffer */
+        if (i < inl) {
+            grasshopper_encrypt_block(&c->encrypt_round_keys,
+                                      (grasshopper_w128_t *) iv,
+                                      (grasshopper_w128_t *) buf, &c->buffer);
+            if (!encrypting) {
+                memcpy(buf + GRASSHOPPER_BLOCK_SIZE, in_ptr, inl - i);
+            }
+            for (j = 0; i < inl; j++, i++) {
+                out_ptr[j] = buf[j] ^ in_ptr[j];
+            }
+            EVP_CIPHER_CTX_set_num(ctx, (int)j);
+            if (encrypting) {
+                memcpy(buf + GRASSHOPPER_BLOCK_SIZE, out_ptr, j);
+            }
         } else {
-            EVP_CIPHER_CTX_set_num(ctx, (int) j);
-            return 1;
+            EVP_CIPHER_CTX_set_num(ctx, 0);
         }
-    }
 
-    for (; i + GRASSHOPPER_BLOCK_SIZE <
-           inl; i += GRASSHOPPER_BLOCK_SIZE, in_ptr += GRASSHOPPER_BLOCK_SIZE, out_ptr += GRASSHOPPER_BLOCK_SIZE) {
-        /*
-         * block cipher current iv
-         */
-        grasshopper_encrypt_block(&c->encrypt_round_keys, (grasshopper_w128_t*) iv, (grasshopper_w128_t*) buf,
-                                  &c->buffer);
-        /*
-         * xor next block of input text with it and output it
-         */
-        /*
-         * output this block
-         */
-        if (!encrypting) {
-            memcpy(iv, in_ptr, GRASSHOPPER_BLOCK_SIZE);
-        }
-        for (j = 0; j < GRASSHOPPER_BLOCK_SIZE; j++) {
-            out_ptr[j] = buf[j] ^ in_ptr[j];
-        }
-        /* Encrypt */
-        /* Next iv is next block of cipher text */
-        if (encrypting) {
-            memcpy(iv, out_ptr, GRASSHOPPER_BLOCK_SIZE);
-        }
+        return 1;
     }
 
-    /* Process rest of buffer */
-    if (i < inl) {
-        grasshopper_encrypt_block(&c->encrypt_round_keys, (grasshopper_w128_t*) iv, (grasshopper_w128_t*) buf,
-                                  &c->buffer);
-        if (!encrypting) {
-            memcpy(buf + GRASSHOPPER_BLOCK_SIZE, in_ptr, inl - i);
-        }
-        for (j = 0; i < inl; j++, i++) {
-            out_ptr[j] = buf[j] ^ in_ptr[j];
-        }
-        EVP_CIPHER_CTX_set_num(ctx, (int) j);
-        if (encrypting) {
-            memcpy(buf + GRASSHOPPER_BLOCK_SIZE, out_ptr, j);
-        }
-    } else {
-        EVP_CIPHER_CTX_set_num(ctx, 0);
-    }
+    int gost_grasshopper_cipher_cleanup(EVP_CIPHER_CTX *ctx) {
+        gost_grasshopper_cipher_ctx *c =
+            (gost_grasshopper_cipher_ctx *) EVP_CIPHER_CTX_get_cipher_data(ctx);
 
-    return 1;
-}
+        if (!c)
+            return 1;
 
-int gost_grasshopper_cipher_cleanup(EVP_CIPHER_CTX* 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];
 
-    if (!c)
-        return 1;
+        gost_grasshopper_cipher_destroy(c);
+        if (params->destroy_cipher != NULL) {
+            params->destroy_cipher(c);
+        }
 
-    struct GRASSHOPPER_CIPHER_PARAMS* params = &gost_cipher_params[c->type];
+        EVP_CIPHER_CTX_set_app_data(ctx, NULL);
 
-    gost_grasshopper_cipher_destroy(c);
-    if (params->destroy_cipher != NULL) {
-        params->destroy_cipher(c);
+        return 1;
     }
 
-    EVP_CIPHER_CTX_set_app_data(ctx, NULL);
-
-    return 1;
-}
-
-int gost_grasshopper_set_asn1_parameters(EVP_CIPHER_CTX* ctx, ASN1_TYPE* params) {
-    int len = 0;
-    unsigned char* buf = NULL;
-    ASN1_OCTET_STRING* os = NULL;
+    int gost_grasshopper_set_asn1_parameters(EVP_CIPHER_CTX *ctx,
+                                             ASN1_TYPE *params) {
+        int len = 0;
+        unsigned char *buf = NULL;
+        ASN1_OCTET_STRING *os = NULL;
 
-    os = ASN1_OCTET_STRING_new();
+        os = ASN1_OCTET_STRING_new();
 
-    if (!os || !ASN1_OCTET_STRING_set(os, buf, len)) {
+        if (!os || !ASN1_OCTET_STRING_set(os, buf, len)) {
+            OPENSSL_free(buf);
+            GOSTerr(GOST_F_GOST_GRASSHOPPER_SET_ASN1_PARAMETERS,
+                    ERR_R_MALLOC_FAILURE);
+            return 0;
+        }
         OPENSSL_free(buf);
-        GOSTerr(GOST_F_GOST_GRASSHOPPER_SET_ASN1_PARAMETERS, ERR_R_MALLOC_FAILURE);
-        return 0;
+
+        ASN1_TYPE_set(params, V_ASN1_SEQUENCE, os);
+        return 1;
     }
-    OPENSSL_free(buf);
 
-    ASN1_TYPE_set(params, V_ASN1_SEQUENCE, os);
-    return 1;
-}
+    GRASSHOPPER_INLINE int gost_grasshopper_get_asn1_parameters(EVP_CIPHER_CTX
+                                                                *ctx,
+                                                                ASN1_TYPE
+                                                                *params) {
+        int ret = -1;
 
-GRASSHOPPER_INLINE int gost_grasshopper_get_asn1_parameters(EVP_CIPHER_CTX* ctx, ASN1_TYPE* params) {
-    int ret = -1;
+        if (ASN1_TYPE_get(params) != V_ASN1_SEQUENCE) {
+            return ret;
+        }
 
-    if (ASN1_TYPE_get(params) != V_ASN1_SEQUENCE) {
-        return ret;
+        return 1;
     }
 
-    return 1;
-}
-
-int gost_grasshopper_cipher_ctl(EVP_CIPHER_CTX* ctx, int type, int arg, void* ptr) {
-    switch (type) {
-        case EVP_CTRL_RAND_KEY: {
-            if (RAND_bytes((unsigned char*) ptr, EVP_CIPHER_CTX_key_length(ctx)) <= 0) {
-                GOSTerr(GOST_F_GOST_GRASSHOPPER_CIPHER_CTL, GOST_R_RNG_ERROR);
-                return -1;
+    int gost_grasshopper_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg,
+                                    void *ptr) {
+        switch (type) {
+        case EVP_CTRL_RAND_KEY:{
+                if (RAND_bytes
+                    ((unsigned char *)ptr,
+                     EVP_CIPHER_CTX_key_length(ctx)) <= 0) {
+                    GOSTerr(GOST_F_GOST_GRASSHOPPER_CIPHER_CTL,
+                            GOST_R_RNG_ERROR);
+                    return -1;
+                }
+                break;
+            }
+        case EVP_CTRL_KEY_MESH:{
+                gost_grasshopper_cipher_ctx_ctr *c =
+                    EVP_CIPHER_CTX_get_cipher_data(ctx);
+                if (c->c.type != GRASSHOPPER_CIPHER_CTRACPKM || !arg
+                    || (arg % GRASSHOPPER_BLOCK_SIZE))
+                    return -1;
+                c->section_size = arg;
+                break;
             }
-            break;
-        }
-        case EVP_CTRL_KEY_MESH: {
-            gost_grasshopper_cipher_ctx_ctr *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
-            if (c->c.type != GRASSHOPPER_CIPHER_CTRACPKM ||
-                !arg || (arg % GRASSHOPPER_BLOCK_SIZE))
-                return -1;
-            c->section_size = arg;
-            break;
-        }
         default:
-            GOSTerr(GOST_F_GOST_GRASSHOPPER_CIPHER_CTL, GOST_R_UNSUPPORTED_CIPHER_CTL_COMMAND);
+            GOSTerr(GOST_F_GOST_GRASSHOPPER_CIPHER_CTL,
+                    GOST_R_UNSUPPORTED_CIPHER_CTL_COMMAND);
             return -1;
+        }
+        return 1;
     }
-    return 1;
-}
 
-GRASSHOPPER_INLINE EVP_CIPHER* cipher_gost_grasshopper_create(int cipher_type, int block_size) {
-    return EVP_CIPHER_meth_new(cipher_type,
-                               block_size  /* block_size */,
-                               GRASSHOPPER_KEY_SIZE /* key_size */);
-}
-
-const int cipher_gost_grasshopper_setup(EVP_CIPHER* cipher, uint8_t mode, int iv_size, bool padding) {
-    return EVP_CIPHER_meth_set_iv_length(cipher, iv_size) &&
-           EVP_CIPHER_meth_set_flags(cipher, (unsigned long) (
-                   mode |
-                   ((!padding) ? EVP_CIPH_NO_PADDING : 0) |
-                   ((iv_size > 0) ? EVP_CIPH_CUSTOM_IV : 0) |
-                   EVP_CIPH_RAND_KEY |
-                   EVP_CIPH_ALWAYS_CALL_INIT)
-           ) &&
-           EVP_CIPHER_meth_set_cleanup(cipher, gost_grasshopper_cipher_cleanup) &&
-           EVP_CIPHER_meth_set_set_asn1_params(cipher, gost_grasshopper_set_asn1_parameters) &&
-           EVP_CIPHER_meth_set_get_asn1_params(cipher, gost_grasshopper_get_asn1_parameters) &&
-           EVP_CIPHER_meth_set_ctrl(cipher, gost_grasshopper_cipher_ctl) &&
-           EVP_CIPHER_meth_set_do_cipher(cipher, gost_grasshopper_cipher_do);
-}
-
-const GRASSHOPPER_INLINE EVP_CIPHER* cipher_gost_grasshopper(uint8_t mode, uint8_t num) {
-    EVP_CIPHER** cipher;
-    struct GRASSHOPPER_CIPHER_PARAMS* params;
+    GRASSHOPPER_INLINE EVP_CIPHER *cipher_gost_grasshopper_create(int
+                                                                  cipher_type,
+                                                                  int
+                                                                  block_size) {
+        return EVP_CIPHER_meth_new(cipher_type, block_size /* block_size */ ,
+                                   GRASSHOPPER_KEY_SIZE /* key_size */ );
+    }
 
-    cipher = &gost_grasshopper_ciphers[num];
+    const int cipher_gost_grasshopper_setup(EVP_CIPHER *cipher, uint8_t mode,
+                                            int iv_size, bool padding) {
+        return EVP_CIPHER_meth_set_iv_length(cipher, iv_size)
+            && EVP_CIPHER_meth_set_flags(cipher,
+                                         (unsigned long)(mode |
+                                                         ((!padding) ?
+                                                          EVP_CIPH_NO_PADDING :
+                                                          0) | ((iv_size >
+                                                                 0) ?
+                                                                EVP_CIPH_CUSTOM_IV
+                                                                : 0) |
+                                                         EVP_CIPH_RAND_KEY |
+                                                         EVP_CIPH_ALWAYS_CALL_INIT)
+            )
+            && EVP_CIPHER_meth_set_cleanup(cipher,
+                                           gost_grasshopper_cipher_cleanup)
+            && EVP_CIPHER_meth_set_set_asn1_params(cipher,
+                                                   gost_grasshopper_set_asn1_parameters)
+            && EVP_CIPHER_meth_set_get_asn1_params(cipher,
+                                                   gost_grasshopper_get_asn1_parameters)
+            && EVP_CIPHER_meth_set_ctrl(cipher, gost_grasshopper_cipher_ctl)
+            && EVP_CIPHER_meth_set_do_cipher(cipher,
+                                             gost_grasshopper_cipher_do);
+    }
 
-    if (*cipher == NULL) {
-        params = &gost_cipher_params[num];
+    const GRASSHOPPER_INLINE EVP_CIPHER *cipher_gost_grasshopper(uint8_t mode,
+                                                                 uint8_t num) {
+        EVP_CIPHER **cipher;
+        struct GRASSHOPPER_CIPHER_PARAMS *params;
 
-        int nid = params->nid;
-        grasshopper_init_cipher_func init_cipher = params->init_cipher;
-        int block_size = params->block_size;
-        int ctx_size = params->ctx_size;
-        int iv_size = params->iv_size;
-        bool padding = params->padding;
+        cipher = &gost_grasshopper_ciphers[num];
 
-        *cipher = cipher_gost_grasshopper_create(nid, block_size);
         if (*cipher == NULL) {
-            return NULL;
-        }
+            params = &gost_cipher_params[num];
+
+            int nid = params->nid;
+            grasshopper_init_cipher_func init_cipher = params->init_cipher;
+            int block_size = params->block_size;
+            int ctx_size = params->ctx_size;
+            int iv_size = params->iv_size;
+            bool padding = params->padding;
+
+            *cipher = cipher_gost_grasshopper_create(nid, block_size);
+            if (*cipher == NULL) {
+                return NULL;
+            }
 
-        if (!cipher_gost_grasshopper_setup(*cipher, mode, iv_size, padding) ||
-            !EVP_CIPHER_meth_set_init(*cipher, init_cipher) ||
-            !EVP_CIPHER_meth_set_impl_ctx_size(*cipher, ctx_size)) {
-            EVP_CIPHER_meth_free(*cipher);
-            *cipher = NULL;
+            if (!cipher_gost_grasshopper_setup(*cipher, mode, iv_size, padding)
+                || !EVP_CIPHER_meth_set_init(*cipher, init_cipher)
+                || !EVP_CIPHER_meth_set_impl_ctx_size(*cipher, ctx_size)) {
+                EVP_CIPHER_meth_free(*cipher);
+                *cipher = NULL;
+            }
         }
-    }
 
-    return *cipher;
-}
+        return *cipher;
+    }
 
-const GRASSHOPPER_INLINE EVP_CIPHER* cipher_gost_grasshopper_ecb() {
-    return cipher_gost_grasshopper(EVP_CIPH_ECB_MODE, GRASSHOPPER_CIPHER_ECB);
-}
+    const GRASSHOPPER_INLINE EVP_CIPHER *cipher_gost_grasshopper_ecb() {
+        return cipher_gost_grasshopper(EVP_CIPH_ECB_MODE,
+                                       GRASSHOPPER_CIPHER_ECB);
+    }
 
-const GRASSHOPPER_INLINE EVP_CIPHER* cipher_gost_grasshopper_cbc() {
-    return cipher_gost_grasshopper(EVP_CIPH_CBC_MODE, GRASSHOPPER_CIPHER_CBC);
-}
+    const GRASSHOPPER_INLINE EVP_CIPHER *cipher_gost_grasshopper_cbc() {
+        return cipher_gost_grasshopper(EVP_CIPH_CBC_MODE,
+                                       GRASSHOPPER_CIPHER_CBC);
+    }
 
-const GRASSHOPPER_INLINE EVP_CIPHER* cipher_gost_grasshopper_ofb() {
-    return cipher_gost_grasshopper(EVP_CIPH_OFB_MODE, GRASSHOPPER_CIPHER_OFB);
-}
+    const GRASSHOPPER_INLINE EVP_CIPHER *cipher_gost_grasshopper_ofb() {
+        return cipher_gost_grasshopper(EVP_CIPH_OFB_MODE,
+                                       GRASSHOPPER_CIPHER_OFB);
+    }
 
-const GRASSHOPPER_INLINE EVP_CIPHER* cipher_gost_grasshopper_cfb() {
-    return cipher_gost_grasshopper(EVP_CIPH_CFB_MODE, GRASSHOPPER_CIPHER_CFB);
-}
+    const GRASSHOPPER_INLINE EVP_CIPHER *cipher_gost_grasshopper_cfb() {
+        return cipher_gost_grasshopper(EVP_CIPH_CFB_MODE,
+                                       GRASSHOPPER_CIPHER_CFB);
+    }
 
-const GRASSHOPPER_INLINE EVP_CIPHER* cipher_gost_grasshopper_ctr() {
-    return cipher_gost_grasshopper(EVP_CIPH_CTR_MODE, GRASSHOPPER_CIPHER_CTR);
-}
+    const GRASSHOPPER_INLINE EVP_CIPHER *cipher_gost_grasshopper_ctr() {
+        return cipher_gost_grasshopper(EVP_CIPH_CTR_MODE,
+                                       GRASSHOPPER_CIPHER_CTR);
+    }
 
-const GRASSHOPPER_INLINE EVP_CIPHER* cipher_gost_grasshopper_ctracpkm() {
-    return cipher_gost_grasshopper(EVP_CIPH_CTR_MODE, GRASSHOPPER_CIPHER_CTRACPKM);
-}
+    const GRASSHOPPER_INLINE EVP_CIPHER *cipher_gost_grasshopper_ctracpkm() {
+        return cipher_gost_grasshopper(EVP_CIPH_CTR_MODE,
+                                       GRASSHOPPER_CIPHER_CTRACPKM);
+    }
 
-void cipher_gost_grasshopper_destroy(void)
-{
-    EVP_CIPHER_meth_free(gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_ECB]);
-    gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_ECB] = NULL;
-    EVP_CIPHER_meth_free(gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CBC]);
-    gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CBC] = NULL;
-    EVP_CIPHER_meth_free(gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_OFB]);
-    gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_OFB] = NULL;
-    EVP_CIPHER_meth_free(gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CFB]);
-    gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CFB] = NULL;
-    EVP_CIPHER_meth_free(gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CTR]);
-    gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CTR] = NULL;
-    EVP_CIPHER_meth_free(gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CTRACPKM]);
-    gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CTRACPKM] = NULL;
-}
+    void cipher_gost_grasshopper_destroy(void) {
+        EVP_CIPHER_meth_free(gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_ECB]);
+        gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_ECB] = NULL;
+        EVP_CIPHER_meth_free(gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CBC]);
+        gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CBC] = NULL;
+        EVP_CIPHER_meth_free(gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_OFB]);
+        gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_OFB] = NULL;
+        EVP_CIPHER_meth_free(gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CFB]);
+        gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CFB] = NULL;
+        EVP_CIPHER_meth_free(gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CTR]);
+        gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CTR] = NULL;
+        EVP_CIPHER_meth_free(gost_grasshopper_ciphers
+                             [GRASSHOPPER_CIPHER_CTRACPKM]);
+        gost_grasshopper_ciphers[GRASSHOPPER_CIPHER_CTRACPKM] = NULL;
+    }
 
 #if defined(__cplusplus)
 }