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@

25 files changed, 187 insertions, 347 deletions

diff --git a/src/lib/libcrypto/evp/digest.c b/src/lib/libcrypto/evp/digest.c
index 6d8ed9b499..ee1f955959 100644
--- a/src/lib/libcrypto/evp/digest.c
+++ b/src/lib/libcrypto/evp/digest.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: digest.c,v 1.26 2015/02/11 03:19:37 doug Exp $ */
+/* $OpenBSD: digest.c,v 1.27 2017/01/29 17:49:23 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -162,8 +162,7 @@ EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
                         ENGINE_finish(ctx->engine);
                 if (impl) {
                         if (!ENGINE_init(impl)) {
-                                EVPerr(EVP_F_EVP_DIGESTINIT_EX,
-                                    EVP_R_INITIALIZATION_ERROR);
+                                EVPerror(EVP_R_INITIALIZATION_ERROR);
                                 return 0;
                         }
                 } else
@@ -174,8 +173,7 @@ EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
                         const EVP_MD *d = ENGINE_get_digest(impl, type->type);
                         if (!d) {
                                 /* Same comment from evp_enc.c */
-                                EVPerr(EVP_F_EVP_DIGESTINIT_EX,
-                                    EVP_R_INITIALIZATION_ERROR);
+                                EVPerror(EVP_R_INITIALIZATION_ERROR);
                                 ENGINE_finish(impl);
                                 return 0;
                         }
@@ -188,7 +186,7 @@ EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
                 } else
                         ctx->engine = NULL;
         } else if (!ctx->digest) {
-                EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_NO_DIGEST_SET);
+                EVPerror(EVP_R_NO_DIGEST_SET);
                 return 0;
         }
 #endif
@@ -206,8 +204,7 @@ EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
                         if (ctx->md_data == NULL) {
                                 EVP_PKEY_CTX_free(ctx->pctx);
                                 ctx->pctx = NULL;
-                                EVPerr(EVP_F_EVP_DIGESTINIT_EX,
-                                    ERR_R_MALLOC_FAILURE);
+                                EVPerror(ERR_R_MALLOC_FAILURE);
                                 return 0;
                         }
                 }
@@ -251,7 +248,7 @@ EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
         int ret;
 
         if ((size_t)ctx->digest->md_size > EVP_MAX_MD_SIZE) {
-                EVPerr(EVP_F_EVP_DIGESTFINAL_EX, EVP_R_TOO_LARGE);
+                EVPerror(EVP_R_TOO_LARGE);
                 return 0;
         }
         ret = ctx->digest->final(ctx, md);
@@ -278,13 +275,13 @@ EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in)
         unsigned char *tmp_buf;
 
         if ((in == NULL) || (in->digest == NULL)) {
-                EVPerr(EVP_F_EVP_MD_CTX_COPY_EX, EVP_R_INPUT_NOT_INITIALIZED);
+                EVPerror(EVP_R_INPUT_NOT_INITIALIZED);
                 return 0;
         }
 #ifndef OPENSSL_NO_ENGINE
         /* Make sure it's safe to copy a digest context using an ENGINE */
         if (in->engine && !ENGINE_init(in->engine)) {
-                EVPerr(EVP_F_EVP_MD_CTX_COPY_EX, ERR_R_ENGINE_LIB);
+                EVPerror(ERR_R_ENGINE_LIB);
                 return 0;
         }
 #endif
@@ -303,8 +300,7 @@ EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in)
                 else {
                         out->md_data = malloc(out->digest->ctx_size);
                         if (!out->md_data) {
-                                EVPerr(EVP_F_EVP_MD_CTX_COPY_EX,
-                                    ERR_R_MALLOC_FAILURE);
+                                EVPerror(ERR_R_MALLOC_FAILURE);
                                 return 0;
                         }
                 }
@@ -386,19 +382,18 @@ EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int type, int arg, void *ptr)
         int ret;
 
         if (!ctx->digest) {
-                EVPerr(EVP_F_EVP_MD_CTX_CTRL, EVP_R_NO_CIPHER_SET);
+                EVPerror(EVP_R_NO_CIPHER_SET);
                 return 0;
         }
 
         if (!ctx->digest->md_ctrl) {
-                EVPerr(EVP_F_EVP_MD_CTX_CTRL, EVP_R_CTRL_NOT_IMPLEMENTED);
+                EVPerror(EVP_R_CTRL_NOT_IMPLEMENTED);
                 return 0;
         }
 
         ret = ctx->digest->md_ctrl(ctx, type, arg, ptr);
         if (ret == -1) {
-                EVPerr(EVP_F_EVP_MD_CTX_CTRL,
-                    EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED);
+                EVPerror(EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED);
                 return 0;
         }
         return ret;
diff --git a/src/lib/libcrypto/evp/e_aes.c b/src/lib/libcrypto/evp/e_aes.c
index b20543a90c..71a18363f1 100644
--- a/src/lib/libcrypto/evp/e_aes.c
+++ b/src/lib/libcrypto/evp/e_aes.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_aes.c,v 1.31 2016/11/04 17:30:30 miod Exp $ */
+/* $OpenBSD: e_aes.c,v 1.32 2017/01/29 17:49:23 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 2001-2011 The OpenSSL Project.  All rights reserved.
  *
@@ -225,7 +225,7 @@ aesni_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
         }
 
         if (ret < 0) {
-                EVPerr(EVP_F_AESNI_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
+                EVPerror(EVP_R_AES_KEY_SETUP_FAILED);
                 return 0;
         }
 
@@ -563,7 +563,7 @@ aes_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
                 }
 
         if (ret < 0) {
-                EVPerr(EVP_F_AES_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
+                EVPerror(EVP_R_AES_KEY_SETUP_FAILED);
                 return 0;
         }
 
@@ -1378,7 +1378,7 @@ aead_aes_gcm_init(EVP_AEAD_CTX *ctx, const unsigned char *key, size_t key_len,
 
         /* EVP_AEAD_CTX_init should catch this. */
         if (key_bits != 128 && key_bits != 256) {
-                EVPerr(EVP_F_AEAD_AES_GCM_INIT, EVP_R_BAD_KEY_LENGTH);
+                EVPerror(EVP_R_BAD_KEY_LENGTH);
                 return 0;
         }
 
