X-Git-Url: http://wagner.pp.ru/gitweb/?a=blobdiff_plain;f=gost_ameth.c;h=8e02a15c27b3c663274b8a81853164716e586a54;hb=HEAD;hp=b7c5354c1ae2937cb10fbf70ae0495e03e42cf08;hpb=c98ba9d03213d0c63d6874539d59f7b55fbc3fae;p=openssl-gost%2Fengine.git diff --git a/gost_ameth.c b/gost_ameth.c index b7c5354..8e02a15 100644 --- a/gost_ameth.c +++ b/gost_ameth.c @@ -16,23 +16,41 @@ #ifndef OPENSSL_NO_CMS # include #endif -#include "gost_params.h" #include "gost_lcl.h" #include "e_gost_err.h" -int gost94_nid_by_params(DSA *p) +#define PK_WRAP_PARAM "LEGACY_PK_WRAP" + +/* + * Pack bignum into byte buffer of given size, filling all leading bytes by + * zeros + */ +int store_bignum(const BIGNUM *bn, unsigned char *buf, int len) { - R3410_params *gost_params; - BIGNUM *q = BN_new(); - for (gost_params = R3410_paramset; gost_params->q != NULL; gost_params++) { - BN_dec2bn(&q, gost_params->q); - if (!BN_cmp(q, p->q)) { - BN_free(q); - return gost_params->nid; - } + int bytes = BN_num_bytes(bn); + + if (bytes > len) + return 0; + memset(buf, 0, len); + BN_bn2bin(bn, buf + len - bytes); + return 1; +} + +static int pkey_bits_gost(const EVP_PKEY *pk) +{ + if (!pk) + return -1; + + switch (EVP_PKEY_base_id(pk)) { + case NID_id_GostR3410_2001: + case NID_id_GostR3410_2001DH: + case NID_id_GostR3410_2012_256: + return 256; + case NID_id_GostR3410_2012_512: + return 512; } - BN_free(q); - return NID_undef; + + return -1; } static ASN1_STRING *encode_gost_algor_params(const EVP_PKEY *key) @@ -40,65 +58,108 @@ static ASN1_STRING *encode_gost_algor_params(const EVP_PKEY *key) ASN1_STRING *params = ASN1_STRING_new(); GOST_KEY_PARAMS *gkp = GOST_KEY_PARAMS_new(); int pkey_param_nid = NID_undef; + void *key_ptr = EVP_PKEY_get0((EVP_PKEY *)key); + int result = 0; if (!params || !gkp) { GOSTerr(GOST_F_ENCODE_GOST_ALGOR_PARAMS, ERR_R_MALLOC_FAILURE); - ASN1_STRING_free(params); - params = NULL; goto err; } switch (EVP_PKEY_base_id(key)) { - case NID_id_GostR3410_2001: - pkey_param_nid = - EC_GROUP_get_curve_name(EC_KEY_get0_group - (EVP_PKEY_get0((EVP_PKEY *)key))); + case NID_id_GostR3410_2012_256: + pkey_param_nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(key_ptr)); + switch (pkey_param_nid) { + case NID_id_GostR3410_2001_TestParamSet: + case NID_id_GostR3410_2001_CryptoPro_A_ParamSet: + case NID_id_GostR3410_2001_CryptoPro_B_ParamSet: + case NID_id_GostR3410_2001_CryptoPro_C_ParamSet: + case NID_id_GostR3410_2001_CryptoPro_XchA_ParamSet: + case NID_id_GostR3410_2001_CryptoPro_XchB_ParamSet: + gkp->hash_params = OBJ_nid2obj(NID_id_GostR3411_2012_256); + } break; - case NID_id_GostR3410_94: - pkey_param_nid = - (int)gost94_nid_by_params(EVP_PKEY_get0((EVP_PKEY *)key)); - if (pkey_param_nid == NID_undef) { - GOSTerr(GOST_F_ENCODE_GOST_ALGOR_PARAMS, - GOST_R_INVALID_GOST94_PARMSET); - ASN1_STRING_free(params); - params = NULL; - goto err; - } + case NID_id_GostR3410_2012_512: + pkey_param_nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(key_ptr)); + switch (pkey_param_nid) { + case NID_id_tc26_gost_3410_2012_512_paramSetTest: + case NID_id_tc26_gost_3410_2012_512_paramSetA: + case NID_id_tc26_gost_3410_2012_512_paramSetB: + gkp->hash_params = OBJ_nid2obj(NID_id_GostR3411_2012_512); + } + break; + case NID_id_GostR3410_2001: + case NID_id_GostR3410_2001DH: + pkey_param_nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(key_ptr)); + gkp->hash_params = OBJ_nid2obj(NID_id_GostR3411_94_CryptoProParamSet); break; } + + if (pkey_param_nid == NID_undef) { + GOSTerr(GOST_F_ENCODE_GOST_ALGOR_PARAMS, GOST_R_INVALID_PARAMSET); + goto err; + } + gkp->key_params = OBJ_nid2obj(pkey_param_nid); - gkp->hash_params = OBJ_nid2obj(NID_id_GostR3411_94_CryptoProParamSet); /* * gkp->cipher_params = OBJ_nid2obj(cipher_param_nid); */ params->length = i2d_GOST_KEY_PARAMS(gkp, ¶ms->data); if (params->length <= 0) { GOSTerr(GOST_F_ENCODE_GOST_ALGOR_PARAMS, ERR_R_MALLOC_FAILURE); - ASN1_STRING_free(params); - params = NULL; goto err; } params->type = V_ASN1_SEQUENCE; + result = 1; err: - GOST_KEY_PARAMS_free(gkp); + if (gkp) + GOST_KEY_PARAMS_free(gkp); + if (result == 0) { /* if error */ + if (params) + ASN1_STRING_free(params); + return NULL; + } return params; } +static int gost_decode_nid_params(EVP_PKEY *pkey, int pkey_nid, int param_nid) +{ + void *key_ptr = EVP_PKEY_get0(pkey); + + switch (pkey_nid) { + case NID_id_GostR3410_2012_256: + case NID_id_GostR3410_2012_512: + case NID_id_GostR3410_2001: + case NID_id_GostR3410_2001DH: + if (!key_ptr) { + key_ptr = EC_KEY_new(); + if (!EVP_PKEY_assign(pkey, pkey_nid, key_ptr)) { + EC_KEY_free(key_ptr); + break; + } + } + return fill_GOST_EC_params(key_ptr, param_nid); + } + + return 0; +} + /* * Parses GOST algorithm parameters from X509_ALGOR and modifies pkey setting * NID and parameters */ -static int decode_gost_algor_params(EVP_PKEY *pkey, X509_ALGOR *palg) +static int decode_gost_algor_params(EVP_PKEY *pkey, + const X509_ALGOR *palg) { - ASN1_OBJECT *palg_obj = NULL; + const ASN1_OBJECT *palg_obj = NULL; int ptype = V_ASN1_UNDEF; int pkey_nid = NID_undef, param_nid = NID_undef; - void *_pval; ASN1_STRING *pval = NULL; const unsigned char *p; GOST_KEY_PARAMS *gkp = NULL; - X509_ALGOR_get0(&palg_obj, &ptype, &_pval, palg); - pval = _pval; + if (!pkey || !palg) + return 0; + X509_ALGOR_get0(&palg_obj, &ptype, (const void **)&pval, palg); if (ptype != V_ASN1_SEQUENCE) { GOSTerr(GOST_F_DECODE_GOST_ALGOR_PARAMS, GOST_R_BAD_KEY_PARAMETERS_FORMAT); @@ -115,55 +176,20 @@ static int decode_gost_algor_params(EVP_PKEY *pkey, X509_ALGOR *palg) } param_nid = OBJ_obj2nid(gkp->key_params); GOST_KEY_PARAMS_free(gkp); - if(!EVP_PKEY_set_type(pkey, pkey_nid)) { + if (!EVP_PKEY_set_type(pkey, pkey_nid)) { GOSTerr(GOST_F_DECODE_GOST_ALGOR_PARAMS, ERR_R_INTERNAL_ERROR); return 0; } - switch (pkey_nid) { - case NID_id_GostR3410_94: - { - DSA *dsa = EVP_PKEY_get0(pkey); - if (!dsa) { - dsa = DSA_new(); - if (!EVP_PKEY_assign(pkey, pkey_nid, dsa)) - return 0; - } - if (!fill_GOST94_params(dsa, param_nid)) - return 0; - break; - } - case NID_id_GostR3410_2001: - { - EC_KEY *ec = EVP_PKEY_get0(pkey); - if (!ec) { - ec = EC_KEY_new(); - if (!EVP_PKEY_assign(pkey, pkey_nid, ec)) - return 0; - } - if (!fill_GOST2001_params(ec, param_nid)) - return 0; - } - } - - return 1; + return gost_decode_nid_params(pkey, pkey_nid, param_nid); } static int gost_set_priv_key(EVP_PKEY *pkey, BIGNUM *priv) { switch (EVP_PKEY_base_id(pkey)) { - case NID_id_GostR3410_94: - { - DSA *dsa = EVP_PKEY_get0(pkey); - if (!dsa) { - dsa = DSA_new(); - EVP_PKEY_assign(pkey, EVP_PKEY_base_id(pkey), dsa); - } - dsa->priv_key = BN_dup(priv); - if (!EVP_PKEY_missing_parameters(pkey)) - gost94_compute_public(dsa); - break; - } + case NID_id_GostR3410_2012_512: + case NID_id_GostR3410_2012_256: case NID_id_GostR3410_2001: + case NID_id_GostR3410_2001DH: { EC_KEY *ec = EVP_PKEY_get0(pkey); if (!ec) { @@ -173,9 +199,11 @@ static int gost_set_priv_key(EVP_PKEY *pkey, BIGNUM *priv) if (!EC_KEY_set_private_key(ec, priv)) return 0; if (!EVP_PKEY_missing_parameters(pkey)) - gost2001_compute_public(ec); + return gost_ec_compute_public(ec); break; } + default: + return 0; } return 1; } @@ -183,95 +211,325 @@ static int gost_set_priv_key(EVP_PKEY *pkey, BIGNUM *priv) BIGNUM *gost_get0_priv_key(const EVP_PKEY *pkey) { switch (EVP_PKEY_base_id(pkey)) { - case NID_id_GostR3410_94: - { - DSA *dsa = EVP_PKEY_get0((EVP_PKEY *)pkey); - if (!dsa) { - return NULL; - } - if (!dsa->priv_key) - return NULL; - return dsa->priv_key; - break; - } + case NID_id_GostR3410_2012_512: + case NID_id_GostR3410_2012_256: case NID_id_GostR3410_2001: + case NID_id_GostR3410_2001DH: { EC_KEY *ec = EVP_PKEY_get0((EVP_PKEY *)pkey); - const BIGNUM *priv; - if (!ec) { - return NULL; - } - if (!(priv = EC_KEY_get0_private_key(ec))) - return NULL; - return (BIGNUM *)priv; + if (ec) + return (BIGNUM *)EC_KEY_get0_private_key(ec); break; } } return NULL; } +/* + * GOST CMS processing functions + */ +/* FIXME reaarange declarations */ +static int pub_decode_gost_ec(EVP_PKEY *pk, const X509_PUBKEY *pub); + +static int gost_cms_set_kari_shared_info(EVP_PKEY_CTX *pctx, CMS_RecipientInfo *ri) +{ + int ret = 0; + X509_ALGOR *alg; + ASN1_OCTET_STRING *ukm; + + /* Deal with originator */ + X509_ALGOR *pubalg = NULL; + ASN1_BIT_STRING *pubkey = NULL; + + EVP_PKEY *peer_key = NULL; + X509_PUBKEY *tmp = NULL; + + int nid; + unsigned char shared_key[64]; + size_t shared_key_size = 64; + const EVP_CIPHER *cipher = NULL; + + if (CMS_RecipientInfo_kari_get0_alg(ri, &alg, &ukm) == 0) + goto err; + + if (CMS_RecipientInfo_kari_get0_orig_id(ri, &pubalg, &pubkey, NULL, NULL, NULL) == 0) + goto err; + + nid = OBJ_obj2nid(alg->algorithm); + if (alg->parameter->type != V_ASN1_SEQUENCE) + goto err; + + switch (nid) { + case NID_kuznyechik_kexp15: + case NID_magma_kexp15: + cipher = EVP_get_cipherbynid(nid); + break; + } + + if (cipher == NULL) { + GOSTerr(GOST_F_GOST_CMS_SET_KARI_SHARED_INFO, GOST_R_CIPHER_NOT_FOUND); + goto err; + } + + if (EVP_PKEY_CTX_ctrl(pctx, -1, -1, EVP_PKEY_CTRL_SET_IV, + ASN1_STRING_length(ukm), (void *)ASN1_STRING_get0_data(ukm)) <= 0) + goto err; + + if (pubkey != NULL && pubalg != NULL) { + const ASN1_OBJECT *paobj = NULL; + int ptype = 0; + const void *param = NULL; + + peer_key = EVP_PKEY_new(); + tmp = X509_PUBKEY_new(); + + if ((peer_key == NULL) || (tmp == NULL)) { + GOSTerr(GOST_F_GOST_CMS_SET_KARI_SHARED_INFO, ERR_R_MALLOC_FAILURE); + goto err; + } + + X509_ALGOR_get0(&paobj, &ptype, ¶m, pubalg); + + if (X509_PUBKEY_set0_param(tmp, (ASN1_OBJECT *)paobj, + ptype, (void *)param, + (unsigned char *)ASN1_STRING_get0_data(pubkey), + ASN1_STRING_length(pubkey) ) == 0) { + GOSTerr(GOST_F_GOST_CMS_SET_KARI_SHARED_INFO, GOST_R_PUBLIC_KEY_UNDEFINED); + goto err; + } + + if (pub_decode_gost_ec(peer_key, tmp) <= 0) { + GOSTerr(GOST_F_GOST_CMS_SET_KARI_SHARED_INFO, GOST_R_ERROR_DECODING_PUBLIC_KEY); + goto err; + } + + if (EVP_PKEY_derive_set_peer(pctx, peer_key) <= 0) { + GOSTerr(GOST_F_GOST_CMS_SET_KARI_SHARED_INFO, GOST_R_ERROR_SETTING_PEER_KEY); + goto err; + } + } + + if (EVP_PKEY_derive(pctx, shared_key, &shared_key_size) <= 0) { + GOSTerr(GOST_F_GOST_CMS_SET_KARI_SHARED_INFO, GOST_R_ERROR_COMPUTING_SHARED_KEY); + goto err; + } + + EVP_CIPHER_CTX_set_flags(CMS_RecipientInfo_kari_get0_ctx(ri), EVP_CIPHER_CTX_FLAG_WRAP_ALLOW); + if (EVP_DecryptInit_ex(CMS_RecipientInfo_kari_get0_ctx(ri), cipher, NULL, + shared_key, ukm->data+24) == 0) + goto err; + + ret = 1; +err: + EVP_PKEY_free(peer_key); + if (ret == 0) { + X509_PUBKEY_free(tmp); + } + + return ret; +} + +static int gost_cms_set_ktri_shared_info(EVP_PKEY_CTX *pctx, CMS_RecipientInfo *ri) +{ + X509_ALGOR *alg; + struct gost_pmeth_data *gctx = EVP_PKEY_CTX_get_data(pctx); + + CMS_RecipientInfo_ktri_get0_algs(ri, NULL, NULL, &alg); + + switch (OBJ_obj2nid(alg->algorithm)) { + case NID_kuznyechik_kexp15: + gctx->cipher_nid = NID_kuznyechik_ctr; + break; + + case NID_magma_kexp15: + gctx->cipher_nid = NID_magma_ctr; + break; + + case NID_id_GostR3410_2001: + case NID_id_GostR3410_2001DH: + case NID_id_GostR3410_2012_256: + case NID_id_GostR3410_2012_512: + gctx->cipher_nid = NID_id_Gost28147_89; + break; + + default: + GOSTerr(GOST_F_GOST_CMS_SET_KTRI_SHARED_INFO, GOST_R_UNSUPPORTED_RECIPIENT_INFO); + return 0; + } + + return 1; +} + +static int gost_cms_set_shared_info(EVP_PKEY_CTX *pctx, CMS_RecipientInfo *ri) +{ + switch(CMS_RecipientInfo_type(ri)) { + case CMS_RECIPINFO_AGREE: + return gost_cms_set_kari_shared_info(pctx, ri); + break; + case CMS_RECIPINFO_TRANS: + return gost_cms_set_ktri_shared_info(pctx, ri); + break; + } + + GOSTerr(GOST_F_GOST_CMS_SET_SHARED_INFO, GOST_R_UNSUPPORTED_RECIPIENT_INFO); + return 0; +} + +static ASN1_STRING *gost_encode_cms_params(int ka_nid) +{ + ASN1_STRING *ret = NULL; + ASN1_STRING *params = ASN1_STRING_new(); + + /* It's a hack. We have only one OID here, so we can use + * GOST_KEY_PARAMS which is a sequence of 3 OIDs, + * the 1st one is mandatory and the rest are optional */ + GOST_KEY_PARAMS *gkp = GOST_KEY_PARAMS_new(); + + if (params == NULL || gkp == NULL) { + GOSTerr(GOST_F_GOST_ENCODE_CMS_PARAMS, ERR_R_MALLOC_FAILURE); + goto end; + } + + gkp->key_params = OBJ_nid2obj(ka_nid); + params->length = i2d_GOST_KEY_PARAMS(gkp, ¶ms->data); + + if (params->length < 0) { + GOSTerr(GOST_F_GOST_ENCODE_CMS_PARAMS, ERR_R_MALLOC_FAILURE); + goto end; + } + + params->type = V_ASN1_SEQUENCE; + ret = params; + +end: + GOST_KEY_PARAMS_free(gkp); + + if (ret == NULL) + ASN1_STRING_free(params); + + return ret; +} + +/* + * Control function + */ static int pkey_ctrl_gost(EVP_PKEY *pkey, int op, long arg1, void *arg2) { + int nid = EVP_PKEY_base_id(pkey), md_nid = NID_undef; + X509_ALGOR *alg1 = NULL, *alg2 = NULL; + + switch (nid) { + case NID_id_GostR3410_2012_512: + md_nid = NID_id_GostR3411_2012_512; + break; + case NID_id_GostR3410_2012_256: + md_nid = NID_id_GostR3411_2012_256; + break; + case NID_id_GostR3410_2001: + case NID_id_GostR3410_2001DH: + case NID_id_GostR3410_94: + md_nid = NID_id_GostR3411_94; + break; + default: + return -1; + } + switch (op) { case ASN1_PKEY_CTRL_PKCS7_SIGN: if (arg1 == 0) { - X509_ALGOR *alg1 = NULL, *alg2 = NULL; - int nid = EVP_PKEY_base_id(pkey); - PKCS7_SIGNER_INFO_get0_algs((PKCS7_SIGNER_INFO *)arg2, - NULL, &alg1, &alg2); - X509_ALGOR_set0(alg1, OBJ_nid2obj(NID_id_GostR3411_94), - V_ASN1_NULL, 0); - if (nid == NID_undef) { - return (-1); - } + PKCS7_SIGNER_INFO_get0_algs((PKCS7_SIGNER_INFO *)arg2, NULL, + &alg1, &alg2); + X509_ALGOR_set0(alg1, OBJ_nid2obj(md_nid), V_ASN1_NULL, 0); X509_ALGOR_set0(alg2, OBJ_nid2obj(nid), V_ASN1_NULL, 0); } return 1; #ifndef OPENSSL_NO_CMS case ASN1_PKEY_CTRL_CMS_SIGN: if (arg1 == 0) { - X509_ALGOR *alg1 = NULL, *alg2 = NULL; - int nid = EVP_PKEY_base_id(pkey); - CMS_SignerInfo_get0_algs((CMS_SignerInfo *)arg2, - NULL, NULL, &alg1, &alg2); - X509_ALGOR_set0(alg1, OBJ_nid2obj(NID_id_GostR3411_94), - V_ASN1_NULL, 0); - if (nid == NID_undef) { - return (-1); - } + CMS_SignerInfo_get0_algs((CMS_SignerInfo *)arg2, NULL, NULL, + &alg1, &alg2); + X509_ALGOR_set0(alg1, OBJ_nid2obj(md_nid), V_ASN1_NULL, 0); X509_ALGOR_set0(alg2, OBJ_nid2obj(nid), V_ASN1_NULL, 0); } return 1; #endif case ASN1_PKEY_CTRL_PKCS7_ENCRYPT: - if (arg1 == 0) { - X509_ALGOR *alg; + if (arg1 == 0) { /* Encryption */ ASN1_STRING *params = encode_gost_algor_params(pkey); if (!params) { return -1; } - PKCS7_RECIP_INFO_get0_alg((PKCS7_RECIP_INFO *)arg2, &alg); - X509_ALGOR_set0(alg, OBJ_nid2obj(pkey->type), + PKCS7_RECIP_INFO_get0_alg((PKCS7_RECIP_INFO *)arg2, &alg1); + X509_ALGOR_set0(alg1, OBJ_nid2obj(EVP_PKEY_id(pkey)), V_ASN1_SEQUENCE, params); - } + } return 1; #ifndef OPENSSL_NO_CMS case ASN1_PKEY_CTRL_CMS_ENVELOPE: if (arg1 == 0) { - X509_ALGOR *alg = NULL; - ASN1_STRING *params = encode_gost_algor_params(pkey); - if (!params) { - return -1; - } - CMS_RecipientInfo_ktri_get0_algs((CMS_RecipientInfo *)arg2, NULL, - NULL, &alg); - X509_ALGOR_set0(alg, OBJ_nid2obj(pkey->type), V_ASN1_SEQUENCE, - params); + EVP_PKEY_CTX *pctx; + CMS_RecipientInfo *ri = arg2; + + struct gost_pmeth_data *gctx = NULL; + ASN1_STRING *params = NULL; + + pctx = CMS_RecipientInfo_get0_pkey_ctx(ri); + if (!pctx) + return 0; + + gctx = EVP_PKEY_CTX_get_data(pctx); + + switch (gctx->cipher_nid) { + case NID_magma_ctr: + case NID_kuznyechik_ctr: + { + int ka_nid; + + nid = (gctx->cipher_nid == NID_magma_ctr) ? NID_magma_kexp15 : + NID_kuznyechik_kexp15; + + ka_nid = (EVP_PKEY_base_id(pkey) == NID_id_GostR3410_2012_256) ? + NID_id_tc26_agreement_gost_3410_2012_256 : NID_id_tc26_agreement_gost_3410_2012_512; + + params = gost_encode_cms_params(ka_nid); + } + break; + default: + params = encode_gost_algor_params(pkey); + break; + } + + if (params == NULL) + return -1; + + CMS_RecipientInfo_ktri_get0_algs((CMS_RecipientInfo *)arg2, NULL, + NULL, &alg1); + X509_ALGOR_set0(alg1, OBJ_nid2obj(nid), V_ASN1_SEQUENCE, params); + } else { + EVP_PKEY_CTX *pctx; + CMS_RecipientInfo *ri = arg2; + pctx = CMS_RecipientInfo_get0_pkey_ctx(ri); + if (!pctx) + return 0; + return gost_cms_set_shared_info(pctx, ri); } return 1; +#ifdef ASN1_PKEY_CTRL_CMS_RI_TYPE + case ASN1_PKEY_CTRL_CMS_RI_TYPE: + *(int *)arg2 = CMS_RECIPINFO_TRANS; + return 1; + case ASN1_PKEY_CTRL_CMS_IS_RI_TYPE_SUPPORTED: + if (arg1 == CMS_RECIPINFO_AGREE || arg1 == CMS_RECIPINFO_TRANS) { + *(int *)arg2 = 1; + return 1; + } + else + return 0; + break; +#endif #endif case ASN1_PKEY_CTRL_DEFAULT_MD_NID: - *(int *)arg2 = NID_id_GostR3411_94; + *(int *)arg2 = md_nid; return 2; } @@ -279,30 +537,65 @@ static int pkey_ctrl_gost(EVP_PKEY *pkey, int op, long arg1, void *arg2) } /* --------------------- free functions * ------------------------------*/ -static void pkey_free_gost94(EVP_PKEY *key) +static void pkey_free_gost_ec(EVP_PKEY *key) { - if (key->pkey.dsa) { - DSA_free(key->pkey.dsa); - } + EC_KEY_free((EC_KEY *)EVP_PKEY_get0(key)); } -static void pkey_free_gost01(EVP_PKEY *key) +/* ------------------ private key functions -----------------------------*/ + +static BIGNUM *unmask_priv_key(EVP_PKEY *pk, + const unsigned char *buf, int len, int num_masks) { - if (key->pkey.ec) { - EC_KEY_free(key->pkey.ec); + BIGNUM *pknum_masked = NULL, *q = NULL; + const EC_KEY *key_ptr = (pk) ? EVP_PKEY_get0(pk) : NULL; + const EC_GROUP *group = (key_ptr) ? EC_KEY_get0_group(key_ptr) : NULL; + + pknum_masked = BN_lebin2bn(buf, len, BN_secure_new()); + if (!pknum_masked) + return NULL; + + if (num_masks > 0) { + /* + * XXX Remove sign by gost94 + */ + const unsigned char *p = buf + num_masks * len; + + q = BN_new(); + if (!q || !group || EC_GROUP_get_order(group, q, NULL) <= 0) { + BN_free(pknum_masked); + pknum_masked = NULL; + goto end; + } + + for (; p != buf; p -= len) { + BIGNUM *mask = BN_lebin2bn(p, len, BN_secure_new()); + BN_CTX *ctx = BN_CTX_secure_new(); + + BN_mod_mul(pknum_masked, pknum_masked, mask, q, ctx); + + BN_CTX_free(ctx); + BN_free(mask); + } } + + end: + if (q) + BN_free(q); + return pknum_masked; } -/* ------------------ private key functions -----------------------------*/ -static int priv_decode_gost(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf) +static int priv_decode_gost(EVP_PKEY *pk, + const PKCS8_PRIV_KEY_INFO *p8inf) { const unsigned char *pkey_buf = NULL, *p = NULL; int priv_len = 0; BIGNUM *pk_num = NULL; int ret = 0; - X509_ALGOR *palg = NULL; - ASN1_OBJECT *palg_obj = NULL; + const X509_ALGOR *palg = NULL; + const ASN1_OBJECT *palg_obj = NULL; ASN1_INTEGER *priv_key = NULL; + int expected_key_len; if (!PKCS8_pkey_get0(&palg_obj, &pkey_buf, &priv_len, &palg, p8inf)) return 0; @@ -310,30 +603,62 @@ static int priv_decode_gost(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf) if (!decode_gost_algor_params(pk, palg)) { return 0; } - if (V_ASN1_OCTET_STRING == *p) { + + expected_key_len = pkey_bits_gost(pk) > 0 ? pkey_bits_gost(pk) / 8 : 0; + if (expected_key_len == 0) { + GOSTerr(GOST_F_PRIV_DECODE_GOST, EVP_R_DECODE_ERROR); + return 0; + } + + if (priv_len % expected_key_len == 0) { + /* Key is not wrapped but masked */ + pk_num = unmask_priv_key(pk, pkey_buf, expected_key_len, + priv_len / expected_key_len - 1); + } else if (V_ASN1_OCTET_STRING == *p) { /* New format - Little endian octet string */ - unsigned char rev_buf[32]; - int i; ASN1_OCTET_STRING *s = d2i_ASN1_OCTET_STRING(NULL, &p, priv_len); - if (!s || s->length != 32) { + if (!s || ((s->length != 32) && (s->length != 64))) { + ASN1_STRING_free(s); GOSTerr(GOST_F_PRIV_DECODE_GOST, EVP_R_DECODE_ERROR); return 0; } - for (i = 0; i < 32; i++) { - rev_buf[31 - i] = s->data[i]; - } + pk_num = BN_lebin2bn(s->data, s->length, BN_secure_new()); ASN1_STRING_free(s); - pk_num = getbnfrombuf(rev_buf, 32); - } else { + } else if (V_ASN1_INTEGER == *p) { priv_key = d2i_ASN1_INTEGER(NULL, &p, priv_len); - if (!priv_key) + if (!priv_key) { + GOSTerr(GOST_F_PRIV_DECODE_GOST, EVP_R_DECODE_ERROR); return 0; - ret = ((pk_num = ASN1_INTEGER_to_BN(priv_key, NULL)) != NULL); + } + pk_num = ASN1_INTEGER_to_BN(priv_key, BN_secure_new()); ASN1_INTEGER_free(priv_key); - if (!ret) { + } else if ((V_ASN1_SEQUENCE | V_ASN1_CONSTRUCTED) == *p) { + MASKED_GOST_KEY *mgk = d2i_MASKED_GOST_KEY(NULL, &p, priv_len); + + if (!mgk) { + GOSTerr(GOST_F_PRIV_DECODE_GOST, EVP_R_DECODE_ERROR); + return 0; + } + + priv_len = mgk->masked_priv_key->length; + if (priv_len % expected_key_len) { + MASKED_GOST_KEY_free(mgk); GOSTerr(GOST_F_PRIV_DECODE_GOST, EVP_R_DECODE_ERROR); return 0; } + + pk_num = unmask_priv_key(pk, mgk->masked_priv_key->data, + expected_key_len, + priv_len / expected_key_len - 1); + MASKED_GOST_KEY_free(mgk); + } else { + GOSTerr(GOST_F_PRIV_DECODE_GOST, EVP_R_DECODE_ERROR); + return 0; + } + + if (pk_num == NULL) { + GOSTerr(GOST_F_PRIV_DECODE_GOST, EVP_R_DECODE_ERROR); + return 0; } ret = gost_set_priv_key(pk, pk_num); @@ -345,167 +670,175 @@ static int priv_decode_gost(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf) static int priv_encode_gost(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk) { ASN1_OBJECT *algobj = OBJ_nid2obj(EVP_PKEY_base_id(pk)); - ASN1_STRING *params = encode_gost_algor_params(pk); - unsigned char *priv_buf = NULL; - int priv_len; + ASN1_STRING *params = NULL; + unsigned char *buf = NULL; + int key_len = pkey_bits_gost(pk), i = 0; + /* unmasked private key */ + const char *pk_format = get_gost_engine_param(GOST_PARAM_PK_FORMAT); + + key_len = (key_len < 0) ? 0 : key_len / 8; + if (key_len == 0 || !(buf = OPENSSL_secure_malloc(key_len))) { + return 0; + } - ASN1_INTEGER *asn1key = NULL; + if (!store_bignum(gost_get0_priv_key(pk), buf, key_len)) { + OPENSSL_secure_free(buf); + return 0; + } + + params = encode_gost_algor_params(pk); if (!params) { + OPENSSL_secure_free(buf); return 0; } - asn1key = BN_to_ASN1_INTEGER(gost_get0_priv_key(pk), NULL); - priv_len = i2d_ASN1_INTEGER(asn1key, &priv_buf); - ASN1_INTEGER_free(asn1key); + + /* Convert buf to Little-endian */ + for (i = 0; i < key_len / 2; i++) { + unsigned char tmp = buf[i]; + buf[i] = buf[key_len - 1 - i]; + buf[key_len - 1 - i] = tmp; + } + + if (pk_format != NULL && strcmp(pk_format, PK_WRAP_PARAM) == 0) { + ASN1_STRING *octet = ASN1_STRING_new(); + int priv_len = 0; + unsigned char *priv_buf = NULL; + if (!octet || !ASN1_OCTET_STRING_set(octet, buf, key_len)) { + ASN1_STRING_free(octet); + ASN1_STRING_free(params); + OPENSSL_secure_free(buf); + return 0; + } + priv_len = i2d_ASN1_OCTET_STRING(octet, &priv_buf); + ASN1_STRING_free(octet); + OPENSSL_secure_free(buf); + + return PKCS8_pkey_set0(p8, algobj, 0, V_ASN1_SEQUENCE, params, + priv_buf, priv_len); + } + return PKCS8_pkey_set0(p8, algobj, 0, V_ASN1_SEQUENCE, params, - priv_buf, priv_len); + buf, key_len); } /* --------- printing keys --------------------------------*/ -static int print_gost_94(BIO *out, const EVP_PKEY *pkey, int indent, - ASN1_PCTX *pctx, int type) +static int print_gost_priv(BIO *out, const EVP_PKEY *pkey, int indent) { - int param_nid = NID_undef; + BIGNUM *key; - if (type == 2) { - BIGNUM *key; + if (!BIO_indent(out, indent, 128)) + return 0; + BIO_printf(out, "Private key: "); + key = gost_get0_priv_key(pkey); + if (!key) + BIO_printf(out, ""); + else + BN_print(out, key); + BIO_printf(out, "\n"); - if (!BIO_indent(out, indent, 128)) - return 0; - BIO_printf(out, "Private key: "); - key = gost_get0_priv_key(pkey); - if (!key) - BIO_printf(out, ""); - else - BN_print(out, key); - BIO_printf(out, "\n"); + return 1; +} + +static int print_gost_ec_pub(BIO *out, const EVP_PKEY *pkey, int indent) +{ + BN_CTX *ctx; + BIGNUM *X, *Y; + const EC_POINT *pubkey; + const EC_GROUP *group; + EC_KEY *key = (EC_KEY *)EVP_PKEY_get0((EVP_PKEY *)pkey); + int ok = 0; + + ctx = BN_CTX_new(); + if (!ctx) { + GOSTerr(GOST_F_PRINT_GOST_EC_PUB, ERR_R_MALLOC_FAILURE); + return 0; } - if (type >= 1) { - BIGNUM *pubkey; - pubkey = ((DSA *)EVP_PKEY_get0((EVP_PKEY *)pkey))->pub_key; - BIO_indent(out, indent, 128); - BIO_printf(out, "Public key: "); - BN_print(out, pubkey); - BIO_printf(out, "\n"); + BN_CTX_start(ctx); + X = BN_CTX_get(ctx); + Y = BN_CTX_get(ctx); + pubkey = (key) ? EC_KEY_get0_public_key(key) : NULL; + group = (key) ? EC_KEY_get0_group(key) : NULL; + if (!pubkey || !group) + goto err; + + if (!EC_POINT_get_affine_coordinates(group, pubkey, X, Y, ctx)) { + GOSTerr(GOST_F_PRINT_GOST_EC_PUB, ERR_R_EC_LIB); + goto err; } + if (!BIO_indent(out, indent, 128)) + goto err; + BIO_printf(out, "Public key:\n"); + if (!BIO_indent(out, indent + 3, 128)) + goto err; + BIO_printf(out, "X:"); + BN_print(out, X); + BIO_printf(out, "\n"); + if (!BIO_indent(out, indent + 3, 128)) + goto err; + BIO_printf(out, "Y:"); + BN_print(out, Y); + BIO_printf(out, "\n"); + ok = 1; + err: + BN_CTX_end(ctx); + BN_CTX_free(ctx); - param_nid = gost94_nid_by_params(EVP_PKEY_get0((EVP_PKEY *)pkey)); - BIO_indent(out, indent, 128); - BIO_printf(out, "Parameter set: %s\n", OBJ_nid2ln(param_nid)); - return 1; + return ok; } -static int param_print_gost94(BIO *out, const EVP_PKEY *pkey, int indent, - ASN1_PCTX *pctx) +static int print_gost_ec_param(BIO *out, const EVP_PKEY *pkey, int indent) { - return print_gost_94(out, pkey, indent, pctx, 0); -} + EC_KEY *ec = EVP_PKEY_get0((EVP_PKEY *)pkey); + const EC_GROUP *group = (ec) ? EC_KEY_get0_group(ec) : NULL; + int param_nid; -static int pub_print_gost94(BIO *out, const EVP_PKEY *pkey, int indent, - ASN1_PCTX *pctx) -{ - return print_gost_94(out, pkey, indent, pctx, 1); -} + if (!group) + return 0; -static int priv_print_gost94(BIO *out, const EVP_PKEY *pkey, int indent, - ASN1_PCTX *pctx) -{ - return print_gost_94(out, pkey, indent, pctx, 2); + param_nid = EC_GROUP_get_curve_name(group); + if (!BIO_indent(out, indent, 128)) + return 0; + BIO_printf(out, "Parameter set: %s\n", OBJ_nid2ln(param_nid)); + + return 1; } -static int print_gost_01(BIO *out, const EVP_PKEY *pkey, int indent, +static int print_gost_ec(BIO *out, const EVP_PKEY *pkey, int indent, ASN1_PCTX *pctx, int type) { - int param_nid = NID_undef; if (type == 2) { - BIGNUM *key; - - if (!BIO_indent(out, indent, 128)) + if (print_gost_priv(out, pkey, indent) == 0) return 0; - BIO_printf(out, "Private key: "); - key = gost_get0_priv_key(pkey); - if (!key) - BIO_printf(out, "= 1) { - BN_CTX *ctx = BN_CTX_new(); - BIGNUM *X, *Y; - const EC_POINT *pubkey; - const EC_GROUP *group; - - if (!ctx) { - GOSTerr(GOST_F_PRINT_GOST_01, ERR_R_MALLOC_FAILURE); - return 0; - } - BN_CTX_start(ctx); - X = BN_CTX_get(ctx); - Y = BN_CTX_get(ctx); - pubkey = - EC_KEY_get0_public_key((EC_KEY *)EVP_PKEY_get0((EVP_PKEY *)pkey)); - group = EC_KEY_get0_group((EC_KEY *)EVP_PKEY_get0((EVP_PKEY *)pkey)); - if (!EC_POINT_get_affine_coordinates_GFp(group, pubkey, X, Y, ctx)) { - GOSTerr(GOST_F_PRINT_GOST_01, ERR_R_EC_LIB); - BN_CTX_free(ctx); - return 0; - } - if (!BIO_indent(out, indent, 128)) - return 0; - BIO_printf(out, "Public key:\n"); - if (!BIO_indent(out, indent + 3, 128)) + if (print_gost_ec_pub(out, pkey, indent) == 0) return 0; - BIO_printf(out, "X:"); - BN_print(out, X); - BIO_printf(out, "\n"); - BIO_indent(out, indent + 3, 128); - BIO_printf(out, "Y:"); - BN_print(out, Y); - BIO_printf(out, "\n"); - BN_CTX_end(ctx); - BN_CTX_free(ctx); - } - - param_nid = - EC_GROUP_get_curve_name(EC_KEY_get0_group - (EVP_PKEY_get0((EVP_PKEY *)pkey))); - if (!BIO_indent(out, indent, 128)) - return 0; - BIO_printf(out, "Parameter set: %s\n", OBJ_nid2ln(param_nid)); - return 1; -} + } -static int param_print_gost01(BIO *out, const EVP_PKEY *pkey, int indent, - ASN1_PCTX *pctx) -{ - return print_gost_01(out, pkey, indent, pctx, 0); + return print_gost_ec_param(out, pkey, indent); } -static int pub_print_gost01(BIO *out, const EVP_PKEY *pkey, int indent, - ASN1_PCTX *pctx) +static int param_print_gost_ec(BIO *out, const EVP_PKEY *pkey, int indent, + ASN1_PCTX *pctx) { - return print_gost_01(out, pkey, indent, pctx, 1); + return print_gost_ec(out, pkey, indent, pctx, 0); } -static int priv_print_gost01(BIO *out, const EVP_PKEY *pkey, int indent, +static int pub_print_gost_ec(BIO *out, const EVP_PKEY *pkey, int indent, ASN1_PCTX *pctx) { - return print_gost_01(out, pkey, indent, pctx, 2); + return print_gost_ec(out, pkey, indent, pctx, 1); } -/* ---------------------------------------------------------------------*/ -static int param_missing_gost94(const EVP_PKEY *pk) +static int priv_print_gost_ec(BIO *out, const EVP_PKEY *pkey, int indent, + ASN1_PCTX *pctx) { - const DSA *dsa = EVP_PKEY_get0((EVP_PKEY *)pk); - if (!dsa) - return 1; - if (!dsa->q) - return 1; - return 0; + return print_gost_ec(out, pkey, indent, pctx, 2); } -static int param_missing_gost01(const EVP_PKEY *pk) +/* ---------------------------------------------------------------------*/ +static int param_missing_gost_ec(const EVP_PKEY *pk) { const EC_KEY *ec = EVP_PKEY_get0((EVP_PKEY *)pk); if (!ec) @@ -515,331 +848,286 @@ static int param_missing_gost01(const EVP_PKEY *pk) return 0; } -static int param_copy_gost94(EVP_PKEY *to, const EVP_PKEY *from) -{ - const DSA *dfrom = EVP_PKEY_get0((EVP_PKEY *)from); - DSA *dto = EVP_PKEY_get0(to); - if (EVP_PKEY_base_id(from) != EVP_PKEY_base_id(to)) { - GOSTerr(GOST_F_PARAM_COPY_GOST94, GOST_R_INCOMPATIBLE_ALGORITHMS); - return 0; - } - if (!dfrom) { - GOSTerr(GOST_F_PARAM_COPY_GOST94, GOST_R_KEY_PARAMETERS_MISSING); - return 0; - } - if (!dto) { - dto = DSA_new(); - EVP_PKEY_assign(to, EVP_PKEY_base_id(from), dto); - } -#define COPYBIGNUM(a,b,x) if (a->x) BN_free(a->x); a->x=BN_dup(b->x); - COPYBIGNUM(dto, dfrom, p) - COPYBIGNUM(dto, dfrom, q) - COPYBIGNUM(dto, dfrom, g) - - if (dto->priv_key) - gost94_compute_public(dto); - return 1; -} - -static int param_copy_gost01(EVP_PKEY *to, const EVP_PKEY *from) +static int param_copy_gost_ec(EVP_PKEY *to, const EVP_PKEY *from) { EC_KEY *eto = EVP_PKEY_get0(to); const EC_KEY *efrom = EVP_PKEY_get0((EVP_PKEY *)from); if (EVP_PKEY_base_id(from) != EVP_PKEY_base_id(to)) { - GOSTerr(GOST_F_PARAM_COPY_GOST01, GOST_R_INCOMPATIBLE_ALGORITHMS); + GOSTerr(GOST_F_PARAM_COPY_GOST_EC, GOST_R_INCOMPATIBLE_ALGORITHMS); return 0; } if (!efrom) { - GOSTerr(GOST_F_PARAM_COPY_GOST01, GOST_R_KEY_PARAMETERS_MISSING); + GOSTerr(GOST_F_PARAM_COPY_GOST_EC, GOST_R_KEY_PARAMETERS_MISSING); return 0; } if (!eto) { eto = EC_KEY_new(); - if(!eto) { - GOSTerr(GOST_F_PARAM_COPY_GOST01, ERR_R_MALLOC_FAILURE); + if (!eto) { + GOSTerr(GOST_F_PARAM_COPY_GOST_EC, ERR_R_MALLOC_FAILURE); return 0; } - if(!EVP_PKEY_assign(to, EVP_PKEY_base_id(from), eto)) { - GOSTerr(GOST_F_PARAM_COPY_GOST01, ERR_R_INTERNAL_ERROR); + if (!EVP_PKEY_assign(to, EVP_PKEY_base_id(from), eto)) { + GOSTerr(GOST_F_PARAM_COPY_GOST_EC, ERR_R_INTERNAL_ERROR); + EC_KEY_free(eto); return 0; } } - if(!EC_KEY_set_group(eto, EC_KEY_get0_group(efrom))) { - GOSTerr(GOST_F_PARAM_COPY_GOST01, ERR_R_INTERNAL_ERROR); + if (!EC_KEY_set_group(eto, EC_KEY_get0_group(efrom))) { + GOSTerr(GOST_F_PARAM_COPY_GOST_EC, ERR_R_INTERNAL_ERROR); return 0; } if (EC_KEY_get0_private_key(eto)) { - gost2001_compute_public(eto); + return gost_ec_compute_public(eto); } return 1; } -static int param_cmp_gost94(const EVP_PKEY *a, const EVP_PKEY *b) +static int param_cmp_gost_ec(const EVP_PKEY *a, const EVP_PKEY *b) { - const DSA *da = EVP_PKEY_get0((EVP_PKEY *)a); - const DSA *db = EVP_PKEY_get0((EVP_PKEY *)b); - if (!BN_cmp(da->q, db->q)) - return 1; - return 0; -} + const EC_GROUP *group_a, *group_b; + EC_KEY *ec_a = EVP_PKEY_get0((EVP_PKEY *)a); + EC_KEY *ec_b = EVP_PKEY_get0((EVP_PKEY *)b); + if (!ec_a || !ec_b) + return 0; -static int param_cmp_gost01(const EVP_PKEY *a, const EVP_PKEY *b) -{ - if (EC_GROUP_get_curve_name - (EC_KEY_get0_group(EVP_PKEY_get0((EVP_PKEY *)a))) == - EC_GROUP_get_curve_name(EC_KEY_get0_group - (EVP_PKEY_get0((EVP_PKEY *)b)))) { + group_a = EC_KEY_get0_group(ec_a); + group_b = EC_KEY_get0_group(ec_b); + if (!group_a || !group_b) + return 0; + + if (EC_GROUP_get_curve_name(group_a) == EC_GROUP_get_curve_name(group_b)) { return 1; } return 0; - } /* ---------- Public key functions * --------------------------------------*/ -static int pub_decode_gost94(EVP_PKEY *pk, X509_PUBKEY *pub) -{ - X509_ALGOR *palg = NULL; - const unsigned char *pubkey_buf = NULL; - unsigned char *databuf; - ASN1_OBJECT *palgobj = NULL; - int pub_len, i, j; - DSA *dsa; - ASN1_OCTET_STRING *octet = NULL; - - if (!X509_PUBKEY_get0_param(&palgobj, &pubkey_buf, &pub_len, &palg, pub)) - return 0; - EVP_PKEY_assign(pk, OBJ_obj2nid(palgobj), NULL); - if (!decode_gost_algor_params(pk, palg)) - return 0; - octet = d2i_ASN1_OCTET_STRING(NULL, &pubkey_buf, pub_len); - if (!octet) { - GOSTerr(GOST_F_PUB_DECODE_GOST94, ERR_R_MALLOC_FAILURE); - return 0; - } - databuf = OPENSSL_malloc(octet->length); - for (i = 0, j = octet->length - 1; i < octet->length; i++, j--) { - databuf[j] = octet->data[i]; - } - dsa = EVP_PKEY_get0(pk); - dsa->pub_key = BN_bin2bn(databuf, octet->length, NULL); - ASN1_OCTET_STRING_free(octet); - OPENSSL_free(databuf); - return 1; - -} - -static int pub_encode_gost94(X509_PUBKEY *pub, const EVP_PKEY *pk) -{ - ASN1_OBJECT *algobj = NULL; - ASN1_OCTET_STRING *octet = NULL; - void *pval = NULL; - unsigned char *buf = NULL, *databuf, *sptr; - int i, j, data_len, ret = 0; - - int ptype = V_ASN1_UNDEF; - DSA *dsa = EVP_PKEY_get0((EVP_PKEY *)pk); - algobj = OBJ_nid2obj(EVP_PKEY_base_id(pk)); - if (pk->save_parameters) { - ASN1_STRING *params = encode_gost_algor_params(pk); - pval = params; - ptype = V_ASN1_SEQUENCE; - } - data_len = BN_num_bytes(dsa->pub_key); - databuf = OPENSSL_malloc(data_len); - BN_bn2bin(dsa->pub_key, databuf); - octet = ASN1_OCTET_STRING_new(); - ASN1_STRING_set(octet, NULL, data_len); - sptr = ASN1_STRING_data(octet); - for (i = 0, j = data_len - 1; i < data_len; i++, j--) { - sptr[i] = databuf[j]; - } - OPENSSL_free(databuf); - ret = i2d_ASN1_OCTET_STRING(octet, &buf); - ASN1_BIT_STRING_free(octet); - if (ret < 0) - return 0; - return X509_PUBKEY_set0_param(pub, algobj, ptype, pval, buf, ret); -} - -static int pub_decode_gost01(EVP_PKEY *pk, X509_PUBKEY *pub) +static int pub_decode_gost_ec(EVP_PKEY *pk, const X509_PUBKEY *pub) { X509_ALGOR *palg = NULL; const unsigned char *pubkey_buf = NULL; - unsigned char *databuf; + unsigned char *databuf = NULL; ASN1_OBJECT *palgobj = NULL; - int pub_len, i, j; - EC_POINT *pub_key; - BIGNUM *X, *Y; + int pub_len; + EC_POINT *pub_key = NULL; + BIGNUM *X = NULL, *Y = NULL; ASN1_OCTET_STRING *octet = NULL; - int len; + size_t len; const EC_GROUP *group; + int retval = 0; if (!X509_PUBKEY_get0_param(&palgobj, &pubkey_buf, &pub_len, &palg, pub)) - return 0; + goto ret; EVP_PKEY_assign(pk, OBJ_obj2nid(palgobj), NULL); if (!decode_gost_algor_params(pk, palg)) - return 0; + goto ret; group = EC_KEY_get0_group(EVP_PKEY_get0(pk)); octet = d2i_ASN1_OCTET_STRING(NULL, &pubkey_buf, pub_len); if (!octet) { - GOSTerr(GOST_F_PUB_DECODE_GOST01, ERR_R_MALLOC_FAILURE); - return 0; + GOSTerr(GOST_F_PUB_DECODE_GOST_EC, ERR_R_MALLOC_FAILURE); + goto ret; } databuf = OPENSSL_malloc(octet->length); - for (i = 0, j = octet->length - 1; i < octet->length; i++, j--) { - databuf[j] = octet->data[i]; + if (!databuf) { + GOSTerr(GOST_F_PUB_DECODE_GOST_EC, ERR_R_MALLOC_FAILURE); + goto ret; } + + BUF_reverse(databuf, octet->data, octet->length); len = octet->length / 2; - ASN1_OCTET_STRING_free(octet); - Y = getbnfrombuf(databuf, len); - X = getbnfrombuf(databuf + len, len); - OPENSSL_free(databuf); + Y = BN_bin2bn(databuf, len, NULL); + X = BN_bin2bn(databuf + len, len, NULL); + if (!X || !Y) { + GOSTerr(GOST_F_PUB_DECODE_GOST_EC, ERR_R_BN_LIB); + goto ret; + } pub_key = EC_POINT_new(group); - if (!EC_POINT_set_affine_coordinates_GFp(group, pub_key, X, Y, NULL)) { - GOSTerr(GOST_F_PUB_DECODE_GOST01, ERR_R_EC_LIB); - EC_POINT_free(pub_key); - BN_free(X); - BN_free(Y); - return 0; + if (!EC_POINT_set_affine_coordinates(group, pub_key, X, Y, NULL)) { + GOSTerr(GOST_F_PUB_DECODE_GOST_EC, ERR_R_EC_LIB); + goto ret; } + + retval = EC_KEY_set_public_key(EVP_PKEY_get0(pk), pub_key); + if (!retval) + GOSTerr(GOST_F_PUB_DECODE_GOST_EC, ERR_R_EC_LIB); + +ret: + EC_POINT_free(pub_key); BN_free(X); BN_free(Y); - if (!EC_KEY_set_public_key(EVP_PKEY_get0(pk), pub_key)) { - GOSTerr(GOST_F_PUB_DECODE_GOST01, ERR_R_EC_LIB); - EC_POINT_free(pub_key); - return 0; - } - EC_POINT_free(pub_key); - return 1; - + OPENSSL_free(databuf); + ASN1_OCTET_STRING_free(octet); + return retval; } -static int pub_encode_gost01(X509_PUBKEY *pub, const EVP_PKEY *pk) +static int pub_encode_gost_ec(X509_PUBKEY *pub, const EVP_PKEY *pk) { - ASN1_OBJECT *algobj = NULL; + ASN1_OBJECT *algobj; ASN1_OCTET_STRING *octet = NULL; - void *pval = NULL; - unsigned char *buf = NULL, *databuf, *sptr; - int i, j, data_len, ret = 0; + void *pval; + unsigned char *buf = NULL, *databuf = NULL; + int data_len, ret = -1; const EC_POINT *pub_key; - BIGNUM *X, *Y, *order; + BIGNUM *X = NULL, *Y = NULL, *order; const EC_KEY *ec = EVP_PKEY_get0((EVP_PKEY *)pk); - int ptype = V_ASN1_UNDEF; + int ptype = V_ASN1_SEQUENCE; + ASN1_STRING *params; algobj = OBJ_nid2obj(EVP_PKEY_base_id(pk)); - if (pk->save_parameters) { - ASN1_STRING *params = encode_gost_algor_params(pk); - pval = params; - ptype = V_ASN1_SEQUENCE; - } + + params = encode_gost_algor_params(pk); + pval = params; + order = BN_new(); - EC_GROUP_get_order(EC_KEY_get0_group(ec), order, NULL); + if (order == NULL || EC_GROUP_get_order(EC_KEY_get0_group(ec), order, NULL) == 0) { + GOSTerr(GOST_F_PUB_ENCODE_GOST_EC, ERR_R_MALLOC_FAILURE); + goto err; + } + if (EC_GROUP_get_order(EC_KEY_get0_group(ec), order, NULL) == 0) { + GOSTerr(GOST_F_PUB_ENCODE_GOST_EC, ERR_R_INTERNAL_ERROR); + goto err; + } pub_key = EC_KEY_get0_public_key(ec); if (!pub_key) { - GOSTerr(GOST_F_PUB_ENCODE_GOST01, GOST_R_PUBLIC_KEY_UNDEFINED); - return 0; + GOSTerr(GOST_F_PUB_ENCODE_GOST_EC, GOST_R_PUBLIC_KEY_UNDEFINED); + goto err; } X = BN_new(); Y = BN_new(); - if(!X || !Y) { - GOSTerr(GOST_F_PUB_ENCODE_GOST01, ERR_R_MALLOC_FAILURE); - if(X) BN_free(X); - if(Y) BN_free(Y); - BN_free(order); - return 0; + if (!X || !Y) { + GOSTerr(GOST_F_PUB_ENCODE_GOST_EC, ERR_R_MALLOC_FAILURE); + goto err; } - if(!EC_POINT_get_affine_coordinates_GFp(EC_KEY_get0_group(ec), - pub_key, X, Y, NULL)) { - GOSTerr(GOST_F_PUB_ENCODE_GOST01, ERR_R_INTERNAL_ERROR); - BN_free(X); - BN_free(Y); - BN_free(order); - return 0; + if (!EC_POINT_get_affine_coordinates(EC_KEY_get0_group(ec), + pub_key, X, Y, NULL)) { + GOSTerr(GOST_F_PUB_ENCODE_GOST_EC, ERR_R_INTERNAL_ERROR); + goto err; } data_len = 2 * BN_num_bytes(order); - BN_free(order); - databuf = OPENSSL_malloc(data_len); - memset(databuf, 0, data_len); + databuf = OPENSSL_zalloc(data_len); + if (databuf == NULL) { + GOSTerr(GOST_F_PUB_ENCODE_GOST_EC, ERR_R_MALLOC_FAILURE); + goto err; + } store_bignum(X, databuf + data_len / 2, data_len / 2); store_bignum(Y, databuf, data_len / 2); - BN_free(X); - BN_free(Y); + BUF_reverse(databuf, NULL, data_len); + octet = ASN1_OCTET_STRING_new(); - ASN1_STRING_set(octet, NULL, data_len); - sptr = ASN1_STRING_data(octet); - for (i = 0, j = data_len - 1; i < data_len; i++, j--) { - sptr[i] = databuf[j]; + if (octet == NULL) { + GOSTerr(GOST_F_PUB_ENCODE_GOST_EC, ERR_R_MALLOC_FAILURE); + goto err; } - OPENSSL_free(databuf); + + if (0 == ASN1_STRING_set(octet, databuf, data_len)) { + GOSTerr(GOST_F_PUB_ENCODE_GOST_EC, ERR_R_MALLOC_FAILURE); + goto err; + } + ret = i2d_ASN1_OCTET_STRING(octet, &buf); + err: ASN1_BIT_STRING_free(octet); + if (X) + BN_free(X); + if (Y) + BN_free(Y); + if (order) + BN_free(order); + if (databuf) + OPENSSL_free(databuf); + if (ret < 0) return 0; return X509_PUBKEY_set0_param(pub, algobj, ptype, pval, buf, ret); } -static int pub_cmp_gost94(const EVP_PKEY *a, const EVP_PKEY *b) -{ - const DSA *da = EVP_PKEY_get0((EVP_PKEY *)a); - const DSA *db = EVP_PKEY_get0((EVP_PKEY *)b); - if (da && db && da->pub_key && db->pub_key - && !BN_cmp(da->pub_key, db->pub_key)) { - return 1; - } - return 0; -} - -static int pub_cmp_gost01(const EVP_PKEY *a, const EVP_PKEY *b) +static int pub_cmp_gost_ec(const EVP_PKEY *a, const EVP_PKEY *b) { const EC_KEY *ea = EVP_PKEY_get0((EVP_PKEY *)a); const EC_KEY *eb = EVP_PKEY_get0((EVP_PKEY *)b); const EC_POINT *ka, *kb; - int ret = 0; if (!ea || !eb) return 0; ka = EC_KEY_get0_public_key(ea); kb = EC_KEY_get0_public_key(eb); if (!ka || !kb) return 0; - ret = (0 == EC_POINT_cmp(EC_KEY_get0_group(ea), ka, kb, NULL)); - return ret; + return (0 == EC_POINT_cmp(EC_KEY_get0_group(ea), ka, kb, NULL)); } static int pkey_size_gost(const EVP_PKEY *pk) { - return 64; -} + if (!pk) + return -1; -static int pkey_bits_gost(const EVP_PKEY *pk) -{ - return 256; + switch (EVP_PKEY_base_id(pk)) { + case NID_id_GostR3410_94: + case NID_id_GostR3410_2001: + case NID_id_GostR3410_2001DH: + case NID_id_GostR3410_2012_256: + return 64; + case NID_id_GostR3410_2012_512: + return 128; + } + + return -1; } /* ---------------------- ASN1 METHOD for GOST MAC -------------------*/ static void mackey_free_gost(EVP_PKEY *pk) { - if (pk->pkey.ptr) { - OPENSSL_free(pk->pkey.ptr); - } + OPENSSL_free(EVP_PKEY_get0(pk)); } static int mac_ctrl_gost(EVP_PKEY *pkey, int op, long arg1, void *arg2) { switch (op) { case ASN1_PKEY_CTRL_DEFAULT_MD_NID: - *(int *)arg2 = NID_id_Gost28147_89_MAC; - return 2; + if (arg2) { + *(int *)arg2 = NID_id_Gost28147_89_MAC; + return 2; + } } return -2; } -static int gost94_param_encode(const EVP_PKEY *pkey, unsigned char **pder) +static int mac_ctrl_gost_12(EVP_PKEY *pkey, int op, long arg1, void *arg2) { - int nid = gost94_nid_by_params(EVP_PKEY_get0((EVP_PKEY *)pkey)); - return i2d_ASN1_OBJECT(OBJ_nid2obj(nid), pder); + switch (op) { + case ASN1_PKEY_CTRL_DEFAULT_MD_NID: + if (arg2) { + *(int *)arg2 = NID_gost_mac_12; + return 2; + } + } + return -2; +} + +static int mac_ctrl_magma(EVP_PKEY *pkey, int op, long arg1, void *arg2) +{ + switch (op) { + case ASN1_PKEY_CTRL_DEFAULT_MD_NID: + if (arg2) { + *(int *)arg2 = NID_magma_mac; + return 2; + } + } + return -2; +} + +static int mac_ctrl_grasshopper(EVP_PKEY *pkey, int op, long arg1, void *arg2) +{ + switch (op) { + case ASN1_PKEY_CTRL_DEFAULT_MD_NID: + if (arg2) { + *(int *)arg2 = NID_grasshopper_mac; + return 2; + } + } + return -2; } static int gost2001_param_encode(const EVP_PKEY *pkey, unsigned char **pder) @@ -850,46 +1138,18 @@ static int gost2001_param_encode(const EVP_PKEY *pkey, unsigned char **pder) return i2d_ASN1_OBJECT(OBJ_nid2obj(nid), pder); } -static int gost94_param_decode(EVP_PKEY *pkey, const unsigned char **pder, - int derlen) -{ - ASN1_OBJECT *obj = NULL; - DSA *dsa = EVP_PKEY_get0(pkey); - int nid; - if (d2i_ASN1_OBJECT(&obj, pder, derlen) == NULL) { - return 0; - } - nid = OBJ_obj2nid(obj); - ASN1_OBJECT_free(obj); - if (!dsa) { - dsa = DSA_new(); - if (!EVP_PKEY_assign(pkey, NID_id_GostR3410_94, dsa)) - return 0; - } - if (!fill_GOST94_params(dsa, nid)) - return 0; - return 1; -} - static int gost2001_param_decode(EVP_PKEY *pkey, const unsigned char **pder, int derlen) { ASN1_OBJECT *obj = NULL; int nid; - EC_KEY *ec = EVP_PKEY_get0(pkey); if (d2i_ASN1_OBJECT(&obj, pder, derlen) == NULL) { return 0; } nid = OBJ_obj2nid(obj); ASN1_OBJECT_free(obj); - if (!ec) { - ec = EC_KEY_new(); - if (!EVP_PKEY_assign(pkey, NID_id_GostR3410_2001, ec)) - return 0; - } - if (!fill_GOST2001_params(ec, nid)) - return 0; - return 1; + + return gost_decode_nid_params(pkey, NID_id_GostR3410_2001, nid); } /* ----------------------------------------------------------------------*/ @@ -900,44 +1160,61 @@ int register_ameth_gost(int nid, EVP_PKEY_ASN1_METHOD **ameth, if (!*ameth) return 0; switch (nid) { - case NID_id_GostR3410_94: - EVP_PKEY_asn1_set_free(*ameth, pkey_free_gost94); + case NID_id_GostR3410_2001: + case NID_id_GostR3410_2001DH: + EVP_PKEY_asn1_set_free(*ameth, pkey_free_gost_ec); EVP_PKEY_asn1_set_private(*ameth, priv_decode_gost, priv_encode_gost, - priv_print_gost94); + priv_print_gost_ec); EVP_PKEY_asn1_set_param(*ameth, - gost94_param_decode, gost94_param_encode, - param_missing_gost94, param_copy_gost94, - param_cmp_gost94, param_print_gost94); + gost2001_param_decode, gost2001_param_encode, + param_missing_gost_ec, param_copy_gost_ec, + param_cmp_gost_ec, param_print_gost_ec); EVP_PKEY_asn1_set_public(*ameth, - pub_decode_gost94, pub_encode_gost94, - pub_cmp_gost94, pub_print_gost94, + pub_decode_gost_ec, pub_encode_gost_ec, + pub_cmp_gost_ec, pub_print_gost_ec, pkey_size_gost, pkey_bits_gost); EVP_PKEY_asn1_set_ctrl(*ameth, pkey_ctrl_gost); + EVP_PKEY_asn1_set_security_bits(*ameth, pkey_bits_gost); break; - case NID_id_GostR3410_2001: - EVP_PKEY_asn1_set_free(*ameth, pkey_free_gost01); + case NID_id_GostR3410_2012_256: + case NID_id_GostR3410_2012_512: + EVP_PKEY_asn1_set_free(*ameth, pkey_free_gost_ec); EVP_PKEY_asn1_set_private(*ameth, priv_decode_gost, priv_encode_gost, - priv_print_gost01); + priv_print_gost_ec); EVP_PKEY_asn1_set_param(*ameth, - gost2001_param_decode, gost2001_param_encode, - param_missing_gost01, param_copy_gost01, - param_cmp_gost01, param_print_gost01); + NULL, NULL, + param_missing_gost_ec, param_copy_gost_ec, + param_cmp_gost_ec, NULL); + EVP_PKEY_asn1_set_public(*ameth, - pub_decode_gost01, pub_encode_gost01, - pub_cmp_gost01, pub_print_gost01, + pub_decode_gost_ec, pub_encode_gost_ec, + pub_cmp_gost_ec, pub_print_gost_ec, pkey_size_gost, pkey_bits_gost); EVP_PKEY_asn1_set_ctrl(*ameth, pkey_ctrl_gost); + EVP_PKEY_asn1_set_security_bits(*ameth, pkey_bits_gost); break; case NID_id_Gost28147_89_MAC: EVP_PKEY_asn1_set_free(*ameth, mackey_free_gost); EVP_PKEY_asn1_set_ctrl(*ameth, mac_ctrl_gost); break; + case NID_gost_mac_12: + EVP_PKEY_asn1_set_free(*ameth, mackey_free_gost); + EVP_PKEY_asn1_set_ctrl(*ameth, mac_ctrl_gost_12); + break; + case NID_magma_mac: + EVP_PKEY_asn1_set_free(*ameth, mackey_free_gost); + EVP_PKEY_asn1_set_ctrl(*ameth, mac_ctrl_magma); + break; + case NID_grasshopper_mac: + EVP_PKEY_asn1_set_free(*ameth, mackey_free_gost); + EVP_PKEY_asn1_set_ctrl(*ameth, mac_ctrl_grasshopper); + break; } return 1; }