lc_sym.h

Go to the documentation of this file.

/*
 * Copyright (C) 2016 - 2025, Stephan Mueller <smueller@chronox.de>
 *
 * License: see COPYING 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_SYM_H
#define _LC_SYM_H
 
#include "ext_headers.h"
#include "lc_memset_secure.h"
#include "lc_memory_support.h"
 
#ifdef __cplusplus
extern "C" {
#endif

struct lc_sym_state;
struct lc_sym {
        int (*init)(struct lc_sym_state *ctx);
        int (*init_nocheck)(struct lc_sym_state *ctx);
        int (*setkey)(struct lc_sym_state *ctx, const uint8_t *key,
                      size_t keylen);
        int (*setiv)(struct lc_sym_state *ctx, const uint8_t *iv, size_t ivlen);
        void (*encrypt)(struct lc_sym_state *ctx, const uint8_t *in,
                        uint8_t *out, size_t len);
        void (*decrypt)(struct lc_sym_state *ctx, const uint8_t *in,
                        uint8_t *out, size_t len);
        uint64_t algorithm_type;
        unsigned int statesize;
        unsigned int blocksize;
};
 
struct lc_sym_ctx {
        const struct lc_sym *sym;
        struct lc_sym_state *sym_state;
};
 
/*
 * Align the lc_sym_state structure to 16 bytes boundary irrespective where
 * it is embedded into. This is achieved by adding 15 more bytes than necessary
 * to LC_ALIGNED_SYM_BUFFER and then adjusting the pointer offset in that range
 * accordingly.
 *
 * TODO: make this adjustable with a lc_sym->alignment setting - but the
 * question is which pre-processor macro to use to select the proper
 * LC_ALIGN_PTR_XX macro depending on lc_sym->alignment during compile time.
 */
#ifndef LC_SYM_COMMON_ALIGNMENT
#define LC_SYM_COMMON_ALIGNMENT (16)
#endif
#define LC_SYM_ALIGNMENT(symname) LC_SYM_COMMON_ALIGNMENT
#define LC_SYM_ALIGNMASK(symname) (LC_SYM_ALIGNMENT(symname) - 1)
 
#define LC_ALIGN_SYM_MASK(p, symname)                                          \
        LC_ALIGN_PTR_64(p, LC_SYM_ALIGNMASK(symname))
 
#define LC_SYM_STATE_SIZE_NONALIGNED(x) ((unsigned long)(x->statesize))
#define LC_SYM_STATE_SIZE(x)                                                   \
        (LC_SYM_STATE_SIZE_NONALIGNED(x) + LC_SYM_COMMON_ALIGNMENT)
#define LC_SYM_CTX_SIZE_NONALIGNED(x)                                          \
        (sizeof(struct lc_sym_ctx) + LC_SYM_STATE_SIZE_NONALIGNED(x))
#define LC_SYM_CTX_SIZE(x) (sizeof(struct lc_sym_ctx) + LC_SYM_STATE_SIZE(x))
 
#define LC_SYM_STATE_SIZE_LEN(len) ((len) + LC_SYM_COMMON_ALIGNMENT)
#define LC_SYM_CTX_SIZE_LEN(len)                                               \
        (sizeof(struct lc_sym_ctx) + LC_SYM_STATE_SIZE_LEN(len))
 
#define _LC_SYM_SET_CTX(name, symname, ctx, offset)                            \
        name->sym_state = (struct lc_sym_state *)LC_ALIGN_SYM_MASK(            \
                ((uint8_t *)(ctx)) + (offset), symname);                       \
        name->sym = symname
 
#define LC_SYM_SET_CTX(name, symname)                                          \
        _LC_SYM_SET_CTX(name, symname, name, sizeof(struct lc_sym_ctx))


int lc_sym_init(struct lc_sym_ctx *ctx);

int lc_sym_setkey(struct lc_sym_ctx *ctx, const uint8_t *key, size_t keylen);

int lc_sym_setiv(struct lc_sym_ctx *ctx, const uint8_t *iv, size_t ivlen);

void lc_sym_encrypt(struct lc_sym_ctx *ctx, const uint8_t *in, uint8_t *out,
                    size_t len);

void lc_sym_decrypt(struct lc_sym_ctx *ctx, const uint8_t *in, uint8_t *out,
                    size_t len);

void lc_sym_zero(struct lc_sym_ctx *ctx);

int lc_sym_alloc(const struct lc_sym *sym, struct lc_sym_ctx **ctx);

void lc_sym_zero_free(struct lc_sym_ctx *ctx);

uint64_t lc_sym_algorithm_type(const struct lc_sym *sym);

uint64_t lc_sym_ctx_algorithm_type(const struct lc_sym_ctx *ctx);

#define LC_SYM_CTX_ON_STACK(name, symname)                                          \
        _Pragma("GCC diagnostic push")                                              \
                _Pragma("GCC diagnostic ignored \"-Wvla\"") _Pragma(                \
                        "GCC diagnostic ignored \"-Wdeclaration-after-statement\"") \
                        LC_ALIGNED_BUFFER(name##_ctx_buf,                           \
                                          LC_SYM_CTX_SIZE(symname),                 \
                                          LC_SYM_COMMON_ALIGNMENT);                 \
        struct lc_sym_ctx *name = (struct lc_sym_ctx *)name##_ctx_buf;              \
        LC_SYM_SET_CTX(name, symname);                                              \
        lc_sym_zero(name);                                                          \
        _Pragma("GCC diagnostic pop")
 
#ifdef __cplusplus
}
#endif
 
#endif /* _LC_SYM_H */