@@ -1386,7 +1386,7 @@ aead_aes_gcm_init(EVP_AEAD_CTX *ctx, const unsigned char *key, size_t key_len,
                 tag_len = EVP_AEAD_AES_GCM_TAG_LEN;
 
         if (tag_len > EVP_AEAD_AES_GCM_TAG_LEN) {
-                EVPerr(EVP_F_AEAD_AES_GCM_INIT, EVP_R_TAG_TOO_LARGE);
+                EVPerror(EVP_R_TAG_TOO_LARGE);
                 return 0;
         }
 
@@ -1432,7 +1432,7 @@ aead_aes_gcm_seal(const EVP_AEAD_CTX *ctx, unsigned char *out, size_t *out_len,
         size_t bulk = 0;
 
         if (max_out_len < in_len + gcm_ctx->tag_len) {
-                EVPerr(EVP_F_AEAD_AES_GCM_SEAL, EVP_R_BUFFER_TOO_SMALL);
+                EVPerror(EVP_R_BUFFER_TOO_SMALL);
                 return 0;
         }
 
@@ -1471,14 +1471,14 @@ aead_aes_gcm_open(const EVP_AEAD_CTX *ctx, unsigned char *out, size_t *out_len,
         size_t bulk = 0;
 
         if (in_len < gcm_ctx->tag_len) {
-                EVPerr(EVP_F_AEAD_AES_GCM_OPEN, EVP_R_BAD_DECRYPT);
+                EVPerror(EVP_R_BAD_DECRYPT);
                 return 0;
         }
 
         plaintext_len = in_len - gcm_ctx->tag_len;
 
         if (max_out_len < plaintext_len) {
-                EVPerr(EVP_F_AEAD_AES_GCM_OPEN, EVP_R_BUFFER_TOO_SMALL);
+                EVPerror(EVP_R_BUFFER_TOO_SMALL);
                 return 0;
         }
 
@@ -1500,7 +1500,7 @@ aead_aes_gcm_open(const EVP_AEAD_CTX *ctx, unsigned char *out, size_t *out_len,
 
         CRYPTO_gcm128_tag(&gcm, tag, gcm_ctx->tag_len);
         if (timingsafe_memcmp(tag, in + plaintext_len, gcm_ctx->tag_len) != 0) {
-                EVPerr(EVP_F_AEAD_AES_GCM_OPEN, EVP_R_BAD_DECRYPT);
+                EVPerror(EVP_R_BAD_DECRYPT);
                 return 0;
         }
 
diff --git a/src/lib/libcrypto/evp/e_camellia.c b/src/lib/libcrypto/evp/e_camellia.c
index e3424cfe94..fd12cf9c50 100644
--- a/src/lib/libcrypto/evp/e_camellia.c
+++ b/src/lib/libcrypto/evp/e_camellia.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_camellia.c,v 1.7 2015/02/10 09:50:12 miod Exp $ */
+/* $OpenBSD: e_camellia.c,v 1.8 2017/01/29 17:49:23 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
  *
@@ -114,8 +114,7 @@ camellia_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
         ret = Camellia_set_key(key, ctx->key_len * 8, ctx->cipher_data);
 
         if (ret < 0) {
-                EVPerr(EVP_F_CAMELLIA_INIT_KEY,
-                    EVP_R_CAMELLIA_KEY_SETUP_FAILED);
+                EVPerror(EVP_R_CAMELLIA_KEY_SETUP_FAILED);
                 return 0;
         }
 
diff --git a/src/lib/libcrypto/evp/e_chacha20poly1305.c b/src/lib/libcrypto/evp/e_chacha20poly1305.c
index e5395ad8ca..e135f9a104 100644
--- a/src/lib/libcrypto/evp/e_chacha20poly1305.c
+++ b/src/lib/libcrypto/evp/e_chacha20poly1305.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_chacha20poly1305.c,v 1.14 2016/04/28 16:06:53 jsing Exp $ */
+/* $OpenBSD: e_chacha20poly1305.c,v 1.15 2017/01/29 17:49:23 beck Exp $ */
 
 /*
  * Copyright (c) 2015 Reyk Floter <reyk@openbsd.org>
@@ -59,7 +59,7 @@ aead_chacha20_poly1305_init(EVP_AEAD_CTX *ctx, const unsigned char *key,
                 tag_len = POLY1305_TAG_LEN;
 
         if (tag_len > POLY1305_TAG_LEN) {
-                EVPerr(EVP_F_AEAD_CHACHA20_POLY1305_INIT, EVP_R_TOO_LARGE);
+                EVPerror(EVP_R_TOO_LARGE);
                 return 0;
         }
 
@@ -142,18 +142,17 @@ aead_chacha20_poly1305_seal(const EVP_AEAD_CTX *ctx, unsigned char *out,
          * Casting to uint64_t inside the conditional is not sufficient to stop
          * the warning. */
         if (in_len_64 >= (1ULL << 32) * 64 - 64) {
-                EVPerr(EVP_F_AEAD_CHACHA20_POLY1305_SEAL, EVP_R_TOO_LARGE);
+                EVPerror(EVP_R_TOO_LARGE);
                 return 0;
         }
 
         if (max_out_len < in_len + c20_ctx->tag_len) {
-                EVPerr(EVP_F_AEAD_CHACHA20_POLY1305_SEAL,
-                    EVP_R_BUFFER_TOO_SMALL);
+                EVPerror(EVP_R_BUFFER_TOO_SMALL);
                 return 0;
         }
 
         if (nonce_len != ctx->aead->nonce_len) {
-                EVPerr(EVP_F_AEAD_CHACHA20_POLY1305_SEAL, EVP_R_IV_TOO_LARGE);
+                EVPerror(EVP_R_IV_TOO_LARGE);
                 return 0;
         }
 
@@ -216,7 +215,7 @@ aead_chacha20_poly1305_open(const EVP_AEAD_CTX *ctx, unsigned char *out,
         uint64_t ctr = 0;
 
         if (in_len < c20_ctx->tag_len) {
-                EVPerr(EVP_F_AEAD_CHACHA20_POLY1305_OPEN, EVP_R_BAD_DECRYPT);
+                EVPerror(EVP_R_BAD_DECRYPT);
                 return 0;
         }
 
@@ -228,20 +227,19 @@ aead_chacha20_poly1305_open(const EVP_AEAD_CTX *ctx, unsigned char *out,
          * Casting to uint64_t inside the conditional is not sufficient to stop
          * the warning. */
         if (in_len_64 >= (1ULL << 32) * 64 - 64) {
-                EVPerr(EVP_F_AEAD_CHACHA20_POLY1305_OPEN, EVP_R_TOO_LARGE);
+                EVPerror(EVP_R_TOO_LARGE);
                 return 0;
         }
 
         if (nonce_len != ctx->aead->nonce_len) {
-                EVPerr(EVP_F_AEAD_CHACHA20_POLY1305_OPEN, EVP_R_IV_TOO_LARGE);
+                EVPerror(EVP_R_IV_TOO_LARGE);
                 return 0;
         }
 
         plaintext_len = in_len - c20_ctx->tag_len;
 
         if (max_out_len < plaintext_len) {
-                EVPerr(EVP_F_AEAD_CHACHA20_POLY1305_OPEN,
-                    EVP_R_BUFFER_TOO_SMALL);
+                EVPerror(EVP_R_BUFFER_TOO_SMALL);
                 return 0;
         }
 
@@ -276,7 +274,7 @@ aead_chacha20_poly1305_open(const EVP_AEAD_CTX *ctx, unsigned char *out,
         CRYPTO_poly1305_finish(&poly1305, mac);
 
         if (timingsafe_memcmp(mac, in + plaintext_len, c20_ctx->tag_len) != 0) {
-                EVPerr(EVP_F_AEAD_CHACHA20_POLY1305_OPEN, EVP_R_BAD_DECRYPT);
+                EVPerror(EVP_R_BAD_DECRYPT);
                 return 0;
         }
 
diff --git a/src/lib/libcrypto/evp/e_gost2814789.c b/src/lib/libcrypto/evp/e_gost2814789.c
index e2235a64b5..730de4fed1 100644
--- a/src/lib/libcrypto/evp/e_gost2814789.c
+++ b/src/lib/libcrypto/evp/e_gost2814789.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_gost2814789.c,v 1.3 2014/11/18 05:30:07 miod Exp $ */
+/* $OpenBSD: e_gost2814789.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
@@ -107,13 +107,12 @@ gost2814789_set_asn1_params(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params)
         GOST_CIPHER_PARAMS *gcp = GOST_CIPHER_PARAMS_new();
 
         if (gcp == NULL) {
-                GOSTerr(GOST_F_GOST89_SET_ASN1_PARAMETERS,
-                    ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 return 0;
         }
         if (ASN1_OCTET_STRING_set(gcp->iv, ctx->iv, ctx->cipher->iv_len) == 0) {
                 GOST_CIPHER_PARAMS_free(gcp);
-                GOSTerr(GOST_F_GOST89_SET_ASN1_PARAMETERS, ERR_R_ASN1_LIB);
+                GOSTerror(ERR_R_ASN1_LIB);
                 return 0;
         }
         ASN1_OBJECT_free(gcp->enc_param_set);
@@ -123,8 +122,7 @@ gost2814789_set_asn1_params(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params)
         p = buf = malloc(len);
         if (buf == NULL) {
                 GOST_CIPHER_PARAMS_free(gcp);
-                GOSTerr(GOST_F_GOST89_SET_ASN1_PARAMETERS,
-                    ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 return 0;
         }
         i2d_GOST_CIPHER_PARAMS(gcp, &p);
@@ -133,14 +131,13 @@ gost2814789_set_asn1_params(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params)
         os = ASN1_OCTET_STRING_new();
         if (os == NULL) {
                 free(buf);
-                GOSTerr(GOST_F_GOST89_SET_ASN1_PARAMETERS,
-                    ERR_R_MALLOC_FAILURE);
+                GOSTerror(ERR_R_MALLOC_FAILURE);
                 return 0;
         }
         if (ASN1_OCTET_STRING_set(os, buf, len) == 0) {
                 ASN1_OCTET_STRING_free(os);
                 free(buf);
-                GOSTerr(GOST_F_GOST89_SET_ASN1_PARAMETERS, ERR_R_ASN1_LIB);
+                GOSTerror(ERR_R_ASN1_LIB);
                 return 0;
         }
         free(buf);
@@ -169,8 +166,7 @@ gost2814789_get_asn1_params(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params)
         len = gcp->iv->length;
         if (len != ctx->cipher->iv_len) {
                 GOST_CIPHER_PARAMS_free(gcp);
-                GOSTerr(GOST_F_GOST89_GET_ASN1_PARAMETERS,
-                    GOST_R_INVALID_IV_LENGTH);
+                GOSTerror(GOST_R_INVALID_IV_LENGTH);
                 return -1;
         }
 
diff --git a/src/lib/libcrypto/evp/e_rc2.c b/src/lib/libcrypto/evp/e_rc2.c
index 9052195ac2..de1b24a306 100644
--- a/src/lib/libcrypto/evp/e_rc2.c
+++ b/src/lib/libcrypto/evp/e_rc2.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_rc2.c,v 1.11 2015/02/10 09:52:35 miod Exp $ */
+/* $OpenBSD: e_rc2.c,v 1.12 2017/01/29 17:49:23 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -171,7 +171,7 @@ rc2_magic_to_meth(int i)
         else if (i == RC2_40_MAGIC)
                 return 40;
         else {
-                EVPerr(EVP_F_RC2_MAGIC_TO_METH, EVP_R_UNSUPPORTED_KEY_SIZE);
+                EVPerror(EVP_R_UNSUPPORTED_KEY_SIZE);
                 return (0);
         }
 }
@@ -188,8 +188,7 @@ rc2_get_asn1_type_and_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
         if (type != NULL) {
                 l = EVP_CIPHER_CTX_iv_length(c);
                 if (l > sizeof(iv)) {
-                        EVPerr(EVP_F_RC2_GET_ASN1_TYPE_AND_IV,
-                            EVP_R_IV_TOO_LARGE);
+                        EVPerror(EVP_R_IV_TOO_LARGE);
                         return -1;
                 }
                 i = ASN1_TYPE_get_int_octetstring(type, &num, iv, l);
diff --git a/src/lib/libcrypto/evp/evp_aead.c b/src/lib/libcrypto/evp/evp_aead.c
index 197b7f515f..40471b0022 100644
--- a/src/lib/libcrypto/evp/evp_aead.c
+++ b/src/lib/libcrypto/evp/evp_aead.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_aead.c,v 1.5 2014/06/21 15:30:36 jsing Exp $ */
+/* $OpenBSD: evp_aead.c,v 1.6 2017/01/29 17:49:23 beck Exp $ */
 /*
  * Copyright (c) 2014, Google Inc.
  *
@@ -53,7 +53,7 @@ EVP_AEAD_CTX_init(EVP_AEAD_CTX *ctx, const EVP_AEAD *aead,
 {
         ctx->aead = aead;
         if (key_len != aead->key_len) {
-                EVPerr(EVP_F_EVP_AEAD_CTX_INIT, EVP_R_UNSUPPORTED_KEY_SIZE);
+                EVPerror(EVP_R_UNSUPPORTED_KEY_SIZE);
                 return 0;
         }
         return aead->init(ctx, key, key_len, tag_len);
@@ -96,12 +96,12 @@ EVP_AEAD_CTX_seal(const EVP_AEAD_CTX *ctx, unsigned char *out, size_t *out_len,
 
         /* Overflow. */
         if (possible_out_len < in_len) {
-                EVPerr(EVP_F_AEAD_CTX_SEAL, EVP_R_TOO_LARGE);
+                EVPerror(EVP_R_TOO_LARGE);
                 goto error;
         }
 
         if (!check_alias(in, in_len, out)) {
-                EVPerr(EVP_F_AEAD_CTX_SEAL, EVP_R_OUTPUT_ALIASES_INPUT);
+                EVPerror(EVP_R_OUTPUT_ALIASES_INPUT);
                 goto error;
         }
 
@@ -125,7 +125,7 @@ EVP_AEAD_CTX_open(const EVP_AEAD_CTX *ctx, unsigned char *out, size_t *out_len,
     size_t ad_len)
 {
         if (!check_alias(in, in_len, out)) {
-                EVPerr(EVP_F_AEAD_CTX_OPEN, EVP_R_OUTPUT_ALIASES_INPUT);
+                EVPerror(EVP_R_OUTPUT_ALIASES_INPUT);
                 goto error;
         }
 
diff --git a/src/lib/libcrypto/evp/evp_enc.c b/src/lib/libcrypto/evp/evp_enc.c
index 0dfb7a5dc3..d0a5eb2d5f 100644
--- a/src/lib/libcrypto/evp/evp_enc.c
+++ b/src/lib/libcrypto/evp/evp_enc.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_enc.c,v 1.35 2016/09/09 00:03:22 bcook Exp $ */
+/* $OpenBSD: evp_enc.c,v 1.36 2017/01/29 17:49:23 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -130,8 +130,7 @@ EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
 #ifndef OPENSSL_NO_ENGINE
                 if (impl) {
                         if (!ENGINE_init(impl)) {
-                                EVPerr(EVP_F_EVP_CIPHERINIT_EX,
-                                    EVP_R_INITIALIZATION_ERROR);
+                                EVPerror(EVP_R_INITIALIZATION_ERROR);
                                 return 0;
                         }
                 } else
@@ -142,8 +141,7 @@ EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
                         const EVP_CIPHER *c =
                             ENGINE_get_cipher(impl, cipher->nid);
                         if (!c) {
-                                EVPerr(EVP_F_EVP_CIPHERINIT_EX,
-                                    EVP_R_INITIALIZATION_ERROR);
+                                EVPerror(EVP_R_INITIALIZATION_ERROR);
                                 return 0;
                         }
                         /* We'll use the ENGINE's private cipher definition */
@@ -160,8 +158,7 @@ EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
                 if (ctx->cipher->ctx_size) {
                         ctx->cipher_data = malloc(ctx->cipher->ctx_size);
                         if (!ctx->cipher_data) {
-                                EVPerr(EVP_F_EVP_CIPHERINIT_EX,
-                                    ERR_R_MALLOC_FAILURE);
+                                EVPerror(ERR_R_MALLOC_FAILURE);
                                 return 0;
                         }
                 } else {
@@ -171,13 +168,12 @@ EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
                 ctx->flags = 0;
                 if (ctx->cipher->flags & EVP_CIPH_CTRL_INIT) {
                         if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL)) {
-                                EVPerr(EVP_F_EVP_CIPHERINIT_EX,
-                                    EVP_R_INITIALIZATION_ERROR);
+                                EVPerror(EVP_R_INITIALIZATION_ERROR);
                                 return 0;
                         }
                 }
         } else if (!ctx->cipher) {
-                EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_NO_CIPHER_SET);
+                EVPerror(EVP_R_NO_CIPHER_SET);
                 return 0;
         }
 #ifndef OPENSSL_NO_ENGINE
@@ -187,7 +183,7 @@ skip_to_init:
         if (ctx->cipher->block_size != 1 &&
             ctx->cipher->block_size != 8 &&
             ctx->cipher->block_size != 16) {
-                EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_BAD_BLOCK_LENGTH);
+                EVPerror(EVP_R_BAD_BLOCK_LENGTH);
                 return 0;
         }
 
@@ -208,8 +204,7 @@ skip_to_init:
 
                         if ((size_t)EVP_CIPHER_CTX_iv_length(ctx) >
                             sizeof(ctx->iv)) {
-                                EVPerr(EVP_F_EVP_CIPHERINIT_EX,
-                                    EVP_R_IV_TOO_LARGE);
+                                EVPerror(EVP_R_IV_TOO_LARGE);
                                 return 0;
                         }
                         if (iv)
@@ -336,7 +331,7 @@ EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
         i = ctx->buf_len;
         bl = ctx->cipher->block_size;
         if ((size_t)bl > sizeof(ctx->buf)) {
-                EVPerr(EVP_F_EVP_ENCRYPTUPDATE, EVP_R_BAD_BLOCK_LENGTH);
+                EVPerror(EVP_R_BAD_BLOCK_LENGTH);
                 *outl = 0;
                 return 0;
         }
@@ -401,7 +396,7 @@ EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
 
         b = ctx->cipher->block_size;
         if (b > sizeof ctx->buf) {
-                EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX, EVP_R_BAD_BLOCK_LENGTH);
+                EVPerror(EVP_R_BAD_BLOCK_LENGTH);
                 return 0;
         }
         if (b == 1) {
@@ -411,8 +406,7 @@ EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
         bl = ctx->buf_len;
         if (ctx->flags & EVP_CIPH_NO_PADDING) {
                 if (bl) {
-                        EVPerr(EVP_F_EVP_ENCRYPTFINAL_EX,
-                            EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH);
+                        EVPerror(EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH);
                         return 0;
                 }
                 *outl = 0;
@@ -458,7 +452,7 @@ EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
 
         b = ctx->cipher->block_size;
         if (b > sizeof ctx->final) {
-                EVPerr(EVP_F_EVP_DECRYPTUPDATE, EVP_R_BAD_BLOCK_LENGTH);
+                EVPerror(EVP_R_BAD_BLOCK_LENGTH);
                 return 0;
         }
 
@@ -519,8 +513,7 @@ EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
         b = ctx->cipher->block_size;
         if (ctx->flags & EVP_CIPH_NO_PADDING) {
                 if (ctx->buf_len) {
-                        EVPerr(EVP_F_EVP_DECRYPTFINAL_EX,
-                            EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH);
+                        EVPerror(EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH);
                         return 0;
                 }
                 *outl = 0;
@@ -528,24 +521,21 @@ EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
         }
         if (b > 1) {
                 if (ctx->buf_len || !ctx->final_used) {
-                        EVPerr(EVP_F_EVP_DECRYPTFINAL_EX,
-                            EVP_R_WRONG_FINAL_BLOCK_LENGTH);
+                        EVPerror(EVP_R_WRONG_FINAL_BLOCK_LENGTH);
                         return (0);
                 }
                 if (b > sizeof ctx->final) {
-                        EVPerr(EVP_F_EVP_DECRYPTFINAL_EX,
-                            EVP_R_BAD_BLOCK_LENGTH);
+                        EVPerror(EVP_R_BAD_BLOCK_LENGTH);
                         return 0;
                 }
                 n = ctx->final[b - 1];
                 if (n == 0 || n > (int)b) {
-                        EVPerr(EVP_F_EVP_DECRYPTFINAL_EX, EVP_R_BAD_DECRYPT);
+                        EVPerror(EVP_R_BAD_DECRYPT);
                         return (0);
                 }
                 for (i = 0; i < n; i++) {
                         if (ctx->final[--b] != n) {
-                                EVPerr(EVP_F_EVP_DECRYPTFINAL_EX,
-                                    EVP_R_BAD_DECRYPT);
+                                EVPerror(EVP_R_BAD_DECRYPT);
                                 return (0);
                         }
                 }
@@ -600,7 +590,7 @@ EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen)
                 c->key_len = keylen;
                 return 1;
         }
-        EVPerr(EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH, EVP_R_INVALID_KEY_LENGTH);
+        EVPerror(EVP_R_INVALID_KEY_LENGTH);
         return 0;
 }
 
@@ -620,19 +610,18 @@ EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
         int ret;
 
         if (!ctx->cipher) {
-                EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_NO_CIPHER_SET);
+                EVPerror(EVP_R_NO_CIPHER_SET);
                 return 0;
         }
 
         if (!ctx->cipher->ctrl) {
-                EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_NOT_IMPLEMENTED);
+                EVPerror(EVP_R_CTRL_NOT_IMPLEMENTED);
                 return 0;
         }
 
         ret = ctx->cipher->ctrl(ctx, type, arg, ptr);
         if (ret == -1) {
-                EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL,
-                    EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED);
+                EVPerror(EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED);
                 return 0;
         }
         return ret;
