gost_crypt.c

   1 /**********************************************************************
   2  *             gost_crypt.c - Initialize all ciphers                  *
   3  *                                                                    *
   4  *             Copyright (c) 2005-2006 Cryptocom LTD                  *
   5  *             Copyright (c) 2020 Chikunov Vitaly <vt@altlinux.org>   *
   6  *         This file is distributed under the same license as OpenSSL *
   7  *                                                                    *
   8  *       OpenSSL interface to GOST 28147-89 cipher functions          *
   9  *          Requires OpenSSL 0.9.9 for compilation                    *
  10  **********************************************************************/
  11 #include <string.h>
  12 #include "gost89.h"
  13 #include <openssl/err.h>
  14 #include <openssl/rand.h>
  15 #include "e_gost_err.h"
  16 #include "gost_lcl.h"
  17 #include "gost_gost2015.h"
  18
  19 #if !defined(CCGOST_DEBUG) && !defined(DEBUG)
  20 # ifndef NDEBUG
  21 #  define NDEBUG
  22 # endif
  23 #endif
  24 #include <assert.h>
  25
  26 static int gost_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
  27                             const unsigned char *iv, int enc);
  28 static int gost_cipher_init_cbc(EVP_CIPHER_CTX *ctx, const unsigned char *key,
  29                                 const unsigned char *iv, int enc);
  30 static int gost_cipher_init_cpa(EVP_CIPHER_CTX *ctx, const unsigned char *key,
  31                                 const unsigned char *iv, int enc);
  32 static int gost_cipher_init_cp_12(EVP_CIPHER_CTX *ctx,
  33                                   const unsigned char *key,
  34                                   const unsigned char *iv, int enc);
  35 /* Handles block of data in CFB mode */
  36 static int gost_cipher_do_cfb(EVP_CIPHER_CTX *ctx, unsigned char *out,
  37                               const unsigned char *in, size_t inl);
  38 /* Handles block of data in CBC mode */
  39 static int gost_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out,
  40                               const unsigned char *in, size_t inl);
  41 /* Handles block of data in CNT mode */
  42 static int gost_cipher_do_cnt(EVP_CIPHER_CTX *ctx, unsigned char *out,
  43                               const unsigned char *in, size_t inl);
  44 /* Cleanup function */
  45 static int gost_cipher_cleanup(EVP_CIPHER_CTX *);
  46 /* set/get cipher parameters */
  47 static int gost89_set_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params);
  48 static int gost89_get_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params);
  49 /* Control function */
  50 static int gost_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
  51
  52 static int magma_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
  53                              const unsigned char *iv, int enc);
  54 static int magma_cipher_init_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, const unsigned char *key,
  55                              const unsigned char *iv, int enc);
  56 /* Handles block of data in CBC mode */
  57 static int magma_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out,
  58                                const unsigned char *in, size_t inl);
  59 static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out,
  60                                const unsigned char *in, size_t inl);
  61
  62 static int magma_cipher_do_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, unsigned char *out,
  63                                const unsigned char *in, size_t inl);
  64
  65 /* set/get cipher parameters */
  66 static int magma_set_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params);
  67 static int magma_get_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params);
  68 /* Control function */
  69 static int magma_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
  70 static int magma_cipher_ctl_acpkm_omac(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
  71
  72 /*
  73  * Single level template accessor.
  74  * Note: that you cannot template 0 value.
  75  */
  76 #define TPL(st,field) ( \
  77     ((st)->field) ?: TPL_VAL(st,field) \
  78 )
  79
  80 #define TPL_VAL(st,field) ( \
  81     ((st)->template ? (st)->template->field : 0) \
  82 )
  83
  84 EVP_CIPHER *GOST_init_cipher(GOST_cipher *c)
  85 {
  86     if (c->cipher)
  87         return c->cipher;
  88
  89     /* Some sanity checking. */
  90     int flags = c->flags | TPL_VAL(c, flags);
  91     int block_size = TPL(c, block_size);
  92     switch (flags & EVP_CIPH_MODE) {
  93     case EVP_CIPH_CTR_MODE:
  94     case EVP_CIPH_CFB_MODE:
  95     case EVP_CIPH_OFB_MODE:
  96         OPENSSL_assert(block_size == 1);
  97         OPENSSL_assert(flags & EVP_CIPH_NO_PADDING);
  98         break;
  99     default:
 100         OPENSSL_assert(block_size != 1);
 101         OPENSSL_assert(!(flags & EVP_CIPH_NO_PADDING));
 102     }
 103
 104     if (TPL(c, iv_len))
 105         OPENSSL_assert(flags & EVP_CIPH_CUSTOM_IV);
 106     else
 107         OPENSSL_assert(!(flags & EVP_CIPH_CUSTOM_IV));
 108
 109     EVP_CIPHER *cipher;
 110     if (!(cipher = EVP_CIPHER_meth_new(c->nid, block_size, TPL(c, key_len)))
 111         || !EVP_CIPHER_meth_set_iv_length(cipher, TPL(c, iv_len))
 112         || !EVP_CIPHER_meth_set_flags(cipher, flags)
 113         || !EVP_CIPHER_meth_set_init(cipher, TPL(c, init))
 114         || !EVP_CIPHER_meth_set_do_cipher(cipher, TPL(c, do_cipher))
 115         || !EVP_CIPHER_meth_set_cleanup(cipher, TPL(c, cleanup))
 116         || !EVP_CIPHER_meth_set_impl_ctx_size(cipher, TPL(c, ctx_size))
 117         || !EVP_CIPHER_meth_set_set_asn1_params(cipher, TPL(c, set_asn1_parameters))
 118         || !EVP_CIPHER_meth_set_get_asn1_params(cipher, TPL(c, get_asn1_parameters))
 119         || !EVP_CIPHER_meth_set_ctrl(cipher, TPL(c, ctrl))) {
 120         EVP_CIPHER_meth_free(cipher);
 121         cipher = NULL;
 122     }
 123     c->cipher = cipher;
 124     return c->cipher;
 125 }
 126
 127 void GOST_deinit_cipher(GOST_cipher *c)
 128 {
 129     if (c->cipher) {
 130         EVP_CIPHER_meth_free(c->cipher);
 131         c->cipher = NULL;
 132     }
 133 }
 134
 135 static GOST_cipher gost_template_cipher = {
 136     .block_size = 8,
 137     .key_len = 32,
 138     .iv_len = 8,
 139     .flags = EVP_CIPH_CUSTOM_IV |
 140         EVP_CIPH_RAND_KEY |
 141         EVP_CIPH_ALWAYS_CALL_INIT,
 142     .cleanup = gost_cipher_cleanup,
 143     .ctx_size = sizeof(struct ossl_gost_cipher_ctx),
 144     .set_asn1_parameters = gost89_set_asn1_parameters,
 145     .get_asn1_parameters = gost89_get_asn1_parameters,
 146     .ctrl = gost_cipher_ctl,
 147 };
 148
 149 GOST_cipher Gost28147_89_cipher = {
 150     .nid = NID_id_Gost28147_89,
 151     .template = &gost_template_cipher,
 152     .block_size = 1,
 153     .flags = EVP_CIPH_CFB_MODE |
 154         EVP_CIPH_NO_PADDING,
 155     .init = gost_cipher_init,
 156     .do_cipher = gost_cipher_do_cfb,
 157 };
 158
 159 GOST_cipher Gost28147_89_cbc_cipher = {
 160     .nid = NID_gost89_cbc,
 161     .template = &gost_template_cipher,
 162     .flags = EVP_CIPH_CBC_MODE,
 163     .init = gost_cipher_init_cbc,
 164     .do_cipher = gost_cipher_do_cbc,
 165 };
 166
 167 GOST_cipher Gost28147_89_cnt_cipher = {
 168     .nid = NID_gost89_cnt,
 169     .template = &gost_template_cipher,
 170     .block_size = 1,
 171     .flags = EVP_CIPH_OFB_MODE |
 172         EVP_CIPH_NO_PADDING,
 173     .init = gost_cipher_init_cpa,
 174     .do_cipher = gost_cipher_do_cnt,
 175 };
 176
 177 GOST_cipher Gost28147_89_cnt_12_cipher = {
 178     .nid = NID_gost89_cnt_12,
 179     .template = &gost_template_cipher,
 180     .block_size = 1,
 181     .flags = EVP_CIPH_OFB_MODE |
 182         EVP_CIPH_NO_PADDING,
 183     .init = gost_cipher_init_cp_12,
 184     .do_cipher = gost_cipher_do_cnt,
 185 };
 186
 187 static GOST_cipher magma_template_cipher = {
 188     .block_size = 8,
 189     .key_len = 32,
 190     .iv_len = 8,
 191     .flags = EVP_CIPH_CUSTOM_IV |
 192         EVP_CIPH_RAND_KEY |
 193         EVP_CIPH_ALWAYS_CALL_INIT,
 194     .cleanup = gost_cipher_cleanup,
 195     .ctx_size = sizeof(struct ossl_gost_cipher_ctx),
 196     .set_asn1_parameters = magma_set_asn1_parameters,
 197     .get_asn1_parameters = magma_get_asn1_parameters,
 198     .do_cipher = magma_cipher_do_ctr,
 199     .ctrl = magma_cipher_ctl,
 200 };
 201
 202 GOST_cipher magma_ctr_cipher = {
 203     .nid = NID_magma_ctr,
 204     .template = &magma_template_cipher,
 205     .block_size = 1,
 206     .iv_len = 4,
 207     .flags = EVP_CIPH_CTR_MODE |
 208         EVP_CIPH_NO_PADDING,
 209     .init = magma_cipher_init,
 210 };
 211
 212 GOST_cipher magma_ctr_acpkm_cipher = {
 213     .nid = NID_magma_ctr_acpkm,
 214     .template = &magma_template_cipher,
 215     .block_size = 1,
 216     .iv_len = 4,
 217     .flags = EVP_CIPH_CTR_MODE |
 218         EVP_CIPH_NO_PADDING,
 219     .init = magma_cipher_init,
 220 };
 221
 222 GOST_cipher magma_ctr_acpkm_omac_cipher = {
 223     .nid = NID_magma_ctr_acpkm_omac,
 224     .template = &magma_template_cipher,
 225     .block_size = 1,
 226     .iv_len = 4,
 227     .flags = EVP_CIPH_CTR_MODE |
 228         EVP_CIPH_NO_PADDING |
 229         EVP_CIPH_CUSTOM_COPY |
 230         EVP_CIPH_FLAG_CUSTOM_CIPHER |
 231         EVP_CIPH_FLAG_CIPHER_WITH_MAC,
 232     .init = magma_cipher_init_ctr_acpkm_omac,
 233     .do_cipher = magma_cipher_do_ctr_acpkm_omac,
 234     .ctrl = magma_cipher_ctl_acpkm_omac,
 235 };
 236
 237 GOST_cipher magma_cbc_cipher = {
 238     .nid = NID_magma_cbc,
 239     .template = &gost_template_cipher,
 240     .flags = EVP_CIPH_CBC_MODE,
 241     .init = magma_cipher_init,
 242     .do_cipher = magma_cipher_do_cbc,
 243 };
 244
 245 /* Implementation of GOST 28147-89 in MAC (imitovstavka) mode */
 246 /* Init functions which set specific parameters */
 247 static int gost_imit_init_cpa(EVP_MD_CTX *ctx);
 248 static int gost_imit_init_cp_12(EVP_MD_CTX *ctx);
 249 /* process block of data */
 250 static int gost_imit_update(EVP_MD_CTX *ctx, const void *data, size_t count);
 251 /* Return computed value */
 252 static int gost_imit_final(EVP_MD_CTX *ctx, unsigned char *md);
 253 /* Copies context */
 254 static int gost_imit_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from);
 255 static int gost_imit_cleanup(EVP_MD_CTX *ctx);
 256 /* Control function, knows how to set MAC key.*/
 257 static int gost_imit_ctrl(EVP_MD_CTX *ctx, int type, int arg, void *ptr);
 258
 259 GOST_digest Gost28147_89_MAC_digest = {
 260     .nid = NID_id_Gost28147_89_MAC,
 261     .result_size = 4,
 262     .input_blocksize = 8,
 263     .app_datasize = sizeof(struct ossl_gost_imit_ctx),
 264     .flags = EVP_MD_FLAG_XOF,
 265     .init = gost_imit_init_cpa,
 266     .update = gost_imit_update,
 267     .final = gost_imit_final,
 268     .copy = gost_imit_copy,
 269     .cleanup = gost_imit_cleanup,
 270     .ctrl = gost_imit_ctrl,
 271 };
 272
 273 GOST_digest Gost28147_89_mac_12_digest = {
 274     .nid = NID_gost_mac_12,
 275     .result_size = 4,
 276     .input_blocksize = 8,
 277     .app_datasize = sizeof(struct ossl_gost_imit_ctx),
 278     .flags = EVP_MD_FLAG_XOF,
 279     .init = gost_imit_init_cp_12,
 280     .update = gost_imit_update,
 281     .final = gost_imit_final,
 282     .copy = gost_imit_copy,
 283     .cleanup = gost_imit_cleanup,
 284     .ctrl = gost_imit_ctrl,
 285 };
 286
 287 /*
 288  * Correspondence between gost parameter OIDs and substitution blocks
 289  * NID field is filed by register_gost_NID function in engine.c
 290  * upon engine initialization
 291  */
 292
 293 static struct gost_cipher_info gost_cipher_list[] = {
 294     /*- NID *//*
 295      * Subst block
 296      *//*
 297      * Key meshing
 298      */
 299     /*
 300      * {NID_id_GostR3411_94_CryptoProParamSet,&GostR3411_94_CryptoProParamSet,0},
 301      */
 302     {NID_id_Gost28147_89_CryptoPro_A_ParamSet, &Gost28147_CryptoProParamSetA,
 303      1},
 304     {NID_id_Gost28147_89_CryptoPro_B_ParamSet, &Gost28147_CryptoProParamSetB,
 305      1},
 306     {NID_id_Gost28147_89_CryptoPro_C_ParamSet, &Gost28147_CryptoProParamSetC,
 307      1},
 308     {NID_id_Gost28147_89_CryptoPro_D_ParamSet, &Gost28147_CryptoProParamSetD,
 309      1},
 310     {NID_id_tc26_gost_28147_param_Z, &Gost28147_TC26ParamSetZ, 1},
 311     {NID_id_Gost28147_89_TestParamSet, &Gost28147_TestParamSet, 1},
 312     {NID_undef, NULL, 0}
 313 };
 314
 315 /*
 316  * get encryption parameters from crypto network settings FIXME For now we
 317  * use environment var CRYPT_PARAMS as place to store these settings.
 318  * Actually, it is better to use engine control command, read from
 319  * configuration file to set them
 320  */
 321 const struct gost_cipher_info *get_encryption_params(ASN1_OBJECT *obj)
 322 {
 323     int nid;
 324     struct gost_cipher_info *param;
 325     if (!obj) {
 326         const char *params = get_gost_engine_param(GOST_PARAM_CRYPT_PARAMS);
 327         if (!params || !strlen(params)) {
 328             int i;
 329             for (i = 0; gost_cipher_list[i].nid != NID_undef; i++)
 330                 if (gost_cipher_list[i].nid == NID_id_tc26_gost_28147_param_Z)
 331                     return &gost_cipher_list[i];
 332             return &gost_cipher_list[0];
 333         }
 334
 335         nid = OBJ_txt2nid(params);
 336         if (nid == NID_undef) {
 337             GOSTerr(GOST_F_GET_ENCRYPTION_PARAMS,
 338                     GOST_R_INVALID_CIPHER_PARAM_OID);
 339             ERR_add_error_data(3, "Unsupported CRYPT_PARAMS='",
 340                 params, "' specified in environment or in config");
 341             return NULL;
 342         }
 343     } else {
 344         nid = OBJ_obj2nid(obj);
 345     }
 346     for (param = gost_cipher_list; param->sblock != NULL && param->nid != nid;
 347          param++) ;
 348     if (!param->sblock) {
 349         GOSTerr(GOST_F_GET_ENCRYPTION_PARAMS, GOST_R_INVALID_CIPHER_PARAMS);
 350         return NULL;
 351     }
 352     return param;
 353 }
 354
 355 /* Sets cipher param from paramset NID. */
 356 static int gost_cipher_set_param(struct ossl_gost_cipher_ctx *c, int nid)
 357 {
 358     const struct gost_cipher_info *param;
 359     param = get_encryption_params((nid == NID_undef ? NULL : OBJ_nid2obj(nid)));
 360     if (!param)
 361         return 0;
 362
 363     c->paramNID = param->nid;
 364     c->key_meshing = param->key_meshing;
 365     c->count = 0;
 366     gost_init(&(c->cctx), param->sblock);
 367     return 1;
 368 }
 369
 370 /* Initializes EVP_CIPHER_CTX by paramset NID */
 371 static int gost_cipher_init_param(EVP_CIPHER_CTX *ctx,
 372                                   const unsigned char *key,
 373                                   const unsigned char *iv, int enc,
 374                                   int paramNID, int mode)
 375 {
 376     struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
 377     if (EVP_CIPHER_CTX_get_app_data(ctx) == NULL) {
 378         if (!gost_cipher_set_param(c, paramNID))
 379             return 0;
 380         EVP_CIPHER_CTX_set_app_data(ctx, EVP_CIPHER_CTX_get_cipher_data(ctx));
 381     }
 382     if (key)
 383         gost_key(&(c->cctx), key);
 384     if (iv) {
 385         memcpy((unsigned char *)EVP_CIPHER_CTX_original_iv(ctx), iv,
 386                EVP_CIPHER_CTX_iv_length(ctx));
 387     }
 388     memcpy(EVP_CIPHER_CTX_iv_noconst(ctx),
 389            EVP_CIPHER_CTX_original_iv(ctx), EVP_CIPHER_CTX_iv_length(ctx));
 390     return 1;
 391 }
 392
 393 static int gost_cipher_init_cnt(EVP_CIPHER_CTX *ctx,
 394                                 const unsigned char *key,
 395                                 const unsigned char *iv,
 396                                 gost_subst_block * block)
 397 {
 398     struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
 399     gost_init(&(c->cctx), block);
 400     c->key_meshing = 1;
 401     c->count = 0;
 402     if (key)
 403         gost_key(&(c->cctx), key);
 404     if (iv) {
 405         memcpy((unsigned char *)EVP_CIPHER_CTX_original_iv(ctx), iv,
 406                EVP_CIPHER_CTX_iv_length(ctx));
 407     }
 408     memcpy(EVP_CIPHER_CTX_iv_noconst(ctx),
 409            EVP_CIPHER_CTX_original_iv(ctx), EVP_CIPHER_CTX_iv_length(ctx));
 410     return 1;
 411 }
 412
 413 static int gost_cipher_init_cpa(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 414                                 const unsigned char *iv, int enc)
 415 {
 416     return gost_cipher_init_cnt(ctx, key, iv, &Gost28147_CryptoProParamSetA);
 417 }
 418
 419 static int gost_cipher_init_cp_12(EVP_CIPHER_CTX *ctx,
 420                                   const unsigned char *key,
 421                                   const unsigned char *iv, int enc)
 422 {
 423     return gost_cipher_init_cnt(ctx, key, iv, &Gost28147_TC26ParamSetZ);
 424 }
 425
 426 /* Initializes EVP_CIPHER_CTX with default values */
 427 static int gost_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 428                      const unsigned char *iv, int enc)
 429 {
 430     return gost_cipher_init_param(ctx, key, iv, enc, NID_undef,
 431                                   EVP_CIPH_CFB_MODE);
 432 }
 433
 434 /* Initializes EVP_CIPHER_CTX with default values */
 435 static int gost_cipher_init_cbc(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 436                          const unsigned char *iv, int enc)
 437 {
 438     return gost_cipher_init_param(ctx, key, iv, enc, NID_undef,
 439                                   EVP_CIPH_CBC_MODE);
 440 }
 441
 442 /* Initializes EVP_CIPHER_CTX with default values */
 443 static int magma_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 444                       const unsigned char *iv, int enc)
 445 {
 446     struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
 447     /* FIXME this is just initializtion check */
 448     if (EVP_CIPHER_CTX_get_app_data(ctx) == NULL) {
 449         if (!gost_cipher_set_param(c, NID_id_tc26_gost_28147_param_Z))
 450             return 0;
 451         EVP_CIPHER_CTX_set_app_data(ctx, EVP_CIPHER_CTX_get_cipher_data(ctx));
 452
 453         if (enc) {
 454             if (init_zero_kdf_seed(c->kdf_seed) == 0)
 455                 return -1;
 456         }
 457     }
 458
 459     if (key) {
 460         magma_key(&(c->cctx), key);
 461         magma_master_key(&(c->cctx), key);
 462     }
 463     if (iv) {
 464         memcpy((unsigned char *)EVP_CIPHER_CTX_original_iv(ctx), iv,
 465                EVP_CIPHER_CTX_iv_length(ctx));
 466     }
 467     memcpy(EVP_CIPHER_CTX_iv_noconst(ctx),
 468            EVP_CIPHER_CTX_original_iv(ctx), EVP_CIPHER_CTX_iv_length(ctx));
 469
 470     if (EVP_CIPHER_CTX_nid(ctx) == NID_magma_ctr_acpkm
 471      || EVP_CIPHER_CTX_nid(ctx) == NID_magma_ctr_acpkm_omac) {
 472        c->key_meshing = 1024;
 473     } else {
 474        c->key_meshing = 0;
 475     }
 476
 477     return 1;
 478 }
 479
 480 /* Initializes EVP_CIPHER_CTX with default values */
 481 static int magma_cipher_init_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 482                       const unsigned char *iv, int enc)
 483 {
 484         if (key) {
 485     struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
 486                 unsigned char cipher_key[32];
 487                 c->omac_ctx = EVP_MD_CTX_new();
 488
 489                 if (c->omac_ctx == NULL) {
 490                     GOSTerr(GOST_F_MAGMA_CIPHER_INIT_CTR_ACPKM_OMAC, ERR_R_MALLOC_FAILURE);
 491                                 return 0;
 492                 }
 493
 494                 if (gost2015_acpkm_omac_init(NID_magma_mac, enc, key,
 495                                  c->omac_ctx, cipher_key, c->kdf_seed) != 1) {
 496                     EVP_MD_CTX_free(c->omac_ctx);
 497                                 c->omac_ctx = NULL;
 498                     return 0;
 499                 }
 500
 501                 return magma_cipher_init(ctx, cipher_key, iv, enc);
 502         }
 503
 504         return magma_cipher_init(ctx, key, iv, enc);
 505 }
 506
 507 /*
 508  * Wrapper around gostcrypt function from gost89.c which perform key meshing
 509  * when nesseccary
 510  */
 511 static void gost_crypt_mesh(void *ctx, unsigned char *iv, unsigned char *buf)
 512 {
 513     struct ossl_gost_cipher_ctx *c = ctx;
 514     assert(c->count % 8 == 0 && c->count <= 1024);
 515     if (c->key_meshing && c->count == 1024) {
 516         cryptopro_key_meshing(&(c->cctx), iv);
 517     }
 518     gostcrypt(&(c->cctx), iv, buf);
 519     c->count = c->count % 1024 + 8;
 520 }
 521
 522 static void gost_cnt_next(void *ctx, unsigned char *iv, unsigned char *buf)
 523 {
 524     struct ossl_gost_cipher_ctx *c = ctx;
 525     word32 g, go;
 526     unsigned char buf1[8];
 527     assert(c->count % 8 == 0 && c->count <= 1024);
 528     if (c->key_meshing && c->count == 1024) {
 529         cryptopro_key_meshing(&(c->cctx), iv);
 530     }
 531     if (c->count == 0) {
 532         gostcrypt(&(c->cctx), iv, buf1);
 533     } else {
 534         memcpy(buf1, iv, 8);
 535     }
 536     g = buf1[0] | (buf1[1] << 8) | (buf1[2] << 16) | ((word32) buf1[3] << 24);
 537     g += 0x01010101;
 538     buf1[0] = (unsigned char)(g & 0xff);
 539     buf1[1] = (unsigned char)((g >> 8) & 0xff);
 540     buf1[2] = (unsigned char)((g >> 16) & 0xff);
 541     buf1[3] = (unsigned char)((g >> 24) & 0xff);
 542     g = buf1[4] | (buf1[5] << 8) | (buf1[6] << 16) | ((word32) buf1[7] << 24);
 543     go = g;
 544     g += 0x01010104;
 545     if (go > g)                 /* overflow */
 546         g++;
 547     buf1[4] = (unsigned char)(g & 0xff);
 548     buf1[5] = (unsigned char)((g >> 8) & 0xff);
 549     buf1[6] = (unsigned char)((g >> 16) & 0xff);
 550     buf1[7] = (unsigned char)((g >> 24) & 0xff);
 551     memcpy(iv, buf1, 8);
 552     gostcrypt(&(c->cctx), buf1, buf);
 553     c->count = c->count % 1024 + 8;
 554 }
 555
 556 /* GOST encryption in CBC mode */
 557 static int gost_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out,
 558                        const unsigned char *in, size_t inl)
 559 {
 560     unsigned char b[8];
 561     const unsigned char *in_ptr = in;
 562     unsigned char *out_ptr = out;
 563     int i;
 564     struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
 565     unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx);
 566     if (EVP_CIPHER_CTX_encrypting(ctx)) {
 567         while (inl > 0) {
 568
 569             for (i = 0; i < 8; i++) {
 570                 b[i] = iv[i] ^ in_ptr[i];
 571             }
 572             gostcrypt(&(c->cctx), b, out_ptr);
 573             memcpy(iv, out_ptr, 8);
 574             out_ptr += 8;
 575             in_ptr += 8;
 576             inl -= 8;
 577         }
 578     } else {
 579         while (inl > 0) {
 580             unsigned char tmpiv[8];
 581             gostdecrypt(&(c->cctx), in_ptr, b);
 582             memcpy(tmpiv, in_ptr, 8);
 583             for (i = 0; i < 8; i++) {
 584                 out_ptr[i] = iv[i] ^ b[i];
 585             }
 586             memcpy(iv, tmpiv, 8);
 587             out_ptr += 8;
 588             in_ptr += 8;
 589             inl -= 8;
 590         }
 591     }
 592     return 1;
 593 }
 594
 595 /* MAGMA encryption in CBC mode */
 596 static int magma_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out,
 597                         const unsigned char *in, size_t inl)
 598 {
 599     unsigned char b[8];
 600     unsigned char d[8];
 601     const unsigned char *in_ptr = in;
 602     unsigned char *out_ptr = out;
 603     int i;
 604     struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
 605     unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx);
 606     if (EVP_CIPHER_CTX_encrypting(ctx)) {
 607         while (inl > 0) {
 608
 609             for (i = 0; i < 8; i++) {
 610                 b[7 - i] = iv[i] ^ in_ptr[i];
 611             }
 612             gostcrypt(&(c->cctx), b, d);
 613
 614             for (i = 0; i < 8; i++) {
 615                 out_ptr[7 - i] = d[i];
 616             }
 617             memcpy(iv, out_ptr, 8);
 618             out_ptr += 8;
 619             in_ptr += 8;
 620             inl -= 8;
 621         }
 622     } else {
 623         while (inl > 0) {
 624             for (i = 0; i < 8; i++) {
 625                 d[7 - i] = in_ptr[i];
 626             }
 627             gostdecrypt(&(c->cctx), d, b);
 628             memcpy(d, in_ptr, 8);
 629             for (i = 0; i < 8; i++) {
 630                 out_ptr[i] = iv[i] ^ b[7 - i];
 631             }
 632             memcpy(iv, d, 8);
 633             out_ptr += 8;
 634             in_ptr += 8;
 635             inl -= 8;
 636         }
 637     }
 638     return 1;
 639 }
 640
 641 /* increment counter (64-bit int) by 1 */
 642 static void ctr64_inc(unsigned char *counter)
 643 {
 644     inc_counter(counter, 8);
 645 }
 646
 647 #define MAGMA_BLOCK_SIZE 8
 648 #define MAGMA_BLOCK_MASK (MAGMA_BLOCK_SIZE - 1)
 649 static inline void apply_acpkm_magma(struct ossl_gost_cipher_ctx *
 650                                            ctx, unsigned int *num)
 651 {
 652     if (!ctx->key_meshing || (*num < (unsigned int)ctx->key_meshing))
 653         return;
 654     acpkm_magma_key_meshing(&ctx->cctx);
 655     *num &= MAGMA_BLOCK_MASK;
 656 }
 657
 658 /* MAGMA encryption in CTR mode */
 659 static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out,
 660                                const unsigned char *in, size_t inl)
 661 {
 662     const unsigned char *in_ptr = in;
 663     unsigned char *out_ptr = out;
 664     size_t j;
 665     struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
 666     unsigned char *buf = EVP_CIPHER_CTX_buf_noconst(ctx);
 667     unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx);
 668     unsigned int num = EVP_CIPHER_CTX_num(ctx);
 669     size_t blocks, i, lasted = inl;
 670     unsigned char b[8];
 671 /* Process partial blocks */
 672     while ((num & MAGMA_BLOCK_MASK) && lasted) {
 673         *out_ptr++ = *in_ptr++ ^ buf[7 - (num & MAGMA_BLOCK_MASK)];
 674         --lasted;
 675         num++;
 676     }
 677     blocks = lasted / MAGMA_BLOCK_SIZE;
 678
 679 /* Process full blocks */
 680     for (i = 0; i < blocks; i++) {
 681         apply_acpkm_magma(c, &num);
 682         for (j = 0; j < 8; j++) {
 683             b[7 - j] = iv[j];
 684         }
 685         gostcrypt(&(c->cctx), b, buf);
 686         for (j = 0; j < 8; j++) {
 687             out_ptr[j] = buf[7 - j] ^ in_ptr[j];
 688         }
 689         ctr64_inc(iv);
 690         c->count += MAGMA_BLOCK_SIZE;
 691         in_ptr += MAGMA_BLOCK_SIZE;
 692         out_ptr += MAGMA_BLOCK_SIZE;
 693         num += MAGMA_BLOCK_SIZE;
 694         lasted -= MAGMA_BLOCK_SIZE;
 695     }
 696
 697 /* Process the rest of plaintext */
 698     if (lasted > 0) {
 699         apply_acpkm_magma(c, &num);
 700         for (j = 0; j < 8; j++) {
 701             b[7 - j] = iv[j];
 702         }
 703         gostcrypt(&(c->cctx), b, buf);
 704
 705         for (i = 0; i < lasted; i++)
 706             out_ptr[i] = buf[7 - i] ^ in_ptr[i];
 707         ctr64_inc(iv);
 708         c->count += j;
 709         num += lasted;
 710     }
 711     EVP_CIPHER_CTX_set_num(ctx, num);
 712
 713     return inl;
 714 }
 715
 716 /* MAGMA encryption in CTR mode */
 717 static int magma_cipher_do_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, unsigned char *out,
 718                                const unsigned char *in, size_t inl)
 719 {
 720   struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
 721
 722         if (in == NULL && inl == 0) /* Final call */
 723                 return gost2015_final_call(ctx, c->omac_ctx, MAGMA_MAC_MAX_SIZE, c->tag, magma_cipher_do_ctr);
 724
 725   if (in == NULL)
 726       return -1;
 727
 728         /* As in and out can be the same pointer, process unencrypted here */
 729         if (EVP_CIPHER_CTX_encrypting(ctx))
 730                 EVP_DigestSignUpdate(c->omac_ctx, in, inl);
 731
 732   if (magma_cipher_do_ctr(ctx, out, in, inl) != inl)
 733       return -1;
 734
 735         /* As in and out can be the same pointer, process decrypted here */
 736         if (!EVP_CIPHER_CTX_encrypting(ctx))
 737                 EVP_DigestSignUpdate(c->omac_ctx, out, inl);
 738
 739         return inl;
 740 }
 741 /* GOST encryption in CFB mode */
 742 static int gost_cipher_do_cfb(EVP_CIPHER_CTX *ctx, unsigned char *out,
 743                        const unsigned char *in, size_t inl)
 744 {
 745     const unsigned char *in_ptr = in;
 746     unsigned char *out_ptr = out;
 747     size_t i = 0;
 748     size_t j = 0;
 749     unsigned char *buf = EVP_CIPHER_CTX_buf_noconst(ctx);
 750     unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx);
 751 /* process partial block if any */
 752     if (EVP_CIPHER_CTX_num(ctx)) {
 753         for (j = EVP_CIPHER_CTX_num(ctx), i = 0; j < 8 && i < inl;
 754              j++, i++, in_ptr++, out_ptr++) {
 755             if (!EVP_CIPHER_CTX_encrypting(ctx))
 756                 buf[j + 8] = *in_ptr;
 757             *out_ptr = buf[j] ^ (*in_ptr);
 758             if (EVP_CIPHER_CTX_encrypting(ctx))
 759                 buf[j + 8] = *out_ptr;
 760         }
 761         if (j == 8) {
 762             memcpy(iv, buf + 8, 8);
 763             EVP_CIPHER_CTX_set_num(ctx, 0);
 764         } else {
 765             EVP_CIPHER_CTX_set_num(ctx, j);
 766             return 1;
 767         }
 768     }
 769
 770     for (; (inl - i) >= 8; i += 8, in_ptr += 8, out_ptr += 8) {
 771         /*
 772          * block cipher current iv
 773          */
 774         gost_crypt_mesh(EVP_CIPHER_CTX_get_cipher_data(ctx), iv, buf);
 775         /*
 776          * xor next block of input text with it and output it
 777          */
 778         /*
 779          * output this block
 780          */
 781         if (!EVP_CIPHER_CTX_encrypting(ctx))
 782             memcpy(iv, in_ptr, 8);
 783         for (j = 0; j < 8; j++) {
 784             out_ptr[j] = buf[j] ^ in_ptr[j];
 785         }
 786         /* Encrypt */
 787         /* Next iv is next block of cipher text */
 788         if (EVP_CIPHER_CTX_encrypting(ctx))
 789             memcpy(iv, out_ptr, 8);
 790     }
 791 /* Process rest of buffer */
 792     if (i < inl) {
 793         gost_crypt_mesh(EVP_CIPHER_CTX_get_cipher_data(ctx), iv, buf);
 794         if (!EVP_CIPHER_CTX_encrypting(ctx))
 795             memcpy(buf + 8, in_ptr, inl - i);
 796         for (j = 0; i < inl; j++, i++) {
 797             out_ptr[j] = buf[j] ^ in_ptr[j];
 798         }
 799         EVP_CIPHER_CTX_set_num(ctx, j);
 800         if (EVP_CIPHER_CTX_encrypting(ctx))
 801             memcpy(buf + 8, out_ptr, j);
 802     } else {
 803         EVP_CIPHER_CTX_set_num(ctx, 0);
 804     }
 805     return 1;
 806 }
 807
 808 static int gost_cipher_do_cnt(EVP_CIPHER_CTX *ctx, unsigned char *out,
 809                               const unsigned char *in, size_t inl)
 810 {
 811     const unsigned char *in_ptr = in;
 812     unsigned char *out_ptr = out;
 813     size_t i = 0;
 814     size_t j;
 815     unsigned char *buf = EVP_CIPHER_CTX_buf_noconst(ctx);
 816     unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx);
 817 /* process partial block if any */
 818     if (EVP_CIPHER_CTX_num(ctx)) {
 819         for (j = EVP_CIPHER_CTX_num(ctx), i = 0; j < 8 && i < inl;
 820              j++, i++, in_ptr++, out_ptr++) {
 821             *out_ptr = buf[j] ^ (*in_ptr);
 822         }
 823         if (j == 8) {
 824             EVP_CIPHER_CTX_set_num(ctx, 0);
 825         } else {
 826             EVP_CIPHER_CTX_set_num(ctx, j);
 827             return 1;
 828         }
 829     }
 830
 831     for (; (inl - i) >= 8; i += 8, in_ptr += 8, out_ptr += 8) {
 832         /*
 833          * block cipher current iv
 834          */
 835         /* Encrypt */
 836         gost_cnt_next(EVP_CIPHER_CTX_get_cipher_data(ctx), iv, buf);
 837         /*
 838          * xor next block of input text with it and output it
 839          */
 840         /*
 841          * output this block
 842          */
 843         for (j = 0; j < 8; j++) {
 844             out_ptr[j] = buf[j] ^ in_ptr[j];
 845         }
 846     }
 847 /* Process rest of buffer */
 848     if (i < inl) {
 849         gost_cnt_next(EVP_CIPHER_CTX_get_cipher_data(ctx), iv, buf);
 850         for (j = 0; i < inl; j++, i++) {
 851             out_ptr[j] = buf[j] ^ in_ptr[j];
 852         }
 853         EVP_CIPHER_CTX_set_num(ctx, j);
 854     } else {
 855         EVP_CIPHER_CTX_set_num(ctx, 0);
 856     }
 857     return 1;
 858 }
 859
 860 /* Cleaning up of EVP_CIPHER_CTX */
 861 static int gost_cipher_cleanup(EVP_CIPHER_CTX *ctx)
 862 {
 863     struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
 864                 EVP_MD_CTX_free(c->omac_ctx);
 865     gost_destroy(&(c->cctx));
 866     EVP_CIPHER_CTX_set_app_data(ctx, NULL);
 867     return 1;
 868 }
 869
 870 /* Control function for gost cipher */
 871 static int gost_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
 872 {
 873     switch (type) {
 874     case EVP_CTRL_RAND_KEY:
 875         {
 876             if (RAND_priv_bytes
 877                 ((unsigned char *)ptr, EVP_CIPHER_CTX_key_length(ctx)) <= 0) {
 878                 GOSTerr(GOST_F_GOST_CIPHER_CTL, GOST_R_RNG_ERROR);
 879                 return -1;
 880             }
 881             break;
 882         }
 883     case EVP_CTRL_PBE_PRF_NID:
 884         if (ptr) {
 885             const char *params = get_gost_engine_param(GOST_PARAM_PBE_PARAMS);
 886             int nid = NID_id_tc26_hmac_gost_3411_2012_512;
 887
 888             if (params) {
 889                 if (!strcmp("md_gost12_256", params))
 890                     nid = NID_id_tc26_hmac_gost_3411_2012_256;
 891                 else if (!strcmp("md_gost12_512", params))
 892                     nid = NID_id_tc26_hmac_gost_3411_2012_512;
 893                 else if (!strcmp("md_gost94", params))
 894                     nid = NID_id_HMACGostR3411_94;
 895             }
 896             *((int *)ptr) = nid;
 897             return 1;
 898         } else {
 899             return 0;
 900         }
 901
 902     case EVP_CTRL_SET_SBOX:
 903         if (ptr) {
 904             struct ossl_gost_cipher_ctx *c =
 905                 EVP_CIPHER_CTX_get_cipher_data(ctx);
 906             int nid;
 907             int cur_meshing;
 908             int ret;
 909
 910             if (c == NULL) {
 911                 return -1;
 912             }
 913
 914             if (c->count != 0) {
 915                 return -1;
 916             }
 917
 918             nid = OBJ_txt2nid(ptr);
 919             if (nid == NID_undef) {
 920                 return 0;
 921             }
 922
 923             cur_meshing = c->key_meshing;
 924             ret = gost_cipher_set_param(c, nid);
 925             c->key_meshing = cur_meshing;
 926             return ret;
 927         } else {
 928             return 0;
 929         }
 930     case EVP_CTRL_KEY_MESH:
 931         {
 932             struct ossl_gost_cipher_ctx *c =
 933                 EVP_CIPHER_CTX_get_cipher_data(ctx);
 934
 935             if (c == NULL) {
 936                 return -1;
 937             }
 938
 939             if (c->count != 0) {
 940                 return -1;
 941             }
 942
 943             c->key_meshing = arg;
 944             return 1;
 945         }
 946     default:
 947         GOSTerr(GOST_F_GOST_CIPHER_CTL, GOST_R_UNSUPPORTED_CIPHER_CTL_COMMAND);
 948         return -1;
 949     }
 950     return 1;
 951 }
 952
 953 /* Decrement 8-byte sequence if needed */
 954 int decrement_sequence(unsigned char *seq, int decrement) {
 955     if (decrement < 0 || decrement > 1)
 956         return 0;
 957
 958     int j;
 959     if (decrement) {
 960        for (j = 7; j >= 0; j--)
 961             {
 962                 if (seq[j] != 0)
 963                 {
 964                     seq[j]--;
 965                     break;
 966                 }
 967                 else
 968                     seq[j] = 0xFF;
 969             }
 970     }
 971     return 1;
 972 }
 973
 974 /* Control function for gost cipher */
 975 static int magma_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
 976 {
 977     switch (type) {
 978     case EVP_CTRL_RAND_KEY:
 979             if (RAND_priv_bytes
 980                 ((unsigned char *)ptr, EVP_CIPHER_CTX_key_length(ctx)) <= 0) {
 981                 GOSTerr(GOST_F_GOST_CIPHER_CTL, GOST_R_RNG_ERROR);
 982                 return -1;
 983             }
 984             break;
 985     case EVP_CTRL_KEY_MESH:
 986         {
 987             struct ossl_gost_cipher_ctx *c =
 988                 EVP_CIPHER_CTX_get_cipher_data(ctx);
 989
 990             if (c == NULL) {
 991                 return -1;
 992             }
 993
 994             if (c->count != 0) {
 995                 return -1;
 996             }
 997
 998             c->key_meshing = arg;
 999             return 1;
1000         }
1001     case EVP_CTRL_TLSTREE:
1002         {
1003             unsigned char newkey[32];
1004             int mode = EVP_CIPHER_CTX_mode(ctx);
1005             struct ossl_gost_cipher_ctx *ctr_ctx = NULL;
1006             gost_ctx *c = NULL;
1007
1008             unsigned char adjusted_iv[8];
1009             unsigned char seq[8];
1010             int j, carry, decrement_arg;
1011             if (mode != EVP_CIPH_CTR_MODE)
1012                 return -1;
1013
1014             ctr_ctx = (struct ossl_gost_cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
1015             c = &(ctr_ctx->cctx);
1016
1017             /*
1018              * 'arg' parameter indicates what we should do with sequence value.
1019              *
1020              * When function called, seq is incremented after MAC calculation.
1021              * In ETM mode, we use seq 'as is' in the ctrl-function (arg = 0)
1022              * Otherwise we have to decrease it in the implementation (arg = 1).
1023              */
1024             memcpy(seq, ptr, 8);
1025             decrement_arg = arg;
1026             if(!decrement_sequence(seq, decrement_arg)) {
1027                 GOSTerr(GOST_F_MAGMA_CIPHER_CTL, GOST_R_CTRL_CALL_FAILED);
1028                 return -1;
1029             }
1030
1031             if (gost_tlstree(NID_magma_cbc, (const unsigned char *)c->master_key, newkey,
1032                              (const unsigned char *)seq) > 0) {
1033                 memset(adjusted_iv, 0, 8);
1034                 memcpy(adjusted_iv, EVP_CIPHER_CTX_original_iv(ctx), 4);
1035                 for (j = 3, carry = 0; j >= 0; j--)
1036                 {
1037                     int adj_byte = adjusted_iv[j] + seq[j+4] + carry;
1038                     carry = (adj_byte > 255) ? 1 : 0;
1039                     adjusted_iv[j] = adj_byte & 0xFF;
1040                 }
1041                 EVP_CIPHER_CTX_set_num(ctx, 0);
1042                 memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), adjusted_iv, 8);
1043
1044                 magma_key(c, newkey);
1045                 return 1;
1046           }
1047         }
1048         return -1;
1049     default:
1050         GOSTerr(GOST_F_MAGMA_CIPHER_CTL, GOST_R_UNSUPPORTED_CIPHER_CTL_COMMAND);
1051         return -1;
1052     }
1053     return 1;
1054 }
1055
1056 static int magma_cipher_ctl_acpkm_omac(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
1057 {
1058         switch (type)
1059         {
1060                 case EVP_CTRL_PROCESS_UNPROTECTED:
1061                 {
1062                         struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
1063                         STACK_OF(X509_ATTRIBUTE) *x = ptr;
1064       return gost2015_process_unprotected_attributes(x, arg, MAGMA_MAC_MAX_SIZE, c->tag);
1065                 }
1066     case EVP_CTRL_COPY: {
1067                         EVP_CIPHER_CTX *out = ptr;
1068       struct ossl_gost_cipher_ctx *in_cctx  = EVP_CIPHER_CTX_get_cipher_data(ctx);
1069       struct ossl_gost_cipher_ctx *out_cctx = EVP_CIPHER_CTX_get_cipher_data(out);
1070
1071                         if (in_cctx->omac_ctx == out_cctx->omac_ctx) {
1072                                 out_cctx->omac_ctx = EVP_MD_CTX_new();
1073                                 if (out_cctx->omac_ctx == NULL) {
1074                                         GOSTerr(GOST_F_MAGMA_CIPHER_CTL_ACPKM_OMAC, ERR_R_MALLOC_FAILURE);
1075                                         return -1;
1076                                 }
1077                         }
1078                         return EVP_MD_CTX_copy(out_cctx->omac_ctx, in_cctx->omac_ctx);
1079                 }
1080                 default:
1081                         return magma_cipher_ctl(ctx, type, arg, ptr);
1082                         break;
1083         }
1084 }
1085
1086 /* Set cipher parameters from ASN1 structure */
1087 static int gost89_set_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params)
1088 {
1089     int len = 0;
1090     unsigned char *buf = NULL;
1091     unsigned char *p = NULL;
1092     struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
1093     GOST_CIPHER_PARAMS *gcp = GOST_CIPHER_PARAMS_new();
1094     ASN1_OCTET_STRING *os = NULL;
1095     if (!gcp) {
1096         GOSTerr(GOST_F_GOST89_SET_ASN1_PARAMETERS, ERR_R_MALLOC_FAILURE);
1097         return 0;
1098     }
1099     if (!ASN1_OCTET_STRING_set
1100         (gcp->iv, EVP_CIPHER_CTX_iv(ctx), EVP_CIPHER_CTX_iv_length(ctx))) {
1101         GOST_CIPHER_PARAMS_free(gcp);
1102         GOSTerr(GOST_F_GOST89_SET_ASN1_PARAMETERS, ERR_R_MALLOC_FAILURE);
1103         return 0;
1104     }
1105     ASN1_OBJECT_free(gcp->enc_param_set);
1106     gcp->enc_param_set = OBJ_nid2obj(c->paramNID);
1107
1108     len = i2d_GOST_CIPHER_PARAMS(gcp, NULL);
1109     p = buf = OPENSSL_malloc(len);
1110     if (!buf) {
1111         GOST_CIPHER_PARAMS_free(gcp);
1112         GOSTerr(GOST_F_GOST89_SET_ASN1_PARAMETERS, ERR_R_MALLOC_FAILURE);
1113         return 0;
1114     }
1115     i2d_GOST_CIPHER_PARAMS(gcp, &p);
1116     GOST_CIPHER_PARAMS_free(gcp);
1117
1118     os = ASN1_OCTET_STRING_new();
1119
1120     if (!os || !ASN1_OCTET_STRING_set(os, buf, len)) {
1121         OPENSSL_free(buf);
1122         GOSTerr(GOST_F_GOST89_SET_ASN1_PARAMETERS, ERR_R_MALLOC_FAILURE);
1123         return 0;
1124     }
1125     OPENSSL_free(buf);
1126
1127     ASN1_TYPE_set(params, V_ASN1_SEQUENCE, os);
1128     return 1;
1129 }
1130
1131 /* Store parameters into ASN1 structure */
1132 static int gost89_get_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params)
1133 {
1134     int len;
1135     GOST_CIPHER_PARAMS *gcp = NULL;
1136     unsigned char *p;
1137     struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
1138     int nid;
1139
1140     if (ASN1_TYPE_get(params) != V_ASN1_SEQUENCE) {
1141         return -1;
1142     }
1143
1144     p = params->value.sequence->data;
1145
1146     gcp = d2i_GOST_CIPHER_PARAMS(NULL, (const unsigned char **)&p,
1147                                  params->value.sequence->length);
1148
1149     len = gcp->iv->length;
1150     if (len != EVP_CIPHER_CTX_iv_length(ctx)) {
1151         GOST_CIPHER_PARAMS_free(gcp);
1152         GOSTerr(GOST_F_GOST89_GET_ASN1_PARAMETERS, GOST_R_INVALID_IV_LENGTH);
1153         return -1;
1154     }
1155
1156     nid = OBJ_obj2nid(gcp->enc_param_set);
1157     if (nid == NID_undef) {
1158         GOST_CIPHER_PARAMS_free(gcp);
1159         GOSTerr(GOST_F_GOST89_GET_ASN1_PARAMETERS,
1160                 GOST_R_INVALID_CIPHER_PARAM_OID);
1161         return -1;
1162     }
1163
1164     if (!gost_cipher_set_param(c, nid)) {
1165         GOST_CIPHER_PARAMS_free(gcp);
1166         return -1;
1167     }
1168     /*XXX missing non-const accessor */
1169     memcpy((unsigned char *)EVP_CIPHER_CTX_original_iv(ctx), gcp->iv->data,
1170            EVP_CIPHER_CTX_iv_length(ctx));
1171
1172     GOST_CIPHER_PARAMS_free(gcp);
1173
1174     return 1;
1175 }
1176
1177 #define MAGMA_UKM_LEN 12
1178 static int magma_set_asn1_parameters (EVP_CIPHER_CTX *ctx, ASN1_TYPE *params)
1179 {
1180   struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
1181         c->key_meshing = 8192;
1182
1183         return gost2015_set_asn1_params(params, EVP_CIPHER_CTX_original_iv(ctx), 4,
1184                 c->kdf_seed);
1185 }
1186
1187 static int magma_get_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params)
1188 {
1189   struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
1190         unsigned char iv[16];
1191
1192         c->key_meshing = 8192;
1193
1194         if (gost2015_get_asn1_params(params, MAGMA_UKM_LEN, iv, 4, c->kdf_seed) < 0)
1195             return -1;
1196
1197         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, sizeof(iv));
1198         memcpy((unsigned char *)EVP_CIPHER_CTX_original_iv(ctx), iv, sizeof(iv));
1199         /* Key meshing 8 kb*/
1200         c->key_meshing = 8192;
1201
1202         return 1;
1203 }
1204
1205 static int gost_imit_init(EVP_MD_CTX *ctx, gost_subst_block * block)
1206 {
1207     struct ossl_gost_imit_ctx *c = EVP_MD_CTX_md_data(ctx);
1208     memset(c->buffer, 0, sizeof(c->buffer));
1209     memset(c->partial_block, 0, sizeof(c->partial_block));
1210     c->count = 0;
1211     c->bytes_left = 0;
1212     c->key_meshing = 1;
1213     c->dgst_size = 4;
1214     gost_init(&(c->cctx), block);
1215     return 1;
1216 }
1217
1218 static int gost_imit_init_cpa(EVP_MD_CTX *ctx)
1219 {
1220     return gost_imit_init(ctx, &Gost28147_CryptoProParamSetA);
1221 }
1222
1223 static int gost_imit_init_cp_12(EVP_MD_CTX *ctx)
1224 {
1225     return gost_imit_init(ctx, &Gost28147_TC26ParamSetZ);
1226 }
1227
1228 static void mac_block_mesh(struct ossl_gost_imit_ctx *c,
1229                            const unsigned char *data)
1230 {
1231     /*
1232      * We are using NULL for iv because CryptoPro doesn't interpret
1233      * internal state of MAC algorithm as iv during keymeshing (but does
1234      * initialize internal state from iv in key transport
1235      */
1236     assert(c->count % 8 == 0 && c->count <= 1024);
1237     if (c->key_meshing && c->count == 1024) {
1238         cryptopro_key_meshing(&(c->cctx), NULL);
1239     }
1240     mac_block(&(c->cctx), c->buffer, data);
1241     c->count = c->count % 1024 + 8;
1242 }
1243
1244 static int gost_imit_update(EVP_MD_CTX *ctx, const void *data, size_t count)
1245 {
1246     struct ossl_gost_imit_ctx *c = EVP_MD_CTX_md_data(ctx);
1247     const unsigned char *p = data;
1248     size_t bytes = count;
1249     if (!(c->key_set)) {
1250         GOSTerr(GOST_F_GOST_IMIT_UPDATE, GOST_R_MAC_KEY_NOT_SET);
1251         return 0;
1252     }
1253     if (c->bytes_left) {
1254         size_t i;
1255         for (i = c->bytes_left; i < 8 && bytes > 0; bytes--, i++, p++) {
1256             c->partial_block[i] = *p;
1257         }
1258         if (i == 8) {
1259             mac_block_mesh(c, c->partial_block);
1260         } else {
1261             c->bytes_left = i;
1262             return 1;
1263         }
1264     }
1265     while (bytes > 8) {
1266         mac_block_mesh(c, p);
1267         p += 8;
1268         bytes -= 8;
1269     }
1270     if (bytes > 0) {
1271         memcpy(c->partial_block, p, bytes);
1272     }
1273     c->bytes_left = bytes;
1274     return 1;
1275 }
1276
1277 static int gost_imit_final(EVP_MD_CTX *ctx, unsigned char *md)
1278 {
1279     struct ossl_gost_imit_ctx *c = EVP_MD_CTX_md_data(ctx);
1280     if (!c->key_set) {
1281         GOSTerr(GOST_F_GOST_IMIT_FINAL, GOST_R_MAC_KEY_NOT_SET);
1282         return 0;
1283     }
1284     if (c->count == 0 && c->bytes_left) {
1285         unsigned char buffer[8];
1286         memset(buffer, 0, 8);
1287         gost_imit_update(ctx, buffer, 8);
1288     }
1289     if (c->bytes_left) {
1290         int i;
1291         for (i = c->bytes_left; i < 8; i++) {
1292             c->partial_block[i] = 0;
1293         }
1294         mac_block_mesh(c, c->partial_block);
1295     }
1296     get_mac(c->buffer, 8 * c->dgst_size, md);
1297     return 1;
1298 }
1299
1300 static int gost_imit_ctrl(EVP_MD_CTX *ctx, int type, int arg, void *ptr)
1301 {
1302     switch (type) {
1303     case EVP_MD_CTRL_KEY_LEN:
1304         *((unsigned int *)(ptr)) = 32;
1305         return 1;
1306     case EVP_MD_CTRL_SET_KEY:
1307         {
1308             struct ossl_gost_imit_ctx *gost_imit_ctx = EVP_MD_CTX_md_data(ctx);
1309
1310             if (EVP_MD_meth_get_init(EVP_MD_CTX_md(ctx)) (ctx) <= 0) {
1311                 GOSTerr(GOST_F_GOST_IMIT_CTRL, GOST_R_MAC_KEY_NOT_SET);
1312                 return 0;
1313             }
1314             EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_NO_INIT);
1315
1316             if (arg == 0) {
1317                 struct gost_mac_key *key = (struct gost_mac_key *)ptr;
1318                 if (key->mac_param_nid != NID_undef) {
1319                     const struct gost_cipher_info *param =
1320                         get_encryption_params(OBJ_nid2obj(key->mac_param_nid));
1321                     if (param == NULL) {
1322                         GOSTerr(GOST_F_GOST_IMIT_CTRL,
1323                                 GOST_R_INVALID_MAC_PARAMS);
1324                         return 0;
1325                     }
1326                     gost_init(&(gost_imit_ctx->cctx), param->sblock);
1327                 }
1328                 gost_key(&(gost_imit_ctx->cctx), key->key);
1329                 gost_imit_ctx->key_set = 1;
1330
1331                 return 1;
1332             } else if (arg == 32) {
1333                 gost_key(&(gost_imit_ctx->cctx), ptr);
1334                 gost_imit_ctx->key_set = 1;
1335                 return 1;
1336             }
1337             GOSTerr(GOST_F_GOST_IMIT_CTRL, GOST_R_INVALID_MAC_KEY_SIZE);
1338             return 0;
1339         }
1340     case EVP_MD_CTRL_XOF_LEN:
1341         {
1342             struct ossl_gost_imit_ctx *c = EVP_MD_CTX_md_data(ctx);
1343             if (arg < 1 || arg > 8) {
1344                 GOSTerr(GOST_F_GOST_IMIT_CTRL, GOST_R_INVALID_MAC_SIZE);
1345                 return 0;
1346             }
1347             c->dgst_size = arg;
1348             return 1;
1349         }
1350
1351     default:
1352         return 0;
1353     }
1354 }
1355
1356 static int gost_imit_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from)
1357 {
1358     if (EVP_MD_CTX_md_data(to) && EVP_MD_CTX_md_data(from)) {
1359         memcpy(EVP_MD_CTX_md_data(to), EVP_MD_CTX_md_data(from),
1360                sizeof(struct ossl_gost_imit_ctx));
1361     }
1362     return 1;
1363 }
1364
1365 /* Clean up imit ctx */
1366 static int gost_imit_cleanup(EVP_MD_CTX *ctx)
1367 {
1368     memset(EVP_MD_CTX_md_data(ctx), 0, sizeof(struct ossl_gost_imit_ctx));
1369     return 1;
1370 }
1371 /* vim: set expandtab cinoptions=\:0,l1,t0,g0,(0 sw=4 : */