Send the function codes from the error functions to the bit bucket,

as was done earlier in libssl. Thanks inoguchi@ for noticing
libssl had more reacharounds into this.
ok jsing@ inoguchi@

6 files changed, 83 insertions, 143 deletions

diff --git a/src/lib/libcrypto/gost/gost89imit_pmeth.c b/src/lib/libcrypto/gost/gost89imit_pmeth.c
index 00eaf1decc..1959b36163 100644
--- a/src/lib/libcrypto/gost/gost89imit_pmeth.c
+++ b/src/lib/libcrypto/gost/gost89imit_pmeth.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: gost89imit_pmeth.c,v 1.3 2014/11/13 20:29:55 miod Exp $ */
+/* $OpenBSD: gost89imit_pmeth.c,v 1.4 2017/01/29 17:49:23 beck Exp $ */
 /*
  * Copyright (c) 2014 Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
  * Copyright (c) 2005-2006 Cryptocom LTD
@@ -110,13 +110,13 @@ pkey_gost_mac_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
         unsigned char *keydata;
 
         if (!data->key_set) {
-                GOSTerr(GOST_F_PKEY_GOST_MAC_KEYGEN, GOST_R_MAC_KEY_NOT_SET);
+                GOSTerror(GOST_R_MAC_KEY_NOT_SET);
                 return 0;
         }
 
         keydata = malloc(32);
         if (keydata == NULL) {
-                GOSTerr(GOST_F_PKEY_GOST_MAC_KEYGEN, ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 return 0;
         }
         memcpy(keydata, data->key, 32);
@@ -133,8 +133,7 @@ pkey_gost_mac_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
         switch (type) {
         case EVP_PKEY_CTRL_MD:
                 if (EVP_MD_type(p2) != NID_id_Gost28147_89_MAC) {
-                        GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL,
-                            GOST_R_INVALID_DIGEST_TYPE);
+                        GOSTerror(GOST_R_INVALID_DIGEST_TYPE);
                         return 0;
                 }
                 data->md = p2;
@@ -142,8 +141,7 @@ pkey_gost_mac_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 
         case EVP_PKEY_CTRL_SET_MAC_KEY:
                 if (p1 != 32) {
-                        GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL,
-                            GOST_R_INVALID_MAC_KEY_LENGTH);
+                        GOSTerror(GOST_R_INVALID_MAC_KEY_LENGTH);
                         return 0;
                 }
 
@@ -159,14 +157,12 @@ pkey_gost_mac_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
                 if (!data->key_set) {
                         EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(ctx);
                         if (pkey == NULL) {
-                                GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL,
-                                    GOST_R_MAC_KEY_NOT_SET);
+                                GOSTerror(GOST_R_MAC_KEY_NOT_SET);
                                 return 0;
                         }
                         key = EVP_PKEY_get0(pkey);
                         if (key == NULL) {
-                                GOSTerr(GOST_F_PKEY_GOST_MAC_CTRL,
-                                    GOST_R_MAC_KEY_NOT_SET);
+                                GOSTerror(GOST_R_MAC_KEY_NOT_SET);
                                 return 0;
                         }
                 } else {
diff --git a/src/lib/libcrypto/gost/gost_err.c b/src/lib/libcrypto/gost/gost_err.c
index b4e061f985..3bf60ff063 100644
--- a/src/lib/libcrypto/gost/gost_err.c
+++ b/src/lib/libcrypto/gost/gost_err.c
@@ -68,37 +68,10 @@
 #define ERR_FUNC(func) ERR_PACK(ERR_LIB_GOST,func,0)
 #define ERR_REASON(reason) ERR_PACK(ERR_LIB_GOST,0,reason)
 
-static ERR_STRING_DATA GOST_str_functs[]=
-        {
-{ERR_FUNC(GOST_F_DECODE_GOST01_ALGOR_PARAMS),   "DECODE_GOST01_ALGOR_PARAMS"},
-{ERR_FUNC(GOST_F_ENCODE_GOST01_ALGOR_PARAMS),   "ENCODE_GOST01_ALGOR_PARAMS"},
-{ERR_FUNC(GOST_F_GOST2001_COMPUTE_PUBLIC),      "GOST2001_COMPUTE_PUBLIC"},
-{ERR_FUNC(GOST_F_GOST2001_DO_SIGN),     "GOST2001_DO_SIGN"},
-{ERR_FUNC(GOST_F_GOST2001_DO_VERIFY),   "GOST2001_DO_VERIFY"},
-{ERR_FUNC(GOST_F_GOST2001_KEYGEN),      "GOST2001_KEYGEN"},
-{ERR_FUNC(GOST_F_GOST89_GET_ASN1_PARAMETERS),   "GOST89_GET_ASN1_PARAMETERS"},
-{ERR_FUNC(GOST_F_GOST89_SET_ASN1_PARAMETERS),   "GOST89_SET_ASN1_PARAMETERS"},
-{ERR_FUNC(GOST_F_GOST_KEY_CHECK_KEY),   "GOST_KEY_check_key"},
-{ERR_FUNC(GOST_F_GOST_KEY_NEW), "GOST_KEY_new"},
-{ERR_FUNC(GOST_F_GOST_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES),   "GOST_KEY_set_public_key_affine_coordinates"},
-{ERR_FUNC(GOST_F_PARAM_COPY_GOST01),    "PARAM_COPY_GOST01"},
-{ERR_FUNC(GOST_F_PARAM_DECODE_GOST01),  "PARAM_DECODE_GOST01"},
-{ERR_FUNC(GOST_F_PKEY_GOST01_CTRL),     "PKEY_GOST01_CTRL"},
-{ERR_FUNC(GOST_F_PKEY_GOST01_DECRYPT),  "PKEY_GOST01_DECRYPT"},
-{ERR_FUNC(GOST_F_PKEY_GOST01_DERIVE),   "PKEY_GOST01_DERIVE"},
-{ERR_FUNC(GOST_F_PKEY_GOST01_ENCRYPT),  "PKEY_GOST01_ENCRYPT"},
-{ERR_FUNC(GOST_F_PKEY_GOST01_PARAMGEN), "PKEY_GOST01_PARAMGEN"},
-{ERR_FUNC(GOST_F_PKEY_GOST01_SIGN),     "PKEY_GOST01_SIGN"},
-{ERR_FUNC(GOST_F_PKEY_GOST_MAC_CTRL),   "PKEY_GOST_MAC_CTRL"},
-{ERR_FUNC(GOST_F_PKEY_GOST_MAC_KEYGEN), "PKEY_GOST_MAC_KEYGEN"},
-{ERR_FUNC(GOST_F_PRIV_DECODE_GOST01),   "PRIV_DECODE_GOST01"},
-{ERR_FUNC(GOST_F_PUB_DECODE_GOST01),    "PUB_DECODE_GOST01"},
-{ERR_FUNC(GOST_F_PUB_ENCODE_GOST01),    "PUB_ENCODE_GOST01"},
-{ERR_FUNC(GOST_F_PUB_PRINT_GOST01),     "PUB_PRINT_GOST01"},
-{ERR_FUNC(GOST_F_UNPACK_SIGNATURE_CP),  "UNPACK_SIGNATURE_CP"},
-{ERR_FUNC(GOST_F_UNPACK_SIGNATURE_LE),  "UNPACK_SIGNATURE_LE"},
-{0,NULL}
-        };
+static ERR_STRING_DATA GOST_str_functs[]= {
+        {ERR_FUNC(0xfff), "CRYPTO_internal"},
+        {0, NULL}
+};
 
 static ERR_STRING_DATA GOST_str_reasons[]=
         {
diff --git a/src/lib/libcrypto/gost/gostr341001.c b/src/lib/libcrypto/gost/gostr341001.c
index 39749394af..ba70d5f1fc 100644
--- a/src/lib/libcrypto/gost/gostr341001.c
+++ b/src/lib/libcrypto/gost/gostr341001.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: gostr341001.c,v 1.6 2017/01/21 11:00:47 beck Exp $ */
+/* $OpenBSD: gostr341001.c,v 1.7 2017/01/29 17:49:23 beck Exp $ */
 /*
  * Copyright (c) 2014 Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
  * Copyright (c) 2005-2006 Cryptocom LTD
@@ -109,14 +109,12 @@ gost2001_compute_public(GOST_KEY *ec)
         int ok = 0;
 
         if (group == NULL) {
-                GOSTerr(GOST_F_GOST2001_COMPUTE_PUBLIC,
-                    GOST_R_KEY_IS_NOT_INITIALIZED);
+                GOSTerror(GOST_R_KEY_IS_NOT_INITIALIZED);
                 return 0;
         }
         ctx = BN_CTX_new();
         if (ctx == NULL) {
-                GOSTerr(GOST_F_GOST2001_COMPUTE_PUBLIC,
-                    ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 return 0;
         }
         BN_CTX_start(ctx);
@@ -134,7 +132,7 @@ gost2001_compute_public(GOST_KEY *ec)
 
         if (ok == 0) {
 err:
-                GOSTerr(GOST_F_GOST2001_COMPUTE_PUBLIC, ERR_R_EC_LIB);
+                GOSTerror(ERR_R_EC_LIB);
         }
         EC_POINT_free(pub_key);
         if (ctx != NULL) {
@@ -158,13 +156,13 @@ gost2001_do_sign(BIGNUM *md, GOST_KEY *eckey)
         int ok = 0;
 
         if (ctx == NULL) {
-                GOSTerr(GOST_F_GOST2001_DO_SIGN, ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 return NULL;
         }
         BN_CTX_start(ctx);
         newsig = ECDSA_SIG_new();
         if (newsig == NULL) {
-                GOSTerr(GOST_F_GOST2001_DO_SIGN, ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 goto err;
         }
         s = newsig->s;
@@ -190,8 +188,7 @@ gost2001_do_sign(BIGNUM *md, GOST_KEY *eckey)
         do {
                 do {
                         if (!BN_rand_range(k, order)) {
-                                GOSTerr(GOST_F_GOST2001_DO_SIGN,
-                                        GOST_R_RANDOM_NUMBER_GENERATOR_FAILED);
+                                GOSTerror(GOST_R_RANDOM_NUMBER_GENERATOR_FAILED);
                                 goto err;
                         }
                         /*
@@ -206,12 +203,12 @@ gost2001_do_sign(BIGNUM *md, GOST_KEY *eckey)
                                         goto err;
 
                         if (EC_POINT_mul(group, C, k, NULL, NULL, ctx) == 0) {
-                                GOSTerr(GOST_F_GOST2001_DO_SIGN, ERR_R_EC_LIB);
+                                GOSTerror(ERR_R_EC_LIB);
                                 goto err;
                         }
                         if (EC_POINT_get_affine_coordinates_GFp(group, C, X,
                             NULL, ctx) == 0) {
-                                GOSTerr(GOST_F_GOST2001_DO_SIGN, ERR_R_EC_LIB);
+                                GOSTerror(ERR_R_EC_LIB);
                                 goto err;
                         }
                         if (BN_nnmod(r, X, order, ctx) == 0)
@@ -285,8 +282,7 @@ gost2001_do_verify(BIGNUM *md, ECDSA_SIG *sig, GOST_KEY *ec)
         pub_key = GOST_KEY_get0_public_key(ec);
         if (BN_is_zero(sig->s) || BN_is_zero(sig->r) ||
             BN_cmp(sig->s, order) >= 1 || BN_cmp(sig->r, order) >= 1) {
-                GOSTerr(GOST_F_GOST2001_DO_VERIFY,
-                    GOST_R_SIGNATURE_PARTS_GREATER_THAN_Q);
+                GOSTerror(GOST_R_SIGNATURE_PARTS_GREATER_THAN_Q);
                 goto err;
         }
 
@@ -305,17 +301,17 @@ gost2001_do_verify(BIGNUM *md, ECDSA_SIG *sig, GOST_KEY *ec)
         if ((C = EC_POINT_new(group)) == NULL)
                 goto err;
         if (EC_POINT_mul(group, C, z1, pub_key, z2, ctx) == 0) {
-                GOSTerr(GOST_F_GOST2001_DO_VERIFY, ERR_R_EC_LIB);
+                GOSTerror(ERR_R_EC_LIB);
                 goto err;
         }
         if (EC_POINT_get_affine_coordinates_GFp(group, C, X, NULL, ctx) == 0) {
-                GOSTerr(GOST_F_GOST2001_DO_VERIFY, ERR_R_EC_LIB);
+                GOSTerror(ERR_R_EC_LIB);
                 goto err;
         }
         if (BN_mod_ct(R, X, order, ctx) == 0)
                 goto err;
         if (BN_cmp(R, sig->r) != 0) {
-                GOSTerr(GOST_F_GOST2001_DO_VERIFY, GOST_R_SIGNATURE_MISMATCH);
+                GOSTerror(GOST_R_SIGNATURE_MISMATCH);
         } else {
                 ok = 1;
         }
@@ -385,8 +381,7 @@ gost2001_keygen(GOST_KEY *ec)
 
         do {
                 if (BN_rand_range(d, order) == 0) {
-                        GOSTerr(GOST_F_GOST2001_KEYGEN,
-                                GOST_R_RANDOM_NUMBER_GENERATOR_FAILED);
+                        GOSTerror(GOST_R_RANDOM_NUMBER_GENERATOR_FAILED);
                         goto err;
                 }
         } while (BN_is_zero(d));
diff --git a/src/lib/libcrypto/gost/gostr341001_ameth.c b/src/lib/libcrypto/gost/gostr341001_ameth.c
index bb569ea846..b6958c77d5 100644
--- a/src/lib/libcrypto/gost/gostr341001_ameth.c
+++ b/src/lib/libcrypto/gost/gostr341001_ameth.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: gostr341001_ameth.c,v 1.10 2016/10/19 16:49:11 jsing Exp $ */
+/* $OpenBSD: gostr341001_ameth.c,v 1.11 2017/01/29 17:49:23 beck Exp $ */
 /*
  * Copyright (c) 2014 Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
  * Copyright (c) 2005-2006 Cryptocom LTD
@@ -86,8 +86,7 @@ decode_gost01_algor_params(EVP_PKEY *pkey, const unsigned char **p, int len)
 
         gkp = d2i_GOST_KEY_PARAMS(NULL, p, len);
         if (gkp == NULL) {
-                GOSTerr(GOST_F_DECODE_GOST01_ALGOR_PARAMS,
-                        GOST_R_BAD_PKEY_PARAMETERS_FORMAT);
+                GOSTerror(GOST_R_BAD_PKEY_PARAMETERS_FORMAT);
                 return 0;
         }
         param_nid = OBJ_obj2nid(gkp->key_params);
@@ -125,8 +124,7 @@ encode_gost01_algor_params(const EVP_PKEY *key)
         int pkey_param_nid = NID_undef;
 
         if (params == NULL || gkp == NULL) {
-                GOSTerr(GOST_F_ENCODE_GOST01_ALGOR_PARAMS,
-                    ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 ASN1_STRING_free(params);
                 params = NULL;
                 goto err;
@@ -139,8 +137,7 @@ encode_gost01_algor_params(const EVP_PKEY *key)
         /*gkp->cipher_params = OBJ_nid2obj(cipher_param_nid); */
         params->length = i2d_GOST_KEY_PARAMS(gkp, &params->data);
         if (params->length <= 0) {
-                GOSTerr(GOST_F_ENCODE_GOST01_ALGOR_PARAMS,
-                    ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 ASN1_STRING_free(params);
                 params = NULL;
                 goto err;
@@ -206,8 +203,7 @@ pub_decode_gost01(EVP_PKEY *pk, X509_PUBKEY *pub)
         (void)EVP_PKEY_assign_GOST(pk, NULL);
         X509_ALGOR_get0(NULL, &ptype, (void **)&pval, palg);
         if (ptype != V_ASN1_SEQUENCE) {
-                GOSTerr(GOST_F_PUB_DECODE_GOST01,
-                    GOST_R_BAD_KEY_PARAMETERS_FORMAT);
+                GOSTerror(GOST_R_BAD_KEY_PARAMETERS_FORMAT);
                 return 0;
         }
         p = pval->data;
@@ -216,7 +212,7 @@ pub_decode_gost01(EVP_PKEY *pk, X509_PUBKEY *pub)
 
         octet = d2i_ASN1_OCTET_STRING(NULL, &pubkey_buf, pub_len);
         if (octet == NULL) {
-                GOSTerr(GOST_F_PUB_DECODE_GOST01, ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 return 0;
         }
         len = octet->length / 2;
@@ -228,7 +224,7 @@ pub_decode_gost01(EVP_PKEY *pk, X509_PUBKEY *pub)
 
         ret = GOST_KEY_set_public_key_affine_coordinates(pk->pkey.gost, X, Y);
         if (ret == 0)
-                GOSTerr(GOST_F_PUB_DECODE_GOST01, ERR_R_EC_LIB);
+                GOSTerror(ERR_R_EC_LIB);
 
         BN_free(X);
         BN_free(Y);
@@ -263,19 +259,19 @@ pub_encode_gost01(X509_PUBKEY *pub, const EVP_PKEY *pk)
 
         pub_key = GOST_KEY_get0_public_key(ec);
         if (pub_key == NULL) {
-                GOSTerr(GOST_F_PUB_ENCODE_GOST01, GOST_R_PUBLIC_KEY_UNDEFINED);
+                GOSTerror(GOST_R_PUBLIC_KEY_UNDEFINED);
                 goto err;
         }
 
         octet = ASN1_OCTET_STRING_new();
         if (octet == NULL) {
-                GOSTerr(GOST_F_PUB_ENCODE_GOST01, ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 goto err;
         }
 
         ret = ASN1_STRING_set(octet, NULL, 2 * key_size);
         if (ret == 0) {
-                GOSTerr(GOST_F_PUB_ENCODE_GOST01, ERR_R_INTERNAL_ERROR);
+                GOSTerror(ERR_R_INTERNAL_ERROR);
                 goto err;
         }
 
@@ -284,13 +280,13 @@ pub_encode_gost01(X509_PUBKEY *pub, const EVP_PKEY *pk)
         X = BN_new();
         Y = BN_new();
         if (X == NULL || Y == NULL) {
-                GOSTerr(GOST_F_PUB_ENCODE_GOST01, ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 goto err;
         }
 
         if (EC_POINT_get_affine_coordinates_GFp(GOST_KEY_get0_group(ec),
             pub_key, X, Y, NULL) == 0) {
-                GOSTerr(GOST_F_PUB_ENCODE_GOST01, ERR_R_EC_LIB);
+                GOSTerror(ERR_R_EC_LIB);
                 goto err;
         }
 
@@ -340,7 +336,7 @@ pub_print_gost01(BIO *out, const EVP_PKEY *pkey, int indent, ASN1_PCTX *pctx)
         const EC_GROUP *group;
 
         if (ctx == NULL) {
-                GOSTerr(GOST_F_PUB_PRINT_GOST01, ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 return 0;
         }
         BN_CTX_start(ctx);
@@ -352,7 +348,7 @@ pub_print_gost01(BIO *out, const EVP_PKEY *pkey, int indent, ASN1_PCTX *pctx)
         group = GOST_KEY_get0_group(pkey->pkey.gost);
         if (EC_POINT_get_affine_coordinates_GFp(group, pubkey, X, Y,
             ctx) == 0) {
-                GOSTerr(GOST_F_PUB_PRINT_GOST01, ERR_R_EC_LIB);
+                GOSTerror(ERR_R_EC_LIB);
                 goto err;
         }
         if (BIO_indent(out, indent, 128) == 0)
@@ -416,8 +412,7 @@ priv_decode_gost01(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf)
         (void)EVP_PKEY_assign_GOST(pk, NULL);
         X509_ALGOR_get0(NULL, &ptype, (void **)&pval, palg);
         if (ptype != V_ASN1_SEQUENCE) {
-                GOSTerr(GOST_F_PUB_DECODE_GOST01,
-                    GOST_R_BAD_KEY_PARAMETERS_FORMAT);
+                GOSTerror(GOST_R_BAD_KEY_PARAMETERS_FORMAT);
                 return 0;
         }
         p = pval->data;
@@ -432,7 +427,7 @@ priv_decode_gost01(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf)
                     d2i_ASN1_OCTET_STRING(NULL, &p, priv_len);
 
                 if (s == NULL || s->length != 32) {
-                        GOSTerr(GOST_F_PRIV_DECODE_GOST01, EVP_R_DECODE_ERROR);
+                        GOSTerror(EVP_R_DECODE_ERROR);
                         ASN1_STRING_free(s);
                         return 0;
                 }
@@ -448,7 +443,7 @@ priv_decode_gost01(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf)
                 ret = ((pk_num = ASN1_INTEGER_to_BN(priv_key, NULL)) != NULL);
                 ASN1_INTEGER_free(priv_key);
                 if (ret == 0) {
-                        GOSTerr(GOST_F_PRIV_DECODE_GOST01, EVP_R_DECODE_ERROR);
+                        GOSTerror(EVP_R_DECODE_ERROR);
                         return 0;
                 }
         }
@@ -533,7 +528,7 @@ param_decode_gost01(EVP_PKEY *pkey, const unsigned char **pder, int derlen)
 
         /* Compatibility */
         if (d2i_ASN1_OBJECT(&obj, pder, derlen) == NULL) {
-                GOSTerr(GOST_F_PARAM_DECODE_GOST01, ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 return 0;
         }
         nid = OBJ_obj2nid(obj);
@@ -541,20 +536,19 @@ param_decode_gost01(EVP_PKEY *pkey, const unsigned char **pder, int derlen)
 
         ec = GOST_KEY_new();
         if (ec == NULL) {
-                GOSTerr(GOST_F_PARAM_DECODE_GOST01, ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 return 0;
         }
         group = EC_GROUP_new_by_curve_name(nid);
         if (group == NULL) {
-                GOSTerr(GOST_F_PARAM_DECODE_GOST01,
-                    EC_R_EC_GROUP_NEW_BY_NAME_FAILURE);
+                GOSTerror(EC_R_EC_GROUP_NEW_BY_NAME_FAILURE);
                 GOST_KEY_free(ec);
                 return 0;
         }
 
         EC_GROUP_set_asn1_flag(group, OPENSSL_EC_NAMED_CURVE);
         if (GOST_KEY_set_group(ec, group) == 0) {
-                GOSTerr(GOST_F_PARAM_DECODE_GOST01, ERR_R_EC_LIB);
+                GOSTerror(ERR_R_EC_LIB);
                 EC_GROUP_free(group);
                 GOST_KEY_free(ec);
                 return 0;
@@ -562,7 +556,7 @@ param_decode_gost01(EVP_PKEY *pkey, const unsigned char **pder, int derlen)
         EC_GROUP_free(group);
         if (GOST_KEY_set_digest(ec,
             NID_id_GostR3411_94_CryptoProParamSet) == 0) {
-                GOSTerr(GOST_F_PARAM_DECODE_GOST01, GOST_R_INVALID_DIGEST_TYPE);
+                GOSTerror(GOST_R_INVALID_DIGEST_TYPE);
                 GOST_KEY_free(ec);
                 return 0;
         }
@@ -594,20 +588,17 @@ param_copy_gost01(EVP_PKEY *to, const EVP_PKEY *from)
         int ret = 1;
 
         if (EVP_PKEY_base_id(from) != EVP_PKEY_base_id(to)) {
-                GOSTerr(GOST_F_PARAM_COPY_GOST01,
-                    GOST_R_INCOMPATIBLE_ALGORITHMS);
+                GOSTerror(GOST_R_INCOMPATIBLE_ALGORITHMS);
                 return 0;
         }
         if (efrom == NULL) {
-                GOSTerr(GOST_F_PARAM_COPY_GOST01,
-                    GOST_R_KEY_PARAMETERS_MISSING);
+                GOSTerror(GOST_R_KEY_PARAMETERS_MISSING);
                 return 0;
         }
         if (eto == NULL) {
                 eto = GOST_KEY_new();
                 if (eto == NULL) {
-                        GOSTerr(GOST_F_PARAM_COPY_GOST01,
-                            ERR_R_MALLOC_FAILURE);
+                        GOSTerror(ERR_R_MALLOC_FAILURE);
                         return 0;
                 }
                 if (EVP_PKEY_assign(to, EVP_PKEY_base_id(from), eto) == 0) {
diff --git a/src/lib/libcrypto/gost/gostr341001_key.c b/src/lib/libcrypto/gost/gostr341001_key.c
index 894a189e3b..0a42a15378 100644
--- a/src/lib/libcrypto/gost/gostr341001_key.c
+++ b/src/lib/libcrypto/gost/gostr341001_key.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: gostr341001_key.c,v 1.6 2015/09/10 15:56:25 jsing Exp $ */
+/* $OpenBSD: gostr341001_key.c,v 1.7 2017/01/29 17:49:23 beck Exp $ */
 /*
  * Copyright (c) 2014 Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
  * Copyright (c) 2005-2006 Cryptocom LTD
@@ -78,7 +78,7 @@ GOST_KEY_new(void)
 
         ret = malloc(sizeof(GOST_KEY));
         if (ret == NULL) {
-                GOSTerr(GOST_F_GOST_KEY_NEW, ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 return (NULL);
         }
         ret->group = NULL;
@@ -118,11 +118,11 @@ GOST_KEY_check_key(const GOST_KEY *key)
         EC_POINT *point = NULL;
 
         if (key == NULL || key->group == NULL || key->pub_key == NULL) {
-                GOSTerr(GOST_F_GOST_KEY_CHECK_KEY, ERR_R_PASSED_NULL_PARAMETER);
+                GOSTerror(ERR_R_PASSED_NULL_PARAMETER);
                 return 0;
         }
         if (EC_POINT_is_at_infinity(key->group, key->pub_key) != 0) {
-                GOSTerr(GOST_F_GOST_KEY_CHECK_KEY, EC_R_POINT_AT_INFINITY);
+                GOSTerror(EC_R_POINT_AT_INFINITY);
                 goto err;
         }
         if ((ctx = BN_CTX_new()) == NULL)
@@ -132,23 +132,23 @@ GOST_KEY_check_key(const GOST_KEY *key)
 
         /* testing whether the pub_key is on the elliptic curve */
         if (EC_POINT_is_on_curve(key->group, key->pub_key, ctx) == 0) {
-                GOSTerr(GOST_F_GOST_KEY_CHECK_KEY, EC_R_POINT_IS_NOT_ON_CURVE);
+                GOSTerror(EC_R_POINT_IS_NOT_ON_CURVE);
                 goto err;
         }
         /* testing whether pub_key * order is the point at infinity */
         if ((order = BN_new()) == NULL)
                 goto err;
         if (EC_GROUP_get_order(key->group, order, ctx) == 0) {
-                GOSTerr(GOST_F_GOST_KEY_CHECK_KEY, EC_R_INVALID_GROUP_ORDER);
+                GOSTerror(EC_R_INVALID_GROUP_ORDER);
                 goto err;
         }
         if (EC_POINT_mul(key->group, point, NULL, key->pub_key, order,
             ctx) == 0) {
-                GOSTerr(GOST_F_GOST_KEY_CHECK_KEY, ERR_R_EC_LIB);
+                GOSTerror(ERR_R_EC_LIB);
                 goto err;
         }
         if (EC_POINT_is_at_infinity(key->group, point) == 0) {
-                GOSTerr(GOST_F_GOST_KEY_CHECK_KEY, EC_R_WRONG_ORDER);
+                GOSTerror(EC_R_WRONG_ORDER);
                 goto err;
         }
         /*
@@ -157,17 +157,16 @@ GOST_KEY_check_key(const GOST_KEY *key)
          */
         if (key->priv_key != NULL) {
                 if (BN_cmp(key->priv_key, order) >= 0) {
-                        GOSTerr(GOST_F_GOST_KEY_CHECK_KEY, EC_R_WRONG_ORDER);
+                        GOSTerror(EC_R_WRONG_ORDER);
                         goto err;
                 }
                 if (EC_POINT_mul(key->group, point, key->priv_key, NULL, NULL,
                     ctx) == 0) {
-                        GOSTerr(GOST_F_GOST_KEY_CHECK_KEY, ERR_R_EC_LIB);
+                        GOSTerror(ERR_R_EC_LIB);
                         goto err;
                 }
                 if (EC_POINT_cmp(key->group, point, key->pub_key, ctx) != 0) {
-                        GOSTerr(GOST_F_GOST_KEY_CHECK_KEY,
-                            EC_R_INVALID_PRIVATE_KEY);
+                        GOSTerror(EC_R_INVALID_PRIVATE_KEY);
                         goto err;
                 }
         }
@@ -188,8 +187,7 @@ GOST_KEY_set_public_key_affine_coordinates(GOST_KEY *key, BIGNUM *x, BIGNUM *y)
         int ok = 0;
 
         if (key == NULL || key->group == NULL || x == NULL || y == NULL) {
-                GOSTerr(GOST_F_GOST_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES,
-                    ERR_R_PASSED_NULL_PARAMETER);
+                GOSTerror(ERR_R_PASSED_NULL_PARAMETER);
                 return 0;
         }
         ctx = BN_CTX_new();
@@ -215,8 +213,7 @@ GOST_KEY_set_public_key_affine_coordinates(GOST_KEY *key, BIGNUM *x, BIGNUM *y)
          * out of range.
          */
         if (BN_cmp(x, tx) != 0 || BN_cmp(y, ty) != 0) {
-                GOSTerr(GOST_F_GOST_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES,
-                    EC_R_COORDINATES_OUT_OF_RANGE);
+                GOSTerror(EC_R_COORDINATES_OUT_OF_RANGE);
                 goto err;
         }
         if (GOST_KEY_set_public_key(key, point) == 0)
diff --git a/src/lib/libcrypto/gost/gostr341001_pmeth.c b/src/lib/libcrypto/gost/gostr341001_pmeth.c
index 30a066612f..0eb1d873de 100644
--- a/src/lib/libcrypto/gost/gostr341001_pmeth.c
+++ b/src/lib/libcrypto/gost/gostr341001_pmeth.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: gostr341001_pmeth.c,v 1.13 2016/10/19 16:49:11 jsing Exp $ */
+/* $OpenBSD: gostr341001_pmeth.c,v 1.14 2017/01/29 17:49:23 beck Exp $ */
 /*
  * Copyright (c) 2014 Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
  * Copyright (c) 2005-2006 Cryptocom LTD
@@ -73,7 +73,7 @@ unpack_signature_cp(const unsigned char *sig, size_t siglen)
 
         s = ECDSA_SIG_new();
         if (s == NULL) {
-                GOSTerr(GOST_F_UNPACK_SIGNATURE_CP, ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 return NULL;
         }
         BN_bin2bn(sig, siglen / 2, s->s);
@@ -106,7 +106,7 @@ unpack_signature_le(const unsigned char *sig, size_t siglen)
 
         s = ECDSA_SIG_new();
         if (s == NULL) {
-                GOSTerr(GOST_F_UNPACK_SIGNATURE_LE, ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 return NULL;
         }
         GOST_le2bn(sig, siglen / 2, s->r);
@@ -190,7 +190,7 @@ pkey_gost01_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 
         if (data->sign_param_nid == NID_undef ||
             data->digest_nid == NID_undef) {
-                GOSTerr(GOST_F_PKEY_GOST01_PARAMGEN, GOST_R_NO_PARAMETERS_SET);
+                GOSTerror(GOST_R_NO_PARAMETERS_SET);
                 return 0;
         }
 
@@ -246,11 +246,11 @@ pkey_gost01_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
                 *siglen = 2 * size;
                 return 1;
         } else if (*siglen < 2 * size) {
-                GOSTerr(GOST_F_PKEY_GOST01_SIGN, EC_R_BUFFER_TOO_SMALL);
+                GOSTerror(EC_R_BUFFER_TOO_SMALL);
                 return 0;
         }
         if (tbs_len != 32 && tbs_len != 64) {
-                GOSTerr(GOST_F_PKEY_GOST01_SIGN, EVP_R_BAD_BLOCK_LENGTH);
+                GOSTerror(EVP_R_BAD_BLOCK_LENGTH);
                 return 0;
         }
         md = GOST_le2bn(tbs, tbs_len, NULL);
@@ -386,8 +386,7 @@ pkey_gost01_decrypt(EVP_PKEY_CTX *pctx, unsigned char *key, size_t *key_len,
         }
         gkt = d2i_GOST_KEY_TRANSPORT(NULL, (const unsigned char **)&p, in_len);
         if (gkt == NULL) {
-                GOSTerr(GOST_F_PKEY_GOST01_DECRYPT,
-                    GOST_R_ERROR_PARSING_KEY_TRANSPORT_INFO);
+                GOSTerror(GOST_R_ERROR_PARSING_KEY_TRANSPORT_INFO);
                 return -1;
         }
 
@@ -395,50 +394,44 @@ pkey_gost01_decrypt(EVP_PKEY_CTX *pctx, unsigned char *key, size_t *key_len,
         eph_key = X509_PUBKEY_get(gkt->key_agreement_info->ephem_key);
         if (eph_key != NULL) {
                 if (EVP_PKEY_derive_set_peer(pctx, eph_key) <= 0) {
-                        GOSTerr(GOST_F_PKEY_GOST01_DECRYPT,
-                            GOST_R_INCOMPATIBLE_PEER_KEY);
+                        GOSTerror(GOST_R_INCOMPATIBLE_PEER_KEY);
                         goto err;
                 }
         } else {
                 /* Set control "public key from client certificate used" */
                 if (EVP_PKEY_CTX_ctrl(pctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 3,
                     NULL) <= 0) {
-                        GOSTerr(GOST_F_PKEY_GOST01_DECRYPT,
-                            GOST_R_CTRL_CALL_FAILED);
+                        GOSTerror(GOST_R_CTRL_CALL_FAILED);
                         goto err;
                 }
         }
         peerkey = EVP_PKEY_CTX_get0_peerkey(pctx);
         if (peerkey == NULL) {
-                GOSTerr(GOST_F_PKEY_GOST01_DECRYPT, GOST_R_NO_PEER_KEY);
+                GOSTerror(GOST_R_NO_PEER_KEY);
                 goto err;
         }
 
         nid = OBJ_obj2nid(gkt->key_agreement_info->cipher);
 
         if (gkt->key_agreement_info->eph_iv->length != 8) {
-                GOSTerr(GOST_F_PKEY_GOST01_DECRYPT,
-                    GOST_R_INVALID_IV_LENGTH);
+                GOSTerror(GOST_R_INVALID_IV_LENGTH);
                 goto err;
         }
         memcpy(wrappedKey, gkt->key_agreement_info->eph_iv->data, 8);
         if (gkt->key_info->encrypted_key->length != 32) {
-                GOSTerr(GOST_F_PKEY_GOST01_DECRYPT,
-                    EVP_R_BAD_KEY_LENGTH);
+                GOSTerror(EVP_R_BAD_KEY_LENGTH);
                 goto err;
         }
         memcpy(wrappedKey + 8, gkt->key_info->encrypted_key->data, 32);
         if (gkt->key_info->imit->length != 4) {
-                GOSTerr(GOST_F_PKEY_GOST01_DECRYPT,
-                    ERR_R_INTERNAL_ERROR);
+                GOSTerror(ERR_R_INTERNAL_ERROR);
                 goto err;
         }
         memcpy(wrappedKey + 40, gkt->key_info->imit->data, 4);
         if (gost01_VKO_key(peerkey, priv, wrappedKey, sharedKey) <= 0)
                 goto err;
         if (gost_key_unwrap_crypto_pro(nid, sharedKey, wrappedKey, key) == 0) {
-                GOSTerr(GOST_F_PKEY_GOST01_DECRYPT,
-                    GOST_R_ERROR_COMPUTING_SHARED_KEY);
+                GOSTerror(GOST_R_ERROR_COMPUTING_SHARED_KEY);
                 goto err;
         }
 
@@ -462,7 +455,7 @@ pkey_gost01_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)
         struct gost_pmeth_data *data = EVP_PKEY_CTX_get_data(ctx);
 
         if (data->shared_ukm == NULL) {
-                GOSTerr(GOST_F_PKEY_GOST01_DERIVE, GOST_R_UKM_NOT_SET);
+                GOSTerror(GOST_R_UKM_NOT_SET);
                 return 0;
         }
 
@@ -500,8 +493,7 @@ pkey_gost01_encrypt(EVP_PKEY_CTX *pctx, unsigned char *out, size_t *out_len,
         if (sec_key) {
                 key_is_ephemeral = 0;
                 if (GOST_KEY_get0_private_key(sec_key->pkey.gost) == 0) {
-                        GOSTerr(GOST_F_PKEY_GOST01_ENCRYPT,
-                            GOST_R_NO_PRIVATE_PART_OF_NON_EPHEMERAL_KEYPAIR);
+                        GOSTerror(GOST_R_NO_PRIVATE_PART_OF_NON_EPHEMERAL_KEYPAIR);
                         goto err;
                 }
         } else {
@@ -548,8 +540,7 @@ pkey_gost01_encrypt(EVP_PKEY_CTX *pctx, unsigned char *out, size_t *out_len,
         if (key_is_ephemeral) {
                 if (X509_PUBKEY_set(&gkt->key_agreement_info->ephem_key,
                     out != NULL ? sec_key : pubk) == 0) {
-                        GOSTerr(GOST_F_PKEY_GOST01_ENCRYPT,
-                            GOST_R_CANNOT_PACK_EPHEMERAL_KEY);
+                        GOSTerror(GOST_R_CANNOT_PACK_EPHEMERAL_KEY);
                         goto err;
                 }
         }
@@ -561,8 +552,7 @@ pkey_gost01_encrypt(EVP_PKEY_CTX *pctx, unsigned char *out, size_t *out_len,
                 /* Set control "public key from client certificate used" */
                 if (EVP_PKEY_CTX_ctrl(pctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 3,
                     NULL) <= 0) {
-                        GOSTerr(GOST_F_PKEY_GOST01_ENCRYPT,
-                            GOST_R_CTRL_CALL_FAILED);
+                        GOSTerror(GOST_R_CTRL_CALL_FAILED);
                         goto err;
                 }
         }
@@ -588,8 +578,7 @@ pkey_gost01_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
         case EVP_PKEY_CTRL_MD:
                 if (EVP_MD_type(p2) !=
                     GostR3410_get_md_digest(pctx->digest_nid)) {
-                        GOSTerr(GOST_F_PKEY_GOST01_CTRL,
-                            GOST_R_INVALID_DIGEST_TYPE);
+                        GOSTerror(GOST_R_INVALID_DIGEST_TYPE);
                         return 0;
                 }
                 pctx->md = p2;
@@ -609,8 +598,7 @@ pkey_gost01_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
                 char *ukm = malloc(p1);
 
                 if (ukm == NULL) {
-                        GOSTerr(GOST_F_PKEY_GOST01_CTRL,
-                            ERR_R_MALLOC_FAILURE);
+                        GOSTerror(ERR_R_MALLOC_FAILURE);
                         return 0;
                 }
                 memcpy(ukm, p2, p1);