X-Git-Url: http://wagner.pp.ru/gitweb/?a=blobdiff_plain;f=gost_crypt.c;h=2bede853fd617919f4d83bb239b0f9ffe1ae8692;hb=69040682b1d04049668bb63712458f28a5c448d4;hp=16fb6610682a31cab052c615e7c433753aa1629c;hpb=a418dfa28b4c3432a6da7d01adc1038789ce209c;p=openssl-gost%2Fengine.git diff --git a/gost_crypt.c b/gost_crypt.c index 16fb661..2bede85 100644 --- a/gost_crypt.c +++ b/gost_crypt.c @@ -12,6 +12,7 @@ #include #include "e_gost_err.h" #include "gost_lcl.h" +#include "gost_gost2015.h" #if !defined(CCGOST_DEBUG) && !defined(DEBUG) # ifndef NDEBUG @@ -48,12 +49,24 @@ static int gost_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr); static int magma_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc); +static int magma_cipher_init_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, const unsigned char *key, + const unsigned char *iv, int enc); /* Handles block of data in CBC mode */ static int magma_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl); static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl); +static int magma_cipher_do_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, unsigned char *out, + const unsigned char *in, size_t inl); + +/* set/get cipher parameters */ +static int magma_set_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params); +static int magma_get_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params); +/* Control function */ +static int magma_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr); +static int magma_cipher_ctl_acpkm_omac(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr); + static EVP_CIPHER *_hidden_Gost28147_89_cipher = NULL; const EVP_CIPHER *cipher_gost(void) { @@ -201,7 +214,7 @@ const EVP_CIPHER *cipher_magma_ctr(void) && ((_hidden_magma_ctr = EVP_CIPHER_meth_new(NID_magma_ctr, 1 /* block_size */ , 32 /* key_size */ )) == NULL - || !EVP_CIPHER_meth_set_iv_length(_hidden_magma_ctr, 8) + || !EVP_CIPHER_meth_set_iv_length(_hidden_magma_ctr, 4) || !EVP_CIPHER_meth_set_flags(_hidden_magma_ctr, EVP_CIPH_CTR_MODE | EVP_CIPH_NO_PADDING | @@ -217,16 +230,86 @@ const EVP_CIPHER *cipher_magma_ctr(void) sizeof(struct ossl_gost_cipher_ctx)) || !EVP_CIPHER_meth_set_set_asn1_params(_hidden_magma_ctr, - gost89_set_asn1_parameters) + magma_set_asn1_parameters) || !EVP_CIPHER_meth_set_get_asn1_params(_hidden_magma_ctr, - gost89_get_asn1_parameters) - || !EVP_CIPHER_meth_set_ctrl(_hidden_magma_ctr, gost_cipher_ctl))) { + magma_get_asn1_parameters) + || !EVP_CIPHER_meth_set_ctrl(_hidden_magma_ctr, magma_cipher_ctl))) { EVP_CIPHER_meth_free(_hidden_magma_ctr); _hidden_magma_ctr = NULL; } return _hidden_magma_ctr; } +static EVP_CIPHER *_hidden_magma_ctr_acpkm = NULL; +const EVP_CIPHER *cipher_magma_ctr_acpkm(void) +{ + if (_hidden_magma_ctr_acpkm == NULL + && ((_hidden_magma_ctr_acpkm = + EVP_CIPHER_meth_new(NID_magma_ctr_acpkm, 1 /* block_size */ , + 32 /* key_size */ )) == NULL + || !EVP_CIPHER_meth_set_iv_length(_hidden_magma_ctr_acpkm, 4) + || !EVP_CIPHER_meth_set_flags(_hidden_magma_ctr_acpkm, + EVP_CIPH_CTR_MODE | + EVP_CIPH_NO_PADDING | + EVP_CIPH_CUSTOM_IV | + EVP_CIPH_RAND_KEY | + EVP_CIPH_ALWAYS_CALL_INIT) + || !EVP_CIPHER_meth_set_init(_hidden_magma_ctr_acpkm, magma_cipher_init) + || !EVP_CIPHER_meth_set_do_cipher(_hidden_magma_ctr_acpkm, + magma_cipher_do_ctr) + || !EVP_CIPHER_meth_set_cleanup(_hidden_magma_ctr_acpkm, + gost_cipher_cleanup) + || !EVP_CIPHER_meth_set_impl_ctx_size(_hidden_magma_ctr_acpkm, + sizeof(struct + ossl_gost_cipher_ctx)) + || !EVP_CIPHER_meth_set_set_asn1_params(_hidden_magma_ctr_acpkm, + magma_set_asn1_parameters) + || !EVP_CIPHER_meth_set_get_asn1_params(_hidden_magma_ctr_acpkm, + magma_get_asn1_parameters) + + || !EVP_CIPHER_meth_set_ctrl(_hidden_magma_ctr_acpkm, magma_cipher_ctl))) { + EVP_CIPHER_meth_free(_hidden_magma_ctr_acpkm); + _hidden_magma_ctr_acpkm = NULL; + } + return _hidden_magma_ctr_acpkm; +} + +static EVP_CIPHER *_hidden_magma_ctr_acpkm_omac = NULL; +const EVP_CIPHER *cipher_magma_ctr_acpkm_omac(void) +{ + if (_hidden_magma_ctr_acpkm_omac == NULL + && ((_hidden_magma_ctr_acpkm_omac = + EVP_CIPHER_meth_new(NID_magma_ctr_acpkm_omac, 1 /* block_size */ , + 32 /* key_size */ )) == NULL + || !EVP_CIPHER_meth_set_iv_length(_hidden_magma_ctr_acpkm_omac, 4) + || !EVP_CIPHER_meth_set_flags(_hidden_magma_ctr_acpkm_omac, + EVP_CIPH_CTR_MODE | + EVP_CIPH_NO_PADDING | + EVP_CIPH_CUSTOM_IV | + EVP_CIPH_RAND_KEY | + EVP_CIPH_ALWAYS_CALL_INIT | + EVP_CIPH_CUSTOM_COPY | + EVP_CIPH_FLAG_CUSTOM_CIPHER | + EVP_CIPH_FLAG_CIPHER_WITH_MAC) + || !EVP_CIPHER_meth_set_init(_hidden_magma_ctr_acpkm_omac, magma_cipher_init_ctr_acpkm_omac) + || !EVP_CIPHER_meth_set_do_cipher(_hidden_magma_ctr_acpkm_omac, + magma_cipher_do_ctr_acpkm_omac) + || !EVP_CIPHER_meth_set_cleanup(_hidden_magma_ctr_acpkm_omac, + gost_cipher_cleanup) + || !EVP_CIPHER_meth_set_impl_ctx_size(_hidden_magma_ctr_acpkm_omac, + sizeof(struct + ossl_gost_cipher_ctx)) + || !EVP_CIPHER_meth_set_set_asn1_params(_hidden_magma_ctr_acpkm_omac, + magma_set_asn1_parameters) + || !EVP_CIPHER_meth_set_get_asn1_params(_hidden_magma_ctr_acpkm_omac, + magma_get_asn1_parameters) + || !EVP_CIPHER_meth_set_ctrl(_hidden_magma_ctr_acpkm_omac, magma_cipher_ctl_acpkm_omac))) { + EVP_CIPHER_meth_free(_hidden_magma_ctr_acpkm_omac); + _hidden_magma_ctr_acpkm_omac = NULL; + } + return _hidden_magma_ctr_acpkm_omac; +} + static EVP_CIPHER *_hidden_magma_cbc = NULL; const EVP_CIPHER *cipher_magma_cbc(void) { @@ -248,11 +331,7 @@ const EVP_CIPHER *cipher_magma_cbc(void) || !EVP_CIPHER_meth_set_impl_ctx_size(_hidden_magma_cbc, sizeof(struct ossl_gost_cipher_ctx)) - || !EVP_CIPHER_meth_set_set_asn1_params(_hidden_magma_cbc, - gost89_set_asn1_parameters) - || !EVP_CIPHER_meth_set_get_asn1_params(_hidden_magma_cbc, - gost89_get_asn1_parameters) - || !EVP_CIPHER_meth_set_ctrl(_hidden_magma_cbc, gost_cipher_ctl))) { + || !EVP_CIPHER_meth_set_ctrl(_hidden_magma_cbc, magma_cipher_ctl))) { EVP_CIPHER_meth_free(_hidden_magma_cbc); _hidden_magma_cbc = NULL; } @@ -273,6 +352,10 @@ void cipher_gost_destroy(void) _hidden_magma_cbc = NULL; EVP_CIPHER_meth_free(_hidden_magma_ctr); _hidden_magma_ctr = NULL; + EVP_CIPHER_meth_free(_hidden_magma_ctr_acpkm); + _hidden_magma_ctr_acpkm = NULL; + EVP_CIPHER_meth_free(_hidden_magma_ctr_acpkm_omac); + _hidden_magma_ctr_acpkm_omac = NULL; } /* Implementation of GOST 28147-89 in MAC (imitovstavka) mode */ @@ -406,6 +489,8 @@ const struct gost_cipher_info *get_encryption_params(ASN1_OBJECT *obj) if (nid == NID_undef) { GOSTerr(GOST_F_GET_ENCRYPTION_PARAMS, GOST_R_INVALID_CIPHER_PARAM_OID); + ERR_add_error_data(3, "Unsupported CRYPT_PARAMS='", + params, "' specified in environment or in config"); return NULL; } } else { @@ -458,28 +543,6 @@ static int gost_cipher_init_param(EVP_CIPHER_CTX *ctx, return 1; } -static int magma_cipher_init_param(EVP_CIPHER_CTX *ctx, - const unsigned char *key, - const unsigned char *iv, int enc, - int paramNID, int mode) -{ - struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx); - if (EVP_CIPHER_CTX_get_app_data(ctx) == NULL) { - if (!gost_cipher_set_param(c, NID_id_tc26_gost_28147_param_Z)) - return 0; - EVP_CIPHER_CTX_set_app_data(ctx, EVP_CIPHER_CTX_get_cipher_data(ctx)); - } - if (key) - magma_key(&(c->cctx), key); - if (iv) { - memcpy((unsigned char *)EVP_CIPHER_CTX_original_iv(ctx), iv, - EVP_CIPHER_CTX_iv_length(ctx)); - } - memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), - EVP_CIPHER_CTX_original_iv(ctx), EVP_CIPHER_CTX_iv_length(ctx)); - return 1; -} - static int gost_cipher_init_cnt(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, @@ -533,8 +596,63 @@ int gost_cipher_init_cbc(EVP_CIPHER_CTX *ctx, const unsigned char *key, int magma_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc) { - return magma_cipher_init_param(ctx, key, iv, enc, NID_undef, - EVP_CIPH_CBC_MODE); + struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx); + /* FIXME this is just initializtion check */ + if (EVP_CIPHER_CTX_get_app_data(ctx) == NULL) { + if (!gost_cipher_set_param(c, NID_id_tc26_gost_28147_param_Z)) + return 0; + EVP_CIPHER_CTX_set_app_data(ctx, EVP_CIPHER_CTX_get_cipher_data(ctx)); + + if (enc) { + if (init_zero_kdf_seed(c->kdf_seed) == 0) + return -1; + } + } + + if (key) + magma_key(&(c->cctx), key); + if (iv) { + memcpy((unsigned char *)EVP_CIPHER_CTX_original_iv(ctx), iv, + EVP_CIPHER_CTX_iv_length(ctx)); + } + memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), + EVP_CIPHER_CTX_original_iv(ctx), EVP_CIPHER_CTX_iv_length(ctx)); + + if (EVP_CIPHER_CTX_nid(ctx) == NID_magma_ctr_acpkm + || EVP_CIPHER_CTX_nid(ctx) == NID_magma_ctr_acpkm_omac) { + c->key_meshing = 1024; + } else { + c->key_meshing = 0; + } + + return 1; +} + +/* Initializes EVP_CIPHER_CTX with default values */ +int magma_cipher_init_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, const unsigned char *key, + const unsigned char *iv, int enc) +{ + if (key) { + struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx); + unsigned char cipher_key[32]; + c->omac_ctx = EVP_MD_CTX_new(); + + if (c->omac_ctx == NULL) { + GOSTerr(GOST_F_MAGMA_CIPHER_INIT_CTR_ACPKM_OMAC, ERR_R_MALLOC_FAILURE); + return 0; + } + + if (gost2015_acpkm_omac_init(NID_magma_mac, enc, key, + c->omac_ctx, cipher_key, c->kdf_seed) != 1) { + EVP_MD_CTX_free(c->omac_ctx); + c->omac_ctx = NULL; + return 0; + } + + return magma_cipher_init(ctx, cipher_key, iv, enc); + } + + return magma_cipher_init(ctx, key, iv, enc); } /* @@ -656,10 +774,11 @@ int magma_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out, d[7 - i] = in_ptr[i]; } gostdecrypt(&(c->cctx), d, b); + memcpy(d, in_ptr, 8); for (i = 0; i < 8; i++) { out_ptr[i] = iv[i] ^ b[7 - i]; } - memcpy(iv, in_ptr, 8); + memcpy(iv, d, 8); out_ptr += 8; in_ptr += 8; inl -= 8; @@ -696,7 +815,7 @@ static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out, EVP_CIPHER_CTX_set_num(ctx, 0); } else { EVP_CIPHER_CTX_set_num(ctx, j); - return 1; + return inl; } } @@ -710,6 +829,9 @@ static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out, out_ptr[j] = buf[7 - j] ^ in_ptr[j]; } ctr64_inc(iv); + c->count += 8; + if (c->key_meshing && (c->count % c->key_meshing == 0)) + acpkm_magma_key_meshing(&(c->cctx)); } /* Process the rest of plaintext */ @@ -717,20 +839,50 @@ static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out, for (j = 0; j < 8; j++) { b[7 - j] = iv[j]; } - gostcrypt(&(c->cctx), iv, buf); - ctr64_inc(iv); + gostcrypt(&(c->cctx), b, buf); + for (j = 0; i < inl; j++, i++) { out_ptr[j] = buf[7 - j] ^ in_ptr[j]; } + ctr64_inc(iv); + c->count += 8; + if (c->key_meshing && (c->count % c->key_meshing == 0)) + acpkm_magma_key_meshing(&(c->cctx)); + EVP_CIPHER_CTX_set_num(ctx, j); } else { EVP_CIPHER_CTX_set_num(ctx, 0); } - return 1; + return inl; } +/* MAGMA encryption in CTR mode */ +static int magma_cipher_do_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, unsigned char *out, + const unsigned char *in, size_t inl) +{ + struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx); + + if (in == NULL && inl == 0) /* Final call */ + return gost2015_final_call(ctx, c->omac_ctx, MAGMA_MAC_MAX_SIZE, c->tag, magma_cipher_do_ctr); + + if (in == NULL) + return -1; + + /* As in and out can be the same pointer, process unencrypted here */ + if (EVP_CIPHER_CTX_encrypting(ctx)) + EVP_DigestSignUpdate(c->omac_ctx, in, inl); + + if (magma_cipher_do_ctr(ctx, out, in, inl) != inl) + return -1; + + /* As in and out can be the same pointer, process decrypted here */ + if (!EVP_CIPHER_CTX_encrypting(ctx)) + EVP_DigestSignUpdate(c->omac_ctx, out, inl); + + return inl; +} /* GOST encryption in CFB mode */ int gost_cipher_do_cfb(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) @@ -853,8 +1005,9 @@ static int gost_cipher_do_cnt(EVP_CIPHER_CTX *ctx, unsigned char *out, /* Cleaning up of EVP_CIPHER_CTX */ int gost_cipher_cleanup(EVP_CIPHER_CTX *ctx) { - gost_destroy(&((struct ossl_gost_cipher_ctx *) - EVP_CIPHER_CTX_get_cipher_data(ctx))->cctx); + struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx); + EVP_MD_CTX_free(c->omac_ctx); + gost_destroy(&(c->cctx)); EVP_CIPHER_CTX_set_app_data(ctx, NULL); return 1; } @@ -863,20 +1016,9 @@ int gost_cipher_cleanup(EVP_CIPHER_CTX *ctx) int gost_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) { switch (type) { -#if 0 - case EVP_CTRL_INIT: - { - struct ossl_gost_cipher_ctx *c = - EVP_CIPHER_CTX_get_cipher_data(ctx); - if (c == NULL) { - return -1; - } - return gost_cipher_set_param(c, arg); - } -#endif case EVP_CTRL_RAND_KEY: { - if (RAND_bytes + if (RAND_priv_bytes ((unsigned char *)ptr, EVP_CIPHER_CTX_key_length(ctx)) <= 0) { GOSTerr(GOST_F_GOST_CIPHER_CTL, GOST_R_RNG_ERROR); return -1; @@ -953,6 +1095,70 @@ int gost_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) return 1; } +/* Control function for gost cipher */ +int magma_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) +{ + switch (type) { + case EVP_CTRL_RAND_KEY: + if (RAND_priv_bytes + ((unsigned char *)ptr, EVP_CIPHER_CTX_key_length(ctx)) <= 0) { + GOSTerr(GOST_F_GOST_CIPHER_CTL, GOST_R_RNG_ERROR); + return -1; + } + break; + case EVP_CTRL_KEY_MESH: + { + struct ossl_gost_cipher_ctx *c = + EVP_CIPHER_CTX_get_cipher_data(ctx); + + if (c == NULL) { + return -1; + } + + if (c->count != 0) { + return -1; + } + + c->key_meshing = arg; + return 1; + } + default: + GOSTerr(GOST_F_MAGMA_CIPHER_CTL, GOST_R_UNSUPPORTED_CIPHER_CTL_COMMAND); + return -1; + } + return 1; +} + +static int magma_cipher_ctl_acpkm_omac(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) +{ + switch (type) + { + case EVP_CTRL_PROCESS_UNPROTECTED: + { + struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx); + STACK_OF(X509_ATTRIBUTE) *x = ptr; + return gost2015_process_unprotected_attributes(x, arg, MAGMA_MAC_MAX_SIZE, c->tag); + } + case EVP_CTRL_COPY: { + EVP_CIPHER_CTX *out = ptr; + struct ossl_gost_cipher_ctx *in_cctx = EVP_CIPHER_CTX_get_cipher_data(ctx); + struct ossl_gost_cipher_ctx *out_cctx = EVP_CIPHER_CTX_get_cipher_data(out); + + if (in_cctx->omac_ctx == out_cctx->omac_ctx) { + out_cctx->omac_ctx = EVP_MD_CTX_new(); + if (out_cctx->omac_ctx == NULL) { + GOSTerr(GOST_F_MAGMA_CIPHER_CTL_ACPKM_OMAC, ERR_R_MALLOC_FAILURE); + return -1; + } + } + return EVP_MD_CTX_copy(out_cctx->omac_ctx, in_cctx->omac_ctx); + } + default: + return magma_cipher_ctl(ctx, type, arg, ptr); + break; + } +} + /* Set cipher parameters from ASN1 structure */ int gost89_set_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params) { @@ -1001,7 +1207,6 @@ int gost89_set_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params) /* Store parameters into ASN1 structure */ int gost89_get_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params) { - int ret = -1; int len; GOST_CIPHER_PARAMS *gcp = NULL; unsigned char *p; @@ -1009,7 +1214,7 @@ int gost89_get_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params) int nid; if (ASN1_TYPE_get(params) != V_ASN1_SEQUENCE) { - return ret; + return -1; } p = params->value.sequence->data; @@ -1045,6 +1250,34 @@ int gost89_get_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params) return 1; } +#define MAGMA_UKM_LEN 12 +static int magma_set_asn1_parameters (EVP_CIPHER_CTX *ctx, ASN1_TYPE *params) +{ + struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx); + c->key_meshing = 8192; + + return gost2015_set_asn1_params(params, EVP_CIPHER_CTX_original_iv(ctx), 4, + c->kdf_seed); +} + +static int magma_get_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params) +{ + struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx); + unsigned char iv[16]; + + c->key_meshing = 8192; + + if (gost2015_get_asn1_params(params, MAGMA_UKM_LEN, iv, 4, c->kdf_seed) < 0) + return -1; + + memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, sizeof(iv)); + memcpy((unsigned char *)EVP_CIPHER_CTX_original_iv(ctx), iv, sizeof(iv)); + /* Key meshing 8 kb*/ + c->key_meshing = 8192; + + return 1; +} + static int gost_imit_init(EVP_MD_CTX *ctx, gost_subst_block * block) { struct ossl_gost_imit_ctx *c = EVP_MD_CTX_md_data(ctx); @@ -1071,15 +1304,14 @@ static int gost_imit_init_cp_12(EVP_MD_CTX *ctx) static void mac_block_mesh(struct ossl_gost_imit_ctx *c, const unsigned char *data) { - unsigned char buffer[8]; /* - * We are using local buffer for iv because CryptoPro doesn't interpret + * We are using NULL for iv because CryptoPro doesn't interpret * internal state of MAC algorithm as iv during keymeshing (but does * initialize internal state from iv in key transport */ assert(c->count % 8 == 0 && c->count <= 1024); if (c->key_meshing && c->count == 1024) { - cryptopro_key_meshing(&(c->cctx), buffer); + cryptopro_key_meshing(&(c->cctx), NULL); } mac_block(&(c->cctx), c->buffer, data); c->count = c->count % 1024 + 8; @@ -1089,12 +1321,13 @@ int gost_imit_update(EVP_MD_CTX *ctx, const void *data, size_t count) { struct ossl_gost_imit_ctx *c = EVP_MD_CTX_md_data(ctx); const unsigned char *p = data; - size_t bytes = count, i; + size_t bytes = count; if (!(c->key_set)) { GOSTerr(GOST_F_GOST_IMIT_UPDATE, GOST_R_MAC_KEY_NOT_SET); return 0; } if (c->bytes_left) { + size_t i; for (i = c->bytes_left; i < 8 && bytes > 0; bytes--, i++, p++) { c->partial_block[i] = *p; }