@@ -651,13 +640,13 @@ int
 EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in)
 {
         if ((in == NULL) || (in->cipher == NULL)) {
-                EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, EVP_R_INPUT_NOT_INITIALIZED);
+                EVPerror(EVP_R_INPUT_NOT_INITIALIZED);
                 return 0;
         }
 #ifndef OPENSSL_NO_ENGINE
         /* Make sure it's safe to copy a cipher context using an ENGINE */
         if (in->engine && !ENGINE_init(in->engine)) {
-                EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, ERR_R_ENGINE_LIB);
+                EVPerror(ERR_R_ENGINE_LIB);
                 return 0;
         }
 #endif
@@ -668,7 +657,7 @@ EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in)
         if (in->cipher_data && in->cipher->ctx_size) {
                 out->cipher_data = malloc(in->cipher->ctx_size);
                 if (!out->cipher_data) {
-                        EVPerr(EVP_F_EVP_CIPHER_CTX_COPY, ERR_R_MALLOC_FAILURE);
+                        EVPerror(ERR_R_MALLOC_FAILURE);
                         return 0;
                 }
                 memcpy(out->cipher_data, in->cipher_data, in->cipher->ctx_size);
diff --git a/src/lib/libcrypto/evp/evp_err.c b/src/lib/libcrypto/evp/evp_err.c
index dadd5365a0..1e1cc8350b 100644
--- a/src/lib/libcrypto/evp/evp_err.c
+++ b/src/lib/libcrypto/evp/evp_err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_err.c,v 1.21 2015/02/15 14:35:30 miod Exp $ */
+/* $OpenBSD: evp_err.c,v 1.22 2017/01/29 17:49:23 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 1999-2011 The OpenSSL Project.  All rights reserved.
  *
@@ -72,102 +72,7 @@
 #define ERR_REASON(reason) ERR_PACK(ERR_LIB_EVP,0,reason)
 
 static ERR_STRING_DATA EVP_str_functs[] = {
-        {ERR_FUNC(EVP_F_AEAD_AES_GCM_INIT), "AEAD_AES_GCM_INIT"},
-        {ERR_FUNC(EVP_F_AEAD_AES_GCM_OPEN), "AEAD_AES_GCM_OPEN"},
-        {ERR_FUNC(EVP_F_AEAD_AES_GCM_SEAL), "AEAD_AES_GCM_SEAL"},
-        {ERR_FUNC(EVP_F_AEAD_CHACHA20_POLY1305_INIT), "AEAD_CHACHA20_POLY1305_INIT"},
-        {ERR_FUNC(EVP_F_AEAD_CHACHA20_POLY1305_OPEN), "AEAD_CHACHA20_POLY1305_OPEN"},
-        {ERR_FUNC(EVP_F_AEAD_CHACHA20_POLY1305_SEAL), "AEAD_CHACHA20_POLY1305_SEAL"},
-        {ERR_FUNC(EVP_F_AEAD_CTX_OPEN), "AEAD_CTX_OPEN"},
-        {ERR_FUNC(EVP_F_AEAD_CTX_SEAL), "AEAD_CTX_SEAL"},
-        {ERR_FUNC(EVP_F_AESNI_INIT_KEY), "AESNI_INIT_KEY"},
-        {ERR_FUNC(EVP_F_AESNI_XTS_CIPHER), "AESNI_XTS_CIPHER"},
-        {ERR_FUNC(EVP_F_AES_INIT_KEY), "AES_INIT_KEY"},
-        {ERR_FUNC(EVP_F_AES_XTS), "AES_XTS"},
-        {ERR_FUNC(EVP_F_AES_XTS_CIPHER), "AES_XTS_CIPHER"},
-        {ERR_FUNC(EVP_F_ALG_MODULE_INIT), "ALG_MODULE_INIT"},
-        {ERR_FUNC(EVP_F_CAMELLIA_INIT_KEY), "CAMELLIA_INIT_KEY"},
-        {ERR_FUNC(EVP_F_CMAC_INIT), "CMAC_INIT"},
-        {ERR_FUNC(EVP_F_D2I_PKEY), "D2I_PKEY"},
-        {ERR_FUNC(EVP_F_DO_SIGVER_INIT), "DO_SIGVER_INIT"},
-        {ERR_FUNC(EVP_F_DSAPKEY2PKCS8), "DSAPKEY2PKCS8"},
-        {ERR_FUNC(EVP_F_DSA_PKEY2PKCS8), "DSA_PKEY2PKCS8"},
-        {ERR_FUNC(EVP_F_ECDSA_PKEY2PKCS8), "ECDSA_PKEY2PKCS8"},
-        {ERR_FUNC(EVP_F_ECKEY_PKEY2PKCS8), "ECKEY_PKEY2PKCS8"},
-        {ERR_FUNC(EVP_F_EVP_AEAD_CTX_INIT), "EVP_AEAD_CTX_init"},
-        {ERR_FUNC(EVP_F_EVP_AEAD_CTX_OPEN), "EVP_AEAD_CTX_open"},
-        {ERR_FUNC(EVP_F_EVP_AEAD_CTX_SEAL), "EVP_AEAD_CTX_seal"},
-        {ERR_FUNC(EVP_F_EVP_BYTESTOKEY), "EVP_BytesToKey"},
-        {ERR_FUNC(EVP_F_EVP_CIPHERINIT_EX), "EVP_CipherInit_ex"},
-        {ERR_FUNC(EVP_F_EVP_CIPHER_CTX_COPY), "EVP_CIPHER_CTX_copy"},
-        {ERR_FUNC(EVP_F_EVP_CIPHER_CTX_CTRL), "EVP_CIPHER_CTX_ctrl"},
-        {ERR_FUNC(EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH), "EVP_CIPHER_CTX_set_key_length"},
-        {ERR_FUNC(EVP_F_EVP_CIPHER_GET_ASN1_IV), "EVP_CIPHER_get_asn1_iv"},
-        {ERR_FUNC(EVP_F_EVP_CIPHER_SET_ASN1_IV), "EVP_CIPHER_set_asn1_iv"},
-        {ERR_FUNC(EVP_F_EVP_DECRYPTFINAL_EX), "EVP_DecryptFinal_ex"},
-        {ERR_FUNC(EVP_F_EVP_DECRYPTUPDATE), "EVP_DecryptUpdate"},
-        {ERR_FUNC(EVP_F_EVP_DIGESTFINAL_EX), "EVP_DigestFinal_ex"},
-        {ERR_FUNC(EVP_F_EVP_DIGESTINIT_EX), "EVP_DigestInit_ex"},
-        {ERR_FUNC(EVP_F_EVP_ENCRYPTFINAL_EX), "EVP_EncryptFinal_ex"},
-        {ERR_FUNC(EVP_F_EVP_ENCRYPTUPDATE), "EVP_EncryptUpdate"},
-        {ERR_FUNC(EVP_F_EVP_MD_CTX_COPY_EX), "EVP_MD_CTX_copy_ex"},
-        {ERR_FUNC(EVP_F_EVP_MD_CTX_CTRL), "EVP_MD_CTX_ctrl"},
-        {ERR_FUNC(EVP_F_EVP_MD_SIZE), "EVP_MD_size"},
-        {ERR_FUNC(EVP_F_EVP_OPENINIT), "EVP_OpenInit"},
-        {ERR_FUNC(EVP_F_EVP_PBE_ALG_ADD), "EVP_PBE_alg_add"},
-        {ERR_FUNC(EVP_F_EVP_PBE_ALG_ADD_TYPE), "EVP_PBE_alg_add_type"},
-        {ERR_FUNC(EVP_F_EVP_PBE_CIPHERINIT), "EVP_PBE_CipherInit"},
-        {ERR_FUNC(EVP_F_EVP_PKCS82PKEY), "EVP_PKCS82PKEY"},
-        {ERR_FUNC(EVP_F_EVP_PKCS82PKEY_BROKEN), "EVP_PKCS82PKEY_BROKEN"},
-        {ERR_FUNC(EVP_F_EVP_PKEY2PKCS8_BROKEN), "EVP_PKEY2PKCS8_broken"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_COPY_PARAMETERS), "EVP_PKEY_copy_parameters"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_CTX_CTRL), "EVP_PKEY_CTX_ctrl"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_CTX_CTRL_STR), "EVP_PKEY_CTX_ctrl_str"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_CTX_DUP), "EVP_PKEY_CTX_dup"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_DECRYPT), "EVP_PKEY_decrypt"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_DECRYPT_INIT), "EVP_PKEY_decrypt_init"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_DECRYPT_OLD), "EVP_PKEY_decrypt_old"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_DERIVE), "EVP_PKEY_derive"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_DERIVE_INIT), "EVP_PKEY_derive_init"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_DERIVE_SET_PEER), "EVP_PKEY_derive_set_peer"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_ENCRYPT), "EVP_PKEY_encrypt"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_ENCRYPT_INIT), "EVP_PKEY_encrypt_init"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_ENCRYPT_OLD), "EVP_PKEY_encrypt_old"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_GET1_DH), "EVP_PKEY_get1_DH"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_GET1_DSA), "EVP_PKEY_get1_DSA"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_GET1_ECDSA), "EVP_PKEY_GET1_ECDSA"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_GET1_EC_KEY), "EVP_PKEY_get1_EC_KEY"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_GET1_RSA), "EVP_PKEY_get1_RSA"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_KEYGEN), "EVP_PKEY_keygen"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_KEYGEN_INIT), "EVP_PKEY_keygen_init"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_NEW), "EVP_PKEY_new"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_PARAMGEN), "EVP_PKEY_paramgen"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_PARAMGEN_INIT), "EVP_PKEY_paramgen_init"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_SIGN), "EVP_PKEY_sign"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_SIGN_INIT), "EVP_PKEY_sign_init"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_VERIFY), "EVP_PKEY_verify"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_VERIFY_INIT), "EVP_PKEY_verify_init"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_VERIFY_RECOVER), "EVP_PKEY_verify_recover"},
-        {ERR_FUNC(EVP_F_EVP_PKEY_VERIFY_RECOVER_INIT), "EVP_PKEY_verify_recover_init"},
-        {ERR_FUNC(EVP_F_EVP_RIJNDAEL), "EVP_RIJNDAEL"},
-        {ERR_FUNC(EVP_F_EVP_SIGNFINAL), "EVP_SignFinal"},
-        {ERR_FUNC(EVP_F_EVP_VERIFYFINAL), "EVP_VerifyFinal"},
-        {ERR_FUNC(EVP_F_FIPS_CIPHERINIT), "FIPS_CIPHERINIT"},
-        {ERR_FUNC(EVP_F_FIPS_CIPHER_CTX_COPY), "FIPS_CIPHER_CTX_COPY"},
-        {ERR_FUNC(EVP_F_FIPS_CIPHER_CTX_CTRL), "FIPS_CIPHER_CTX_CTRL"},
-        {ERR_FUNC(EVP_F_FIPS_CIPHER_CTX_SET_KEY_LENGTH), "FIPS_CIPHER_CTX_SET_KEY_LENGTH"},
-        {ERR_FUNC(EVP_F_FIPS_DIGESTINIT), "FIPS_DIGESTINIT"},
-        {ERR_FUNC(EVP_F_FIPS_MD_CTX_COPY), "FIPS_MD_CTX_COPY"},
-        {ERR_FUNC(EVP_F_HMAC_INIT_EX), "HMAC_Init_ex"},
-        {ERR_FUNC(EVP_F_INT_CTX_NEW), "INT_CTX_NEW"},
-        {ERR_FUNC(EVP_F_PKCS5_PBE_KEYIVGEN), "PKCS5_PBE_keyivgen"},
-        {ERR_FUNC(EVP_F_PKCS5_V2_PBE_KEYIVGEN), "PKCS5_v2_PBE_keyivgen"},
-        {ERR_FUNC(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN), "PKCS5_V2_PBKDF2_KEYIVGEN"},
-        {ERR_FUNC(EVP_F_PKCS8_SET_BROKEN), "PKCS8_set_broken"},
-        {ERR_FUNC(EVP_F_PKEY_SET_TYPE), "PKEY_SET_TYPE"},
-        {ERR_FUNC(EVP_F_RC2_GET_ASN1_TYPE_AND_IV), "RC2_GET_ASN1_TYPE_AND_IV"},
-        {ERR_FUNC(EVP_F_RC2_MAGIC_TO_METH), "RC2_MAGIC_TO_METH"},
-        {ERR_FUNC(EVP_F_RC5_CTRL), "RC5_CTRL"},
+        {ERR_FUNC(0xfff), "CRYPTO_internal"},
         {0, NULL}
 };
 
diff --git a/src/lib/libcrypto/evp/evp_key.c b/src/lib/libcrypto/evp/evp_key.c
index 2c76743e42..33de513ef2 100644
--- a/src/lib/libcrypto/evp/evp_key.c
+++ b/src/lib/libcrypto/evp/evp_key.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_key.c,v 1.23 2015/09/10 15:56:25 jsing Exp $ */
+/* $OpenBSD: evp_key.c,v 1.24 2017/01/29 17:49:23 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -135,11 +135,11 @@ EVP_BytesToKey(const EVP_CIPHER *type, const EVP_MD *md,
         niv = type->iv_len;
 
         if ((size_t)nkey > EVP_MAX_KEY_LENGTH) {
-                EVPerr(EVP_F_EVP_BYTESTOKEY, EVP_R_BAD_KEY_LENGTH);
+                EVPerror(EVP_R_BAD_KEY_LENGTH);
                 return 0;
         }
         if ((size_t)niv > EVP_MAX_IV_LENGTH) {
-                EVPerr(EVP_F_EVP_BYTESTOKEY, EVP_R_IV_TOO_LARGE);
+                EVPerror(EVP_R_IV_TOO_LARGE);
                 return 0;
         }
 
diff --git a/src/lib/libcrypto/evp/evp_lib.c b/src/lib/libcrypto/evp/evp_lib.c
index 491c8d6f67..ad97a3b7b9 100644
--- a/src/lib/libcrypto/evp/evp_lib.c
+++ b/src/lib/libcrypto/evp/evp_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_lib.c,v 1.14 2015/02/10 09:52:35 miod Exp $ */
+/* $OpenBSD: evp_lib.c,v 1.15 2017/01/29 17:49:23 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -100,8 +100,7 @@ EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
         if (type != NULL) {
                 l = EVP_CIPHER_CTX_iv_length(c);
                 if (l > sizeof(c->iv)) {
-                        EVPerr(EVP_F_EVP_CIPHER_GET_ASN1_IV,
-                             EVP_R_IV_TOO_LARGE);
+                        EVPerror(EVP_R_IV_TOO_LARGE);
                         return 0;
                 }
                 i = ASN1_TYPE_get_octetstring(type, c->oiv, l);
@@ -122,8 +121,7 @@ EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
         if (type != NULL) {
                 j = EVP_CIPHER_CTX_iv_length(c);
                 if (j > sizeof(c->iv)) {
-                        EVPerr(EVP_F_EVP_CIPHER_SET_ASN1_IV,
-                             EVP_R_IV_TOO_LARGE);
+                        EVPerror(EVP_R_IV_TOO_LARGE);
                         return 0;
                 }
                 i = ASN1_TYPE_set_octetstring(type, c->oiv, j);
@@ -291,7 +289,7 @@ int
 EVP_MD_size(const EVP_MD *md)
 {
         if (!md) {
-                EVPerr(EVP_F_EVP_MD_SIZE, EVP_R_MESSAGE_DIGEST_IS_NULL);
+                EVPerror(EVP_R_MESSAGE_DIGEST_IS_NULL);
                 return -1;
         }
         return md->md_size;
diff --git a/src/lib/libcrypto/evp/evp_pbe.c b/src/lib/libcrypto/evp/evp_pbe.c
index c7f0c7749a..de08c8d78c 100644
--- a/src/lib/libcrypto/evp/evp_pbe.c
+++ b/src/lib/libcrypto/evp/evp_pbe.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_pbe.c,v 1.24 2017/01/21 04:38:23 jsing Exp $ */
+/* $OpenBSD: evp_pbe.c,v 1.25 2017/01/29 17:49:23 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -128,7 +128,7 @@ EVP_PBE_CipherInit(ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
         if (!EVP_PBE_find(EVP_PBE_TYPE_OUTER, OBJ_obj2nid(pbe_obj),
             &cipher_nid, &md_nid, &keygen)) {
                 char obj_tmp[80];
-                EVPerr(EVP_F_EVP_PBE_CIPHERINIT, EVP_R_UNKNOWN_PBE_ALGORITHM);
+                EVPerror(EVP_R_UNKNOWN_PBE_ALGORITHM);
                 if (!pbe_obj)
                         strlcpy(obj_tmp, "NULL", sizeof obj_tmp);
                 else
@@ -147,7 +147,7 @@ EVP_PBE_CipherInit(ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
         else {
                 cipher = EVP_get_cipherbynid(cipher_nid);
                 if (!cipher) {
-                        EVPerr(EVP_F_EVP_PBE_CIPHERINIT, EVP_R_UNKNOWN_CIPHER);
+                        EVPerror(EVP_R_UNKNOWN_CIPHER);
                         return 0;
                 }
         }
@@ -157,13 +157,13 @@ EVP_PBE_CipherInit(ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
         else {
                 md = EVP_get_digestbynid(md_nid);
                 if (!md) {
-                        EVPerr(EVP_F_EVP_PBE_CIPHERINIT, EVP_R_UNKNOWN_DIGEST);
+                        EVPerror(EVP_R_UNKNOWN_DIGEST);
                         return 0;
                 }
         }
 
         if (!keygen(ctx, pass, passlen, param, cipher, md, en_de)) {
-                EVPerr(EVP_F_EVP_PBE_CIPHERINIT, EVP_R_KEYGEN_FAILURE);
+                EVPerror(EVP_R_KEYGEN_FAILURE);
                 return 0;
         }
         return 1;
@@ -222,14 +222,13 @@ EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid, int md_nid,
         if (pbe_algs == NULL) {
                 pbe_algs = sk_EVP_PBE_CTL_new(pbe_cmp);
                 if (pbe_algs == NULL) {
-                        EVPerr(EVP_F_EVP_PBE_ALG_ADD_TYPE,
-                            ERR_R_MALLOC_FAILURE);
+                        EVPerror(ERR_R_MALLOC_FAILURE);
                         return 0;
                 }
         }
         pbe_tmp = malloc(sizeof(EVP_PBE_CTL));
         if (pbe_tmp == NULL) {
-                EVPerr(EVP_F_EVP_PBE_ALG_ADD_TYPE, ERR_R_MALLOC_FAILURE);
+                EVPerror(ERR_R_MALLOC_FAILURE);
                 return 0;
         }
         pbe_tmp->pbe_type = pbe_type;
@@ -240,7 +239,7 @@ EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid, int md_nid,
 
         if (sk_EVP_PBE_CTL_push(pbe_algs, pbe_tmp) == 0) {
                 free(pbe_tmp);
-                EVPerr(EVP_F_EVP_PBE_ALG_ADD_TYPE, ERR_R_MALLOC_FAILURE);
+                EVPerror(ERR_R_MALLOC_FAILURE);
                 return 0;
         }
         return 1;
diff --git a/src/lib/libcrypto/evp/evp_pkey.c b/src/lib/libcrypto/evp/evp_pkey.c
index 689ff596ce..4dcd2a15a9 100644
--- a/src/lib/libcrypto/evp/evp_pkey.c
+++ b/src/lib/libcrypto/evp/evp_pkey.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_pkey.c,v 1.18 2014/10/18 17:20:40 jsing Exp $ */
+/* $OpenBSD: evp_pkey.c,v 1.19 2017/01/29 17:49:23 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -77,13 +77,12 @@ EVP_PKCS82PKEY(PKCS8_PRIV_KEY_INFO *p8)
                 return NULL;
 
         if (!(pkey = EVP_PKEY_new())) {
-                EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_MALLOC_FAILURE);
+                EVPerror(ERR_R_MALLOC_FAILURE);
                 return NULL;
         }
 
         if (!EVP_PKEY_set_type(pkey, OBJ_obj2nid(algoid))) {
-                EVPerr(EVP_F_EVP_PKCS82PKEY,
-                    EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM);
+                EVPerror(EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM);
                 i2t_ASN1_OBJECT(obj_tmp, 80, algoid);
                 ERR_asprintf_error_data("TYPE=%s", obj_tmp);
                 goto error;
@@ -91,12 +90,11 @@ EVP_PKCS82PKEY(PKCS8_PRIV_KEY_INFO *p8)
 
         if (pkey->ameth->priv_decode) {
                 if (!pkey->ameth->priv_decode(pkey, p8)) {
-                        EVPerr(EVP_F_EVP_PKCS82PKEY,
-                            EVP_R_PRIVATE_KEY_DECODE_ERROR);
+                        EVPerror(EVP_R_PRIVATE_KEY_DECODE_ERROR);
                         goto error;
                 }
         } else {
-                EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_METHOD_NOT_SUPPORTED);
+                EVPerror(EVP_R_METHOD_NOT_SUPPORTED);
                 goto error;
         }
 
@@ -121,7 +119,7 @@ EVP_PKEY2PKCS8_broken(EVP_PKEY *pkey, int broken)
         PKCS8_PRIV_KEY_INFO *p8;
 
         if (!(p8 = PKCS8_PRIV_KEY_INFO_new())) {
-                EVPerr(EVP_F_EVP_PKEY2PKCS8_BROKEN, ERR_R_MALLOC_FAILURE);
+                EVPerror(ERR_R_MALLOC_FAILURE);
                 return NULL;
         }
         p8->broken = broken;
@@ -129,18 +127,15 @@ EVP_PKEY2PKCS8_broken(EVP_PKEY *pkey, int broken)
         if (pkey->ameth) {
                 if (pkey->ameth->priv_encode) {
                         if (!pkey->ameth->priv_encode(p8, pkey)) {
-                                EVPerr(EVP_F_EVP_PKEY2PKCS8_BROKEN,
-                                    EVP_R_PRIVATE_KEY_ENCODE_ERROR);
+                                EVPerror(EVP_R_PRIVATE_KEY_ENCODE_ERROR);
                                 goto error;
                         }
                 } else {
-                        EVPerr(EVP_F_EVP_PKEY2PKCS8_BROKEN,
-                            EVP_R_METHOD_NOT_SUPPORTED);
+                        EVPerror(EVP_R_METHOD_NOT_SUPPORTED);
                         goto error;
                 }
         } else {
-                EVPerr(EVP_F_EVP_PKEY2PKCS8_BROKEN,
-                    EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM);
+                EVPerror(EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM);
                 goto error;
         }
         return p8;
@@ -166,7 +161,7 @@ PKCS8_set_broken(PKCS8_PRIV_KEY_INFO *p8, int broken)
                 break;
 
         default:
-                EVPerr(EVP_F_PKCS8_SET_BROKEN, EVP_R_PKCS8_UNKNOWN_BROKEN_TYPE);
+                EVPerror(EVP_R_PKCS8_UNKNOWN_BROKEN_TYPE);
                 return NULL;
         }
 }
diff --git a/src/lib/libcrypto/evp/m_sigver.c b/src/lib/libcrypto/evp/m_sigver.c
index 579325be67..6e955d9480 100644
--- a/src/lib/libcrypto/evp/m_sigver.c
+++ b/src/lib/libcrypto/evp/m_sigver.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: m_sigver.c,v 1.5 2015/12/14 03:37:27 beck Exp $ */
+/* $OpenBSD: m_sigver.c,v 1.6 2017/01/29 17:49:23 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -81,7 +81,7 @@ do_sigver_init(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type,
         }
 
         if (type == NULL) {
-                EVPerr(EVP_F_DO_SIGVER_INIT, EVP_R_NO_DEFAULT_DIGEST);
+                EVPerror(EVP_R_NO_DEFAULT_DIGEST);
                 return 0;
         }
 
diff --git a/src/lib/libcrypto/evp/p5_crpt.c b/src/lib/libcrypto/evp/p5_crpt.c
index 1d02cbf4a6..75a631bf98 100644
--- a/src/lib/libcrypto/evp/p5_crpt.c
+++ b/src/lib/libcrypto/evp/p5_crpt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p5_crpt.c,v 1.17 2016/11/08 20:01:06 miod Exp $ */
+/* $OpenBSD: p5_crpt.c,v 1.18 2017/01/29 17:49:23 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -90,7 +90,7 @@ PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *cctx, const char *pass, int passlen,
         /* Extract useful info from parameter */
         if (param == NULL || param->type != V_ASN1_SEQUENCE ||
             param->value.sequence == NULL) {
-                EVPerr(EVP_F_PKCS5_PBE_KEYIVGEN, EVP_R_DECODE_ERROR);
+                EVPerror(EVP_R_DECODE_ERROR);
                 return 0;
         }
 
@@ -100,15 +100,14 @@ PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *cctx, const char *pass, int passlen,
 
         pbuf = param->value.sequence->data;
         if (!(pbe = d2i_PBEPARAM(NULL, &pbuf, param->value.sequence->length))) {
-                EVPerr(EVP_F_PKCS5_PBE_KEYIVGEN, EVP_R_DECODE_ERROR);
+                EVPerror(EVP_R_DECODE_ERROR);
                 return 0;
         }
 
         if (!pbe->iter)
                 iter = 1;
         else if ((iter = ASN1_INTEGER_get(pbe->iter)) <= 0) {
-                EVPerr(EVP_F_PKCS5_PBE_KEYIVGEN,
-                    EVP_R_UNSUPORTED_NUMBER_OF_ROUNDS);
+                EVPerror(EVP_R_UNSUPORTED_NUMBER_OF_ROUNDS);
                 return 0;
         }
         salt = pbe->salt->data;
@@ -138,12 +137,12 @@ PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *cctx, const char *pass, int passlen,
                         goto err;
         }
         if ((size_t)EVP_CIPHER_key_length(cipher) > sizeof(md_tmp)) {
-                EVPerr(EVP_F_PKCS5_PBE_KEYIVGEN, EVP_R_BAD_KEY_LENGTH);
+                EVPerror(EVP_R_BAD_KEY_LENGTH);
                 goto err;
         }
         memcpy(key, md_tmp, EVP_CIPHER_key_length(cipher));
         if ((size_t)EVP_CIPHER_iv_length(cipher) > 16) {
-                EVPerr(EVP_F_PKCS5_PBE_KEYIVGEN, EVP_R_IV_TOO_LARGE);
+                EVPerror(EVP_R_IV_TOO_LARGE);
                 goto err;
         }
         memcpy(iv, md_tmp + (16 - EVP_CIPHER_iv_length(cipher)),
diff --git a/src/lib/libcrypto/evp/p5_crpt2.c b/src/lib/libcrypto/evp/p5_crpt2.c
index 44e8b331fb..4bef287706 100644
--- a/src/lib/libcrypto/evp/p5_crpt2.c
+++ b/src/lib/libcrypto/evp/p5_crpt2.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p5_crpt2.c,v 1.22 2016/11/08 20:01:06 miod Exp $ */
+/* $OpenBSD: p5_crpt2.c,v 1.23 2017/01/29 17:49:23 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -175,22 +175,21 @@ PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
 
         if (param == NULL || param->type != V_ASN1_SEQUENCE ||
             param->value.sequence == NULL) {
-                EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN, EVP_R_DECODE_ERROR);
+                EVPerror(EVP_R_DECODE_ERROR);
                 goto err;
         }
 
         pbuf = param->value.sequence->data;
         plen = param->value.sequence->length;
         if (!(pbe2 = d2i_PBE2PARAM(NULL, &pbuf, plen))) {
-                EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN, EVP_R_DECODE_ERROR);
+                EVPerror(EVP_R_DECODE_ERROR);
                 goto err;
         }
 
         /* See if we recognise the key derivation function */
 
         if (OBJ_obj2nid(pbe2->keyfunc->algorithm) != NID_id_pbkdf2) {
-                EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN,
-                    EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION);
+                EVPerror(EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION);
                 goto err;
         }
 
