Fix external symbols in the provider digest implementations.
authorShane Lontis <shane.lontis@oracle.com>
Wed, 17 Feb 2021 09:56:35 +0000 (19:56 +1000)
committerPauli <ppzgs1@gmail.com>
Thu, 18 Feb 2021 11:14:32 +0000 (21:14 +1000)
Partial fix for #12964

This adds ossl_ names for the following symbols:

blake2b512_init,blake2b_final,blake2b_init,blake2b_init_key,
blake2b_param_init,blake2b_param_set_digest_length,blake2b_param_set_key_length,
blake2b_param_set_personal,blake2b_param_set_salt,blake2b_update,
blake2s256_init,blake2s_final,blake2s_init,blake2s_init_key,
blake2s_param_init,blake2s_param_set_digest_length,blake2s_param_set_key_length,
blake2s_param_set_personal,blake2s_param_set_salt,blake2s_update,
digest_default_get_params,digest_default_gettable_params

Reviewed-by: Paul Dale <pauli@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/14211)

crypto/evp/legacy_blake2.c
providers/implementations/digests/blake2_prov.c
providers/implementations/digests/blake2b_prov.c
providers/implementations/digests/blake2s_prov.c
providers/implementations/digests/digestcommon.c
providers/implementations/include/prov/blake2.h
providers/implementations/include/prov/digestcommon.h
providers/implementations/macs/blake2b_mac.c
providers/implementations/macs/blake2s_mac.c

index e034034..22765ac 100644 (file)
 #include "prov/blake2.h"        /* diverse BLAKE2 macros */
 #include "legacy_meth.h"
 
-#define blake2b_init blake2b512_init
-#define blake2s_init blake2s256_init
+#define ossl_blake2b_init ossl_blake2b512_init
+#define ossl_blake2s_init ossl_blake2s256_init
 
-IMPLEMENT_LEGACY_EVP_MD_METH_LC(blake2s_int, blake2s)
-IMPLEMENT_LEGACY_EVP_MD_METH_LC(blake2b_int, blake2b)
+IMPLEMENT_LEGACY_EVP_MD_METH_LC(blake2s_int, ossl_blake2s)
+IMPLEMENT_LEGACY_EVP_MD_METH_LC(blake2b_int, ossl_blake2b)
 
 static const EVP_MD blake2b_md = {
     NID_blake2b512,
index 8bb1050..a97d17a 100644 (file)
 #include "prov/digestcommon.h"
 #include "prov/implementations.h"
 
-OSSL_FUNC_digest_init_fn blake2s256_init;
-OSSL_FUNC_digest_init_fn blake2b512_init;
+OSSL_FUNC_digest_init_fn ossl_blake2s256_init;
+OSSL_FUNC_digest_init_fn ossl_blake2b512_init;
 
-int blake2s256_init(void *ctx)
+int ossl_blake2s256_init(void *ctx)
 {
     BLAKE2S_PARAM P;
 
-    blake2s_param_init(&P);
-    return blake2s_init((BLAKE2S_CTX *)ctx, &P);
+    ossl_blake2s_param_init(&P);
+    return ossl_blake2s_init((BLAKE2S_CTX *)ctx, &P);
 }
 
-int blake2b512_init(void *ctx)
+int ossl_blake2b512_init(void *ctx)
 {
     BLAKE2B_PARAM P;
 
-    blake2b_param_init(&P);
-    return blake2b_init((BLAKE2B_CTX *)ctx, &P);
+    ossl_blake2b_param_init(&P);
+    return ossl_blake2b_init((BLAKE2B_CTX *)ctx, &P);
 }
 
 /* ossl_blake2s256_functions */
 IMPLEMENT_digest_functions(blake2s256, BLAKE2S_CTX,
                            BLAKE2S_BLOCKBYTES, BLAKE2S_DIGEST_LENGTH, 0,
-                           blake2s256_init, blake2s_update, blake2s_final)
+                           ossl_blake2s256_init, ossl_blake2s_update,
+                           ossl_blake2s_final)
 
 /* ossl_blake2b512_functions */
 IMPLEMENT_digest_functions(blake2b512, BLAKE2B_CTX,
                            BLAKE2B_BLOCKBYTES, BLAKE2B_DIGEST_LENGTH, 0,
-                           blake2b512_init, blake2b_update, blake2b_final)
+                           ossl_blake2b512_init, ossl_blake2b_update,
+                           ossl_blake2b_final)
index baa33e9..2b31882 100644 (file)
@@ -80,7 +80,7 @@ static void blake2b_init_param(BLAKE2B_CTX *S, const BLAKE2B_PARAM *P)
 }
 
 /* Initialize the parameter block with default values */
