Adding in curl and openssl repos

openssl-3.4.2/crypto/hmac/build.info

@@ -0,0 +1,23 @@
+LIBS=../../libcrypto
+
+$COMMON=hmac.c
+
+IF[{- !$disabled{asm} -}]
+  IF[{- ($target{perlasm_scheme} // '') ne '31' -}]
+    $HMACASM_s390x=hmac_s390x.c
+    $HMACDEF_s390x=OPENSSL_HMAC_S390X
+  ENDIF
+
+  # Now that we have defined all the arch specific variables, use the
+  # appropriate ones, and define the appropriate macros
+  IF[$HMACASM_{- $target{asm_arch} -}]
+    $HMACASM=$HMACASM_{- $target{asm_arch} -}
+    $HMACDEF=$HMACDEF_{- $target{asm_arch} -}
+  ENDIF
+ENDIF
+
+DEFINE[../../libcrypto]=$HMACDEF
+DEFINE[../../providers/libfips.a]=$HMACDEF
+
+SOURCE[../../libcrypto]=$COMMON $HMACASM
+SOURCE[../../providers/libfips.a]=$COMMON $HMACASM

openssl-3.4.2/crypto/hmac/hmac.c

@@ -0,0 +1,277 @@
+/*
+ * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * HMAC low level APIs are deprecated for public use, but still ok for internal
+ * use.
+ */
+#include "internal/deprecated.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "internal/cryptlib.h"
+#include <openssl/opensslconf.h>
+#include <openssl/hmac.h>
+#include <openssl/core_names.h>
+#include "hmac_local.h"
+
+int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
+                 const EVP_MD *md, ENGINE *impl)
+{
+    int rv = 0, reset = 0;
+    int i, j;
+    unsigned char pad[HMAC_MAX_MD_CBLOCK_SIZE];
+    unsigned int keytmp_length;
+    unsigned char keytmp[HMAC_MAX_MD_CBLOCK_SIZE];
+
+    /* If we are changing MD then we must have a key */
+    if (md != NULL && md != ctx->md && (key == NULL || len < 0))
+        return 0;
+
+    if (md != NULL)
+        ctx->md = md;
+    else if (ctx->md != NULL)
+        md = ctx->md;
+    else
+        return 0;
+
+    /*
+     * The HMAC construction is not allowed to be used with the
+     * extendable-output functions (XOF) shake128 and shake256.
+     */
+    if (EVP_MD_xof(md))
+        return 0;
+
+#ifdef OPENSSL_HMAC_S390X
+    rv = s390x_HMAC_init(ctx, key, len, impl);
+    if (rv >= 1)
+        return rv;
+#endif
+
+    if (key != NULL) {
+        reset = 1;
+
+        j = EVP_MD_get_block_size(md);
+        if (!ossl_assert(j <= (int)sizeof(keytmp)))
+            return 0;
+        if (j < 0)
+            return 0;
+        if (j < len) {
+            if (!EVP_DigestInit_ex(ctx->md_ctx, md, impl)
+                    || !EVP_DigestUpdate(ctx->md_ctx, key, len)
+                    || !EVP_DigestFinal_ex(ctx->md_ctx, keytmp,
+                                           &keytmp_length))
+                return 0;
+        } else {
+            if (len < 0 || len > (int)sizeof(keytmp))
+                return 0;
+            memcpy(keytmp, key, len);
+            keytmp_length = len;
+        }
+        if (keytmp_length != HMAC_MAX_MD_CBLOCK_SIZE)
+            memset(&keytmp[keytmp_length], 0,
+                   HMAC_MAX_MD_CBLOCK_SIZE - keytmp_length);
+
+        for (i = 0; i < HMAC_MAX_MD_CBLOCK_SIZE; i++)
+            pad[i] = 0x36 ^ keytmp[i];
+        if (!EVP_DigestInit_ex(ctx->i_ctx, md, impl)
+                || !EVP_DigestUpdate(ctx->i_ctx, pad,
+                                     EVP_MD_get_block_size(md)))
+            goto err;
+
+        for (i = 0; i < HMAC_MAX_MD_CBLOCK_SIZE; i++)
+            pad[i] = 0x5c ^ keytmp[i];
+        if (!EVP_DigestInit_ex(ctx->o_ctx, md, impl)
+                || !EVP_DigestUpdate(ctx->o_ctx, pad,
+                                     EVP_MD_get_block_size(md)))
+            goto err;
+    }
+    if (!EVP_MD_CTX_copy_ex(ctx->md_ctx, ctx->i_ctx))
+        goto err;
+    rv = 1;
+ err:
+    if (reset) {
+        OPENSSL_cleanse(keytmp, sizeof(keytmp));
+        OPENSSL_cleanse(pad, sizeof(pad));
+    }
+    return rv;
+}
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+int HMAC_Init(HMAC_CTX *ctx, const void *key, int len, const EVP_MD *md)
+{
+    if (key && md)
+        HMAC_CTX_reset(ctx);
+    return HMAC_Init_ex(ctx, key, len, md, NULL);
+}
+#endif
+
+int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, size_t len)
+{
+    if (!ctx->md)
+        return 0;
+
+#ifdef OPENSSL_HMAC_S390X
+    if (ctx->plat.s390x.fc)
+        return s390x_HMAC_update(ctx, data, len);
+#endif
+
+    return EVP_DigestUpdate(ctx->md_ctx, data, len);
+}
+
+int HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len)
+{
+    unsigned int i;
+    unsigned char buf[EVP_MAX_MD_SIZE];
+
+    if (!ctx->md)
+        goto err;
+
+#ifdef OPENSSL_HMAC_S390X
+    if (ctx->plat.s390x.fc)
+        return s390x_HMAC_final(ctx, md, len);
+#endif
+
+    if (!EVP_DigestFinal_ex(ctx->md_ctx, buf, &i))
+        goto err;
+    if (!EVP_MD_CTX_copy_ex(ctx->md_ctx, ctx->o_ctx))
+        goto err;
+    if (!EVP_DigestUpdate(ctx->md_ctx, buf, i))
+        goto err;
+    if (!EVP_DigestFinal_ex(ctx->md_ctx, md, len))
+        goto err;
+    return 1;
+ err:
+    return 0;
+}
+
+size_t HMAC_size(const HMAC_CTX *ctx)
+{
+    int size = EVP_MD_get_size((ctx)->md);
+
+    return (size < 0) ? 0 : size;
+}
+
+HMAC_CTX *HMAC_CTX_new(void)
+{
+    HMAC_CTX *ctx = OPENSSL_zalloc(sizeof(HMAC_CTX));
+
+    if (ctx != NULL) {
+        if (!HMAC_CTX_reset(ctx)) {
+            HMAC_CTX_free(ctx);
+            return NULL;
+        }
+    }
+    return ctx;
+}
+
+static void hmac_ctx_cleanup(HMAC_CTX *ctx)
+{
+    EVP_MD_CTX_reset(ctx->i_ctx);
+    EVP_MD_CTX_reset(ctx->o_ctx);
+    EVP_MD_CTX_reset(ctx->md_ctx);
+    ctx->md = NULL;
+
+#ifdef OPENSSL_HMAC_S390X
+    s390x_HMAC_CTX_cleanup(ctx);
+#endif
+}
+
+void HMAC_CTX_free(HMAC_CTX *ctx)
+{
+    if (ctx != NULL) {
+        hmac_ctx_cleanup(ctx);
+        EVP_MD_CTX_free(ctx->i_ctx);
+        EVP_MD_CTX_free(ctx->o_ctx);
+        EVP_MD_CTX_free(ctx->md_ctx);
+        OPENSSL_free(ctx);
+    }
+}
+
+static int hmac_ctx_alloc_mds(HMAC_CTX *ctx)
+{
+    if (ctx->i_ctx == NULL)
+        ctx->i_ctx = EVP_MD_CTX_new();
+    if (ctx->i_ctx == NULL)
+        return 0;
+    if (ctx->o_ctx == NULL)
+        ctx->o_ctx = EVP_MD_CTX_new();
+    if (ctx->o_ctx == NULL)
+        return 0;
+    if (ctx->md_ctx == NULL)
+        ctx->md_ctx = EVP_MD_CTX_new();
+    if (ctx->md_ctx == NULL)
+        return 0;
+    return 1;
+}
+
+int HMAC_CTX_reset(HMAC_CTX *ctx)
+{
+    hmac_ctx_cleanup(ctx);
+    if (!hmac_ctx_alloc_mds(ctx)) {
+        hmac_ctx_cleanup(ctx);
+        return 0;
+    }
+    return 1;
+}
+
+int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx)
+{
+    if (!hmac_ctx_alloc_mds(dctx))
+        goto err;
+    if (!EVP_MD_CTX_copy_ex(dctx->i_ctx, sctx->i_ctx))
+        goto err;
+    if (!EVP_MD_CTX_copy_ex(dctx->o_ctx, sctx->o_ctx))
+        goto err;
+    if (!EVP_MD_CTX_copy_ex(dctx->md_ctx, sctx->md_ctx))
+        goto err;
+    dctx->md = sctx->md;
+
+#ifdef OPENSSL_HMAC_S390X
+    if (s390x_HMAC_CTX_copy(dctx, sctx) == 0)
+        goto err;
+#endif
+
+    return 1;
+ err:
+    hmac_ctx_cleanup(dctx);
+    return 0;
+}
+
+unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len,
+                    const unsigned char *data, size_t data_len,
+                    unsigned char *md, unsigned int *md_len)
+{
+    static unsigned char static_md[EVP_MAX_MD_SIZE];
+    int size = EVP_MD_get_size(evp_md);
+    size_t temp_md_len = 0;
+    unsigned char *ret = NULL;
+
+    if (size > 0) {
+        ret = EVP_Q_mac(NULL, "HMAC", NULL, EVP_MD_get0_name(evp_md), NULL,
+                        key, key_len, data, data_len,
+                        md == NULL ? static_md : md, size, &temp_md_len);
+        if (md_len != NULL)
+            *md_len = (unsigned int)temp_md_len;
+    }
+    return ret;
+}
+
+void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags)
+{
+    EVP_MD_CTX_set_flags(ctx->i_ctx, flags);
+    EVP_MD_CTX_set_flags(ctx->o_ctx, flags);
+    EVP_MD_CTX_set_flags(ctx->md_ctx, flags);
+}
+
+const EVP_MD *HMAC_CTX_get_md(const HMAC_CTX *ctx)
+{
+    return ctx->md;
+}