@@ -200,8 +199,7 @@ PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
         cipher = EVP_get_cipherbyobj(pbe2->encryption->algorithm);
 
         if (!cipher) {
-                EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN,
-                    EVP_R_UNSUPPORTED_CIPHER);
+                EVPerror(EVP_R_UNSUPPORTED_CIPHER);
                 goto err;
         }
 
@@ -209,8 +207,7 @@ PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
         if (!EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, en_de))
                 goto err;
         if (EVP_CIPHER_asn1_to_param(ctx, pbe2->encryption->parameter) < 0) {
-                EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN,
-                    EVP_R_CIPHER_PARAMETER_ERROR);
+                EVPerror(EVP_R_CIPHER_PARAMETER_ERROR);
                 goto err;
         }
         rv = PKCS5_v2_PBKDF2_keyivgen(ctx, pass, passlen,
@@ -235,19 +232,19 @@ PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
         const EVP_MD *prfmd;
 
         if (EVP_CIPHER_CTX_cipher(ctx) == NULL) {
-                EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_NO_CIPHER_SET);
+                EVPerror(EVP_R_NO_CIPHER_SET);
                 return 0;
         }
         keylen = EVP_CIPHER_CTX_key_length(ctx);
         if (keylen > sizeof key) {
-                EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_BAD_KEY_LENGTH);
+                EVPerror(EVP_R_BAD_KEY_LENGTH);
                 return 0;
         }
 
         /* Decode parameter */
 
         if (!param || (param->type != V_ASN1_SEQUENCE)) {
-                EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_DECODE_ERROR);
+                EVPerror(EVP_R_DECODE_ERROR);
                 return 0;
         }
 