-void blake2b_param_init(BLAKE2B_PARAM *P)
+void ossl_blake2b_param_init(BLAKE2B_PARAM *P)
 {
     P->digest_length = BLAKE2B_DIGEST_LENGTH;
     P->key_length    = 0;
@@ -95,23 +95,25 @@ void blake2b_param_init(BLAKE2B_PARAM *P)
     memset(P->personal, 0, sizeof(P->personal));
 }
 
-void blake2b_param_set_digest_length(BLAKE2B_PARAM *P, uint8_t outlen)
+void ossl_blake2b_param_set_digest_length(BLAKE2B_PARAM *P, uint8_t outlen)
 {
     P->digest_length = outlen;
 }
 
-void blake2b_param_set_key_length(BLAKE2B_PARAM *P, uint8_t keylen)
+void ossl_blake2b_param_set_key_length(BLAKE2B_PARAM *P, uint8_t keylen)
 {
     P->key_length = keylen;
 }
 
-void blake2b_param_set_personal(BLAKE2B_PARAM *P, const uint8_t *personal, size_t len)
+void ossl_blake2b_param_set_personal(BLAKE2B_PARAM *P, const uint8_t *personal,
+                                     size_t len)
 {
     memcpy(P->personal, personal, len);
     memset(P->personal + len, 0, BLAKE2B_PERSONALBYTES - len);
 }
 