openssl-3.4.2/crypto/hmac/hmac_local.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OSSL_CRYPTO_HMAC_LOCAL_H
+# define OSSL_CRYPTO_HMAC_LOCAL_H
+
+# include "internal/common.h"
+# include "internal/numbers.h"
+# include "openssl/sha.h"
+
+/* The current largest case is for SHA3-224 */
+#define HMAC_MAX_MD_CBLOCK_SIZE     144
+
+struct hmac_ctx_st {
+    const EVP_MD *md;
+    EVP_MD_CTX *md_ctx;
+    EVP_MD_CTX *i_ctx;
+    EVP_MD_CTX *o_ctx;
+
+    /* Platform specific data */
+    union {
+        int dummy;
+# ifdef OPENSSL_HMAC_S390X
+        struct {
+            unsigned int fc; /* 0 if not supported by kmac instruction */
+            int blk_size;
+            int ikp;
+            int iimp;
+            unsigned char *buf;
+            size_t size; /* must be multiple of digest block size */
+            size_t num;
+            union {
+                OSSL_UNION_ALIGN;
+                struct {
+                    uint32_t h[8];
+                    uint64_t imbl;
+                    unsigned char key[64];
+                } hmac_224_256;
+                struct {
+                    uint64_t h[8];
+                    uint128_t imbl;
+                    unsigned char key[128];
+                } hmac_384_512;
+            } param;
+        } s390x;
+# endif /* OPENSSL_HMAC_S390X */
+    } plat;
+};
+
+# ifdef OPENSSL_HMAC_S390X
+#  define HMAC_S390X_BUF_NUM_BLOCKS 64
+
+int s390x_HMAC_init(HMAC_CTX *ctx, const void *key, int key_len, ENGINE *impl);
+int s390x_HMAC_update(HMAC_CTX *ctx, const unsigned char *data, size_t len);
+int s390x_HMAC_final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len);
+int s390x_HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx);
+int s390x_HMAC_CTX_cleanup(HMAC_CTX *ctx);
+# endif /* OPENSSL_HMAC_S390X */
+
+#endif