@@ -255,7 +252,7 @@ PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
         plen = param->value.sequence->length;
 
         if (!(kdf = d2i_PBKDF2PARAM(NULL, &pbuf, plen)) ) {
-                EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_DECODE_ERROR);
+                EVPerror(EVP_R_DECODE_ERROR);
                 return 0;
         }
 
@@ -263,8 +260,7 @@ PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
 
         if (kdf->keylength &&
             (ASN1_INTEGER_get(kdf->keylength) != (int)keylen)){
-                EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN,
-                    EVP_R_UNSUPPORTED_KEYLENGTH);
+                EVPerror(EVP_R_UNSUPPORTED_KEYLENGTH);
                 goto err;
         }
 
@@ -274,19 +270,18 @@ PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
                 prf_nid = NID_hmacWithSHA1;
 
         if (!EVP_PBE_find(EVP_PBE_TYPE_PRF, prf_nid, NULL, &hmac_md_nid, 0)) {
-                EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_PRF);
+                EVPerror(EVP_R_UNSUPPORTED_PRF);
                 goto err;
         }
 
         prfmd = EVP_get_digestbynid(hmac_md_nid);
         if (prfmd == NULL) {
-                EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_PRF);
+                EVPerror(EVP_R_UNSUPPORTED_PRF);
                 goto err;
         }
 
         if (kdf->salt->type != V_ASN1_OCTET_STRING) {
-                EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN,
-                    EVP_R_UNSUPPORTED_SALT_TYPE);
+                EVPerror(EVP_R_UNSUPPORTED_SALT_TYPE);
                 goto err;
         }
 
