lc_sphincs.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 - 2025, 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.
 */
/*
 * This code is derived in parts from the code distribution provided with
 * https://github.com/pq-crystals/sphincs
 *
 * That code is released under Public Domain
 * (https://creativecommons.org/share-your-work/public-domain/cc0/);
 * or Apache 2.0 License (https://www.apache.org/licenses/LICENSE-2.0.html).
 */
 
#ifndef LC_SPHINCS_H
#define LC_SPHINCS_H
 
#include "ext_headers.h"
 
#if defined __has_include
#if __has_include("lc_sphincs_shake_256s.h")
#include "lc_sphincs_shake_256s.h"
#define LC_SPHINCS_SHAKE_256s_ENABLED
#endif
#if __has_include("lc_sphincs_shake_256f.h")
#include "lc_sphincs_shake_256f.h"
#define LC_SPHINCS_SHAKE_256f_ENABLED
#endif
#if __has_include("lc_sphincs_shake_192s.h")
#include "lc_sphincs_shake_192s.h"
#define LC_SPHINCS_SHAKE_192s_ENABLED
#endif
#if __has_include("lc_sphincs_shake_192f.h")
#include "lc_sphincs_shake_192f.h"
#define LC_SPHINCS_SHAKE_192f_ENABLED
#endif
#if __has_include("lc_sphincs_shake_128s.h")
#include "lc_sphincs_shake_128s.h"
#define LC_SPHINCS_SHAKE_128s_ENABLED
#endif
#if __has_include("lc_sphincs_shake_128f.h")
#include "lc_sphincs_shake_128f.h"
#define LC_SPHINCS_SHAKE_128f_ENABLED
#endif
#else
#error "Compiler misses __has_include"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum lc_sphincs_type {
        LC_SPHINCS_UNKNOWN,
        LC_SPHINCS_SHAKE_256s,
        LC_SPHINCS_SHAKE_256f,
        LC_SPHINCS_SHAKE_192s,
        LC_SPHINCS_SHAKE_192f,
        LC_SPHINCS_SHAKE_128s,
        LC_SPHINCS_SHAKE_128f,
};


struct lc_sphincs_sk {
        enum lc_sphincs_type sphincs_type;
        union {
#ifdef LC_SPHINCS_SHAKE_256s_ENABLED
                struct lc_sphincs_shake_256s_sk sk_shake_256s;
#endif
#ifdef LC_SPHINCS_SHAKE_256f_ENABLED
                struct lc_sphincs_shake_256f_sk sk_shake_256f;
#endif
#ifdef LC_SPHINCS_SHAKE_192s_ENABLED
                struct lc_sphincs_shake_192s_sk sk_shake_192s;
#endif
#ifdef LC_SPHINCS_SHAKE_192f_ENABLED
                struct lc_sphincs_shake_192f_sk sk_shake_192f;
#endif
#ifdef LC_SPHINCS_SHAKE_128s_ENABLED
                struct lc_sphincs_shake_128s_sk sk_shake_128s;
#endif
#ifdef LC_SPHINCS_SHAKE_128f_ENABLED
                struct lc_sphincs_shake_128f_sk sk_shake_128f;
#endif
        } key;
};

struct lc_sphincs_pk {
        enum lc_sphincs_type sphincs_type;
        union {
#ifdef LC_SPHINCS_SHAKE_256s_ENABLED
                struct lc_sphincs_shake_256s_pk pk_shake_256s;
#endif
#ifdef LC_SPHINCS_SHAKE_256f_ENABLED
                struct lc_sphincs_shake_256f_pk pk_shake_256f;
#endif
#ifdef LC_SPHINCS_SHAKE_192s_ENABLED
                struct lc_sphincs_shake_192s_pk pk_shake_192s;
#endif
#ifdef LC_SPHINCS_SHAKE_192f_ENABLED
                struct lc_sphincs_shake_192f_pk pk_shake_192f;
#endif
#ifdef LC_SPHINCS_SHAKE_128s_ENABLED
                struct lc_sphincs_shake_128s_pk pk_shake_128s;
#endif
#ifdef LC_SPHINCS_SHAKE_128f_ENABLED
                struct lc_sphincs_shake_128f_pk pk_shake_128f;
#endif
        } key;
};

struct lc_sphincs_sig {
        enum lc_sphincs_type sphincs_type;
        union {
#ifdef LC_SPHINCS_SHAKE_256s_ENABLED
                struct lc_sphincs_shake_256s_sig sig_shake_256s;
#endif
#ifdef LC_SPHINCS_SHAKE_256f_ENABLED
                struct lc_sphincs_shake_256f_sig sig_shake_256f;
#endif
#ifdef LC_SPHINCS_SHAKE_192s_ENABLED
                struct lc_sphincs_shake_192s_sig sig_shake_192s;
#endif
#ifdef LC_SPHINCS_SHAKE_192f_ENABLED
                struct lc_sphincs_shake_192f_sig sig_shake_192f;
#endif
#ifdef LC_SPHINCS_SHAKE_128s_ENABLED
                struct lc_sphincs_shake_128s_sig sig_shake_128s;
#endif
#ifdef LC_SPHINCS_SHAKE_128f_ENABLED
                struct lc_sphincs_shake_128f_sig sig_shake_128f;
#endif
        } sig;
};