-void blake2b_param_set_salt(BLAKE2B_PARAM *P, const uint8_t *salt, size_t len)
+void ossl_blake2b_param_set_salt(BLAKE2B_PARAM *P, const uint8_t *salt,
+                                 size_t len)
 {
     memcpy(P->salt, salt, len);
     memset(P->salt + len, 0, BLAKE2B_SALTBYTES - len);
@@ -121,7 +123,7 @@ void blake2b_param_set_salt(BLAKE2B_PARAM *P, const uint8_t *salt, size_t len)
  * Initialize the hashing context with the given parameter block.
  * Always returns 1.
  */
-int blake2b_init(BLAKE2B_CTX *c, const BLAKE2B_PARAM *P)
+int ossl_blake2b_init(BLAKE2B_CTX *c, const BLAKE2B_PARAM *P)
 {
     blake2b_init_param(c, P);
     return 1;
@@ -131,7 +133,8 @@ int blake2b_init(BLAKE2B_CTX *c, const BLAKE2B_PARAM *P)
  * Initialize the hashing context with the given parameter block and key.
  * Always returns 1.
  */
-int blake2b_init_key(BLAKE2B_CTX *c, const BLAKE2B_PARAM *P, const void *key)
+int ossl_blake2b_init_key(BLAKE2B_CTX *c, const BLAKE2B_PARAM *P,
+                          const void *key)
 {
     blake2b_init_param(c, P);
 
@@ -140,7 +143,7 @@ int blake2b_init_key(BLAKE2B_CTX *c, const BLAKE2B_PARAM *P, const void *key)
         uint8_t block[BLAKE2B_BLOCKBYTES] = {0};
 
         memcpy(block, key, P->key_length);
-        blake2b_update(c, block, BLAKE2B_BLOCKBYTES);
+        ossl_blake2b_update(c, block, BLAKE2B_BLOCKBYTES);
         OPENSSL_cleanse(block, BLAKE2B_BLOCKBYTES);
     }
 
@@ -252,7 +255,7 @@ static void blake2b_compress(BLAKE2B_CTX *S,
 }
 
 /* Absorb the input data into the hash state.  Always returns 1. */
-int blake2b_update(BLAKE2B_CTX *c, const void *data, size_t datalen)
+int ossl_blake2b_update(BLAKE2B_CTX *c, const void *data, size_t datalen)
 {
     const uint8_t *in = data;
     size_t fill;
@@ -300,7 +303,7 @@ int blake2b_update(BLAKE2B_CTX *c, const void *data, size_t datalen)
  * Calculate the final hash and save it in md.
  * Always returns 1.
  */
-int blake2b_final(unsigned char *md, BLAKE2B_CTX *c)
+int ossl_blake2b_final(unsigned char *md, BLAKE2B_CTX *c)
 {
     uint8_t outbuffer[BLAKE2B_OUTBYTES] = {0};
     uint8_t *target = outbuffer;
index 703d8a8..997d0e2 100644 (file)
@@ -75,7 +75,7 @@ static void blake2s_init_param(BLAKE2S_CTX *S, const BLAKE2S_PARAM *P)
     }
 }
 
-void blake2s_param_init(BLAKE2S_PARAM *P)
+void ossl_blake2s_param_init(BLAKE2S_PARAM *P)
 {
     P->digest_length = BLAKE2S_DIGEST_LENGTH;
     P->key_length    = 0;
@@ -89,23 +89,25 @@ void blake2s_param_init(BLAKE2S_PARAM *P)
     memset(P->personal, 0, sizeof(P->personal));
 }
 
-void blake2s_param_set_digest_length(BLAKE2S_PARAM *P, uint8_t outlen)
+void ossl_blake2s_param_set_digest_length(BLAKE2S_PARAM *P, uint8_t outlen)
 {
     P->digest_length = outlen;
 }
 
-void blake2s_param_set_key_length(BLAKE2S_PARAM *P, uint8_t keylen)
+void ossl_blake2s_param_set_key_length(BLAKE2S_PARAM *P, uint8_t keylen)
 {
     P->key_length = keylen;
 }
 
-void blake2s_param_set_personal(BLAKE2S_PARAM *P, const uint8_t *personal, size_t len)
+void ossl_blake2s_param_set_personal(BLAKE2S_PARAM *P, const uint8_t *personal,
+                                     size_t len)
 {
     memcpy(P->personal, personal, len);
     memset(P->personal + len, 0, BLAKE2S_PERSONALBYTES - len);
 }
 
-void blake2s_param_set_salt(BLAKE2S_PARAM *P, const uint8_t *salt, size_t len)
+void ossl_blake2s_param_set_salt(BLAKE2S_PARAM *P, const uint8_t *salt,
+                                 size_t len)
 {
     memcpy(P->salt, salt, len);
     memset(P->salt + len, 0, BLAKE2S_SALTBYTES - len);}
@@ -114,7 +116,7 @@ void blake2s_param_set_salt(BLAKE2S_PARAM *P, const uint8_t *salt, size_t len)
  * Initialize the hashing context with the given parameter block.
  * Always returns 1.
  */
-int blake2s_init(BLAKE2S_CTX *c, const BLAKE2S_PARAM *P)
+int ossl_blake2s_init(BLAKE2S_CTX *c, const BLAKE2S_PARAM *P)
 {
     blake2s_init_param(c, P);
     return 1;
@@ -124,7 +126,8 @@ int blake2s_init(BLAKE2S_CTX *c, const BLAKE2S_PARAM *P)
  * Initialize the hashing context with the given parameter block and key.
  * Always returns 1.
  */
-int blake2s_init_key(BLAKE2S_CTX *c, const BLAKE2S_PARAM *P, const void *key)
+int ossl_blake2s_init_key(BLAKE2S_CTX *c, const BLAKE2S_PARAM *P,
+                          const void *key)
 {
     blake2s_init_param(c, P);
 
@@ -133,7 +136,7 @@ int blake2s_init_key(BLAKE2S_CTX *c, const BLAKE2S_PARAM *P, const void *key)
         uint8_t block[BLAKE2S_BLOCKBYTES] = {0};
 
         memcpy(block, key, P->key_length);
-        blake2s_update(c, block, BLAKE2S_BLOCKBYTES);
+        ossl_blake2s_update(c, block, BLAKE2S_BLOCKBYTES);
         OPENSSL_cleanse(block, BLAKE2S_BLOCKBYTES);
     }
 
@@ -243,7 +246,7 @@ static void blake2s_compress(BLAKE2S_CTX *S,
 }
 
 /* Absorb the input data into the hash state.  Always returns 1. */
-int blake2s_update(BLAKE2S_CTX *c, const void *data, size_t datalen)
+int ossl_blake2s_update(BLAKE2S_CTX *c, const void *data, size_t datalen)
 {
     const uint8_t *in = data;
     size_t fill;
@@ -291,7 +294,7 @@ int blake2s_update(BLAKE2S_CTX *c, const void *data, size_t datalen)
  * Calculate the final hash and save it in md.
  * Always returns 1.
  */
-int blake2s_final(unsigned char *md, BLAKE2S_CTX *c)
+int ossl_blake2s_final(unsigned char *md, BLAKE2S_CTX *c)
 {
     uint8_t outbuffer[BLAKE2S_OUTBYTES] = {0};
     uint8_t *target = outbuffer;
index cbf32ac..373b3bb 100644 (file)
@@ -11,8 +11,8 @@
 #include <openssl/proverr.h>
 #include "prov/digestcommon.h"
 
-int digest_default_get_params(OSSL_PARAM params[], size_t blksz, size_t paramsz,
-                              unsigned long flags)
+int ossl_digest_default_get_params(OSSL_PARAM params[], size_t blksz,
+                                   size_t paramsz, unsigned long flags)
 {
     OSSL_PARAM *p = NULL;
 
@@ -48,7 +48,7 @@ static const OSSL_PARAM digest_default_known_gettable_params[] = {
     OSSL_PARAM_int(OSSL_DIGEST_PARAM_ALGID_ABSENT, NULL),
     OSSL_PARAM_END
 };
-const OSSL_PARAM *digest_default_gettable_params(void *provctx)
+const OSSL_PARAM *ossl_digest_default_gettable_params(void *provctx)
 {
     return digest_default_known_gettable_params;
 }
index 895cfb8..33b8249 100644 (file)
@@ -83,34 +83,39 @@ struct blake2b_ctx_st {
 typedef struct blake2s_ctx_st BLAKE2S_CTX;
 typedef struct blake2b_ctx_st BLAKE2B_CTX;
 
-int blake2s256_init(void *ctx);
-int blake2b512_init(void *ctx);
+int ossl_blake2s256_init(void *ctx);
+int ossl_blake2b512_init(void *ctx);
 
-int blake2b_init(BLAKE2B_CTX *c, const BLAKE2B_PARAM *P);
-int blake2b_init_key(BLAKE2B_CTX *c, const BLAKE2B_PARAM *P, const void *key);
-int blake2b_update(BLAKE2B_CTX *c, const void *data, size_t datalen);
-int blake2b_final(unsigned char *md, BLAKE2B_CTX *c);
+int ossl_blake2b_init(BLAKE2B_CTX *c, const BLAKE2B_PARAM *P);
+int ossl_blake2b_init_key(BLAKE2B_CTX *c, const BLAKE2B_PARAM *P,
+                          const void *key);
+int ossl_blake2b_update(BLAKE2B_CTX *c, const void *data, size_t datalen);
+int ossl_blake2b_final(unsigned char *md, BLAKE2B_CTX *c);
 
 /*
  * These setters are internal and do not check the validity of their parameters.
  * See blake2b_mac_ctrl for validation logic.
  */
 
-void blake2b_param_init(BLAKE2B_PARAM *P);
-void blake2b_param_set_digest_length(BLAKE2B_PARAM *P, uint8_t outlen);
-void blake2b_param_set_key_length(BLAKE2B_PARAM *P, uint8_t keylen);
-void blake2b_param_set_personal(BLAKE2B_PARAM *P, const uint8_t *personal, size_t length);
-void blake2b_param_set_salt(BLAKE2B_PARAM *P, const uint8_t *salt, size_t length);
-
-int blake2s_init(BLAKE2S_CTX *c, const BLAKE2S_PARAM *P);
-int blake2s_init_key(BLAKE2S_CTX *c, const BLAKE2S_PARAM *P, const void *key);
-int blake2s_update(BLAKE2S_CTX *c, const void *data, size_t datalen);
-int blake2s_final(unsigned char *md, BLAKE2S_CTX *c);
-
-void blake2s_param_init(BLAKE2S_PARAM *P);
-void blake2s_param_set_digest_length(BLAKE2S_PARAM *P, uint8_t outlen);
-void blake2s_param_set_key_length(BLAKE2S_PARAM *P, uint8_t keylen);
-void blake2s_param_set_personal(BLAKE2S_PARAM *P, const uint8_t *personal, size_t length);
-void blake2s_param_set_salt(BLAKE2S_PARAM *P, const uint8_t *salt, size_t length);
+void ossl_blake2b_param_init(BLAKE2B_PARAM *P);
+void ossl_blake2b_param_set_digest_length(BLAKE2B_PARAM *P, uint8_t outlen);
+void ossl_blake2b_param_set_key_length(BLAKE2B_PARAM *P, uint8_t keylen);
+void ossl_blake2b_param_set_personal(BLAKE2B_PARAM *P, const uint8_t *personal,
+                                     size_t length);
+void ossl_blake2b_param_set_salt(BLAKE2B_PARAM *P, const uint8_t *salt,
+                                 size_t length);
+int ossl_blake2s_init(BLAKE2S_CTX *c, const BLAKE2S_PARAM *P);
+int ossl_blake2s_init_key(BLAKE2S_CTX *c, const BLAKE2S_PARAM *P,
+                          const void *key);
+int ossl_blake2s_update(BLAKE2S_CTX *c, const void *data, size_t datalen);
+int ossl_blake2s_final(unsigned char *md, BLAKE2S_CTX *c);
+
+void ossl_blake2s_param_init(BLAKE2S_PARAM *P);
+void ossl_blake2s_param_set_digest_length(BLAKE2S_PARAM *P, uint8_t outlen);
+void ossl_blake2s_param_set_key_length(BLAKE2S_PARAM *P, uint8_t keylen);
+void ossl_blake2s_param_set_personal(BLAKE2S_PARAM *P, const uint8_t *personal,
+                                     size_t length);
+void ossl_blake2s_param_set_salt(BLAKE2S_PARAM *P, const uint8_t *salt,
+                                 size_t length);
 
 #endif /* OSSL_PROVIDERS_DEFAULT_INCLUDE_INTERNAL_BLAKE2_H */
index f1164c5..894e729 100644 (file)
@@ -24,25 +24,25 @@ extern "C" {
 # endif
 
 #define PROV_FUNC_DIGEST_GET_PARAM(name, blksize, dgstsize, flags)             \
-static OSSL_FUNC_digest_get_params_fn name##_get_params;                         \
+static OSSL_FUNC_digest_get_params_fn name##_get_params;                       \
 static int name##_get_params(OSSL_PARAM params[])                              \
 {                                                                              \
-    return digest_default_get_params(params, blksize, dgstsize, flags);        \
+    return ossl_digest_default_get_params(params, blksize, dgstsize, flags);   \
 }
 
 #define PROV_DISPATCH_FUNC_DIGEST_GET_PARAMS(name)                             \
 { OSSL_FUNC_DIGEST_GET_PARAMS, (void (*)(void))name##_get_params },            \
 { OSSL_FUNC_DIGEST_GETTABLE_PARAMS,                                            \
-  (void (*)(void))digest_default_gettable_params }
+  (void (*)(void))ossl_digest_default_gettable_params }
 
 # define PROV_DISPATCH_FUNC_DIGEST_CONSTRUCT_START(                            \
     name, CTX, blksize, dgstsize, flags, init, upd, fin)                       \
-static OSSL_FUNC_digest_newctx_fn name##_newctx;                                 \
-static OSSL_FUNC_digest_freectx_fn name##_freectx;                               \
-static OSSL_FUNC_digest_dupctx_fn name##_dupctx;                                 \
+static OSSL_FUNC_digest_newctx_fn name##_newctx;                               \
+static OSSL_FUNC_digest_freectx_fn name##_freectx;                             \
+static OSSL_FUNC_digest_dupctx_fn name##_dupctx;                               \
 static void *name##_newctx(void *prov_ctx)                                     \
 {                                                                              \
-    CTX *ctx = ossl_prov_is_running() ? OPENSSL_zalloc(sizeof(*ctx)) : NULL;    \
+    CTX *ctx = ossl_prov_is_running() ? OPENSSL_zalloc(sizeof(*ctx)) : NULL;   \
     return ctx;                                                                \
 }                                                                              \
 static void name##_freectx(void *vctx)                                         \
@@ -53,7 +53,7 @@ static void name##_freectx(void *vctx)                                         \
 static void *name##_dupctx(void *ctx)                                          \
 {                                                                              \
     CTX *in = (CTX *)ctx;                                                      \
-    CTX *ret = ossl_prov_is_running() ? OPENSSL_malloc(sizeof(*ret)) : NULL;    \
+    CTX *ret = ossl_prov_is_running() ? OPENSSL_malloc(sizeof(*ret)) : NULL;   \
     if (ret != NULL)                                                           \
         *ret = *in;                                                            \
     return ret;                                                                \
@@ -61,13 +61,13 @@ static void *name##_dupctx(void *ctx)                                          \
 static OSSL_FUNC_digest_init_fn name##_internal_init;                          \
 static int name##_internal_init(void *ctx)                                     \
 {                                                                              \
-    return ossl_prov_is_running() ? init(ctx) : 0;                              \
+    return ossl_prov_is_running() ? init(ctx) : 0;                             \
 }                                                                              \
 static OSSL_FUNC_digest_final_fn name##_internal_final;                        \
 static int name##_internal_final(void *ctx, unsigned char *out, size_t *outl,  \
                                  size_t outsz)                                 \
 {                                                                              \
-    if (ossl_prov_is_running() && outsz >= dgstsize && fin(out, ctx)) {         \
+    if (ossl_prov_is_running() && outsz >= dgstsize && fin(out, ctx)) {        \
         *outl = dgstsize;                                                      \
         return 1;                                                              \
     }                                                                          \
@@ -103,9 +103,9 @@ PROV_DISPATCH_FUNC_DIGEST_CONSTRUCT_START(name, CTX, blksize, dgstsize, flags, \
 PROV_DISPATCH_FUNC_DIGEST_CONSTRUCT_END
 
 
-const OSSL_PARAM *digest_default_gettable_params(void *provctx);
-int digest_default_get_params(OSSL_PARAM params[], size_t blksz, size_t paramsz,
-                              unsigned long flags);
+const OSSL_PARAM *ossl_digest_default_gettable_params(void *provctx);
+int ossl_digest_default_get_params(OSSL_PARAM params[], size_t blksz,
+                                   size_t paramsz, unsigned long flags);
 
 # ifdef __cplusplus
 }
index 31c3dd0..d1781d0 100644 (file)
 #define BLAKE2_SALTBYTES BLAKE2B_SALTBYTES
 
 /* Function names */
-#define BLAKE2_PARAM_INIT blake2b_param_init
-#define BLAKE2_INIT_KEY blake2b_init_key
-#define BLAKE2_UPDATE blake2b_update
-#define BLAKE2_FINAL blake2b_final
-#define BLAKE2_PARAM_SET_DIGEST_LENGTH blake2b_param_set_digest_length
-#define BLAKE2_PARAM_SET_KEY_LENGTH blake2b_param_set_key_length
-#define BLAKE2_PARAM_SET_PERSONAL blake2b_param_set_personal
-#define BLAKE2_PARAM_SET_SALT blake2b_param_set_salt
+#define BLAKE2_PARAM_INIT ossl_blake2b_param_init
+#define BLAKE2_INIT_KEY ossl_blake2b_init_key
+#define BLAKE2_UPDATE ossl_blake2b_update
+#define BLAKE2_FINAL ossl_blake2b_final
+#define BLAKE2_PARAM_SET_DIGEST_LENGTH ossl_blake2b_param_set_digest_length
+#define BLAKE2_PARAM_SET_KEY_LENGTH ossl_blake2b_param_set_key_length
+#define BLAKE2_PARAM_SET_PERSONAL ossl_blake2b_param_set_personal
+#define BLAKE2_PARAM_SET_SALT ossl_blake2b_param_set_salt
 
 /* OSSL_DISPATCH symbol */
 #define BLAKE2_FUNCTIONS ossl_blake2bmac_functions
index 54db7e3..90583a5 100644 (file)
 #define BLAKE2_SALTBYTES BLAKE2S_SALTBYTES
 
 /* Function names */
-#define BLAKE2_PARAM_INIT blake2s_param_init
-#define BLAKE2_INIT_KEY blake2s_init_key
-#define BLAKE2_UPDATE blake2s_update
-#define BLAKE2_FINAL blake2s_final
-#define BLAKE2_PARAM_SET_DIGEST_LENGTH blake2s_param_set_digest_length
-#define BLAKE2_PARAM_SET_KEY_LENGTH blake2s_param_set_key_length
-#define BLAKE2_PARAM_SET_PERSONAL blake2s_param_set_personal
-#define BLAKE2_PARAM_SET_SALT blake2s_param_set_salt
+#define BLAKE2_PARAM_INIT ossl_blake2s_param_init
+#define BLAKE2_INIT_KEY ossl_blake2s_init_key
+#define BLAKE2_UPDATE ossl_blake2s_update
+#define BLAKE2_FINAL ossl_blake2s_final
+#define BLAKE2_PARAM_SET_DIGEST_LENGTH ossl_blake2s_param_set_digest_length
+#define BLAKE2_PARAM_SET_KEY_LENGTH ossl_blake2s_param_set_key_length
+#define BLAKE2_PARAM_SET_PERSONAL ossl_blake2s_param_set_personal
+#define BLAKE2_PARAM_SET_SALT ossl_blake2s_param_set_salt
 
 /* OSSL_DISPATCH symbol */
 #define BLAKE2_FUNCTIONS ossl_blake2smac_functions