openssl-3.4.2/crypto/hmac/hmac_s390x.c

@@ -0,0 +1,340 @@
+/*
+ * Copyright 2024-2025 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/* We need to use some engine deprecated APIs */
+#define OPENSSL_SUPPRESS_DEPRECATED
+
+#include "crypto/s390x_arch.h"
+#include "hmac_local.h"
+#include "openssl/obj_mac.h"
+#include "openssl/evp.h"
+#include "openssl/err.h"
+#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
+# include <openssl/engine.h>
+#endif
+
+#ifdef OPENSSL_HMAC_S390X
+
+static int s390x_fc_from_md(const EVP_MD *md)
+{
+    int fc;
+
+    if (EVP_MD_is_a(md, "SHA2-224"))
+        fc = S390X_HMAC_SHA_224;
+    else if (EVP_MD_is_a(md, "SHA2-256"))
+        fc = S390X_HMAC_SHA_256;
+    else if (EVP_MD_is_a(md, "SHA2-384"))
+        fc = S390X_HMAC_SHA_384;
+    else if (EVP_MD_is_a(md, "SHA2-512"))
+        fc = S390X_HMAC_SHA_512;
+    else
+        return 0;
+
+    if ((OPENSSL_s390xcap_P.kmac[1] & S390X_CAPBIT(fc)) == 0)
+        return 0;
+
+    return fc;
+}
+
+static void s390x_call_kmac(HMAC_CTX *ctx, const unsigned char *in, size_t len)
+{
+    unsigned int fc = ctx->plat.s390x.fc;
+
+    if (ctx->plat.s390x.ikp)
+        fc |= S390X_KMAC_IKP;
+
+    if (ctx->plat.s390x.iimp)
+        fc |= S390X_KMAC_IIMP;
+
+    switch (ctx->plat.s390x.fc) {
+    case S390X_HMAC_SHA_224:
+    case S390X_HMAC_SHA_256:
+        ctx->plat.s390x.param.hmac_224_256.imbl += ((uint64_t)len * 8);
+        break;
+    case S390X_HMAC_SHA_384:
+    case S390X_HMAC_SHA_512:
+        ctx->plat.s390x.param.hmac_384_512.imbl += ((uint128_t)len * 8);
+        break;
+    default:
+        break;
+    }
+
+    s390x_kmac(in, len, fc, &ctx->plat.s390x.param);
+
+    ctx->plat.s390x.ikp = 1;
+}
+
+static int s390x_check_engine_used(const EVP_MD *md, ENGINE *impl)
+{
+# if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
+    const EVP_MD *d;
+
+    if (impl != NULL) {
+        if (!ENGINE_init(impl))
+            return 0;
+    } else {
+        impl = ENGINE_get_digest_engine(EVP_MD_get_type(md));
+    }
+
+    if (impl == NULL)
+        return 0;
+
+    d = ENGINE_get_digest(impl, EVP_MD_get_type(md));
+    ENGINE_finish(impl);
+
+    if (d != NULL)
+        return 1;
+# endif
+
+    return 0;
+}
+
+int s390x_HMAC_init(HMAC_CTX *ctx, const void *key, int key_len, ENGINE *impl)
+{
+    unsigned char *key_param;
+    unsigned int key_param_len;
+
+    ctx->plat.s390x.fc = s390x_fc_from_md(ctx->md);
+    if (ctx->plat.s390x.fc == 0)
+        return -1; /* Not supported by kmac instruction */
+
+    if (s390x_check_engine_used(ctx->md, impl)) {
+        ctx->plat.s390x.fc = 0;
+        return -1; /* An engine handles the digest, disable acceleration */
+    }
+
+    ctx->plat.s390x.blk_size = EVP_MD_get_block_size(ctx->md);
+    if (ctx->plat.s390x.blk_size < 0)
+        return 0;
+
+    if (ctx->plat.s390x.size !=
+        (size_t)(ctx->plat.s390x.blk_size * HMAC_S390X_BUF_NUM_BLOCKS)) {
+        OPENSSL_clear_free(ctx->plat.s390x.buf, ctx->plat.s390x.size);
+        ctx->plat.s390x.size = 0;
+        ctx->plat.s390x.buf = OPENSSL_zalloc(ctx->plat.s390x.blk_size *
+                                             HMAC_S390X_BUF_NUM_BLOCKS);
+        if (ctx->plat.s390x.buf == NULL)
+            return 0;
+        ctx->plat.s390x.size = ctx->plat.s390x.blk_size *
+            HMAC_S390X_BUF_NUM_BLOCKS;
+    }
+    ctx->plat.s390x.num = 0;
+
+    ctx->plat.s390x.ikp = 0;
+    ctx->plat.s390x.iimp = 1;
+
+    switch (ctx->plat.s390x.fc) {
+    case S390X_HMAC_SHA_224:
+    case S390X_HMAC_SHA_256:
+        ctx->plat.s390x.param.hmac_224_256.imbl = 0;
+        OPENSSL_cleanse(ctx->plat.s390x.param.hmac_224_256.h,
+                        sizeof(ctx->plat.s390x.param.hmac_224_256.h));
+        break;
+    case S390X_HMAC_SHA_384:
+    case S390X_HMAC_SHA_512:
+        ctx->plat.s390x.param.hmac_384_512.imbl = 0;
+        OPENSSL_cleanse(ctx->plat.s390x.param.hmac_384_512.h,
+                        sizeof(ctx->plat.s390x.param.hmac_384_512.h));
+        break;
+    default:
+        return 0;
+    }
+
+    if (key != NULL) {
+        switch (ctx->plat.s390x.fc) {
+        case S390X_HMAC_SHA_224:
+        case S390X_HMAC_SHA_256:
+            OPENSSL_cleanse(&ctx->plat.s390x.param.hmac_224_256.key,
+                            sizeof(ctx->plat.s390x.param.hmac_224_256.key));
+            key_param = ctx->plat.s390x.param.hmac_224_256.key;
+            key_param_len = sizeof(ctx->plat.s390x.param.hmac_224_256.key);
+            break;
+        case S390X_HMAC_SHA_384:
+        case S390X_HMAC_SHA_512:
+            OPENSSL_cleanse(&ctx->plat.s390x.param.hmac_384_512.key,
+                            sizeof(ctx->plat.s390x.param.hmac_384_512.key));
+            key_param = ctx->plat.s390x.param.hmac_384_512.key;
+            key_param_len = sizeof(ctx->plat.s390x.param.hmac_384_512.key);
+            break;
+        default:
+            return 0;
+        }
+
+        if (!ossl_assert(ctx->plat.s390x.blk_size <= (int)key_param_len))
+            return 0;
+
+        if (key_len > ctx->plat.s390x.blk_size) {
+            if (!EVP_DigestInit_ex(ctx->md_ctx, ctx->md, impl)
+                    || !EVP_DigestUpdate(ctx->md_ctx, key, key_len)
+                    || !EVP_DigestFinal_ex(ctx->md_ctx, key_param,
+                                           &key_param_len))
+                return 0;
+        } else {
+            if (key_len < 0 || key_len > (int)key_param_len)
+                return 0;
+            memcpy(key_param, key, key_len);
+            /* remaining key bytes already zeroed out above */
+        }
+    }
+
+    return 1;
+}
+
+int s390x_HMAC_update(HMAC_CTX *ctx, const unsigned char *data, size_t len)
+{
+    size_t remain, num;
+
+    if (ctx->plat.s390x.iimp != 1) {
+        ERR_raise(ERR_LIB_EVP, EVP_R_UPDATE_ERROR);
+        return 0;
+    }
+
+    if (len == 0)
+        return 1;
+
+    /* buffer is full, process it now */
+    if (ctx->plat.s390x.num == ctx->plat.s390x.size) {
+        s390x_call_kmac(ctx, ctx->plat.s390x.buf, ctx->plat.s390x.num);
+
+        ctx->plat.s390x.num = 0;
+    }
+
+    remain = ctx->plat.s390x.size - ctx->plat.s390x.num;
+    if (len > remain) {
+        /* data does not fit into buffer */
+        if (ctx->plat.s390x.num > 0) {
+            /* first fill buffer and process it */
+            memcpy(&ctx->plat.s390x.buf[ctx->plat.s390x.num], data, remain);
+            ctx->plat.s390x.num += remain;
+
+            s390x_call_kmac(ctx, ctx->plat.s390x.buf, ctx->plat.s390x.num);
+
+            ctx->plat.s390x.num = 0;
+
+            data += remain;
+            len -= remain;
+        }
+
+        if (!ossl_assert(ctx->plat.s390x.num == 0))
+            return 0;
+
+        if (len > ctx->plat.s390x.size) {
+            /*
+             * remaining data is still larger than buffer, process remaining
+             * full blocks of input directly
+             */
+            remain = len % ctx->plat.s390x.blk_size;
+            num = len - remain;
+
+            s390x_call_kmac(ctx, data, num);
+
+            data += num;
+            len -= num;
+        }
+    }
+
+    /* add remaining input data (which is < buffer size) to buffer */
+    if (!ossl_assert(len <= ctx->plat.s390x.size))
+        return 0;
+
+    if (len > 0) {
+        memcpy(&ctx->plat.s390x.buf[ctx->plat.s390x.num], data, len);
+        ctx->plat.s390x.num += len;
+    }
+
+    return 1;
+}
+
+int s390x_HMAC_final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len)
+{
+    void *result;
+    unsigned int res_len;
+
+    if (ctx->plat.s390x.iimp != 1) {
+        ERR_raise(ERR_LIB_EVP, EVP_R_FINAL_ERROR);
+        return 0;
+    }
+
+    ctx->plat.s390x.iimp = 0; /* last block */
+    s390x_call_kmac(ctx, ctx->plat.s390x.buf, ctx->plat.s390x.num);
+
+    ctx->plat.s390x.num = 0;
+
+    switch (ctx->plat.s390x.fc) {
+    case S390X_HMAC_SHA_224:
+        result = &ctx->plat.s390x.param.hmac_224_256.h[0];
+        res_len = SHA224_DIGEST_LENGTH;
+        break;
+    case S390X_HMAC_SHA_256:
+        result = &ctx->plat.s390x.param.hmac_224_256.h[0];
+        res_len = SHA256_DIGEST_LENGTH;
+        break;
+    case S390X_HMAC_SHA_384:
+        result = &ctx->plat.s390x.param.hmac_384_512.h[0];
+        res_len = SHA384_DIGEST_LENGTH;
+        break;
+    case S390X_HMAC_SHA_512:
+        result = &ctx->plat.s390x.param.hmac_384_512.h[0];
+        res_len = SHA512_DIGEST_LENGTH;
+        break;
+    default:
+        return 0;
+    }
+
+    memcpy(md, result, res_len);
+    if (len != NULL)
+        *len = res_len;
+
+    return 1;
+}
+
+int s390x_HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx)
+{
+    dctx->plat.s390x.fc = sctx->plat.s390x.fc;
+    dctx->plat.s390x.blk_size = sctx->plat.s390x.blk_size;
+    dctx->plat.s390x.ikp = sctx->plat.s390x.ikp;
+    dctx->plat.s390x.iimp = sctx->plat.s390x.iimp;
+
+    memcpy(&dctx->plat.s390x.param, &sctx->plat.s390x.param,
+           sizeof(dctx->plat.s390x.param));
+
+    OPENSSL_clear_free(dctx->plat.s390x.buf, dctx->plat.s390x.size);
+    dctx->plat.s390x.buf = NULL;
+    if (sctx->plat.s390x.buf != NULL) {
+        dctx->plat.s390x.buf = OPENSSL_memdup(sctx->plat.s390x.buf,
+                                              sctx->plat.s390x.size);
+        if (dctx->plat.s390x.buf == NULL)
+            return 0;
+    }
+
+    dctx->plat.s390x.size = sctx->plat.s390x.size;
+    dctx->plat.s390x.num = sctx->plat.s390x.num;
+
+    return 1;
+}
+
+int s390x_HMAC_CTX_cleanup(HMAC_CTX *ctx)
+{
+    OPENSSL_clear_free(ctx->plat.s390x.buf, ctx->plat.s390x.size);
+    ctx->plat.s390x.buf = NULL;
+    ctx->plat.s390x.size = 0;
+    ctx->plat.s390x.num = 0;
+
+    OPENSSL_cleanse(&ctx->plat.s390x.param, sizeof(ctx->plat.s390x.param));
+
+    ctx->plat.s390x.blk_size = 0;
+    ctx->plat.s390x.ikp = 0;
+    ctx->plat.s390x.iimp = 1;
+
+    ctx->plat.s390x.fc = 0;
+
+    return 1;
+}
+
+#endif

