engines/ccgost/gost_pmeth.c

   1 /**********************************************************************
   2  *                          gost_pmeth.c                              *
   3  *             Copyright (c) 2005-2006 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 0.9.9 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 <stdlib.h>
  16 #include <string.h>
  17 #include <ctype.h>
  18 #include "gost_lcl.h"
  19 #include "e_gost_err.h"
  20 /* -----init, cleanup, copy - uniform for all algs  ---------------*/
  21 /* Allocates new gost_pmeth_data structure and assigns it as data */
  22 static int pkey_gost_init(EVP_PKEY_CTX *ctx)
  23 {
  24     struct gost_pmeth_data *data;
  25     EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(ctx);
  26
  27     data = OPENSSL_malloc(sizeof(*data));
  28     if (!data)
  29         return 0;
  30     memset(data, 0, sizeof(*data));
  31     if (pkey && EVP_PKEY_get0(pkey)) {
  32         switch (EVP_PKEY_base_id(pkey)) {
  33         case NID_id_GostR3410_2001:
  34             data->sign_param_nid =
  35                 EC_GROUP_get_curve_name(EC_KEY_get0_group
  36                                         (EVP_PKEY_get0((EVP_PKEY *)pkey)));
  37             break;
  38         default:
  39             return 0;
  40         }
  41     }
  42     EVP_PKEY_CTX_set_data(ctx, data);
  43     return 1;
  44 }
  45
  46 /* Copies contents of gost_pmeth_data structure */
  47 static int pkey_gost_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
  48 {
  49     struct gost_pmeth_data *dst_data, *src_data;
  50     if (!pkey_gost_init(dst)) {
  51         return 0;
  52     }
  53     src_data = EVP_PKEY_CTX_get_data(src);
  54     dst_data = EVP_PKEY_CTX_get_data(dst);
  55     *dst_data = *src_data;
  56     if (src_data->shared_ukm) {
  57         dst_data->shared_ukm = NULL;
  58     }
  59     return 1;
  60 }
  61
  62 /* Frees up gost_pmeth_data structure */
  63 static void pkey_gost_cleanup(EVP_PKEY_CTX *ctx)
  64 {
  65     struct gost_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
  66
  67     OPENSSL_free(data->shared_ukm);
  68     OPENSSL_free(data);
  69 }
  70
  71 /* --------------------- control functions  ------------------------------*/
  72 static int pkey_gost_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
  73 {
  74     struct gost_pmeth_data *pctx =
  75         (struct gost_pmeth_data *)EVP_PKEY_CTX_get_data(ctx);
  76     switch (type) {
  77     case EVP_PKEY_CTRL_MD:
  78         {
  79             if (EVP_MD_type((const EVP_MD *)p2) != NID_id_GostR3411_94) {
  80                 GOSTerr(GOST_F_PKEY_GOST_CTRL, GOST_R_INVALID_DIGEST_TYPE);
  81                 return 0;
  82             }
  83             pctx->md = (EVP_MD *)p2;
  84             return 1;
  85         }
  86
  87     case EVP_PKEY_CTRL_GET_MD:
  88         *(const EVP_MD **)p2 = pctx->md;
  89         return 1;
  90
  91     case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
  92     case EVP_PKEY_CTRL_PKCS7_DECRYPT:
  93     case EVP_PKEY_CTRL_PKCS7_SIGN:
  94     case EVP_PKEY_CTRL_DIGESTINIT:
  95 #ifndef OPENSSL_NO_CMS
  96     case EVP_PKEY_CTRL_CMS_ENCRYPT:
  97     case EVP_PKEY_CTRL_CMS_DECRYPT:
  98     case EVP_PKEY_CTRL_CMS_SIGN:
  99 #endif
 100         return 1;
 101
 102     case EVP_PKEY_CTRL_GOST_PARAMSET:
 103         pctx->sign_param_nid = (int)p1;
 104         return 1;
 105     case EVP_PKEY_CTRL_SET_IV:
 106         pctx->shared_ukm = OPENSSL_malloc((int)p1);
 107         if (pctx->shared_ukm == NULL) {
 108             GOSTerr(GOST_F_PKEY_GOST_CTRL, ERR_R_MALLOC_FAILURE);
 109             return 0;
 110         }
 111         memcpy(pctx->shared_ukm, p2, (int)p1);
 112         return 1;
 113     case EVP_PKEY_CTRL_PEER_KEY:
 114         if (p1 == 0 || p1 == 1) /* call from EVP_PKEY_derive_set_peer */
 115             return 1;
 116         if (p1 == 2)            /* TLS: peer key used? */
 117             return pctx->peer_key_used;
 118         if (p1 == 3)            /* TLS: peer key used! */
 119             return (pctx->peer_key_used = 1);
 120         return -2;
 121     }
 122     return -2;
 123 }
 124
 125 static int pkey_gost_ctrl01_str(EVP_PKEY_CTX *ctx,
 126                                 const char *type, const char *value)
 127 {
 128     int param_nid = 0;
 129
 130     if (strcmp(type, param_ctrl_string) == 0) {
 131         if (!value) {
 132             return 0;
 133         }
 134         if (strlen(value) == 1) {
 135             switch (toupper((unsigned char)value[0])) {
 136             case 'A':
 137                 param_nid = NID_id_GostR3410_2001_CryptoPro_A_ParamSet;
 138                 break;
 139             case 'B':
 140                 param_nid = NID_id_GostR3410_2001_CryptoPro_B_ParamSet;
 141                 break;
 142             case 'C':
 143                 param_nid = NID_id_GostR3410_2001_CryptoPro_C_ParamSet;
 144                 break;
 145             case '0':
 146                 param_nid = NID_id_GostR3410_2001_TestParamSet;
 147                 break;
 148             default:
 149                 return 0;
 150             }
 151         } else if ((strlen(value) == 2)
 152                    && (toupper((unsigned char)value[0]) == 'X')) {
 153             switch (toupper((unsigned char)value[1])) {
 154             case 'A':
 155                 param_nid = NID_id_GostR3410_2001_CryptoPro_XchA_ParamSet;
 156                 break;
 157             case 'B':
 158                 param_nid = NID_id_GostR3410_2001_CryptoPro_XchB_ParamSet;
 159                 break;
 160             default:
 161                 return 0;
 162             }
 163         } else {
 164             R3410_2001_params *p = R3410_2001_paramset;
 165             param_nid = OBJ_txt2nid(value);
 166             if (param_nid == NID_undef) {
 167                 return 0;
 168             }
 169             for (; p->nid != NID_undef; p++) {
 170                 if (p->nid == param_nid)
 171                     break;
 172             }
 173             if (p->nid == NID_undef) {
 174                 GOSTerr(GOST_F_PKEY_GOST_CTRL01_STR, GOST_R_INVALID_PARAMSET);
 175                 return 0;
 176             }
 177         }
 178
 179         return pkey_gost_ctrl(ctx, EVP_PKEY_CTRL_GOST_PARAMSET,
 180                               param_nid, NULL);
 181     }
 182     return -2;
 183 }
 184
 185 /* --------------------- key generation  --------------------------------*/
 186
 187 static int pkey_gost_paramgen_init(EVP_PKEY_CTX *ctx)
 188 {
 189     return 1;
 190 }
 191
 192 static int pkey_gost01_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 193 {
 194     struct gost_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
 195     EC_KEY *ec = NULL;
 196
 197     if (data->sign_param_nid == NID_undef) {
 198         GOSTerr(GOST_F_PKEY_GOST01_PARAMGEN, GOST_R_NO_PARAMETERS_SET);
 199         return 0;
 200     }
 201     if (!ec)
 202         ec = EC_KEY_new();
 203     if (!fill_GOST2001_params(ec, data->sign_param_nid)) {
 204         EC_KEY_free(ec);
 205         return 0;
 206     }
 207     EVP_PKEY_assign(pkey, NID_id_GostR3410_2001, ec);
 208     return 1;
 209 }
 210
 211 /* Generates GOST_R3410 2001 key and assigns it using specified type */
 212 static int pkey_gost01cp_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 213 {
 214     EC_KEY *ec;
 215     if (!pkey_gost01_paramgen(ctx, pkey))
 216         return 0;
 217     ec = EVP_PKEY_get0(pkey);
 218     gost2001_keygen(ec);
 219     return 1;
 220 }
 221
 222 /* ----------- sign callbacks --------------------------------------*/
 223 /*
 224  * Packs signature according to Cryptopro rules
 225  * and frees up DSA_SIG structure
 226  */
 227 int pack_sign_cp(DSA_SIG *s, int order, unsigned char *sig, size_t *siglen)
 228 {
 229     *siglen = 2 * order;
 230     memset(sig, 0, *siglen);
 231     store_bignum(s->s, sig, order);
 232     store_bignum(s->r, sig + order, order);
 233     DSA_SIG_free(s);
 234     return 1;
 235 }
 236
 237
 238 static int pkey_gost01_cp_sign(EVP_PKEY_CTX *ctx, unsigned char *sig,
 239                                size_t *siglen, const unsigned char *tbs,
 240                                size_t tbs_len)
 241 {
 242     DSA_SIG *unpacked_sig = NULL;
 243     EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(ctx);
 244     if (!siglen)
 245         return 0;
 246     if (!sig) {
 247         *siglen = 64;           /* better to check size of curve order */
 248         return 1;
 249     }
 250     unpacked_sig = gost2001_do_sign(tbs, tbs_len, EVP_PKEY_get0(pkey));
 251     if (!unpacked_sig) {
 252         return 0;
 253     }
 254     return pack_sign_cp(unpacked_sig, 32, sig, siglen);
 255 }
 256
 257 /* ------------------- verify callbacks ---------------------------*/
 258 /* Unpack signature according to cryptopro rules  */
 259 DSA_SIG *unpack_cp_signature(const unsigned char *sig, size_t siglen)
 260 {
 261     DSA_SIG *s;
 262
 263     s = DSA_SIG_new();
 264     if (s == NULL) {
 265         GOSTerr(GOST_F_UNPACK_CP_SIGNATURE, ERR_R_MALLOC_FAILURE);
 266         return NULL;
 267     }
 268     s->s = BN_bin2bn(sig, siglen / 2, NULL);
 269     s->r = BN_bin2bn(sig + siglen / 2, siglen / 2, NULL);
 270     return s;
 271 }
 272
 273
 274 static int pkey_gost01_cp_verify(EVP_PKEY_CTX *ctx, const unsigned char *sig,
 275                                  size_t siglen, const unsigned char *tbs,
 276                                  size_t tbs_len)
 277 {
 278     int ok = 0;
 279     EVP_PKEY *pub_key = EVP_PKEY_CTX_get0_pkey(ctx);
 280     DSA_SIG *s = unpack_cp_signature(sig, siglen);
 281     if (!s)
 282         return 0;
 283 #ifdef DEBUG_SIGN
 284     fprintf(stderr, "R=");
 285     BN_print_fp(stderr, s->r);
 286     fprintf(stderr, "\nS=");
 287     BN_print_fp(stderr, s->s);
 288     fprintf(stderr, "\n");
 289 #endif
 290     if (pub_key)
 291         ok = gost2001_do_verify(tbs, tbs_len, s, EVP_PKEY_get0(pub_key));
 292     DSA_SIG_free(s);
 293     return ok;
 294 }
 295
 296 /* ------------- encrypt init -------------------------------------*/
 297 /* Generates ephermeral key */
 298 static int pkey_gost_encrypt_init(EVP_PKEY_CTX *ctx)
 299 {
 300     return 1;
 301 }
 302
 303 /* --------------- Derive init ------------------------------------*/
 304 static int pkey_gost_derive_init(EVP_PKEY_CTX *ctx)
 305 {
 306     return 1;
 307 }
 308
 309 /* -------- PKEY_METHOD for GOST MAC algorithm --------------------*/
 310 static int pkey_gost_mac_init(EVP_PKEY_CTX *ctx)
 311 {
 312     struct gost_mac_pmeth_data *data = OPENSSL_malloc(sizeof(*data));
 313
 314     if (!data)
 315         return 0;
 316     memset(data, 0, sizeof(*data));
 317     EVP_PKEY_CTX_set_data(ctx, data);
 318     return 1;
 319 }
 320
 321 static void pkey_gost_mac_cleanup(EVP_PKEY_CTX *ctx)
 322 {
 323     struct gost_mac_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
 324     OPENSSL_free(data);
 325 }
 326
 327 static int pkey_gost_mac_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
 328 {
 329     struct gost_mac_pmeth_data *dst_data, *src_data;
 330     if (!pkey_gost_mac_init(dst)) {
 331         return 0;
 332     }
 333     src_data = EVP_PKEY_CTX_get_data(src);
 334     dst_data = EVP_PKEY_CTX_get_data(dst);
 335     *dst_data = *src_data;
 336     return 1;
 337 }
 338
 339 static int pkey_gost_mac_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 340 {
 341     struct gost_mac_pmeth_data *data =
 342         (struct gost_mac_pmeth_data *)EVP_PKEY_CTX_get_data(ctx);
 343
 344     switch (type) {
 345     case EVP_PKEY_CTRL_MD:
 346         {
 347             if (EVP_MD_type((const EVP_MD *)p2) != NID_id_Gost28147_89_MAC) {
 348                 GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL,
 349                         GOST_R_INVALID_DIGEST_TYPE);
 350                 return 0;
 351             }
 352             data->md = (EVP_MD *)p2;
 353             return 1;
 354         }
 355
 356     case EVP_PKEY_CTRL_GET_MD:
 357         *(const EVP_MD **)p2 = data->md;
 358         return 1;
 359
 360     case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
 361     case EVP_PKEY_CTRL_PKCS7_DECRYPT:
 362     case EVP_PKEY_CTRL_PKCS7_SIGN:
 363         return 1;
 364     case EVP_PKEY_CTRL_SET_MAC_KEY:
 365         if (p1 != 32) {
 366             GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL, GOST_R_INVALID_MAC_KEY_LENGTH);
 367             return 0;
 368         }
 369
 370         memcpy(data->key, p2, 32);
 371         data->key_set = 1;
 372         return 1;
 373     case EVP_PKEY_CTRL_DIGESTINIT:
 374         {
 375             EVP_MD_CTX *mctx = p2;
 376             void *key;
 377             if (!data->key_set) {
 378                 EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(ctx);
 379                 if (!pkey) {
 380                     GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL,
 381                             GOST_R_MAC_KEY_NOT_SET);
 382                     return 0;
 383                 }
 384                 key = EVP_PKEY_get0(pkey);
 385                 if (!key) {
 386                     GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL,
 387                             GOST_R_MAC_KEY_NOT_SET);
 388                     return 0;
 389                 }
 390             } else {
 391                 key = &(data->key);
 392             }
 393             return mctx->digest->md_ctrl(mctx, EVP_MD_CTRL_SET_KEY, 32, key);
 394         }
 395     }
 396     return -2;
 397 }
 398
 399 static int pkey_gost_mac_ctrl_str(EVP_PKEY_CTX *ctx,
 400                                   const char *type, const char *value)
 401 {
 402     if (strcmp(type, key_ctrl_string) == 0) {
 403         if (strlen(value) != 32) {
 404             GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL_STR,
 405                     GOST_R_INVALID_MAC_KEY_LENGTH);
 406             return 0;
 407         }
 408         return pkey_gost_mac_ctrl(ctx, EVP_PKEY_CTRL_SET_MAC_KEY,
 409                                   32, (char *)value);
 410     }
 411     if (strcmp(type, hexkey_ctrl_string) == 0) {
 412         long keylen;
 413         int ret;
 414         unsigned char *keybuf = string_to_hex(value, &keylen);
 415         if (!keybuf || keylen != 32) {
 416             GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL_STR,
 417                     GOST_R_INVALID_MAC_KEY_LENGTH);
 418             OPENSSL_free(keybuf);
 419             return 0;
 420         }
 421         ret = pkey_gost_mac_ctrl(ctx, EVP_PKEY_CTRL_SET_MAC_KEY, 32, keybuf);
 422         OPENSSL_free(keybuf);
 423         return ret;
 424
 425     }
 426     return -2;
 427 }
 428
 429 static int pkey_gost_mac_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 430 {
 431     struct gost_mac_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
 432     unsigned char *keydata;
 433     if (!data->key_set) {
 434         GOSTerr(GOST_F_PKEY_GOST_MAC_KEYGEN, GOST_R_MAC_KEY_NOT_SET);
 435         return 0;
 436     }
 437     keydata = OPENSSL_malloc(32);
 438     if (keydata == NULL)
 439         return 0;
 440     memcpy(keydata, data->key, 32);
 441     EVP_PKEY_assign(pkey, NID_id_Gost28147_89_MAC, keydata);
 442     return 1;
 443 }
 444
 445 static int pkey_gost_mac_signctx_init(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx)
 446 {
 447     return 1;
 448 }
 449
 450 static int pkey_gost_mac_signctx(EVP_PKEY_CTX *ctx, unsigned char *sig,
 451                                  size_t *siglen, EVP_MD_CTX *mctx)
 452 {
 453     unsigned int tmpsiglen = *siglen; /* for platforms where
 454                                        * sizeof(int)!=sizeof(size_t) */
 455     int ret;
 456     if (!sig) {
 457         *siglen = 4;
 458         return 1;
 459     }
 460     ret = EVP_DigestFinal_ex(mctx, sig, &tmpsiglen);
 461     *siglen = tmpsiglen;
 462     return ret;
 463 }
 464
 465 /* ----------------------------------------------------------------*/
 466 int register_pmeth_gost(int id, EVP_PKEY_METHOD **pmeth, int flags)
 467 {
 468     *pmeth = EVP_PKEY_meth_new(id, flags);
 469     if (!*pmeth)
 470         return 0;
 471
 472     switch (id) {
 473     case NID_id_GostR3410_2001:
 474         EVP_PKEY_meth_set_ctrl(*pmeth, pkey_gost_ctrl, pkey_gost_ctrl01_str);
 475         EVP_PKEY_meth_set_sign(*pmeth, NULL, pkey_gost01_cp_sign);
 476         EVP_PKEY_meth_set_verify(*pmeth, NULL, pkey_gost01_cp_verify);
 477
 478         EVP_PKEY_meth_set_keygen(*pmeth, NULL, pkey_gost01cp_keygen);
 479
 480         EVP_PKEY_meth_set_encrypt(*pmeth,
 481                                   pkey_gost_encrypt_init,
 482                                   pkey_GOST01cp_encrypt);
 483         EVP_PKEY_meth_set_decrypt(*pmeth, NULL, pkey_GOST01cp_decrypt);
 484         EVP_PKEY_meth_set_derive(*pmeth,
 485                                  pkey_gost_derive_init, pkey_gost2001_derive);
 486         EVP_PKEY_meth_set_paramgen(*pmeth, pkey_gost_paramgen_init,
 487                                    pkey_gost01_paramgen);
 488         break;
 489     case NID_id_Gost28147_89_MAC:
 490         EVP_PKEY_meth_set_ctrl(*pmeth, pkey_gost_mac_ctrl,
 491                                pkey_gost_mac_ctrl_str);
 492         EVP_PKEY_meth_set_signctx(*pmeth, pkey_gost_mac_signctx_init,
 493                                   pkey_gost_mac_signctx);
 494         EVP_PKEY_meth_set_keygen(*pmeth, NULL, pkey_gost_mac_keygen);
 495         EVP_PKEY_meth_set_init(*pmeth, pkey_gost_mac_init);
 496         EVP_PKEY_meth_set_cleanup(*pmeth, pkey_gost_mac_cleanup);
 497         EVP_PKEY_meth_set_copy(*pmeth, pkey_gost_mac_copy);
 498         return 1;
 499     default:                   /* Unsupported method */
 500         return 0;
 501     }
 502     EVP_PKEY_meth_set_init(*pmeth, pkey_gost_init);
 503     EVP_PKEY_meth_set_cleanup(*pmeth, pkey_gost_cleanup);
 504
 505     EVP_PKEY_meth_set_copy(*pmeth, pkey_gost_copy);
 506     /*
 507      * FIXME derive etc...
 508      */
 509
 510     return 1;
 511 }