X-Git-Url: http://www.wagner.pp.ru/gitweb/?p=openssl-gost%2Fengine.git;a=blobdiff_plain;f=gost_crypt.c;h=516e598d4dc1f32cf2168dff7b7f031044d21bbe;hp=66885bfafd8cb6771962607b090dbac2f0f2de6f;hb=HEAD;hpb=d3756bbed444cfe1072e9469c469bfba8b6c6dbe diff --git a/gost_crypt.c b/gost_crypt.c index 66885bf..516e598 100644 --- a/gost_crypt.c +++ b/gost_crypt.c @@ -43,6 +43,7 @@ static int gost_cipher_do_cnt(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl); /* Cleanup function */ static int gost_cipher_cleanup(EVP_CIPHER_CTX *); +static int gost_magma_mgm_cleanup(EVP_CIPHER_CTX *c); /* set/get cipher parameters */ static int gost89_set_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params); static int gost89_get_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params); @@ -53,7 +54,11 @@ 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); +static int gost_magma_cipher_init_mgm(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_ecb(EVP_CIPHER_CTX *ctx, unsigned char *out, + const unsigned char *in, size_t inl); 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, @@ -61,20 +66,22 @@ static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out, static int magma_cipher_do_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl); - +static int gost_magma_cipher_do_mgm(EVP_CIPHER_CTX *ctx, unsigned char *out, + const unsigned char *in, size_t len); /* 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 int gost_magma_mgm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr); /* * Single level template accessor. * Note: that you cannot template 0 value. */ #define TPL(st,field) ( \ - ((st)->field) ?: TPL_VAL(st,field) \ + ((st)->field) ? ((st)->field) : TPL_VAL(st,field) \ ) #define TPL_VAL(st,field) ( \ @@ -90,15 +97,15 @@ EVP_CIPHER *GOST_init_cipher(GOST_cipher *c) int flags = c->flags | TPL_VAL(c, flags); int block_size = TPL(c, block_size); switch (flags & EVP_CIPH_MODE) { - case EVP_CIPH_CTR_MODE: - case EVP_CIPH_CFB_MODE: - case EVP_CIPH_OFB_MODE: - OPENSSL_assert(block_size == 1); - OPENSSL_assert(flags & EVP_CIPH_NO_PADDING); - break; - default: + case EVP_CIPH_CBC_MODE: + case EVP_CIPH_ECB_MODE: + case EVP_CIPH_WRAP_MODE: OPENSSL_assert(block_size != 1); OPENSSL_assert(!(flags & EVP_CIPH_NO_PADDING)); + break; + default: + OPENSSL_assert(block_size == 1); + OPENSSL_assert(flags & EVP_CIPH_NO_PADDING); } if (TPL(c, iv_len)) @@ -187,8 +194,7 @@ GOST_cipher Gost28147_89_cnt_12_cipher = { static GOST_cipher magma_template_cipher = { .block_size = 8, .key_len = 32, - .iv_len = 8, - .flags = EVP_CIPH_CUSTOM_IV | + .flags = EVP_CIPH_RAND_KEY | EVP_CIPH_ALWAYS_CALL_INIT, .cleanup = gost_cipher_cleanup, @@ -205,6 +211,7 @@ GOST_cipher magma_ctr_cipher = { .block_size = 1, .iv_len = 4, .flags = EVP_CIPH_CTR_MODE | + EVP_CIPH_CUSTOM_IV | EVP_CIPH_NO_PADDING, .init = magma_cipher_init, }; @@ -215,6 +222,7 @@ GOST_cipher magma_ctr_acpkm_cipher = { .block_size = 1, .iv_len = 4, .flags = EVP_CIPH_CTR_MODE | + EVP_CIPH_CUSTOM_IV | EVP_CIPH_NO_PADDING, .init = magma_cipher_init, }; @@ -225,6 +233,7 @@ GOST_cipher magma_ctr_acpkm_omac_cipher = { .block_size = 1, .iv_len = 4, .flags = EVP_CIPH_CTR_MODE | + EVP_CIPH_CUSTOM_IV | EVP_CIPH_NO_PADDING | EVP_CIPH_CUSTOM_COPY | EVP_CIPH_FLAG_CUSTOM_CIPHER | @@ -234,10 +243,46 @@ GOST_cipher magma_ctr_acpkm_omac_cipher = { .ctrl = magma_cipher_ctl_acpkm_omac, }; +GOST_cipher magma_ecb_cipher = { + .nid = NID_magma_ecb, + .template = &magma_template_cipher, + .flags = EVP_CIPH_ECB_MODE, + .init = magma_cipher_init, + .do_cipher = magma_cipher_do_ecb, +}; + + GOST_cipher magma_mgm_cipher = { + .nid = NID_undef, + .template = &magma_template_cipher, + .block_size = 1, + .iv_len = 8, + .flags = EVP_CIPH_NO_PADDING | + EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_CUSTOM_CIPHER | + EVP_CIPH_CTRL_INIT | EVP_CIPH_FLAG_AEAD_CIPHER, + .init = gost_magma_cipher_init_mgm, + .do_cipher = gost_magma_cipher_do_mgm, + .ctrl = gost_magma_mgm_ctrl, + .cleanup = gost_magma_mgm_cleanup, + .ctx_size = sizeof(gost_mgm_ctx) + }; + +static void magma_NID_callback (int nid) +{ + magma_mgm_cipher.nid = nid; +} + +GOST_NID_JOB magma_mgm_NID = { + .sn = SN_magma_mgm, + .ln = SN_magma_mgm, + .callback = magma_NID_callback, +}; + GOST_cipher magma_cbc_cipher = { .nid = NID_magma_cbc, .template = &gost_template_cipher, - .flags = EVP_CIPH_CBC_MODE, + .iv_len = 8, + .flags = EVP_CIPH_CBC_MODE | + EVP_CIPH_CUSTOM_IV, .init = magma_cipher_init, .do_cipher = magma_cipher_do_cbc, }; @@ -270,16 +315,6 @@ GOST_digest Gost28147_89_MAC_digest = { .ctrl = gost_imit_ctrl, }; -EVP_MD *imit_gost_cpa(void) -{ - return GOST_init_digest(&Gost28147_89_MAC_digest); -} - -void imit_gost_cpa_destroy(void) -{ - GOST_deinit_digest(&Gost28147_89_MAC_digest); -} - GOST_digest Gost28147_89_mac_12_digest = { .nid = NID_gost_mac_12, .result_size = 4, @@ -294,23 +329,13 @@ GOST_digest Gost28147_89_mac_12_digest = { .ctrl = gost_imit_ctrl, }; -EVP_MD *imit_gost_cp_12(void) -{ - return GOST_init_digest(&Gost28147_89_mac_12_digest); -} - -void imit_gost_cp_12_destroy(void) -{ - GOST_deinit_digest(&Gost28147_89_mac_12_digest); -} - /* * Correspondence between gost parameter OIDs and substitution blocks * NID field is filed by register_gost_NID function in engine.c * upon engine initialization */ -struct gost_cipher_info gost_cipher_list[] = { +static struct gost_cipher_info gost_cipher_list[] = { /*- NID *//* * Subst block *//* @@ -444,7 +469,7 @@ static int gost_cipher_init_cp_12(EVP_CIPHER_CTX *ctx, } /* Initializes EVP_CIPHER_CTX with default values */ -int gost_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key, +static int gost_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc) { return gost_cipher_init_param(ctx, key, iv, enc, NID_undef, @@ -452,7 +477,7 @@ int gost_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key, } /* Initializes EVP_CIPHER_CTX with default values */ -int gost_cipher_init_cbc(EVP_CIPHER_CTX *ctx, const unsigned char *key, +static int gost_cipher_init_cbc(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc) { return gost_cipher_init_param(ctx, key, iv, enc, NID_undef, @@ -460,7 +485,7 @@ int gost_cipher_init_cbc(EVP_CIPHER_CTX *ctx, const unsigned char *key, } /* Initializes EVP_CIPHER_CTX with default values */ -int magma_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key, +static int magma_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc) { struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx); @@ -476,8 +501,10 @@ int magma_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key, } } - if (key) + if (key) { magma_key(&(c->cctx), key); + magma_master_key(&(c->cctx), key); + } if (iv) { memcpy((unsigned char *)EVP_CIPHER_CTX_original_iv(ctx), iv, EVP_CIPHER_CTX_iv_length(ctx)); @@ -496,7 +523,7 @@ int magma_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key, } /* Initializes EVP_CIPHER_CTX with default values */ -int magma_cipher_init_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, const unsigned char *key, +static int magma_cipher_init_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc) { if (key) { @@ -522,6 +549,110 @@ int magma_cipher_init_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, const unsigned char *k return magma_cipher_init(ctx, key, iv, enc); } +void gost_magma_encrypt_wrap(unsigned char *in, unsigned char *out, + struct ossl_gost_cipher_ctx *c) { + int i; + unsigned char b[8]; + unsigned char d[8]; + for (i = 0; i < 8; i++) { + b[7 - i] = in[i]; + } + gostcrypt(&(c->cctx), b, d); + for (i = 0; i < 8; i++) { + out[7 - i] = d[i]; + } +} + +/* ----------------------------------------------------------------------------------------------- */ +/*! Функция реализует операцию умножения двух элементов конечного поля \f$ \mathbb F_{2^{64}}\f$, + порожденного неприводимым многочленом + \f$ f(x) = x^{64} + x^4 + x^3 + x + 1 \in \mathbb F_2[x]\f$. Для умножения используется + простейшая реализация, основанная на приведении по модулю после каждого шага алгоритма. */ +/* ----------------------------------------------------------------------------------------------- */ +static void gf64_mul (uint64_t *result, uint64_t *arg1, uint64_t *arg2) +{ + int i = 0; + register uint64_t t, X0; + uint64_t Z0 = 0; + +#ifdef L_ENDIAN + X0 = BSWAP64(*arg1); +#else + X0 = *arg1; +#endif + +#ifdef L_ENDIAN + t = BSWAP64(*(arg2)); +#else + t = *(arg2); +#endif + + for (i = 0; i < 63; i++) { + if (t & 0x1) { + Z0 ^= X0; + } + t >>= 1; + if (X0 & 0x8000000000000000) { + X0 <<= 1; + X0 ^= 0x1b; + } + else { + X0 <<= 1; + } + } + + if (t & 0x1) { + Z0 ^= X0; + } + +#ifdef L_ENDIAN + *(result) = BSWAP64(Z0); +#else + *(result) = Z0; +#endif +} + +static int gost_magma_cipher_init_mgm(EVP_CIPHER_CTX *ctx, const unsigned char *key, + const unsigned char *iv, int enc) +{ + gost_mgm_ctx *mctx = + (gost_mgm_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); + int bl; + + if (!iv && !key) + return 1; + if (key) { + bl = EVP_CIPHER_CTX_iv_length(ctx); + if (!gost_cipher_set_param(&mctx->ks.g_ks, NID_id_tc26_gost_28147_param_Z)) + return 0; + magma_key(&(mctx->ks.g_ks.cctx), key); + gost_mgm128_init(&mctx->mgm, &mctx->ks, + (block128_f) gost_magma_encrypt_wrap, gf64_mul, bl); + + /* + * If we have an iv can set it directly, otherwise use saved IV. + */ + if (iv == NULL && mctx->iv_set) + iv = mctx->iv; + if (iv) { + if (gost_mgm128_setiv(&mctx->mgm, iv, mctx->ivlen) != 1) + return 0; + mctx->iv_set = 1; + } + mctx->key_set = 1; + } else { + /* If key set use IV, otherwise copy */ + if (mctx->key_set) { + if (gost_mgm128_setiv(&mctx->mgm, iv, mctx->ivlen) != 1) + return 0; + } + else + memcpy(mctx->iv, iv, mctx->ivlen); + mctx->iv_set = 1; + } + return 1; +} + /* * Wrapper around gostcrypt function from gost89.c which perform key meshing * when nesseccary @@ -572,7 +703,7 @@ static void gost_cnt_next(void *ctx, unsigned char *iv, unsigned char *buf) } /* GOST encryption in CBC mode */ -int gost_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out, +static int gost_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) { unsigned char b[8]; @@ -595,11 +726,13 @@ int gost_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out, } } else { while (inl > 0) { + unsigned char tmpiv[8]; gostdecrypt(&(c->cctx), in_ptr, b); + memcpy(tmpiv, in_ptr, 8); for (i = 0; i < 8; i++) { out_ptr[i] = iv[i] ^ b[i]; } - memcpy(iv, in_ptr, 8); + memcpy(iv, tmpiv, 8); out_ptr += 8; in_ptr += 8; inl -= 8; @@ -608,8 +741,31 @@ int gost_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out, return 1; } +/* MAGMA encryption in ECB mode */ +static int magma_cipher_do_ecb(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 (EVP_CIPHER_CTX_encrypting(ctx)) { + while (inl > 0) { + magmacrypt(&(c->cctx), in, out); + out += 8; + in += 8; + inl -= 8; + } + } else { + while (inl > 0) { + magmadecrypt(&(c->cctx), in, out); + out += 8; + in += 8; + inl -= 8; + } + } + return 1; +} + /* MAGMA encryption in CBC mode */ -int magma_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out, +static int magma_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) { unsigned char b[8]; @@ -623,13 +779,9 @@ int magma_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out, while (inl > 0) { for (i = 0; i < 8; i++) { - b[7 - i] = iv[i] ^ in_ptr[i]; - } - gostcrypt(&(c->cctx), b, d); - - for (i = 0; i < 8; i++) { - out_ptr[7 - i] = d[i]; + out_ptr[i] = iv[i] ^ in_ptr[i]; } + magmacrypt(&(c->cctx), out_ptr, out_ptr); memcpy(iv, out_ptr, 8); out_ptr += 8; in_ptr += 8; @@ -637,13 +789,10 @@ int magma_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out, } } else { while (inl > 0) { - for (i = 0; i < 8; i++) { - d[7 - i] = in_ptr[i]; - } - gostdecrypt(&(c->cctx), d, b); + magmadecrypt(&(c->cctx), in_ptr, b); memcpy(d, in_ptr, 8); for (i = 0; i < 8; i++) { - out_ptr[i] = iv[i] ^ b[7 - i]; + out_ptr[i] = iv[i] ^ b[i]; } memcpy(iv, d, 8); out_ptr += 8; @@ -660,67 +809,64 @@ static void ctr64_inc(unsigned char *counter) inc_counter(counter, 8); } +#define MAGMA_BLOCK_SIZE 8 +#define MAGMA_BLOCK_MASK (MAGMA_BLOCK_SIZE - 1) +static inline void apply_acpkm_magma(struct ossl_gost_cipher_ctx * + ctx, unsigned int *num) +{ + if (!ctx->key_meshing || (*num < (unsigned int)ctx->key_meshing)) + return; + acpkm_magma_key_meshing(&ctx->cctx); + *num &= MAGMA_BLOCK_MASK; +} + /* MAGMA encryption in CTR mode */ static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) { const unsigned char *in_ptr = in; unsigned char *out_ptr = out; - size_t i = 0; size_t j; struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx); unsigned char *buf = EVP_CIPHER_CTX_buf_noconst(ctx); unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx); - unsigned char b[8]; + unsigned int num = EVP_CIPHER_CTX_num(ctx); + size_t blocks, i, lasted = inl; /* Process partial blocks */ - if (EVP_CIPHER_CTX_num(ctx)) { - for (j = EVP_CIPHER_CTX_num(ctx), i = 0; j < 8 && i < inl; - j++, i++, in_ptr++, out_ptr++) { - *out_ptr = buf[7 - j] ^ (*in_ptr); - } - if (j == 8) { - EVP_CIPHER_CTX_set_num(ctx, 0); - } else { - EVP_CIPHER_CTX_set_num(ctx, j); - return inl; - } + while ((num & MAGMA_BLOCK_MASK) && lasted) { + *out_ptr++ = *in_ptr++ ^ buf[num & MAGMA_BLOCK_MASK]; + --lasted; + num++; } + blocks = lasted / MAGMA_BLOCK_SIZE; /* Process full blocks */ - for (; i + 8 <= inl; i += 8, in_ptr += 8, out_ptr += 8) { + for (i = 0; i < blocks; i++) { + apply_acpkm_magma(c, &num); + magmacrypt(&(c->cctx), iv, buf); for (j = 0; j < 8; j++) { - b[7 - j] = iv[j]; - } - gostcrypt(&(c->cctx), b, buf); - for (j = 0; j < 8; j++) { - out_ptr[j] = buf[7 - j] ^ in_ptr[j]; + out_ptr[j] = buf[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)); + c->count += MAGMA_BLOCK_SIZE; + in_ptr += MAGMA_BLOCK_SIZE; + out_ptr += MAGMA_BLOCK_SIZE; + num += MAGMA_BLOCK_SIZE; + lasted -= MAGMA_BLOCK_SIZE; } /* Process the rest of plaintext */ - if (i < inl) { - for (j = 0; j < 8; j++) { - b[7 - j] = iv[j]; - } - gostcrypt(&(c->cctx), b, buf); - - for (j = 0; i < inl; j++, i++) { - out_ptr[j] = buf[7 - j] ^ in_ptr[j]; - } + if (lasted > 0) { + apply_acpkm_magma(c, &num); + magmacrypt(&(c->cctx), iv, buf); + for (i = 0; i < lasted; i++) + out_ptr[i] = buf[i] ^ in_ptr[i]; 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); + num += lasted; } + EVP_CIPHER_CTX_set_num(ctx, num); return inl; } @@ -750,8 +896,60 @@ static int magma_cipher_do_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, unsigned char *ou return inl; } + +static int gost_magma_cipher_do_mgm(EVP_CIPHER_CTX *ctx, unsigned char *out, + const unsigned char *in, size_t len) +{ + gost_mgm_ctx *mctx = + (gost_mgm_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); + int enc = EVP_CIPHER_CTX_encrypting(ctx); + + /* If not set up, return error */ + if (!mctx->key_set) { + GOSTerr(GOST_F_GOST_MAGMA_CIPHER_DO_MGM, + GOST_R_BAD_ORDER); + return -1; + } + + if (!mctx->iv_set) { + GOSTerr(GOST_F_GOST_MAGMA_CIPHER_DO_MGM, + GOST_R_BAD_ORDER); + return -1; + } + if (in) { + if (out == NULL) { + if (gost_mgm128_aad(&mctx->mgm, in, len)) + return -1; + } else if (enc) { + if (gost_mgm128_encrypt(&mctx->mgm, in, out, len)) + return -1; + } else { + if (gost_mgm128_decrypt(&mctx->mgm, in, out, len)) + return -1; + } + return len; + } else { + if (!enc) { + if (mctx->taglen < 0) + return -1; + if (gost_mgm128_finish(&mctx->mgm, + EVP_CIPHER_CTX_buf_noconst(ctx), + mctx->taglen) != 0) + return -1; + mctx->iv_set = 0; + return 0; + } + gost_mgm128_tag(&mctx->mgm, EVP_CIPHER_CTX_buf_noconst(ctx), 8); + mctx->taglen = 8; + /* Don't reuse the IV */ + mctx->iv_set = 0; + return 0; + } + +} + /* GOST encryption in CFB mode */ -int gost_cipher_do_cfb(EVP_CIPHER_CTX *ctx, unsigned char *out, +static int gost_cipher_do_cfb(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) { const unsigned char *in_ptr = in; @@ -779,7 +977,7 @@ int gost_cipher_do_cfb(EVP_CIPHER_CTX *ctx, unsigned char *out, } } - for (; i + 8 < inl; i += 8, in_ptr += 8, out_ptr += 8) { + for (; (inl - i) >= 8; i += 8, in_ptr += 8, out_ptr += 8) { /* * block cipher current iv */ @@ -840,7 +1038,7 @@ static int gost_cipher_do_cnt(EVP_CIPHER_CTX *ctx, unsigned char *out, } } - for (; i + 8 < inl; i += 8, in_ptr += 8, out_ptr += 8) { + for (; (inl - i) >= 8; i += 8, in_ptr += 8, out_ptr += 8) { /* * block cipher current iv */ @@ -870,7 +1068,7 @@ 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) +static int gost_cipher_cleanup(EVP_CIPHER_CTX *ctx) { struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx); EVP_MD_CTX_free(c->omac_ctx); @@ -879,8 +1077,80 @@ int gost_cipher_cleanup(EVP_CIPHER_CTX *ctx) return 1; } +static int gost_magma_mgm_cleanup(EVP_CIPHER_CTX *c) +{ + gost_mgm_ctx *mctx = + (gost_mgm_ctx *)EVP_CIPHER_CTX_get_cipher_data(c); + if (mctx == NULL) + return 0; + gost_destroy(&mctx->ks.g_ks.cctx); + OPENSSL_cleanse(&mctx->mgm, sizeof(mctx->mgm)); + EVP_CIPHER_CTX_set_app_data(c, NULL); + return 1; +} + +static int gost_magma_mgm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr) +{ + gost_mgm_ctx *mctx = + (gost_mgm_ctx *)EVP_CIPHER_CTX_get_cipher_data(c); + unsigned char *buf, *iv; + int ivlen, enc; + + switch (type) { + case EVP_CTRL_INIT: + ivlen = EVP_CIPHER_iv_length(EVP_CIPHER_CTX_cipher(c)); + iv = EVP_CIPHER_CTX_iv_noconst(c); + mctx->key_set = 0; + mctx->iv_set = 0; + mctx->ivlen = ivlen; + mctx->iv = iv; + mctx->taglen = -1; + return 1; + + case EVP_CTRL_GET_IVLEN: + *(int *)ptr = mctx->ivlen; + return 1; + + case EVP_CTRL_AEAD_SET_IVLEN: + if (arg <= 0) + return 0; + if ((arg > EVP_MAX_IV_LENGTH) && (arg > mctx->ivlen)) { + // TODO: Allocate memory for IV or set error + return 0; + } + mctx->ivlen = arg; + return 1; + + case EVP_CTRL_AEAD_SET_TAG: + buf = EVP_CIPHER_CTX_buf_noconst(c); + enc = EVP_CIPHER_CTX_encrypting(c); + if (arg <= 0 || arg != 8 || enc) { + GOSTerr(GOST_F_GOST_MAGMA_MGM_CTRL, + GOST_R_INVALID_TAG_LENGTH); + return 0; + } + memcpy(buf, ptr, arg); + mctx->taglen = arg; + return 1; + + case EVP_CTRL_AEAD_GET_TAG: + buf = EVP_CIPHER_CTX_buf_noconst(c); + enc = EVP_CIPHER_CTX_encrypting(c); + if (arg <= 0 || arg > 8 || !enc || mctx->taglen < 0) { + GOSTerr(GOST_F_GOST_MAGMA_MGM_CTRL, + GOST_R_INVALID_TAG_LENGTH); + return 0; + } + memcpy(ptr, buf, arg); + return 1; + + default: + return -1; + } +} + /* Control function for gost cipher */ -int gost_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) +static int gost_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) { switch (type) { case EVP_CTRL_RAND_KEY: @@ -962,14 +1232,35 @@ int gost_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) return 1; } +/* Decrement 8-byte sequence if needed */ +int decrement_sequence(unsigned char *seq, int decrement) { + if (decrement < 0 || decrement > 1) + return 0; + + int j; + if (decrement) { + for (j = 7; j >= 0; j--) + { + if (seq[j] != 0) + { + seq[j]--; + break; + } + else + seq[j] = 0xFF; + } + } + return 1; +} + /* Control function for gost cipher */ -int magma_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) +static 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); + GOSTerr(GOST_F_MAGMA_CIPHER_CTL, GOST_R_RNG_ERROR); return -1; } break; @@ -989,6 +1280,54 @@ int magma_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) c->key_meshing = arg; return 1; } + case EVP_CTRL_TLSTREE: + { + unsigned char newkey[32]; + int mode = EVP_CIPHER_CTX_mode(ctx); + struct ossl_gost_cipher_ctx *ctr_ctx = NULL; + gost_ctx *c = NULL; + + unsigned char adjusted_iv[8]; + unsigned char seq[8]; + int j, carry, decrement_arg; + if (mode != EVP_CIPH_CTR_MODE) + return -1; + + ctr_ctx = (struct ossl_gost_cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); + c = &(ctr_ctx->cctx); + + /* + * 'arg' parameter indicates what we should do with sequence value. + * + * When function called, seq is incremented after MAC calculation. + * In ETM mode, we use seq 'as is' in the ctrl-function (arg = 0) + * Otherwise we have to decrease it in the implementation (arg = 1). + */ + memcpy(seq, ptr, 8); + decrement_arg = arg; + if(!decrement_sequence(seq, decrement_arg)) { + GOSTerr(GOST_F_MAGMA_CIPHER_CTL, GOST_R_CTRL_CALL_FAILED); + return -1; + } + + if (gost_tlstree(NID_magma_cbc, (const unsigned char *)c->master_key, newkey, + (const unsigned char *)seq) > 0) { + memset(adjusted_iv, 0, 8); + memcpy(adjusted_iv, EVP_CIPHER_CTX_original_iv(ctx), 4); + for (j = 3, carry = 0; j >= 0; j--) + { + int adj_byte = adjusted_iv[j] + seq[j+4] + carry; + carry = (adj_byte > 255) ? 1 : 0; + adjusted_iv[j] = adj_byte & 0xFF; + } + EVP_CIPHER_CTX_set_num(ctx, 0); + memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), adjusted_iv, 8); + + magma_key(c, newkey); + return 1; + } + } + return -1; default: GOSTerr(GOST_F_MAGMA_CIPHER_CTL, GOST_R_UNSUPPORTED_CIPHER_CTL_COMMAND); return -1; @@ -1027,7 +1366,7 @@ static int magma_cipher_ctl_acpkm_omac(EVP_CIPHER_CTX *ctx, int type, int arg, v } /* Set cipher parameters from ASN1 structure */ -int gost89_set_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params) +static int gost89_set_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params) { int len = 0; unsigned char *buf = NULL; @@ -1072,7 +1411,7 @@ 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) +static int gost89_get_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params) { int len; GOST_CIPHER_PARAMS *gcp = NULL; @@ -1184,7 +1523,7 @@ static void mac_block_mesh(struct ossl_gost_imit_ctx *c, c->count = c->count % 1024 + 8; } -int gost_imit_update(EVP_MD_CTX *ctx, const void *data, size_t count) +static 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; @@ -1217,7 +1556,7 @@ int gost_imit_update(EVP_MD_CTX *ctx, const void *data, size_t count) return 1; } -int gost_imit_final(EVP_MD_CTX *ctx, unsigned char *md) +static int gost_imit_final(EVP_MD_CTX *ctx, unsigned char *md) { struct ossl_gost_imit_ctx *c = EVP_MD_CTX_md_data(ctx); if (!c->key_set) { @@ -1240,7 +1579,7 @@ int gost_imit_final(EVP_MD_CTX *ctx, unsigned char *md) return 1; } -int gost_imit_ctrl(EVP_MD_CTX *ctx, int type, int arg, void *ptr) +static int gost_imit_ctrl(EVP_MD_CTX *ctx, int type, int arg, void *ptr) { switch (type) { case EVP_MD_CTRL_KEY_LEN: @@ -1296,7 +1635,7 @@ int gost_imit_ctrl(EVP_MD_CTX *ctx, int type, int arg, void *ptr) } } -int gost_imit_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from) +static int gost_imit_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from) { if (EVP_MD_CTX_md_data(to) && EVP_MD_CTX_md_data(from)) { memcpy(EVP_MD_CTX_md_data(to), EVP_MD_CTX_md_data(from), @@ -1306,7 +1645,7 @@ int gost_imit_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from) } /* Clean up imit ctx */ -int gost_imit_cleanup(EVP_MD_CTX *ctx) +static int gost_imit_cleanup(EVP_MD_CTX *ctx) { memset(EVP_MD_CTX_md_data(ctx), 0, sizeof(struct ossl_gost_imit_ctx)); return 1;