openssl-3.4.2/crypto/hmac/libcrypto-lib-hmac.d

@@ -0,0 +1,21 @@
+crypto/hmac/libcrypto-lib-hmac.o: crypto/hmac/hmac.c \
+ include/internal/deprecated.h include/openssl/configuration.h \
+ include/openssl/macros.h include/openssl/opensslconf.h \
+ include/openssl/opensslv.h include/internal/cryptlib.h \
+ include/internal/common.h include/internal/e_os.h \
+ include/openssl/e_os2.h include/openssl/crypto.h \
+ include/openssl/safestack.h include/openssl/stack.h \
+ include/openssl/types.h include/openssl/cryptoerr.h \
+ include/openssl/symhacks.h include/openssl/cryptoerr_legacy.h \
+ include/openssl/core.h include/internal/numbers.h \
+ include/internal/nelem.h include/openssl/buffer.h \
+ include/openssl/buffererr.h include/openssl/bio.h \
+ include/openssl/bioerr.h include/openssl/asn1.h \
+ include/openssl/asn1err.h include/openssl/bn.h include/openssl/bnerr.h \
+ include/openssl/err.h include/openssl/lhash.h include/openssl/hmac.h \
+ include/openssl/evp.h include/openssl/core_dispatch.h \
+ include/openssl/indicator.h include/openssl/params.h \
+ include/openssl/evperr.h include/openssl/objects.h \
+ include/openssl/obj_mac.h include/openssl/objectserr.h \
+ include/openssl/core_names.h crypto/hmac/hmac_local.h \
+ include/openssl/sha.h