int lc_sphincs_ctx_alloc(struct lc_sphincs_ctx **ctx);

void lc_sphincs_ctx_zero_free(struct lc_sphincs_ctx *ctx);

void lc_sphincs_ctx_zero(struct lc_sphincs_ctx *ctx);

void lc_sphincs_ctx_internal(struct lc_sphincs_ctx *ctx);

void lc_sphincs_ctx_hash(struct lc_sphincs_ctx *ctx,
                         const struct lc_hash *hash);

void lc_sphincs_ctx_userctx(struct lc_sphincs_ctx *ctx, const uint8_t *userctx,
                            size_t userctxlen);

enum lc_sphincs_type lc_sphincs_sk_type(const struct lc_sphincs_sk *sk);

enum lc_sphincs_type lc_sphincs_pk_type(const struct lc_sphincs_pk *pk);

enum lc_sphincs_type lc_sphincs_sig_type(const struct lc_sphincs_sig *sig);

LC_PURE unsigned int lc_sphincs_sk_size(enum lc_sphincs_type sphincs_type);

LC_PURE unsigned int lc_sphincs_pk_size(enum lc_sphincs_type sphincs_type);

LC_PURE unsigned int lc_sphincs_sig_size(enum lc_sphincs_type sphincs_type);

int lc_sphincs_sk_load(struct lc_sphincs_sk *sk, const uint8_t *src_key,
                       size_t src_key_len);

int lc_sphincs_sk_set_keytype_fast(struct lc_sphincs_sk *sk);

int lc_sphincs_sk_set_keytype_small(struct lc_sphincs_sk *sk);

int lc_sphincs_pk_load(struct lc_sphincs_pk *pk, const uint8_t *src_key,
                       size_t src_key_len);

int lc_sphincs_pk_set_keytype_fast(struct lc_sphincs_pk *pk);

int lc_sphincs_pk_set_keytype_small(struct lc_sphincs_pk *pk);

int lc_sphincs_sig_load(struct lc_sphincs_sig *sig, const uint8_t *src_sig,
                        size_t src_sig_len);

int lc_sphincs_sk_ptr(uint8_t **sphincs_key, size_t *sphincs_key_len,
                      struct lc_sphincs_sk *sk);

int lc_sphincs_pk_ptr(uint8_t **sphincs_key, size_t *sphincs_key_len,
                      struct lc_sphincs_pk *pk);

int lc_sphincs_sig_ptr(uint8_t **sphincs_sig, size_t *sphincs_sig_len,
                       struct lc_sphincs_sig *sig);

int lc_sphincs_keypair(struct lc_sphincs_pk *pk, struct lc_sphincs_sk *sk,
                       struct lc_rng_ctx *rng_ctx,
                       enum lc_sphincs_type sphincs_type);

int lc_sphincs_keypair_from_seed(struct lc_sphincs_pk *pk,
                                 struct lc_sphincs_sk *sk, const uint8_t *seed,
                                 size_t seedlen,
                                 enum lc_sphincs_type sphincs_type);

int lc_sphincs_pct(const struct lc_sphincs_pk *pk,
                   const struct lc_sphincs_sk *sk);

int lc_sphincs_sign(struct lc_sphincs_sig *sig, const uint8_t *m, size_t mlen,
                    const struct lc_sphincs_sk *sk, struct lc_rng_ctx *rng_ctx);

int lc_sphincs_sign_ctx(struct lc_sphincs_sig *sig, struct lc_sphincs_ctx *ctx,
                        const uint8_t *m, size_t mlen,
                        const struct lc_sphincs_sk *sk,
                        struct lc_rng_ctx *rng_ctx);

int lc_sphincs_sign_init(struct lc_sphincs_ctx *ctx,
                         const struct lc_sphincs_sk *sk);

int lc_sphincs_sign_update(struct lc_sphincs_ctx *ctx, const uint8_t *m,
                           size_t mlen);

int lc_sphincs_sign_final(struct lc_sphincs_sig *sig,
                          struct lc_sphincs_ctx *ctx,
                          const struct lc_sphincs_sk *sk,
                          struct lc_rng_ctx *rng_ctx);

int lc_sphincs_verify(const struct lc_sphincs_sig *sig, const uint8_t *m,
                      size_t mlen, const struct lc_sphincs_pk *pk);

int lc_sphincs_verify_ctx(const struct lc_sphincs_sig *sig,
                          struct lc_sphincs_ctx *ctx, const uint8_t *m,
                          size_t mlen, const struct lc_sphincs_pk *pk);

int lc_sphincs_verify_init(struct lc_sphincs_ctx *ctx,
                           const struct lc_sphincs_pk *pk);

int lc_sphincs_verify_update(struct lc_sphincs_ctx *ctx, const uint8_t *m,
                             size_t mlen);

int lc_sphincs_verify_final(const struct lc_sphincs_sig *sig,
                            struct lc_sphincs_ctx *ctx,
                            const struct lc_sphincs_pk *pk);
 
#ifdef __cplusplus
}
#endif
 
#endif /* LC_SPHINCS_H */