lc_hmac.h

Go to the documentation of this file.

/*
 * Copyright (C) 2020 - 2024, Stephan Mueller <smueller@chronox.de>
 *
 * License: see LICENSE file in root directory
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
 * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 */
 
#ifndef LC_HMAC_H
#define LC_HMAC_H
 
#include "lc_hash.h"
#include "lc_sha3.h"
#include "lc_memset_secure.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if LC_SHA3_MAX_SIZE_BLOCK
#define LC_SHA_MAX_SIZE_BLOCK LC_SHA3_MAX_SIZE_BLOCK
#elif LC_SHA512_SIZE_BLOCK
#define LC_SHA_MAX_SIZE_BLOCK LC_SHA512_SIZE_BLOCK
#elif LC_SHA256_SIZE_BLOCK
#define LC_SHA_MAX_SIZE_BLOCK LC_SHA256_SIZE_BLOCK
#else
#error "No known maximum block size defined - include sha3.h, sha512.h or sha256.h before hmac.h"
#endif
 
struct lc_hmac_ctx {
        uint8_t *k_opad;
        uint8_t *k_ipad;
        struct lc_hash_ctx hash_ctx;
};
 
#define LC_HMAC_STATE_SIZE(x)                                                  \
        (LC_HASH_STATE_SIZE(x) + 2 * LC_SHA_MAX_SIZE_BLOCK)
#define LC_HMAC_CTX_SIZE(x) (LC_HMAC_STATE_SIZE(x) + sizeof(struct lc_hmac_ctx))
 
#define _LC_HMAC_SET_CTX(name, hashname, ctx, offset)                          \
        _LC_HASH_SET_CTX((&name->hash_ctx), hashname, ctx, offset);            \
        name->k_opad = (uint8_t *)((uint8_t *)ctx + offset +                   \
                                   LC_HASH_STATE_SIZE(hashname));              \
        name->k_ipad = (uint8_t *)((uint8_t *)ctx + offset +                   \
                                   LC_HASH_STATE_SIZE(hashname) +              \
                                   LC_SHA_MAX_SIZE_BLOCK)
 
#define LC_HMAC_SET_CTX(name, hashname)                                        \
        _LC_HMAC_SET_CTX(name, hashname, name, sizeof(struct lc_hmac_ctx))
 
void lc_hmac_init(struct lc_hmac_ctx *hmac_ctx, const uint8_t *key,
                  size_t keylen);
 
void lc_hmac_reinit(struct lc_hmac_ctx *hmac_ctx);
 
void lc_hmac_update(struct lc_hmac_ctx *hmac_ctx, const uint8_t *in,
                    size_t inlen);
 
void lc_hmac_final(struct lc_hmac_ctx *hmac_ctx, uint8_t *mac);
 
int lc_hmac_alloc(const struct lc_hash *hash, struct lc_hmac_ctx **hmac_ctx);
 
void lc_hmac_zero_free(struct lc_hmac_ctx *hmac_ctx);
 
static inline void lc_hmac_zero(struct lc_hmac_ctx *hmac_ctx)
{
        struct lc_hash_ctx *hash_ctx = &hmac_ctx->hash_ctx;
        const struct lc_hash *hash = hash_ctx->hash;
 
        lc_memset_secure((uint8_t *)hmac_ctx + sizeof(struct lc_hmac_ctx), 0,
                         LC_HMAC_STATE_SIZE(hash));
}
 
#define LC_HMAC_CTX_ON_STACK(name, hashname)                                        \
        _Pragma("GCC diagnostic push")                                              \
                _Pragma("GCC diagnostic ignored \"-Wvla\"") _Pragma(                \
                        "GCC diagnostic ignored \"-Wdeclaration-after-statement\"") \
                        LC_ALIGNED_BUFFER(name##_ctx_buf,                           \
                                          LC_HMAC_CTX_SIZE(hashname),               \
                                          LC_HASH_COMMON_ALIGNMENT);                \
        struct lc_hmac_ctx *name = (struct lc_hmac_ctx *)name##_ctx_buf;            \
        LC_HMAC_SET_CTX(name, hashname);                                            \
        lc_hmac_zero(name);                                                         \
        _Pragma("GCC diagnostic pop")
 
static inline size_t lc_hmac_macsize(struct lc_hmac_ctx *hmac_ctx)
{
        struct lc_hash_ctx *hash_ctx = &hmac_ctx->hash_ctx;
 
        return lc_hash_digestsize(hash_ctx);
}
 
static inline void lc_hmac(const struct lc_hash *hash, const uint8_t *key,
                           size_t keylen, const uint8_t *in, size_t inlen,
                           uint8_t *mac)
{
        LC_HMAC_CTX_ON_STACK(hmac_ctx, hash);
 
        lc_hmac_init(hmac_ctx, key, keylen);
        lc_hmac_update(hmac_ctx, in, inlen);
        lc_hmac_final(hmac_ctx, mac);
 
        lc_hmac_zero(hmac_ctx);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* LC_HMAC_H */