@@ -294,8 +289,7 @@ PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
         salt = kdf->salt->value.octet_string->data;
         saltlen = kdf->salt->value.octet_string->length;
         if ((iter = ASN1_INTEGER_get(kdf->iter)) <= 0) {
-                EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN,
-                    EVP_R_UNSUPORTED_NUMBER_OF_ROUNDS);
+                EVPerror(EVP_R_UNSUPORTED_NUMBER_OF_ROUNDS);
                 goto err;
         }
         if (!PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter, prfmd,
diff --git a/src/lib/libcrypto/evp/p_dec.c b/src/lib/libcrypto/evp/p_dec.c
index 2244ae8c62..c827c5e4c2 100644
--- a/src/lib/libcrypto/evp/p_dec.c
+++ b/src/lib/libcrypto/evp/p_dec.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p_dec.c,v 1.10 2014/10/18 17:20:40 jsing Exp $ */
+/* $OpenBSD: p_dec.c,v 1.11 2017/01/29 17:49:23 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -78,7 +78,7 @@ EVP_PKEY_decrypt_old(unsigned char *key, const unsigned char *ek, int ekl,
 #ifndef OPENSSL_NO_RSA
         if (priv->type != EVP_PKEY_RSA) {
 #endif
-                EVPerr(EVP_F_EVP_PKEY_DECRYPT_OLD, EVP_R_PUBLIC_KEY_NOT_RSA);
+                EVPerror(EVP_R_PUBLIC_KEY_NOT_RSA);
 #ifndef OPENSSL_NO_RSA
                 goto err;
         }
diff --git a/src/lib/libcrypto/evp/p_enc.c b/src/lib/libcrypto/evp/p_enc.c
index 63d2649f6e..49c46f1a70 100644
--- a/src/lib/libcrypto/evp/p_enc.c
+++ b/src/lib/libcrypto/evp/p_enc.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p_enc.c,v 1.10 2014/10/18 17:20:40 jsing Exp $ */
+/* $OpenBSD: p_enc.c,v 1.11 2017/01/29 17:49:23 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -78,7 +78,7 @@ EVP_PKEY_encrypt_old(unsigned char *ek, const unsigned char *key, int key_len,
 #ifndef OPENSSL_NO_RSA
         if (pubk->type != EVP_PKEY_RSA) {
 #endif
-                EVPerr(EVP_F_EVP_PKEY_ENCRYPT_OLD, EVP_R_PUBLIC_KEY_NOT_RSA);
+                EVPerror(EVP_R_PUBLIC_KEY_NOT_RSA);
 #ifndef OPENSSL_NO_RSA
                 goto err;
         }
diff --git a/src/lib/libcrypto/evp/p_lib.c b/src/lib/libcrypto/evp/p_lib.c
index e172c34894..0d4cd26d45 100644
--- a/src/lib/libcrypto/evp/p_lib.c
+++ b/src/lib/libcrypto/evp/p_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p_lib.c,v 1.16 2014/07/12 22:26:01 miod Exp $ */
+/* $OpenBSD: p_lib.c,v 1.17 2017/01/29 17:49:23 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -128,14 +128,12 @@ int
 EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from)
 {
         if (to->type != from->type) {
-                EVPerr(EVP_F_EVP_PKEY_COPY_PARAMETERS,
-                    EVP_R_DIFFERENT_KEY_TYPES);
+                EVPerror(EVP_R_DIFFERENT_KEY_TYPES);
                 goto err;
         }
 
         if (EVP_PKEY_missing_parameters(from)) {
-                EVPerr(EVP_F_EVP_PKEY_COPY_PARAMETERS,
-                    EVP_R_MISSING_PARAMETERS);
+                EVPerror(EVP_R_MISSING_PARAMETERS);
                 goto err;
         }
         if (from->ameth && from->ameth->param_copy)
@@ -192,7 +190,7 @@ EVP_PKEY_new(void)
 
         ret = malloc(sizeof(EVP_PKEY));
         if (ret == NULL) {
-                EVPerr(EVP_F_EVP_PKEY_NEW, ERR_R_MALLOC_FAILURE);
+                EVPerror(ERR_R_MALLOC_FAILURE);
                 return (NULL);
         }
         ret->type = EVP_PKEY_NONE;
@@ -240,7 +238,7 @@ pkey_set_type(EVP_PKEY *pkey, int type, const char *str, int len)
                 ENGINE_finish(e);
 #endif
         if (!ameth) {
-                EVPerr(EVP_F_PKEY_SET_TYPE, EVP_R_UNSUPPORTED_ALGORITHM);
+                EVPerror(EVP_R_UNSUPPORTED_ALGORITHM);
                 return 0;
         }
         if (pkey) {
@@ -294,7 +292,7 @@ RSA *
 EVP_PKEY_get1_RSA(EVP_PKEY *pkey)
 {
         if (pkey->type != EVP_PKEY_RSA) {
-                EVPerr(EVP_F_EVP_PKEY_GET1_RSA, EVP_R_EXPECTING_AN_RSA_KEY);
+                EVPerror(EVP_R_EXPECTING_AN_RSA_KEY);
                 return NULL;
         }
         RSA_up_ref(pkey->pkey.rsa);
@@ -316,7 +314,7 @@ DSA *
 EVP_PKEY_get1_DSA(EVP_PKEY *pkey)
 {
         if (pkey->type != EVP_PKEY_DSA) {
-                EVPerr(EVP_F_EVP_PKEY_GET1_DSA, EVP_R_EXPECTING_A_DSA_KEY);
+                EVPerror(EVP_R_EXPECTING_A_DSA_KEY);
                 return NULL;
         }
         DSA_up_ref(pkey->pkey.dsa);
@@ -339,7 +337,7 @@ EC_KEY *
 EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey)
 {
         if (pkey->type != EVP_PKEY_EC) {
-                EVPerr(EVP_F_EVP_PKEY_GET1_EC_KEY, EVP_R_EXPECTING_A_EC_KEY);
+                EVPerror(EVP_R_EXPECTING_A_EC_KEY);
                 return NULL;
         }
         EC_KEY_up_ref(pkey->pkey.ec);
@@ -363,7 +361,7 @@ DH *
 EVP_PKEY_get1_DH(EVP_PKEY *pkey)
 {
         if (pkey->type != EVP_PKEY_DH) {
-                EVPerr(EVP_F_EVP_PKEY_GET1_DH, EVP_R_EXPECTING_A_DH_KEY);
+                EVPerror(EVP_R_EXPECTING_A_DH_KEY);
                 return NULL;
         }
         DH_up_ref(pkey->pkey.dh);
diff --git a/src/lib/libcrypto/evp/p_open.c b/src/lib/libcrypto/evp/p_open.c
index 002a6dea70..1eb238dfde 100644
--- a/src/lib/libcrypto/evp/p_open.c
+++ b/src/lib/libcrypto/evp/p_open.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p_open.c,v 1.17 2015/09/10 15:56:25 jsing Exp $ */
+/* $OpenBSD: p_open.c,v 1.18 2017/01/29 17:49:23 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -86,7 +86,7 @@ EVP_OpenInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                 return 1;
 
         if (priv->type != EVP_PKEY_RSA) {
-                EVPerr(EVP_F_EVP_OPENINIT, EVP_R_PUBLIC_KEY_NOT_RSA);
+                EVPerror(EVP_R_PUBLIC_KEY_NOT_RSA);
                 goto err;
         }
 
@@ -94,7 +94,7 @@ EVP_OpenInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
         key = malloc(size + 2);
         if (key == NULL) {
                 /* ERROR */
-                EVPerr(EVP_F_EVP_OPENINIT, ERR_R_MALLOC_FAILURE);
+                EVPerror(ERR_R_MALLOC_FAILURE);
                 goto err;
         }
 
