gost_pmeth.c

   1 /**********************************************************************
   2  *                          gost_pmeth.c                              *
   3  *             Copyright (c) 2005-2013 Cryptocom LTD                  *
   4  *         This file is distributed under the same license as OpenSSL *
   5  *                                                                    *
   6  *   Implementation of RFC 4357 (GOST R 34.10) Publick key method     *
   7  *       for OpenSSL                                                  *
   8  *          Requires OpenSSL 1.0.0+ for compilation                   *
   9  **********************************************************************/
  10 #include <openssl/evp.h>
  11 #include <openssl/objects.h>
  12 #include <openssl/ec.h>
  13 #include <openssl/err.h>
  14 #include <openssl/x509v3.h>     /* For string_to_hex */
  15 #include <openssl/opensslv.h>   /* For OPENSSL_VERSION_MAJOR */
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <ctype.h>
  19 #include "gost_lcl.h"
  20 #include "e_gost_err.h"
  21
  22 #define ossl3_const
  23 #ifdef OPENSSL_VERSION_MAJOR
  24 #undef ossl3_const
  25 #define ossl3_const const
  26 #endif
  27
  28 /* -----init, cleanup, copy - uniform for all algs  --------------*/
  29 /* Allocates new gost_pmeth_data structure and assigns it as data */
  30 static int pkey_gost_init(EVP_PKEY_CTX *ctx)
  31 {
  32     struct gost_pmeth_data *data;
  33     EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(ctx);
  34
  35     data = OPENSSL_malloc(sizeof(*data));
  36     if (!data)
  37         return 0;
  38     memset(data, 0, sizeof(*data));
  39     if (pkey && EVP_PKEY_get0(pkey)) {
  40         switch (EVP_PKEY_base_id(pkey)) {
  41         case NID_id_GostR3410_2001:
  42         case NID_id_GostR3410_2001DH:
  43         case NID_id_GostR3410_2012_256:
  44         case NID_id_GostR3410_2012_512:
  45             {
  46                 const EC_GROUP *group =
  47                     EC_KEY_get0_group(EVP_PKEY_get0((EVP_PKEY *)pkey));
  48                 if (group != NULL) {
  49                     data->sign_param_nid = EC_GROUP_get_curve_name(group);
  50                     break;
  51                 }
  52                 /* else */
  53             }
  54         default:
  55             OPENSSL_free(data);
  56             return 0;
  57         }
  58     }
  59     EVP_PKEY_CTX_set_data(ctx, data);
  60     return 1;
  61 }
  62
  63 /* Copies contents of gost_pmeth_data structure */
  64 static int pkey_gost_copy(EVP_PKEY_CTX *dst, ossl3_const EVP_PKEY_CTX *src)
  65 {
  66     struct gost_pmeth_data *dst_data, *src_data;
  67     if (!pkey_gost_init(dst)) {
  68         return 0;
  69     }
  70     src_data = EVP_PKEY_CTX_get_data(src);
  71     dst_data = EVP_PKEY_CTX_get_data(dst);
  72     if (!src_data || !dst_data)
  73         return 0;
  74
  75     *dst_data = *src_data;
  76
  77     return 1;
  78 }
  79
  80 /* Frees up gost_pmeth_data structure */
  81 static void pkey_gost_cleanup(EVP_PKEY_CTX *ctx)
  82 {
  83     struct gost_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
  84     if (!data)
  85         return;
  86     OPENSSL_free(data);
  87 }
  88
  89 /*
  90 * signature schemes(hex)        NamedGroup(hex) Curve Identifier                            param_nid                                       paramset
  91 *  (draft-smyshlyaev-tls13)                                                                 (gost-engine)
  92 * --------------------------------------------------------------------------------------------------------------------------------------------------
  93 * gostr34102012_256a(0x0709)    GC256A(0x22)    id-tc26-gost-3410-2012-256-paramSetA        NID_id_tc26_gost_3410_2012_256_paramSetA        TCA
  94 * gostr34102012_256b(0x070A)    GC256B(0x23)    id-GostR3410-2001-CryptoPro-A-ParamSet      NID_id_GostR3410_2001_CryptoPro_A_ParamSet      A
  95 *                                              *id-GostR3410_2001-CryptoPro-XchA-ParamSet   NID_id_GostR3410_2001_CryptoPro_XchA_ParamSet   XA
  96 *                                              *id-tc26-gost-3410-2012-256-paramSetB        NID_id_tc26_gost_3410_2012_256_paramSetB        TCB
  97 * gostr34102012_256c(0x070B)    GC256C(0x24)    id-GostR3410-2001-CryptoPro-B-ParamSet      NID_id_GostR3410_2001_CryptoPro_B_ParamSet      B
  98 *                                              *id-tc26-gost-3410-2012-256-paramSetC        NID_id_tc26_gost_3410_2012_256_paramSetC        TCC
  99 * gostr34102012_256d(0x070C)    GC256D(0x25)    id-GostR3410-2001-CryptoPro-C-ParamSet      NID_id_GostR3410_2001_CryptoPro_C_ParamSet      C
 100 *                                              *id-GostR3410-2001-CryptoPro-XchB-ParamSet   NID_id_GostR3410_2001_CryptoPro_XchB_ParamSet   XB
 101 *                                              *id-tc26-gost-3410-2012-256-paramSetD        NID_id_tc26_gost_3410_2012_256_paramSetD        TCD
 102 * gostr34102012_512a(0x070D)    GC512A(0x26)    id-tc26-gost-3410-12-512-paramSetA          NID_id_tc26_gost_3410_2012_512_paramSetA        A
 103 * gostr34102012_512b(0x070E)    GC512B(0x27)    id-tc26-gost-3410-12-512-paramSetB          NID_id_tc26_gost_3410_2012_512_paramSetB        B
 104 * gostr34102012_512c(0x070F)    GC512C(0x28)    id-tc26-gost-3410-2012-512-paramSetC        NID_id_tc26_gost_3410_2012_512_paramSetC        C
 105 *
 106 * */
 107
 108 typedef struct paramset_match_tbl_st {
 109     int lookup_id;  // SIGALG_LOOKUP.curve
 110     int param_nid;
 111 } PARAMSET_MATCH_TBL;
 112
 113 static PARAMSET_MATCH_TBL paramset_matches[] = {
 114     { NID_id_tc26_gost_3410_2012_256_paramSetA, NID_id_tc26_gost_3410_2012_256_paramSetA },
 115     { NID_id_tc26_gost_3410_2012_256_paramSetB, NID_id_GostR3410_2001_CryptoPro_A_ParamSet },
 116     { NID_id_tc26_gost_3410_2012_256_paramSetB, NID_id_GostR3410_2001_CryptoPro_XchA_ParamSet },
 117     { NID_id_tc26_gost_3410_2012_256_paramSetB, NID_id_tc26_gost_3410_2012_256_paramSetB },
 118     { NID_id_tc26_gost_3410_2012_256_paramSetC, NID_id_GostR3410_2001_CryptoPro_B_ParamSet },
 119     { NID_id_tc26_gost_3410_2012_256_paramSetC, NID_id_tc26_gost_3410_2012_256_paramSetC },
 120     { NID_id_tc26_gost_3410_2012_256_paramSetD, NID_id_GostR3410_2001_CryptoPro_C_ParamSet },
 121     { NID_id_tc26_gost_3410_2012_256_paramSetD, NID_id_GostR3410_2001_CryptoPro_XchB_ParamSet },
 122     { NID_id_tc26_gost_3410_2012_256_paramSetD, NID_id_tc26_gost_3410_2012_256_paramSetD },
 123     { NID_id_tc26_gost_3410_2012_512_paramSetA, NID_id_tc26_gost_3410_2012_512_paramSetA },
 124     { NID_id_tc26_gost_3410_2012_512_paramSetB, NID_id_tc26_gost_3410_2012_512_paramSetB },
 125     { NID_id_tc26_gost_3410_2012_512_paramSetC, NID_id_tc26_gost_3410_2012_512_paramSetC }
 126 };
 127
 128 #ifndef OSSL_NELEM
 129 # define OSSL_NELEM(x) (sizeof(x)/sizeof((x)[0]))
 130 #endif
 131
 132 /* --------------------- control functions  ------------------------------*/
 133 static int pkey_gost_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 134 {
 135     struct gost_pmeth_data *pctx =
 136         (struct gost_pmeth_data *)EVP_PKEY_CTX_get_data(ctx);
 137     if (pctx == NULL)
 138         return 0;
 139
 140     switch (type) {
 141     case EVP_PKEY_CTRL_PARAMS_MATCH:
 142         {
 143             int param_nid = pctx->sign_param_nid;
 144             int i;
 145
 146             // key is incomparable by 'params' or there is no matches
 147             if (param_nid == 0 || p1 == 0)
 148                 return 0;
 149
 150             for (i = 0; i < OSSL_NELEM(paramset_matches); i++) {
 151                 if (paramset_matches[i].lookup_id == p1
 152                     && paramset_matches[i].param_nid == param_nid)
 153                 return 1;
 154             }
 155             return 0;
 156         }
 157
 158     case EVP_PKEY_CTRL_MD:
 159         {
 160             EVP_PKEY *key = EVP_PKEY_CTX_get0_pkey(ctx);
 161             int pkey_nid = (key == NULL) ? NID_undef : EVP_PKEY_base_id(key);
 162
 163             OPENSSL_assert(p2 != NULL);
 164
 165             switch (EVP_MD_type((const EVP_MD *)p2)) {
 166             case NID_id_GostR3411_94:
 167                 if (pkey_nid == NID_id_GostR3410_2001
 168                     || pkey_nid == NID_id_GostR3410_2001DH
 169                     || pkey_nid == NID_id_GostR3410_94) {
 170                     pctx->md = (EVP_MD *)p2;
 171                     return 1;
 172                 }
 173                 break;
 174
 175             case NID_id_GostR3411_2012_256:
 176                 if (pkey_nid == NID_id_GostR3410_2012_256) {
 177                     pctx->md = (EVP_MD *)p2;
 178                     return 1;
 179                 }
 180                 break;
 181
 182             case NID_id_GostR3411_2012_512:
 183                 if (pkey_nid == NID_id_GostR3410_2012_512) {
 184                     pctx->md = (EVP_MD *)p2;
 185                     return 1;
 186                 }
 187                 break;
 188             }
 189
 190             GOSTerr(GOST_F_PKEY_GOST_CTRL, GOST_R_INVALID_DIGEST_TYPE);
 191             return 0;
 192         }
 193
 194     case EVP_PKEY_CTRL_GET_MD:
 195         *(const EVP_MD **)p2 = pctx->md;
 196         return 1;
 197
 198     case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
 199     case EVP_PKEY_CTRL_PKCS7_DECRYPT:
 200     case EVP_PKEY_CTRL_PKCS7_SIGN:
 201     case EVP_PKEY_CTRL_DIGESTINIT:
 202 #ifndef OPENSSL_NO_CMS
 203     case EVP_PKEY_CTRL_CMS_ENCRYPT:
 204     case EVP_PKEY_CTRL_CMS_DECRYPT:
 205     case EVP_PKEY_CTRL_CMS_SIGN:
 206 #endif
 207         return 1;
 208
 209     case EVP_PKEY_CTRL_GOST_PARAMSET:
 210         pctx->sign_param_nid = (int)p1;
 211         return 1;
 212     case EVP_PKEY_CTRL_SET_IV:
 213         if (p1 > sizeof(pctx->shared_ukm) || !p2) {
 214             GOSTerr(GOST_F_PKEY_GOST_CTRL, GOST_R_UKM_NOT_SET);
 215             return 0;
 216         }
 217         memcpy(pctx->shared_ukm, p2, (int)p1);
 218         pctx->shared_ukm_size = p1;
 219         return 1;
 220     case EVP_PKEY_CTRL_SET_VKO:
 221         switch (p1) {
 222             case 0: /* switch to KEG */
 223             case NID_id_GostR3411_2012_256:
 224             case NID_id_GostR3411_2012_512:
 225                 break;
 226             default:
 227                 GOSTerr(GOST_F_PKEY_GOST_CTRL, GOST_R_INVALID_DIGEST_TYPE);
 228                 return 0;
 229         }
 230         pctx->vko_dgst_nid = p1;
 231         return 1;
 232   case EVP_PKEY_CTRL_CIPHER:
 233         switch (p1) {
 234           case NID_magma_ctr_acpkm:
 235           case NID_magma_ctr_acpkm_omac:
 236           case NID_magma_ctr:
 237             pctx->cipher_nid = NID_magma_ctr;
 238             return 1;
 239           case NID_kuznyechik_ctr_acpkm:
 240           case NID_kuznyechik_ctr_acpkm_omac:
 241           case NID_kuznyechik_ctr:
 242             pctx->cipher_nid = NID_kuznyechik_ctr;
 243             return 1;
 244           default:
 245             pctx->cipher_nid = p1;
 246             return 1;
 247         }
 248         return 1;
 249     case EVP_PKEY_CTRL_PEER_KEY:
 250         if (p1 == 0 || p1 == 1) /* call from EVP_PKEY_derive_set_peer */
 251             return 1;
 252         if (p1 == 2)            /* TLS: peer key used? */
 253             return pctx->peer_key_used;
 254         if (p1 == 3)            /* TLS: peer key used! */
 255             return (pctx->peer_key_used = 1);
 256         break;
 257     }
 258
 259     GOSTerr(GOST_F_PKEY_GOST_CTRL, GOST_R_CTRL_CALL_FAILED);
 260     return -2;
 261 }
 262
 263 static int pkey_gost_ec_ctrl_str_common(EVP_PKEY_CTX *ctx,
 264                                      const char *type, const char *value)
 265 {
 266   if (0 == strcmp(type, ukm_ctrl_string)) {
 267     unsigned char ukm_buf[32], *tmp = NULL;
 268     long len = 0;
 269     tmp = OPENSSL_hexstr2buf(value, &len);
 270     if (tmp == NULL)
 271       return 0;
 272
 273     if (len > 32) {
 274       OPENSSL_free(tmp);
 275       GOSTerr(GOST_F_PKEY_GOST_EC_CTRL_STR_COMMON, GOST_R_CTRL_CALL_FAILED);
 276       return 0;
 277     }
 278     memcpy(ukm_buf, tmp, len);
 279     OPENSSL_free(tmp);
 280
 281     return pkey_gost_ctrl(ctx, EVP_PKEY_CTRL_SET_IV, len, ukm_buf);
 282   } else if (strcmp(type, vko_ctrl_string) == 0) {
 283       int bits = atoi(value);
 284       int vko_dgst_nid = 0;
 285
 286       if (bits == 256)
 287           vko_dgst_nid = NID_id_GostR3411_2012_256;
 288       else if (bits == 512)
 289           vko_dgst_nid = NID_id_GostR3411_2012_512;
 290       else if (bits != 0) {
 291           GOSTerr(GOST_F_PKEY_GOST_EC_CTRL_STR_COMMON, GOST_R_INVALID_DIGEST_TYPE);
 292           return 0;
 293       }
 294       return pkey_gost_ctrl(ctx, EVP_PKEY_CTRL_SET_VKO, vko_dgst_nid, NULL);
 295   }
 296   return -2;
 297 }
 298
 299 static int pkey_gost_ec_ctrl_str_256(EVP_PKEY_CTX *ctx,
 300                                      const char *type, const char *value)
 301 {
 302     if (strcmp(type, param_ctrl_string) == 0) {
 303         int param_nid = 0;
 304
 305         if (!value) {
 306             return 0;
 307         }
 308         if (strlen(value) == 1) {
 309             switch (toupper((unsigned char)value[0])) {
 310             case 'A':
 311                 param_nid = NID_id_GostR3410_2001_CryptoPro_A_ParamSet;
 312                 break;
 313             case 'B':
 314                 param_nid = NID_id_GostR3410_2001_CryptoPro_B_ParamSet;
 315                 break;
 316             case 'C':
 317                 param_nid = NID_id_GostR3410_2001_CryptoPro_C_ParamSet;
 318                 break;
 319             case '0':
 320                 param_nid = NID_id_GostR3410_2001_TestParamSet;
 321                 break;
 322             default:
 323                 return 0;
 324             }
 325         } else if ((strlen(value) == 2)
 326                    && (toupper((unsigned char)value[0]) == 'X')) {
 327             switch (toupper((unsigned char)value[1])) {
 328             case 'A':
 329                 param_nid = NID_id_GostR3410_2001_CryptoPro_XchA_ParamSet;
 330                 break;
 331             case 'B':
 332                 param_nid = NID_id_GostR3410_2001_CryptoPro_XchB_ParamSet;
 333                 break;
 334             default:
 335                 return 0;
 336             }
 337     } else if ((strlen(value) == 3)
 338         && (toupper((unsigned char)value[0]) == 'T')
 339         && (toupper((unsigned char)value[1]) == 'C')) {
 340             switch (toupper((unsigned char)value[2])) {
 341             case 'A':
 342                 param_nid = NID_id_tc26_gost_3410_2012_256_paramSetA;
 343                 break;
 344             case 'B':
 345                 param_nid = NID_id_tc26_gost_3410_2012_256_paramSetB;
 346                 break;
 347             case 'C':
 348                 param_nid = NID_id_tc26_gost_3410_2012_256_paramSetC;
 349                 break;
 350             case 'D':
 351                 param_nid = NID_id_tc26_gost_3410_2012_256_paramSetD;
 352                 break;
 353             default:
 354                 return 0;
 355             }
 356         } else {
 357             R3410_ec_params *p = R3410_2001_paramset;
 358             param_nid = OBJ_txt2nid(value);
 359             if (param_nid == NID_undef) {
 360                 return 0;
 361             }
 362             for (; p->nid != NID_undef; p++) {
 363                 if (p->nid == param_nid)
 364                     break;
 365             }
 366             if (p->nid == NID_undef) {
 367                 GOSTerr(GOST_F_PKEY_GOST_EC_CTRL_STR_256,
 368                         GOST_R_INVALID_PARAMSET);
 369                 return 0;
 370             }
 371         }
 372
 373         return pkey_gost_ctrl(ctx, EVP_PKEY_CTRL_GOST_PARAMSET,
 374                               param_nid, NULL);
 375     }
 376
 377     return pkey_gost_ec_ctrl_str_common(ctx, type, value);
 378 }
 379
 380 static int pkey_gost_ec_ctrl_str_512(EVP_PKEY_CTX *ctx,
 381                                      const char *type, const char *value)
 382 {
 383     int param_nid = NID_undef;
 384
 385     if (strcmp(type, param_ctrl_string))
 386       return pkey_gost_ec_ctrl_str_common(ctx, type, value);
 387
 388     if (!value)
 389         return 0;
 390
 391     if (strlen(value) == 1) {
 392         switch (toupper((unsigned char)value[0])) {
 393         case 'A':
 394             param_nid = NID_id_tc26_gost_3410_2012_512_paramSetA;
 395             break;
 396
 397         case 'B':
 398             param_nid = NID_id_tc26_gost_3410_2012_512_paramSetB;
 399             break;
 400
 401         case 'C':
 402             param_nid = NID_id_tc26_gost_3410_2012_512_paramSetC;
 403             break;
 404
 405         default:
 406             return 0;
 407         }
 408     } else {
 409         R3410_ec_params *p = R3410_2012_512_paramset;
 410         param_nid = OBJ_txt2nid(value);
 411         if (param_nid == NID_undef)
 412             return 0;
 413
 414         while (p->nid != NID_undef && p->nid != param_nid)
 415             p++;
 416
 417         if (p->nid == NID_undef) {
 418             GOSTerr(GOST_F_PKEY_GOST_EC_CTRL_STR_512,
 419                     GOST_R_INVALID_PARAMSET);
 420             return 0;
 421         }
 422     }
 423
 424     return pkey_gost_ctrl(ctx, EVP_PKEY_CTRL_GOST_PARAMSET, param_nid, NULL);
 425 }
 426
 427 /* --------------------- key generation  --------------------------------*/
 428
 429 static int pkey_gost_paramgen_init(EVP_PKEY_CTX *ctx)
 430 {
 431     return 1;
 432 }
 433
 434 static int pkey_gost2001_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 435 {
 436     struct gost_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
 437     EC_KEY *ec = NULL;
 438
 439     if (!data || data->sign_param_nid == NID_undef) {
 440         GOSTerr(GOST_F_PKEY_GOST2001_PARAMGEN, GOST_R_NO_PARAMETERS_SET);
 441         return 0;
 442     }
 443
 444     ec = EC_KEY_new();
 445     if (!fill_GOST_EC_params(ec, data->sign_param_nid)
 446         || !EVP_PKEY_assign(pkey, NID_id_GostR3410_2001, ec)) {
 447         EC_KEY_free(ec);
 448         return 0;
 449     }
 450     return 1;
 451 }
 452
 453 static int pkey_gost2012_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 454 {
 455     struct gost_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
 456     EC_KEY *ec;
 457     int result = 0;
 458
 459     if (!data || data->sign_param_nid == NID_undef) {
 460         GOSTerr(GOST_F_PKEY_GOST2012_PARAMGEN, GOST_R_NO_PARAMETERS_SET);
 461         return 0;
 462     }
 463
 464     ec = EC_KEY_new();
 465     if (!fill_GOST_EC_params(ec, data->sign_param_nid)) {
 466         EC_KEY_free(ec);
 467         return 0;
 468     }
 469
 470     switch (data->sign_param_nid) {
 471     case NID_id_tc26_gost_3410_2012_512_paramSetA:
 472     case NID_id_tc26_gost_3410_2012_512_paramSetB:
 473     case NID_id_tc26_gost_3410_2012_512_paramSetC:
 474     case NID_id_tc26_gost_3410_2012_512_paramSetTest:
 475         result =
 476             (EVP_PKEY_assign(pkey, NID_id_GostR3410_2012_512, ec)) ? 1 : 0;
 477         break;
 478
 479     case NID_id_GostR3410_2001_CryptoPro_A_ParamSet:
 480     case NID_id_GostR3410_2001_CryptoPro_B_ParamSet:
 481     case NID_id_GostR3410_2001_CryptoPro_C_ParamSet:
 482     case NID_id_GostR3410_2001_CryptoPro_XchA_ParamSet:
 483     case NID_id_GostR3410_2001_CryptoPro_XchB_ParamSet:
 484     case NID_id_GostR3410_2001_TestParamSet:
 485     case NID_id_tc26_gost_3410_2012_256_paramSetA:
 486     case NID_id_tc26_gost_3410_2012_256_paramSetB:
 487     case NID_id_tc26_gost_3410_2012_256_paramSetC:
 488     case NID_id_tc26_gost_3410_2012_256_paramSetD:
 489         result =
 490             (EVP_PKEY_assign(pkey, NID_id_GostR3410_2012_256, ec)) ? 1 : 0;
 491         break;
 492     default:
 493         result = 0;
 494         break;
 495     }
 496
 497     if (result == 0)
 498         EC_KEY_free(ec);
 499
 500     return result;
 501 }
 502
 503 /* ----------- keygen callbacks --------------------------------------*/
 504 /* Generates GOST_R3410 2001 key and assigns it using specified type */
 505 static int pkey_gost2001cp_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 506 {
 507     EC_KEY *ec;
 508     if (!pkey_gost2001_paramgen(ctx, pkey))
 509         return 0;
 510     ec = EVP_PKEY_get0(pkey);
 511     gost_ec_keygen(ec);
 512     return 1;
 513 }
 514
 515 /* Generates GOST_R3410 2012 key and assigns it using specified type */
 516 static int pkey_gost2012cp_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 517 {
 518     if (!pkey_gost2012_paramgen(ctx, pkey))
 519         return 0;
 520
 521     gost_ec_keygen(EVP_PKEY_get0(pkey));
 522     return 1;
 523 }
 524
 525 /* ----------- sign callbacks --------------------------------------*/
 526 /*
 527  * Packs signature according to Cryptopro rules
 528  * and frees up ECDSA_SIG structure
 529  */
 530 int pack_sign_cp(ECDSA_SIG *s, int order, unsigned char *sig, size_t *siglen)
 531 {
 532     const BIGNUM *sig_r = NULL, *sig_s = NULL;
 533     ECDSA_SIG_get0(s, &sig_r, &sig_s);
 534     *siglen = 2 * order;
 535     memset(sig, 0, *siglen);
 536     store_bignum(sig_s, sig, order);
 537     store_bignum(sig_r, sig + order, order);
 538     ECDSA_SIG_free(s);
 539     return 1;
 540 }
 541
 542 static int pkey_gost_ec_cp_sign(EVP_PKEY_CTX *ctx, unsigned char *sig,
 543                                 size_t *siglen, const unsigned char *tbs,
 544                                 size_t tbs_len)
 545 {
 546     ECDSA_SIG *unpacked_sig = NULL;
 547     EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(ctx);
 548     int order = 0;
 549
 550     if (!siglen)
 551         return 0;
 552     if (!pkey)
 553         return 0;
 554
 555     switch (EVP_PKEY_base_id(pkey)) {
 556     case NID_id_GostR3410_2001:
 557     case NID_id_GostR3410_2001DH:
 558     case NID_id_GostR3410_2012_256:
 559         order = 64;
 560         break;
 561     case NID_id_GostR3410_2012_512:
 562         order = 128;
 563         break;
 564     default:
 565         return 0;
 566     }
 567
 568     if (!sig) {
 569         *siglen = order;
 570         return 1;
 571     }
 572     unpacked_sig = gost_ec_sign(tbs, tbs_len, EVP_PKEY_get0(pkey));
 573     if (!unpacked_sig) {
 574         return 0;
 575     }
 576     return pack_sign_cp(unpacked_sig, order / 2, sig, siglen);
 577 }
 578
 579 /* ------------------- verify callbacks ---------------------------*/
 580 /* Unpack signature according to cryptopro rules  */
 581 ECDSA_SIG *unpack_cp_signature(const unsigned char *sigbuf, size_t siglen)
 582 {
 583     ECDSA_SIG *sig;
 584     BIGNUM *r = NULL, *s = NULL;
 585
 586     sig = ECDSA_SIG_new();
 587     if (sig == NULL) {
 588         GOSTerr(GOST_F_UNPACK_CP_SIGNATURE, ERR_R_MALLOC_FAILURE);
 589         return NULL;
 590     }
 591     s = BN_bin2bn(sigbuf, siglen / 2, NULL);
 592     r = BN_bin2bn(sigbuf + siglen / 2, siglen / 2, NULL);
 593     ECDSA_SIG_set0(sig, r, s);
 594     return sig;
 595 }
 596
 597 static int pkey_gost_ec_cp_verify(EVP_PKEY_CTX *ctx, const unsigned char *sig,
 598                                   size_t siglen, const unsigned char *tbs,
 599                                   size_t tbs_len)
 600 {
 601     int ok = 0;
 602     EVP_PKEY *pub_key = EVP_PKEY_CTX_get0_pkey(ctx);
 603     ECDSA_SIG *s = (sig) ? unpack_cp_signature(sig, siglen) : NULL;
 604     if (!s)
 605         return 0;
 606 #ifdef DEBUG_SIGN
 607     fprintf(stderr, "R=");
 608     BN_print_fp(stderr, ECDSA_SIG_get0_r(s));
 609     fprintf(stderr, "\nS=");
 610     BN_print_fp(stderr, ECDSA_SIG_get0_s(s));
 611     fprintf(stderr, "\n");
 612 #endif
 613     if (pub_key)
 614         ok = gost_ec_verify(tbs, tbs_len, s, EVP_PKEY_get0(pub_key));
 615     ECDSA_SIG_free(s);
 616     return ok;
 617 }
 618
 619 /* ------------- encrypt init -------------------------------------*/
 620 /* Generates ephermeral key */
 621 static int pkey_gost_encrypt_init(EVP_PKEY_CTX *ctx)
 622 {
 623     return 1;
 624 }
 625
 626 /* --------------- Derive init ------------------------------------*/
 627 static int pkey_gost_derive_init(EVP_PKEY_CTX *ctx)
 628 {
 629     return 1;
 630 }
 631
 632 /* -------- PKEY_METHOD for GOST MAC algorithm --------------------*/
 633 static int pkey_gost_mac_init(EVP_PKEY_CTX *ctx)
 634 {
 635     struct gost_mac_pmeth_data *data = OPENSSL_malloc(sizeof(*data));
 636     EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(ctx);
 637
 638     if (!data)
 639         return 0;
 640     memset(data, 0, sizeof(*data));
 641     data->mac_size = 4;
 642     data->mac_param_nid = NID_undef;
 643
 644     if (pkey) {
 645         struct gost_mac_key *key = EVP_PKEY_get0(pkey);
 646         if (key) {
 647             data->mac_param_nid = key->mac_param_nid;
 648             data->mac_size = key->mac_size;
 649         }
 650     }
 651
 652     EVP_PKEY_CTX_set_data(ctx, data);
 653     return 1;
 654 }
 655
 656 static int pkey_gost_omac_init(EVP_PKEY_CTX *ctx, size_t mac_size)
 657 {
 658     struct gost_mac_pmeth_data *data = OPENSSL_malloc(sizeof(*data));
 659     EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(ctx);
 660
 661     if (!data)
 662         return 0;
 663     memset(data, 0, sizeof(*data));
 664     data->mac_size = mac_size;
 665     data->mac_param_nid = NID_undef;
 666
 667     if (pkey) {
 668         struct gost_mac_key *key = EVP_PKEY_get0(pkey);
 669         if (key) {
 670             data->mac_param_nid = key->mac_param_nid;
 671             data->mac_size = key->mac_size;
 672         }
 673     }
 674
 675     EVP_PKEY_CTX_set_data(ctx, data);
 676     return 1;
 677 }
 678
 679 static int pkey_gost_magma_mac_init(EVP_PKEY_CTX *ctx)
 680 {
 681     return pkey_gost_omac_init(ctx, 8);
 682 }
 683
 684 static int pkey_gost_grasshopper_mac_init(EVP_PKEY_CTX *ctx)
 685 {
 686     return pkey_gost_omac_init(ctx, 16);
 687 }
 688
 689 static void pkey_gost_mac_cleanup(EVP_PKEY_CTX *ctx)
 690 {
 691     struct gost_mac_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
 692     if (data)
 693         OPENSSL_free(data);
 694 }
 695
 696 static int pkey_gost_mac_copy(EVP_PKEY_CTX *dst, ossl3_const EVP_PKEY_CTX *src)
 697 {
 698     struct gost_mac_pmeth_data *dst_data, *src_data;
 699     if (!pkey_gost_mac_init(dst)) {
 700         return 0;
 701     }
 702     src_data = EVP_PKEY_CTX_get_data(src);
 703     dst_data = EVP_PKEY_CTX_get_data(dst);
 704     if (!src_data || !dst_data)
 705         return 0;
 706
 707     *dst_data = *src_data;
 708     return 1;
 709 }
 710
 711 static int pkey_gost_mac_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 712 {
 713     struct gost_mac_pmeth_data *data =
 714         (struct gost_mac_pmeth_data *)EVP_PKEY_CTX_get_data(ctx);
 715
 716     switch (type) {
 717     case EVP_PKEY_CTRL_MD:
 718         {
 719             int nid = EVP_MD_type((const EVP_MD *)p2);
 720             if (nid != NID_id_Gost28147_89_MAC && nid != NID_gost_mac_12) {
 721                 GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL,
 722                         GOST_R_INVALID_DIGEST_TYPE);
 723                 return 0;
 724             }
 725             data->md = (EVP_MD *)p2;
 726             return 1;
 727         }
 728
 729     case EVP_PKEY_CTRL_GET_MD:
 730         *(const EVP_MD **)p2 = data->md;
 731         return 1;
 732
 733     case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
 734     case EVP_PKEY_CTRL_PKCS7_DECRYPT:
 735     case EVP_PKEY_CTRL_PKCS7_SIGN:
 736         return 1;
 737     case EVP_PKEY_CTRL_SET_MAC_KEY:
 738         if (p1 != 32) {
 739             GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL, GOST_R_INVALID_MAC_KEY_LENGTH);
 740             return 0;
 741         }
 742
 743         memcpy(data->key, p2, 32);
 744         data->key_set = 1;
 745         return 1;
 746     case EVP_PKEY_CTRL_GOST_PARAMSET:
 747         {
 748             struct gost_cipher_info *param = p2;
 749             data->mac_param_nid = param->nid;
 750             return 1;
 751         }
 752     case EVP_PKEY_CTRL_DIGESTINIT:
 753         {
 754             EVP_MD_CTX *mctx = p2;
 755             if (!data->key_set) {
 756                 struct gost_mac_key *key;
 757                 EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(ctx);
 758                 if (!pkey) {
 759                     GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL,
 760                             GOST_R_MAC_KEY_NOT_SET);
 761                     return 0;
 762                 }
 763                 key = EVP_PKEY_get0(pkey);
 764                 if (!key) {
 765                     GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL,
 766                             GOST_R_MAC_KEY_NOT_SET);
 767                     return 0;
 768                 }
 769                 return EVP_MD_meth_get_ctrl(EVP_MD_CTX_md(mctx))
 770                     (mctx, EVP_MD_CTRL_SET_KEY, 0, key);
 771             } else {
 772                 return EVP_MD_meth_get_ctrl(EVP_MD_CTX_md(mctx))
 773                     (mctx, EVP_MD_CTRL_SET_KEY, 32, &(data->key));
 774             }
 775         }
 776     case EVP_PKEY_CTRL_MAC_LEN:
 777         {
 778             if (p1 < 1 || p1 > 8) {
 779
 780                 GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL, GOST_R_INVALID_MAC_SIZE);
 781                 return 0;
 782             }
 783             data->mac_size = p1;
 784             return 1;
 785         }
 786     }
 787     return -2;
 788 }
 789
 790 static int pkey_gost_mac_ctrl_str(EVP_PKEY_CTX *ctx,
 791                                   const char *type, const char *value)
 792 {
 793     if (strcmp(type, key_ctrl_string) == 0) {
 794         if (strlen(value) != 32) {
 795             GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL_STR,
 796                     GOST_R_INVALID_MAC_KEY_LENGTH);
 797             return 0;
 798         }
 799         return pkey_gost_mac_ctrl(ctx, EVP_PKEY_CTRL_SET_MAC_KEY,
 800                                   32, (char *)value);
 801     }
 802     if (strcmp(type, hexkey_ctrl_string) == 0) {
 803         long keylen;
 804         int ret;
 805         unsigned char *keybuf = string_to_hex(value, &keylen);
 806         if (!keybuf || keylen != 32) {
 807             GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL_STR,
 808                     GOST_R_INVALID_MAC_KEY_LENGTH);
 809             OPENSSL_free(keybuf);
 810             return 0;
 811         }
 812         ret = pkey_gost_mac_ctrl(ctx, EVP_PKEY_CTRL_SET_MAC_KEY, 32, keybuf);
 813         OPENSSL_free(keybuf);
 814         return ret;
 815
 816     }
 817     if (!strcmp(type, maclen_ctrl_string)) {
 818         char *endptr;
 819         long size = strtol(value, &endptr, 10);
 820         if (*endptr != '\0') {
 821             GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL_STR, GOST_R_INVALID_MAC_SIZE);
 822             return 0;
 823         }
 824         return pkey_gost_mac_ctrl(ctx, EVP_PKEY_CTRL_MAC_LEN, size, NULL);
 825     }
 826     if (strcmp(type, param_ctrl_string) == 0) {
 827         ASN1_OBJECT *obj = OBJ_txt2obj(value, 0);
 828         const struct gost_cipher_info *param = NULL;
 829         if (obj == NULL) {
 830             GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL_STR, GOST_R_INVALID_MAC_PARAMS);
 831             return 0;
 832         }
 833
 834         param = get_encryption_params(obj);
 835         ASN1_OBJECT_free(obj);
 836         if (param == NULL) {
 837             GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL_STR, GOST_R_INVALID_MAC_PARAMS);
 838             return 0;
 839         }
 840
 841
 842         return pkey_gost_mac_ctrl(ctx, EVP_PKEY_CTRL_GOST_PARAMSET, 0,
 843                                   (void *)param);
 844     }
 845     return -2;
 846 }
 847
 848 static int pkey_gost_omac_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2, size_t max_size)
 849 {
 850     struct gost_mac_pmeth_data *data =
 851         (struct gost_mac_pmeth_data *)EVP_PKEY_CTX_get_data(ctx);
 852
 853     switch (type) {
 854     case EVP_PKEY_CTRL_MD:
 855         {
 856             int nid = EVP_MD_type((const EVP_MD *)p2);
 857             if (nid != NID_magma_mac && nid != NID_grasshopper_mac
 858                 && nid != NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac /* FIXME beldmit */
 859                 && nid != NID_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac) {
 860                 GOSTerr(GOST_F_PKEY_GOST_OMAC_CTRL,
 861                         GOST_R_INVALID_DIGEST_TYPE);
 862                 return 0;
 863             }
 864             data->md = (EVP_MD *)p2;
 865             return 1;
 866         }
 867
 868     case EVP_PKEY_CTRL_GET_MD:
 869         *(const EVP_MD **)p2 = data->md;
 870         return 1;
 871
 872     case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
 873     case EVP_PKEY_CTRL_PKCS7_DECRYPT:
 874     case EVP_PKEY_CTRL_PKCS7_SIGN:
 875         return 1;
 876     case EVP_PKEY_CTRL_SET_MAC_KEY:
 877         if (p1 != 32) {
 878             GOSTerr(GOST_F_PKEY_GOST_OMAC_CTRL, GOST_R_INVALID_MAC_KEY_LENGTH);
 879             return 0;
 880         }
 881
 882         memcpy(data->key, p2, 32);
 883         data->key_set = 1;
 884         return 1;
 885     case EVP_PKEY_CTRL_DIGESTINIT:
 886         {
 887             EVP_MD_CTX *mctx = p2;
 888             if (!data->key_set) {
 889                 struct gost_mac_key *key;
 890                 EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(ctx);
 891                 if (!pkey) {
 892                     GOSTerr(GOST_F_PKEY_GOST_OMAC_CTRL,
 893                             GOST_R_MAC_KEY_NOT_SET);
 894                     return 0;
 895                 }
 896                 key = EVP_PKEY_get0(pkey);
 897                 if (!key) {
 898                     GOSTerr(GOST_F_PKEY_GOST_OMAC_CTRL,
 899                             GOST_R_MAC_KEY_NOT_SET);
 900                     return 0;
 901                 }
 902                 return EVP_MD_meth_get_ctrl(EVP_MD_CTX_md(mctx))
 903                     (mctx, EVP_MD_CTRL_SET_KEY, 0, key);
 904             } else {
 905                 return EVP_MD_meth_get_ctrl(EVP_MD_CTX_md(mctx))
 906                     (mctx, EVP_MD_CTRL_SET_KEY, 32, &(data->key));
 907             }
 908         }
 909     case EVP_PKEY_CTRL_MAC_LEN:
 910         {
 911             if (p1 < 1 || p1 > max_size) {
 912
 913                 GOSTerr(GOST_F_PKEY_GOST_OMAC_CTRL, GOST_R_INVALID_MAC_SIZE);
 914                 return 0;
 915             }
 916             data->mac_size = p1;
 917             return 1;
 918         }
 919     }
 920     return -2;
 921 }
 922
 923 static int pkey_gost_magma_mac_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 924 {
 925     return pkey_gost_omac_ctrl(ctx, type, p1, p2, 8);
 926 }
 927
 928 static int pkey_gost_grasshopper_mac_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 929 {
 930     return pkey_gost_omac_ctrl(ctx, type, p1, p2, 16);
 931 }
 932
 933 static int pkey_gost_omac_ctrl_str(EVP_PKEY_CTX *ctx,
 934                                   const char *type, const char *value, size_t max_size)
 935 {
 936     if (strcmp(type, key_ctrl_string) == 0) {
 937         if (strlen(value) != 32) {
 938             GOSTerr(GOST_F_PKEY_GOST_OMAC_CTRL_STR,
 939                     GOST_R_INVALID_MAC_KEY_LENGTH);
 940             return 0;
 941         }
 942         return pkey_gost_mac_ctrl(ctx, EVP_PKEY_CTRL_SET_MAC_KEY,
 943                                   32, (char *)value);
 944     }
 945     if (strcmp(type, hexkey_ctrl_string) == 0) {
 946         long keylen;
 947         int ret;
 948         unsigned char *keybuf = string_to_hex(value, &keylen);
 949         if (!keybuf || keylen != 32) {
 950             GOSTerr(GOST_F_PKEY_GOST_OMAC_CTRL_STR,
 951                     GOST_R_INVALID_MAC_KEY_LENGTH);
 952             OPENSSL_free(keybuf);
 953             return 0;
 954         }
 955         ret = pkey_gost_mac_ctrl(ctx, EVP_PKEY_CTRL_SET_MAC_KEY, 32, keybuf);
 956         OPENSSL_free(keybuf);
 957         return ret;
 958
 959     }
 960     if (!strcmp(type, maclen_ctrl_string)) {
 961         char *endptr;
 962         long size = strtol(value, &endptr, 10);
 963         if (*endptr != '\0') {
 964             GOSTerr(GOST_F_PKEY_GOST_OMAC_CTRL_STR, GOST_R_INVALID_MAC_SIZE);
 965             return 0;
 966         }
 967         return pkey_gost_omac_ctrl(ctx, EVP_PKEY_CTRL_MAC_LEN, size, NULL, max_size);
 968     }
 969     return -2;
 970 }
 971
 972 static int pkey_gost_magma_mac_ctrl_str(EVP_PKEY_CTX *ctx,
 973                                   const char *type, const char *value)
 974 {
 975     return pkey_gost_omac_ctrl_str(ctx, type, value, 8);
 976 }
 977
 978 static int pkey_gost_grasshopper_mac_ctrl_str(EVP_PKEY_CTX *ctx,
 979                                   const char *type, const char *value)
 980 {
 981     return pkey_gost_omac_ctrl_str(ctx, type, value, 8);
 982 }
 983
 984 static int pkey_gost_mac_keygen_base(EVP_PKEY_CTX *ctx,
 985                                      EVP_PKEY *pkey, int mac_nid)
 986 {
 987     struct gost_mac_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
 988     struct gost_mac_key *keydata;
 989     if (!data || !data->key_set) {
 990         GOSTerr(GOST_F_PKEY_GOST_MAC_KEYGEN_BASE, GOST_R_MAC_KEY_NOT_SET);
 991         return 0;
 992     }
 993     keydata = OPENSSL_malloc(sizeof(struct gost_mac_key));
 994     if (keydata == NULL)
 995         return 0;
 996     memcpy(keydata->key, data->key, 32);
 997     keydata->mac_param_nid = data->mac_param_nid;
 998     keydata->mac_size = data->mac_size;
 999     EVP_PKEY_assign(pkey, mac_nid, keydata);
1000     return 1;
1001 }
1002
1003 static int pkey_gost_mac_keygen_12(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
1004 {
1005     return pkey_gost_mac_keygen_base(ctx, pkey, NID_gost_mac_12);
1006 }
1007
1008 static int pkey_gost_mac_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
1009 {
1010     return pkey_gost_mac_keygen_base(ctx, pkey, NID_id_Gost28147_89_MAC);
1011 }
1012
1013 static int pkey_gost_magma_mac_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
1014 {
1015     return pkey_gost_mac_keygen_base(ctx, pkey, NID_magma_mac);
1016 }
1017
1018 static int pkey_gost_grasshopper_mac_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
1019 {
1020     return pkey_gost_mac_keygen_base(ctx, pkey, NID_grasshopper_mac);
1021 }
1022
1023 static int pkey_gost_mac_signctx_init(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx)
1024 {
1025     struct gost_mac_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
1026
1027     if (data == NULL) {
1028         pkey_gost_mac_init(ctx);
1029     }
1030
1031     data = EVP_PKEY_CTX_get_data(ctx);
1032     if (!data) {
1033         GOSTerr(GOST_F_PKEY_GOST_MAC_SIGNCTX_INIT, GOST_R_MAC_KEY_NOT_SET);
1034         return 0;
1035     }
1036
1037     return 1;
1038 }
1039
1040 static int pkey_gost_magma_mac_signctx_init(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx)
1041 {
1042     struct gost_mac_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
1043
1044     if (data == NULL) {
1045         pkey_gost_omac_init(ctx, 4);
1046     }
1047
1048     data = EVP_PKEY_CTX_get_data(ctx);
1049     if (!data) {
1050         GOSTerr(GOST_F_PKEY_GOST_MAGMA_MAC_SIGNCTX_INIT, GOST_R_MAC_KEY_NOT_SET);
1051         return 0;
1052     }
1053
1054     return 1;
1055 }
1056
1057 static int pkey_gost_grasshopper_mac_signctx_init(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx)
1058 {
1059     struct gost_mac_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
1060
1061     if (data == NULL) {
1062         pkey_gost_omac_init(ctx, 8);
1063     }
1064
1065     data = EVP_PKEY_CTX_get_data(ctx);
1066     if (!data) {
1067         GOSTerr(GOST_F_PKEY_GOST_GRASSHOPPER_MAC_SIGNCTX_INIT, GOST_R_MAC_KEY_NOT_SET);
1068         return 0;
1069     }
1070
1071     return 1;
1072 }
1073
1074 static int pkey_gost_mac_signctx(EVP_PKEY_CTX *ctx, unsigned char *sig,
1075                                  size_t *siglen, EVP_MD_CTX *mctx)
1076 {
1077     unsigned int tmpsiglen;
1078     int ret;
1079     struct gost_mac_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
1080
1081     if (!siglen)
1082         return 0;
1083     tmpsiglen = *siglen;        /* for platforms where sizeof(int) !=
1084                                  * sizeof(size_t) */
1085
1086     if (!sig) {
1087         *siglen = data->mac_size;
1088         return 1;
1089     }
1090
1091     EVP_MD_meth_get_ctrl(EVP_MD_CTX_md(mctx))
1092         (mctx, EVP_MD_CTRL_XOF_LEN, data->mac_size, NULL);
1093     ret = EVP_DigestFinal_ex(mctx, sig, &tmpsiglen);
1094     *siglen = data->mac_size;
1095     return ret;
1096 }
1097
1098 /* ----------- misc callbacks -------------------------------------*/
1099
1100 /* Callback for both EVP_PKEY_check() and EVP_PKEY_public_check. */
1101 static int pkey_gost_check(EVP_PKEY *pkey)
1102 {
1103     return EC_KEY_check_key(EVP_PKEY_get0(pkey));
1104 }
1105
1106 /* ----------------------------------------------------------------*/
1107 int register_pmeth_gost(int id, EVP_PKEY_METHOD **pmeth, int flags)
1108 {
1109     *pmeth = EVP_PKEY_meth_new(id, flags);
1110     if (!*pmeth)
1111         return 0;
1112
1113     switch (id) {
1114     case NID_id_GostR3410_2001:
1115     case NID_id_GostR3410_2001DH:
1116         EVP_PKEY_meth_set_ctrl(*pmeth,
1117                                pkey_gost_ctrl, pkey_gost_ec_ctrl_str_256);
1118         EVP_PKEY_meth_set_sign(*pmeth, NULL, pkey_gost_ec_cp_sign);
1119         EVP_PKEY_meth_set_verify(*pmeth, NULL, pkey_gost_ec_cp_verify);
1120
1121         EVP_PKEY_meth_set_keygen(*pmeth, NULL, pkey_gost2001cp_keygen);
1122
1123         EVP_PKEY_meth_set_encrypt(*pmeth,
1124                                   pkey_gost_encrypt_init,
1125                                   pkey_gost_encrypt);
1126         EVP_PKEY_meth_set_decrypt(*pmeth, NULL, pkey_gost_decrypt);
1127         EVP_PKEY_meth_set_derive(*pmeth,
1128                                  pkey_gost_derive_init, pkey_gost_ec_derive);
1129         EVP_PKEY_meth_set_paramgen(*pmeth, pkey_gost_paramgen_init,
1130                                    pkey_gost2001_paramgen);
1131     EVP_PKEY_meth_set_check(*pmeth, pkey_gost_check);
1132     EVP_PKEY_meth_set_public_check(*pmeth, pkey_gost_check);
1133         break;
1134     case NID_id_GostR3410_2012_256:
1135         EVP_PKEY_meth_set_ctrl(*pmeth,
1136                                pkey_gost_ctrl, pkey_gost_ec_ctrl_str_256);
1137         EVP_PKEY_meth_set_sign(*pmeth, NULL, pkey_gost_ec_cp_sign);
1138         EVP_PKEY_meth_set_verify(*pmeth, NULL, pkey_gost_ec_cp_verify);
1139
1140         EVP_PKEY_meth_set_keygen(*pmeth, NULL, pkey_gost2012cp_keygen);
1141
1142         EVP_PKEY_meth_set_encrypt(*pmeth,
1143                                   pkey_gost_encrypt_init,
1144                                   pkey_gost_encrypt);
1145         EVP_PKEY_meth_set_decrypt(*pmeth, NULL, pkey_gost_decrypt);
1146         EVP_PKEY_meth_set_derive(*pmeth,
1147                                  pkey_gost_derive_init, pkey_gost_ec_derive);
1148         EVP_PKEY_meth_set_paramgen(*pmeth,
1149                                    pkey_gost_paramgen_init,
1150                                    pkey_gost2012_paramgen);
1151     EVP_PKEY_meth_set_check(*pmeth, pkey_gost_check);
1152     EVP_PKEY_meth_set_public_check(*pmeth, pkey_gost_check);
1153         break;
1154     case NID_id_GostR3410_2012_512:
1155         EVP_PKEY_meth_set_ctrl(*pmeth,
1156                                pkey_gost_ctrl, pkey_gost_ec_ctrl_str_512);
1157         EVP_PKEY_meth_set_sign(*pmeth, NULL, pkey_gost_ec_cp_sign);
1158         EVP_PKEY_meth_set_verify(*pmeth, NULL, pkey_gost_ec_cp_verify);
1159
1160         EVP_PKEY_meth_set_keygen(*pmeth, NULL, pkey_gost2012cp_keygen);
1161
1162         EVP_PKEY_meth_set_encrypt(*pmeth,
1163                                   pkey_gost_encrypt_init,
1164                                   pkey_gost_encrypt);
1165         EVP_PKEY_meth_set_decrypt(*pmeth, NULL, pkey_gost_decrypt);
1166         EVP_PKEY_meth_set_derive(*pmeth,
1167                                  pkey_gost_derive_init, pkey_gost_ec_derive);
1168         EVP_PKEY_meth_set_paramgen(*pmeth,
1169                                    pkey_gost_paramgen_init,
1170                                    pkey_gost2012_paramgen);
1171     EVP_PKEY_meth_set_check(*pmeth, pkey_gost_check);
1172     EVP_PKEY_meth_set_public_check(*pmeth, pkey_gost_check);
1173         break;
1174     case NID_id_Gost28147_89_MAC:
1175         EVP_PKEY_meth_set_ctrl(*pmeth, pkey_gost_mac_ctrl,
1176                                pkey_gost_mac_ctrl_str);
1177         EVP_PKEY_meth_set_signctx(*pmeth, pkey_gost_mac_signctx_init,
1178                                   pkey_gost_mac_signctx);
1179         EVP_PKEY_meth_set_keygen(*pmeth, NULL, pkey_gost_mac_keygen);
1180         EVP_PKEY_meth_set_init(*pmeth, pkey_gost_mac_init);
1181         EVP_PKEY_meth_set_cleanup(*pmeth, pkey_gost_mac_cleanup);
1182         EVP_PKEY_meth_set_copy(*pmeth, pkey_gost_mac_copy);
1183         return 1;
1184     case NID_gost_mac_12:
1185         EVP_PKEY_meth_set_ctrl(*pmeth, pkey_gost_mac_ctrl,
1186                                pkey_gost_mac_ctrl_str);
1187         EVP_PKEY_meth_set_signctx(*pmeth, pkey_gost_mac_signctx_init,
1188                                   pkey_gost_mac_signctx);
1189         EVP_PKEY_meth_set_keygen(*pmeth, NULL, pkey_gost_mac_keygen_12);
1190         EVP_PKEY_meth_set_init(*pmeth, pkey_gost_mac_init);
1191         EVP_PKEY_meth_set_cleanup(*pmeth, pkey_gost_mac_cleanup);
1192         EVP_PKEY_meth_set_copy(*pmeth, pkey_gost_mac_copy);
1193         return 1;
1194     case NID_magma_mac:
1195         EVP_PKEY_meth_set_ctrl(*pmeth, pkey_gost_magma_mac_ctrl,
1196                                pkey_gost_magma_mac_ctrl_str);
1197         EVP_PKEY_meth_set_signctx(*pmeth, pkey_gost_magma_mac_signctx_init,
1198                                   pkey_gost_mac_signctx);
1199         EVP_PKEY_meth_set_keygen(*pmeth, NULL, pkey_gost_magma_mac_keygen);
1200         EVP_PKEY_meth_set_init(*pmeth, pkey_gost_magma_mac_init);
1201         EVP_PKEY_meth_set_cleanup(*pmeth, pkey_gost_mac_cleanup);
1202         EVP_PKEY_meth_set_copy(*pmeth, pkey_gost_mac_copy);
1203         return 1;
1204     case NID_grasshopper_mac:
1205     case NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac: /* FIXME beldmit */
1206         EVP_PKEY_meth_set_ctrl(*pmeth, pkey_gost_grasshopper_mac_ctrl,
1207                                pkey_gost_grasshopper_mac_ctrl_str);
1208         EVP_PKEY_meth_set_signctx(*pmeth, pkey_gost_grasshopper_mac_signctx_init,
1209                                   pkey_gost_mac_signctx);
1210         EVP_PKEY_meth_set_keygen(*pmeth, NULL, pkey_gost_grasshopper_mac_keygen);
1211         EVP_PKEY_meth_set_init(*pmeth, pkey_gost_grasshopper_mac_init);
1212         EVP_PKEY_meth_set_cleanup(*pmeth, pkey_gost_mac_cleanup);
1213         EVP_PKEY_meth_set_copy(*pmeth, pkey_gost_mac_copy);
1214         return 1;
1215     default:                   /* Unsupported method */
1216         return 0;
1217     }
1218     EVP_PKEY_meth_set_init(*pmeth, pkey_gost_init);
1219     EVP_PKEY_meth_set_cleanup(*pmeth, pkey_gost_cleanup);
1220
1221     EVP_PKEY_meth_set_copy(*pmeth, pkey_gost_copy);
1222     /*
1223      * FIXME derive etc...
1224      */
1225
1226     return 1;
1227 }