diff --git a/src/lib/libcrypto/evp/p_sign.c b/src/lib/libcrypto/evp/p_sign.c
index 4058d47f07..6312924518 100644
--- a/src/lib/libcrypto/evp/p_sign.c
+++ b/src/lib/libcrypto/evp/p_sign.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p_sign.c,v 1.13 2015/02/07 13:19:15 doug Exp $ */
+/* $OpenBSD: p_sign.c,v 1.14 2017/01/29 17:49:23 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -110,12 +110,12 @@ err:
                 }
         }
         if (!ok) {
-                EVPerr(EVP_F_EVP_SIGNFINAL, EVP_R_WRONG_PUBLIC_KEY_TYPE);
+                EVPerror(EVP_R_WRONG_PUBLIC_KEY_TYPE);
                 return (0);
         }
 
         if (ctx->digest->sign == NULL) {
-                EVPerr(EVP_F_EVP_SIGNFINAL, EVP_R_NO_SIGN_FUNCTION_CONFIGURED);
+                EVPerror(EVP_R_NO_SIGN_FUNCTION_CONFIGURED);
                 return (0);
         }
         return(ctx->digest->sign(ctx->digest->type, m, m_len, sigret, siglen,
diff --git a/src/lib/libcrypto/evp/p_verify.c b/src/lib/libcrypto/evp/p_verify.c
index e653fcf6a5..7dd752c4fb 100644
--- a/src/lib/libcrypto/evp/p_verify.c
+++ b/src/lib/libcrypto/evp/p_verify.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p_verify.c,v 1.12 2014/07/11 08:44:48 jsing Exp $ */
+/* $OpenBSD: p_verify.c,v 1.13 2017/01/29 17:49:23 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -105,12 +105,11 @@ err:
                 }
         }
         if (!ok) {
-                EVPerr(EVP_F_EVP_VERIFYFINAL, EVP_R_WRONG_PUBLIC_KEY_TYPE);
+                EVPerror(EVP_R_WRONG_PUBLIC_KEY_TYPE);
                 return (-1);
         }
         if (ctx->digest->verify == NULL) {
-                EVPerr(EVP_F_EVP_VERIFYFINAL,
-                    EVP_R_NO_VERIFY_FUNCTION_CONFIGURED);
+                EVPerror(EVP_R_NO_VERIFY_FUNCTION_CONFIGURED);
                 return (0);
         }
 
diff --git a/src/lib/libcrypto/evp/pmeth_fn.c b/src/lib/libcrypto/evp/pmeth_fn.c
index 4cf18a0be1..c9117eedd4 100644
--- a/src/lib/libcrypto/evp/pmeth_fn.c
+++ b/src/lib/libcrypto/evp/pmeth_fn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pmeth_fn.c,v 1.5 2014/07/12 16:03:37 miod Exp $ */
+/* $OpenBSD: pmeth_fn.c,v 1.6 2017/01/29 17:49:23 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -76,7 +76,7 @@
                         } \
                 else if (*arglen < pksize) \
                         { \
-                        EVPerr(err, EVP_R_BUFFER_TOO_SMALL); /*ckerr_ignore*/\
+                        EVPerror(EVP_R_BUFFER_TOO_SMALL); /*ckerr_ignore*/\
                         return 0; \
                         } \
                 }
@@ -87,8 +87,7 @@ EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx)
         int ret;
 
         if (!ctx || !ctx->pmeth || !ctx->pmeth->sign) {
-                EVPerr(EVP_F_EVP_PKEY_SIGN_INIT,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         ctx->operation = EVP_PKEY_OP_SIGN;
@@ -105,12 +104,11 @@ EVP_PKEY_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
     const unsigned char *tbs, size_t tbslen)
 {
         if (!ctx || !ctx->pmeth || !ctx->pmeth->sign) {
-                EVPerr(EVP_F_EVP_PKEY_SIGN,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         if (ctx->operation != EVP_PKEY_OP_SIGN) {
-                EVPerr(EVP_F_EVP_PKEY_SIGN, EVP_R_OPERATON_NOT_INITIALIZED);
+                EVPerror(EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
         }
         M_check_autoarg(ctx, sig, siglen, EVP_F_EVP_PKEY_SIGN)
@@ -123,8 +121,7 @@ EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx)
         int ret;
 
         if (!ctx || !ctx->pmeth || !ctx->pmeth->verify) {
-                EVPerr(EVP_F_EVP_PKEY_VERIFY_INIT,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         ctx->operation = EVP_PKEY_OP_VERIFY;
@@ -141,12 +138,11 @@ EVP_PKEY_verify(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
     const unsigned char *tbs, size_t tbslen)
 {
         if (!ctx || !ctx->pmeth || !ctx->pmeth->verify) {
-                EVPerr(EVP_F_EVP_PKEY_VERIFY,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         if (ctx->operation != EVP_PKEY_OP_VERIFY) {
-                EVPerr(EVP_F_EVP_PKEY_VERIFY, EVP_R_OPERATON_NOT_INITIALIZED);
+                EVPerror(EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
         }
         return ctx->pmeth->verify(ctx, sig, siglen, tbs, tbslen);
@@ -158,8 +154,7 @@ EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx)
         int ret;
 
         if (!ctx || !ctx->pmeth || !ctx->pmeth->verify_recover) {
-                EVPerr(EVP_F_EVP_PKEY_VERIFY_RECOVER_INIT,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         ctx->operation = EVP_PKEY_OP_VERIFYRECOVER;
@@ -176,13 +171,11 @@ EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx, unsigned char *rout, size_t *routlen,
     const unsigned char *sig, size_t siglen)
 {
         if (!ctx || !ctx->pmeth || !ctx->pmeth->verify_recover) {
-                EVPerr(EVP_F_EVP_PKEY_VERIFY_RECOVER,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         if (ctx->operation != EVP_PKEY_OP_VERIFYRECOVER) {
-                EVPerr(EVP_F_EVP_PKEY_VERIFY_RECOVER,
-                    EVP_R_OPERATON_NOT_INITIALIZED);
+                EVPerror(EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
         }
         M_check_autoarg(ctx, rout, routlen, EVP_F_EVP_PKEY_VERIFY_RECOVER)
@@ -195,8 +188,7 @@ EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx)
         int ret;
 
         if (!ctx || !ctx->pmeth || !ctx->pmeth->encrypt) {
-                EVPerr(EVP_F_EVP_PKEY_ENCRYPT_INIT,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         ctx->operation = EVP_PKEY_OP_ENCRYPT;
@@ -213,12 +205,11 @@ EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
     const unsigned char *in, size_t inlen)
 {
         if (!ctx || !ctx->pmeth || !ctx->pmeth->encrypt) {
-                EVPerr(EVP_F_EVP_PKEY_ENCRYPT,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         if (ctx->operation != EVP_PKEY_OP_ENCRYPT) {
-                EVPerr(EVP_F_EVP_PKEY_ENCRYPT, EVP_R_OPERATON_NOT_INITIALIZED);
+                EVPerror(EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
         }
         M_check_autoarg(ctx, out, outlen, EVP_F_EVP_PKEY_ENCRYPT)
@@ -231,8 +222,7 @@ EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx)
         int ret;
 
         if (!ctx || !ctx->pmeth || !ctx->pmeth->decrypt) {
-                EVPerr(EVP_F_EVP_PKEY_DECRYPT_INIT,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         ctx->operation = EVP_PKEY_OP_DECRYPT;
@@ -249,12 +239,11 @@ EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
     const unsigned char *in, size_t inlen)
 {
         if (!ctx || !ctx->pmeth || !ctx->pmeth->decrypt) {
-                EVPerr(EVP_F_EVP_PKEY_DECRYPT,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         if (ctx->operation != EVP_PKEY_OP_DECRYPT) {
-                EVPerr(EVP_F_EVP_PKEY_DECRYPT, EVP_R_OPERATON_NOT_INITIALIZED);
+                EVPerror(EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
         }
         M_check_autoarg(ctx, out, outlen, EVP_F_EVP_PKEY_DECRYPT)
@@ -267,8 +256,7 @@ EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx)
         int ret;
 
         if (!ctx || !ctx->pmeth || !ctx->pmeth->derive) {
-                EVPerr(EVP_F_EVP_PKEY_DERIVE_INIT,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         ctx->operation = EVP_PKEY_OP_DERIVE;
@@ -288,15 +276,13 @@ EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer)
         if (!ctx || !ctx->pmeth || !(ctx->pmeth->derive ||
             ctx->pmeth->encrypt || ctx->pmeth->decrypt) ||
             !ctx->pmeth->ctrl) {
-                EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         if (ctx->operation != EVP_PKEY_OP_DERIVE &&
             ctx->operation != EVP_PKEY_OP_ENCRYPT &&
             ctx->operation != EVP_PKEY_OP_DECRYPT) {
-                EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER,
-                    EVP_R_OPERATON_NOT_INITIALIZED);
+                EVPerror(EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
         }
 
@@ -309,13 +295,12 @@ EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer)
                 return 1;
 
         if (!ctx->pkey) {
-                EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER, EVP_R_NO_KEY_SET);
+                EVPerror(EVP_R_NO_KEY_SET);
                 return -1;
         }
 
         if (ctx->pkey->type != peer->type) {
-                EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER,
-                    EVP_R_DIFFERENT_KEY_TYPES);
+                EVPerror(EVP_R_DIFFERENT_KEY_TYPES);
                 return -1;
         }
 
@@ -326,8 +311,7 @@ EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer)
          * -2 is OK for us here, as well as 1, so we can check for 0 only. */
         if (!EVP_PKEY_missing_parameters(peer) &&
             !EVP_PKEY_cmp_parameters(ctx->pkey, peer)) {
-                EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER,
-                    EVP_R_DIFFERENT_PARAMETERS);
+                EVPerror(EVP_R_DIFFERENT_PARAMETERS);
                 return -1;
         }
 
@@ -349,12 +333,11 @@ int
 EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *pkeylen)
 {
         if (!ctx || !ctx->pmeth || !ctx->pmeth->derive) {
-                EVPerr(EVP_F_EVP_PKEY_DERIVE,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         if (ctx->operation != EVP_PKEY_OP_DERIVE) {
-                EVPerr(EVP_F_EVP_PKEY_DERIVE, EVP_R_OPERATON_NOT_INITIALIZED);
+                EVPerror(EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
         }
         M_check_autoarg(ctx, key, pkeylen, EVP_F_EVP_PKEY_DERIVE)
diff --git a/src/lib/libcrypto/evp/pmeth_gn.c b/src/lib/libcrypto/evp/pmeth_gn.c
index 29f533625a..d1cbdc409f 100644
--- a/src/lib/libcrypto/evp/pmeth_gn.c
+++ b/src/lib/libcrypto/evp/pmeth_gn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pmeth_gn.c,v 1.5 2014/07/12 16:03:37 miod Exp $ */
+/* $OpenBSD: pmeth_gn.c,v 1.6 2017/01/29 17:49:23 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -72,8 +72,7 @@ EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx)
         int ret;
 
         if (!ctx || !ctx->pmeth || !ctx->pmeth->paramgen) {
-                EVPerr(EVP_F_EVP_PKEY_PARAMGEN_INIT,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         ctx->operation = EVP_PKEY_OP_PARAMGEN;
@@ -91,13 +90,12 @@ EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
         int ret;
 
         if (!ctx || !ctx->pmeth || !ctx->pmeth->paramgen) {
-                EVPerr(EVP_F_EVP_PKEY_PARAMGEN,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
 
         if (ctx->operation != EVP_PKEY_OP_PARAMGEN) {
-                EVPerr(EVP_F_EVP_PKEY_PARAMGEN, EVP_R_OPERATON_NOT_INITIALIZED);
+                EVPerror(EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
         }
 
@@ -121,8 +119,7 @@ EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx)
         int ret;
 
         if (!ctx || !ctx->pmeth || !ctx->pmeth->keygen) {
-                EVPerr(EVP_F_EVP_PKEY_KEYGEN_INIT,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         ctx->operation = EVP_PKEY_OP_KEYGEN;
@@ -140,12 +137,11 @@ EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
         int ret;
 
         if (!ctx || !ctx->pmeth || !ctx->pmeth->keygen) {
-                EVPerr(EVP_F_EVP_PKEY_KEYGEN,
-                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                EVPerror(EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
         }
         if (ctx->operation != EVP_PKEY_OP_KEYGEN) {
-                EVPerr(EVP_F_EVP_PKEY_KEYGEN, EVP_R_OPERATON_NOT_INITIALIZED);
+                EVPerror(EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
         }
 
diff --git a/src/lib/libcrypto/evp/pmeth_lib.c b/src/lib/libcrypto/evp/pmeth_lib.c
index 1d64edcbeb..fc5f4ef91e 100644
--- a/src/lib/libcrypto/evp/pmeth_lib.c
+++ b/src/lib/libcrypto/evp/pmeth_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pmeth_lib.c,v 1.12 2017/01/21 04:38:23 jsing Exp $ */
+/* $OpenBSD: pmeth_lib.c,v 1.13 2017/01/29 17:49:23 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -166,7 +166,7 @@ int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
         /* Try to find an ENGINE which implements this method */
         if (e) {
                 if (!ENGINE_init(e)) {
-                        EVPerr(EVP_F_INT_CTX_NEW, ERR_R_ENGINE_LIB);
+                        EVPerror(ERR_R_ENGINE_LIB);
                         return NULL;
                 }
         } else
@@ -183,7 +183,7 @@ int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
                 pmeth = EVP_PKEY_meth_find(id);
 
         if (pmeth == NULL) {
-                EVPerr(EVP_F_INT_CTX_NEW, EVP_R_UNSUPPORTED_ALGORITHM);
+                EVPerror(EVP_R_UNSUPPORTED_ALGORITHM);
                 return NULL;
         }
 
@@ -193,7 +193,7 @@ int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
                 if (e)
                         ENGINE_finish(e);
 #endif
-                EVPerr(EVP_F_INT_CTX_NEW, ERR_R_MALLOC_FAILURE);
+                EVPerror(ERR_R_MALLOC_FAILURE);
                 return NULL;
         }
         ret->engine = e;
@@ -336,7 +336,7 @@ EVP_PKEY_CTX_dup(EVP_PKEY_CTX *pctx)
 #ifndef OPENSSL_NO_ENGINE
         /* Make sure it's safe to copy a pkey context using an ENGINE */
         if (pctx->engine && !ENGINE_init(pctx->engine)) {
-                EVPerr(EVP_F_EVP_PKEY_CTX_DUP, ERR_R_ENGINE_LIB);
+                EVPerror(ERR_R_ENGINE_LIB);
                 return 0;
         }
 #endif
@@ -409,26 +409,26 @@ EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype, int cmd,
         int ret;
 
         if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl) {
-                EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
+                EVPerror(EVP_R_COMMAND_NOT_SUPPORTED);
                 return -2;
         }
         if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype))
                 return -1;
 
         if (ctx->operation == EVP_PKEY_OP_UNDEFINED) {
-                EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_NO_OPERATION_SET);
+                EVPerror(EVP_R_NO_OPERATION_SET);
                 return -1;
         }
 
         if ((optype != -1) && !(ctx->operation & optype)) {
-                EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_INVALID_OPERATION);
+                EVPerror(EVP_R_INVALID_OPERATION);
                 return -1;
         }
 
         ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2);
 
         if (ret == -2)
-                EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
+                EVPerror(EVP_R_COMMAND_NOT_SUPPORTED);
 
         return ret;
 
@@ -438,15 +438,13 @@ int
 EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *name, const char *value)
 {
         if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str) {
-                EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR,
-                    EVP_R_COMMAND_NOT_SUPPORTED);
+                EVPerror(EVP_R_COMMAND_NOT_SUPPORTED);
                 return -2;
         }
         if (!strcmp(name, "digest")) {
                 const EVP_MD *md;
                 if (!value || !(md = EVP_get_digestbyname(value))) {
-                        EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR,
-                            EVP_R_INVALID_DIGEST);
+                        EVPerror(EVP_R_INVALID_DIGEST);
                         return 0;
                 }
                 return EVP_PKEY_CTX_set_signature_md(ctx, md);