diff --git a/CMakeLists.txt b/CMakeLists.txt index 3d8d6fc8..e379842c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -53,7 +53,7 @@ option(ENABLE_SM4_XTS "Enable SM4 XTS mode" ON) option(ENABLE_SM4_CBC_MAC "Enable SM4-CBC-MAC" ON) option(ENABLE_SM2_EXTS "Enable SM2 Extensions" OFF) -option(ENABLE_SM3_LMS "Enable SM3-LMS signature" ON) +option(ENABLE_LMS_HSS "Enable LMS/HSS signature" ON) option(ENABLE_SM3_XMSS "Enable SM3-XMSS signature" OFF) @@ -416,18 +416,18 @@ if (ENABLE_SM2_EXTS) endif() -if (ENABLE_SM3_LMS) - message(STATUS "ENABLE_SM3_LMS is ON") - add_definitions(-DENABLE_SM3_LMS) - list(APPEND src src/sm3_lms.c) - list(APPEND tools tools/sm3lmskeygen.c tools/sm3lmssign.c tools/sm3lmsverify.c) - list(APPEND tools tools/sm3hsskeygen.c tools/sm3hsssign.c tools/sm3hssverify.c) - list(APPEND tests sm3_lms) +if (ENABLE_LMS_HSS) + message(STATUS "ENABLE_LMS_HSS is ON") + add_definitions(-DENABLE_LMS_HSS) + list(APPEND src src/lms.c) + list(APPEND tools tools/lmskeygen.c tools/lmssign.c tools/lmsverify.c) + list(APPEND tools tools/hsskeygen.c tools/hsssign.c tools/hssverify.c) + list(APPEND tests lms) - option(ENABLE_SM3_LMS_CROSSCHECK "Enable LMS SHA-256 cross-check" OFF) - if (ENABLE_SM3_LMS_CROSSCHECK) - message(STATUS "ENABLE_SM3_LMS_CROSSCHECK is ON") - add_definitions(-DENABLE_SM3_LMS_CROSSCHECK) + option(ENABLE_LMS_HSS_CROSSCHECK "Enable LMS SHA-256 cross-check" OFF) + if (ENABLE_LMS_HSS_CROSSCHECK) + message(STATUS "ENABLE_LMS_HSS_CROSSCHECK is ON") + add_definitions(-DENABLE_LMS_HSS_CROSSCHECK) endif() endif() diff --git a/include/gmssl/lms.h b/include/gmssl/lms.h new file mode 100644 index 00000000..af319f10 --- /dev/null +++ b/include/gmssl/lms.h @@ -0,0 +1,305 @@ +/* + * Copyright 2014-2025 The GmSSL Project. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * + * http://www.apache.org/licenses/LICENSE-2.0 + */ + +#ifndef GMSSL_LMS_H +#define GMSSL_LMS_H + +#include +#include +#include +#include + + +#include +#include +#include +#include +#ifdef ENABLE_SHA2 +#include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + + +typedef uint8_t hash256_t[32]; + + +#define HSS_MAX_LEVELS 5 +#define LMS_MAX_HEIGHT 25 + + +// Crosscheck with data from LMS-reference (SHA-256), except the LMS signature. +#if defined(ENABLE_LMS_CROSSCHECK) && defined(ENABLE_SHA2) +# define HASH256_CTX SHA256_CTX +# define hash256_init sha256_init +# define hash256_update sha256_update +# define hash256_finish sha256_finish +# define hash256_digest sha256_digest +# define LMOTS_HASH256_N32_W8 LMOTS_SHA256_N32_W8 +# define LMOTS_HASH256_N32_W8_NAME "LMOTS_SHA256_N32_W8" +# define LMS_HASH256_M32_H5 LMS_SHA256_M32_H5 +# define LMS_HASH256_M32_H10 LMS_SHA256_M32_H10 +# define LMS_HASH256_M32_H15 LMS_SHA256_M32_H15 +# define LMS_HASH256_M32_H20 LMS_SHA256_M32_H20 +# define LMS_HASH256_M32_H25 LMS_SHA256_M32_H25 +# define LMS_HASH256_M32_H5_NAME "LMS_SHA256_M32_H5" +# define LMS_HASH256_M32_H10_NAME "LMS_SHA256_M32_H10" +# define LMS_HASH256_M32_H15_NAME "LMS_SHA256_M32_H15" +# define LMS_HASH256_M32_H20_NAME "LMS_SHA256_M32_H20" +# define LMS_HASH256_M32_H25_NAME "LMS_SHA256_M32_H25" +#else +# define HASH256_CTX SM3_CTX +# define hash256_init sm3_init +# define hash256_update sm3_update +# define hash256_finish sm3_finish +# define hash256_digest sm3_digest +# define LMOTS_HASH256_N32_W8 LMOTS_SM3_N32_W8 +# define LMOTS_HASH256_N32_W8_NAME "LMOTS_SM3_N32_W8" +# define LMS_HASH256_M32_H5 LMS_SM3_M32_H5 +# define LMS_HASH256_M32_H10 LMS_SM3_M32_H10 +# define LMS_HASH256_M32_H15 LMS_SM3_M32_H15 +# define LMS_HASH256_M32_H20 LMS_SM3_M32_H20 +# define LMS_HASH256_M32_H25 LMS_SM3_M32_H25 +# define LMS_HASH256_M32_H5_NAME "LMS_SM3_M32_H5" +# define LMS_HASH256_M32_H10_NAME "LMS_SM3_M32_H10" +# define LMS_HASH256_M32_H15_NAME "LMS_SM3_M32_H15" +# define LMS_HASH256_M32_H20_NAME "LMS_SM3_M32_H20" +# define LMS_HASH256_M32_H25_NAME "LMS_SM3_M32_H25" +#endif + +enum { + LMOTS_RESERVED = 0, + LMOTS_SHA256_N32_W1 = 1, + LMOTS_SHA256_N32_W2 = 2, + LMOTS_SHA256_N32_W4 = 3, + LMOTS_SHA256_N32_W8 = 4, + LMOTS_SM3_N32_W1 = 11, + LMOTS_SM3_N32_W2 = 12, + LMOTS_SM3_N32_W4 = 13, + LMOTS_SM3_N32_W8 = 14, +}; + +enum { +#if defined(ENABLE_LMS_CROSSCHECK) && defined(ENABLE_SHA2) + LMS_SHA256_M32_H5 = 5, + LMS_SHA256_M32_H10 = 6, + LMS_SHA256_M32_H15 = 7, + LMS_SHA256_M32_H20 = 8, + LMS_SHA256_M32_H25 = 9, +#else + // TODO: submit to IETF + LMS_SM3_M32_H5 = 5, + LMS_SM3_M32_H10 = 6, + LMS_SM3_M32_H15 = 7, + LMS_SM3_M32_H20 = 8, + LMS_SM3_M32_H25 = 9, +#endif +}; + + +char *lmots_type_name(int lmots_type); +void lmots_derive_secrets(const hash256_t seed, const uint8_t I[16], int q, hash256_t x[34]); +void lmots_secrets_to_public_hash(const uint8_t I[16], int q, const hash256_t x[34], hash256_t pub); +void lmots_compute_signature(const uint8_t I[16], int q, const hash256_t dgst, const hash256_t x[34], hash256_t y[34]); +void lmots_signature_to_public_hash(const uint8_t I[16], int q, const hash256_t y[34], const hash256_t dgst, hash256_t pub); + + +char *lms_type_name(int lms_type); +int lms_type_from_name(const char *name); +int lms_type_to_height(int type, size_t *height); +void lms_derive_merkle_tree(const hash256_t seed, const uint8_t I[16], int height, hash256_t *tree); +void lms_derive_merkle_root(const hash256_t seed, const uint8_t I[16], int height, hash256_t root); + + +typedef struct { + int lms_type; + int lmots_type; + uint8_t I[16]; // lms key identifier + hash256_t root; // merkle tree root +} LMS_PUBLIC_KEY; + +#define LMS_PUBLIC_KEY_SIZE (4 + 4 + 16 + 32) // = 56 bytes + +typedef struct { + LMS_PUBLIC_KEY public_key; + hash256_t *tree; + hash256_t seed; + uint32_t q; // in [0, 2^h - 1], q++ after every sign +} LMS_KEY; + +#define LMS_PRIVATE_KEY_SIZE (LMS_PUBLIC_KEY_SIZE + 32 + 4) // = 92 bytes + +// FIXME: do we need a function to update lms_key->q ? + +int lms_key_generate_ex(LMS_KEY *key, int lms_type, const hash256_t seed, const uint8_t I[16], int cache_tree); +int lms_key_generate(LMS_KEY *key, int lms_type); +int lms_key_check(const LMS_KEY *key, const LMS_PUBLIC_KEY *pub); +int lms_key_remaining_signs(const LMS_KEY *key, size_t *count); +int lms_public_key_to_bytes(const LMS_KEY *key, uint8_t **out, size_t *outlen); +int lms_public_key_from_bytes_ex(const LMS_PUBLIC_KEY **key, const uint8_t **in, size_t *inlen); +int lms_public_key_from_bytes(LMS_KEY *key, const uint8_t **in, size_t *inlen); +int lms_private_key_to_bytes(const LMS_KEY *key, uint8_t **out, size_t *outlen); +int lms_private_key_from_bytes(LMS_KEY *key, const uint8_t **in, size_t *inlen); +int lms_public_key_print(FILE *fp, int fmt, int ind, const char *label, const LMS_PUBLIC_KEY *pub); +int lms_key_print(FILE *fp, int fmt, int ind, const char *label, const LMS_KEY *key); +void lms_key_cleanup(LMS_KEY *key); + + + +typedef struct { + int q; // index of LMS tree leaf, in [0, 2^h - 1] + struct { + int lmots_type; // LMOTS_SM3_N32_W8 or LMOTS_SHA256_N32_W8 in compile time + hash256_t C; // randomness of every LMOTS signature + hash256_t y[34]; // for w = 8 and hash256, 34 winternitz chains + } lmots_sig; + int lms_type; + hash256_t path[25]; // max tree height = 25 when LMS_SM3_M32_H25 +} LMS_SIGNATURE; + +// encoded size, SHOULD be changed when supporting text/der encoding +#define LMS_SIGNATURE_MIN_SIZE (4 + 4 + 32 + 32*34 + 4 + 32*5) // = 1292 bytes +#define LMS_SIGNATURE_MAX_SIZE (4 + 4 + 32 + 32*34 + 4 + 32*25) // = 1932 bytes + + +int lms_signature_to_merkle_root(const uint8_t I[16], size_t h, int q, + const hash256_t y[34], const hash256_t *path, + const hash256_t dgst, hash256_t root); + + +/* + * LMS_HASH256_M32_H5 1292 + * LMS_HASH256_M32_H10 1452 + * LMS_HASH256_M32_H15 1612 + * LMS_HASH256_M32_H20 1772 + * LMS_HASH256_M32_H25 1932 + */ +int lms_signature_size(int lms_type, size_t *siglen); +int lms_key_get_signature_size(const LMS_KEY *key, size_t *siglen); + +int lms_signature_to_bytes(const LMS_SIGNATURE *sig, uint8_t **out, size_t *outlen); +int lms_signature_from_bytes_ex(const LMS_SIGNATURE **sig, size_t *siglen, const uint8_t **in, size_t *inlen); +int lms_signature_from_bytes(LMS_SIGNATURE *sig, const uint8_t **in, size_t *inlen); +int lms_signature_print_ex(FILE *fp, int fmt, int ind, const char *label, const LMS_SIGNATURE *sig); +int lms_signature_print(FILE *fp, int fmt, int ind, const char *label, const uint8_t *sig, size_t siglen); + + +typedef struct { + HASH256_CTX hash256_ctx; + LMS_PUBLIC_KEY lms_public_key; // FIXME: or use LMS_PUBLIC_KEY to re-use tree? + LMS_SIGNATURE lms_sig; +} LMS_SIGN_CTX; + +int lms_sign_init(LMS_SIGN_CTX *ctx, LMS_KEY *key); +int lms_sign_update(LMS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen); +int lms_sign_finish(LMS_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen); +int lms_sign_finish_ex(LMS_SIGN_CTX *ctx, LMS_SIGNATURE *sig); +int lms_verify_init_ex(LMS_SIGN_CTX *ctx, const LMS_KEY *key, const LMS_SIGNATURE *sig); +int lms_verify_init(LMS_SIGN_CTX *ctx, const LMS_KEY *key, const uint8_t *sigbuf, size_t siglen); +int lms_verify_update(LMS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen); +int lms_verify_finish(LMS_SIGN_CTX *ctx); + +// `lms_sign_init` copy lmots private to ctx->lms_sig.y +// call `lms_sign_ctx_cleanup` incase `lms_sign_finish` not called nor finished +void lms_sign_ctx_cleanup(LMS_SIGN_CTX *ctx); + + +/* +// just for reference, HSS_PUBLIC_KEY memory layout might not compatible with HSS_KEY +typedef struct { + uint32_t levels; + LMS_PUBLIC_KEY lms_public_key; +} HSS_PUBLIC_KEY; +*/ + +// HSS_PUBLIC_KEY: { level, lms_key[0].public_key } +#define HSS_PUBLIC_KEY_SIZE (4 + LMS_PUBLIC_KEY_SIZE) + + +// TODO: LMS_KEY should be a tree other than a vector +// when updated, low level lms keys will lost, maybe a good feature +typedef struct { + uint32_t levels; // should be checked to prevent memory error + LMS_KEY lms_key[5]; + LMS_SIGNATURE lms_sig[4]; +} HSS_KEY; + + +#define HSS_PRIVATE_KEY_MAX_SIZE sizeof(HSS_KEY) +int hss_private_key_size(const int *lms_types, size_t levels, size_t *len); + +int hss_key_generate(HSS_KEY *key, const int *lms_types, size_t levels); +int hss_key_update(HSS_KEY *key); + +int hss_public_key_digest(const HSS_KEY *key, uint8_t dgst[32]); +int hss_public_key_to_bytes(const HSS_KEY *key, uint8_t **out, size_t *outlen); +int hss_private_key_to_bytes(const HSS_KEY *key, uint8_t **out, size_t *outlen); +int hss_public_key_from_bytes(HSS_KEY *key, const uint8_t **in, size_t *inlen); +int hss_private_key_from_bytes(HSS_KEY *key, const uint8_t **in, size_t *inlen); +int hss_public_key_print(FILE *fp, int fmt, int ind, const char *label, const HSS_KEY *key); +int hss_key_print(FILE *fp, int fmt, int ind, const char *label, const HSS_KEY *key); +void hss_key_cleanup(HSS_KEY *key); + + +typedef struct { + uint32_t num_signed_public_keys; // = hss_key->levels - 1 + struct { + LMS_SIGNATURE lms_sig; // lms_sig[i] = sign(hss_key->lms_key[i], lms_public_key[i]) + LMS_PUBLIC_KEY lms_public_key; // signed_public_keys[i] = hss_key->lms_key[i+1].public_key + } signed_public_keys[HSS_MAX_LEVELS - 1]; + LMS_SIGNATURE msg_lms_sig; // = sign(hss->lms_key[levels-1], msg) +} HSS_SIGNATURE; + + +#define HSS_SIGNATURE_MAX_SIZE sizeof(HSS_SIGNATURE) +int hss_signature_size(const int *lms_types, size_t levels, size_t *len); +int hss_key_get_signature_size(const HSS_KEY *key, size_t *siglen); + +int hss_signature_to_bytes(const HSS_SIGNATURE *sig, uint8_t **out, size_t *outlen); +int hss_signature_from_bytes(HSS_SIGNATURE *sig, const uint8_t **in, size_t *inlen); +int hss_signature_print_ex(FILE *fp, int fmt, int ind, const char *label, const HSS_SIGNATURE *sig); +int hss_signature_print(FILE *fp, int fmt, int ind, const char *label, const uint8_t *sig, size_t siglen); + + +typedef struct { + LMS_SIGN_CTX lms_ctx; + uint32_t levels; + LMS_SIGNATURE lms_sigs[HSS_MAX_LEVELS - 1]; + LMS_PUBLIC_KEY lms_public_keys[HSS_MAX_LEVELS - 1]; +} HSS_SIGN_CTX; + + +int hss_sign_init(HSS_SIGN_CTX *ctx, HSS_KEY *key); +int hss_sign_update(HSS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen); +int hss_sign_finish(HSS_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen); +int hss_sign_finish_ex(HSS_SIGN_CTX *ctx, HSS_SIGNATURE *sig); +int hss_verify_init_ex(HSS_SIGN_CTX *ctx, const HSS_KEY *key, const HSS_SIGNATURE *sig); +int hss_verify_init(HSS_SIGN_CTX *ctx, const HSS_KEY *key, const uint8_t *sigbuf, size_t siglen); +int hss_verify_update(HSS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen); +int hss_verify_finish(HSS_SIGN_CTX *ctx); + + +// X.509 related +#define HSS_PUBLIC_KEY_DER_SIZE 63 +#define HSS_PUBLIC_KEY_INFO_SIZE 82 + +int hss_public_key_to_der(const HSS_KEY *key, uint8_t **out, size_t *outlen); +int hss_public_key_from_der(HSS_KEY *key, const uint8_t **in, size_t *inlen); +int hss_public_key_algor_to_der(uint8_t **out, size_t *outlen); +int hss_public_key_algor_from_der(const uint8_t **in, size_t *inlen); +int hss_public_key_info_to_der(const HSS_KEY *key, uint8_t **out, size_t *outlen); +int hss_public_key_info_from_der(HSS_KEY *key, const uint8_t **in, size_t *inlen); + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/gmssl/sm3_lms.h b/include/gmssl/sm3_lms.h deleted file mode 100644 index ebc76353..00000000 --- a/include/gmssl/sm3_lms.h +++ /dev/null @@ -1,305 +0,0 @@ -/* - * Copyright 2014-2025 The GmSSL Project. All Rights Reserved. - * - * Licensed under the Apache License, Version 2.0 (the License); you may - * not use this file except in compliance with the License. - * - * http://www.apache.org/licenses/LICENSE-2.0 - */ - -#ifndef GMSSL_SM3_LMS_H -#define GMSSL_SM3_LMS_H - -#include -#include -#include -#include - - -#include -#include -#include -#include -#ifdef ENABLE_SHA2 -#include -#endif - -#ifdef __cplusplus -extern "C" { -#endif - - -typedef uint8_t hash256_t[32]; - - -#define SM3_HSS_MAX_LEVELS 5 -#define SM3_LMS_MAX_HEIGHT 25 - - -// Crosscheck with data from LMS-reference (SHA-256), except the LMS signature. -#if defined(ENABLE_SM3_LMS_CROSSCHECK) && defined(ENABLE_SHA2) -# define HASH256_CTX SHA256_CTX -# define hash256_init sha256_init -# define hash256_update sha256_update -# define hash256_finish sha256_finish -# define hash256_digest sha256_digest -# define LMOTS_HASH256_N32_W8 LMOTS_SHA256_N32_W8 -# define LMOTS_HASH256_N32_W8_NAME "LMOTS_SHA256_N32_W8" -# define LMS_HASH256_M32_H5 LMS_SHA256_M32_H5 -# define LMS_HASH256_M32_H10 LMS_SHA256_M32_H10 -# define LMS_HASH256_M32_H15 LMS_SHA256_M32_H15 -# define LMS_HASH256_M32_H20 LMS_SHA256_M32_H20 -# define LMS_HASH256_M32_H25 LMS_SHA256_M32_H25 -# define LMS_HASH256_M32_H5_NAME "LMS_SHA256_M32_H5" -# define LMS_HASH256_M32_H10_NAME "LMS_SHA256_M32_H10" -# define LMS_HASH256_M32_H15_NAME "LMS_SHA256_M32_H15" -# define LMS_HASH256_M32_H20_NAME "LMS_SHA256_M32_H20" -# define LMS_HASH256_M32_H25_NAME "LMS_SHA256_M32_H25" -#else -# define HASH256_CTX SM3_CTX -# define hash256_init sm3_init -# define hash256_update sm3_update -# define hash256_finish sm3_finish -# define hash256_digest sm3_digest -# define LMOTS_HASH256_N32_W8 LMOTS_SM3_N32_W8 -# define LMOTS_HASH256_N32_W8_NAME "LMOTS_SM3_N32_W8" -# define LMS_HASH256_M32_H5 LMS_SM3_M32_H5 -# define LMS_HASH256_M32_H10 LMS_SM3_M32_H10 -# define LMS_HASH256_M32_H15 LMS_SM3_M32_H15 -# define LMS_HASH256_M32_H20 LMS_SM3_M32_H20 -# define LMS_HASH256_M32_H25 LMS_SM3_M32_H25 -# define LMS_HASH256_M32_H5_NAME "LMS_SM3_M32_H5" -# define LMS_HASH256_M32_H10_NAME "LMS_SM3_M32_H10" -# define LMS_HASH256_M32_H15_NAME "LMS_SM3_M32_H15" -# define LMS_HASH256_M32_H20_NAME "LMS_SM3_M32_H20" -# define LMS_HASH256_M32_H25_NAME "LMS_SM3_M32_H25" -#endif - -enum { - LMOTS_RESERVED = 0, - LMOTS_SHA256_N32_W1 = 1, - LMOTS_SHA256_N32_W2 = 2, - LMOTS_SHA256_N32_W4 = 3, - LMOTS_SHA256_N32_W8 = 4, - LMOTS_SM3_N32_W1 = 11, - LMOTS_SM3_N32_W2 = 12, - LMOTS_SM3_N32_W4 = 13, - LMOTS_SM3_N32_W8 = 14, -}; - -enum { -#if defined(ENABLE_SM3_LMS_CROSSCHECK) && defined(ENABLE_SHA2) - LMS_SHA256_M32_H5 = 5, - LMS_SHA256_M32_H10 = 6, - LMS_SHA256_M32_H15 = 7, - LMS_SHA256_M32_H20 = 8, - LMS_SHA256_M32_H25 = 9, -#else - // TODO: submit to IETF - LMS_SM3_M32_H5 = 5, - LMS_SM3_M32_H10 = 6, - LMS_SM3_M32_H15 = 7, - LMS_SM3_M32_H20 = 8, - LMS_SM3_M32_H25 = 9, -#endif -}; - - -char *sm3_lmots_type_name(int lmots_type); -void sm3_lmots_derive_secrets(const hash256_t seed, const uint8_t I[16], int q, hash256_t x[34]); -void sm3_lmots_secrets_to_public_hash(const uint8_t I[16], int q, const hash256_t x[34], hash256_t pub); -void sm3_lmots_compute_signature(const uint8_t I[16], int q, const hash256_t dgst, const hash256_t x[34], hash256_t y[34]); -void sm3_lmots_signature_to_public_hash(const uint8_t I[16], int q, const hash256_t y[34], const hash256_t dgst, hash256_t pub); - - -char *sm3_lms_type_name(int lms_type); -int sm3_lms_type_from_name(const char *name); -int sm3_lms_type_to_height(int type, size_t *height); -void sm3_lms_derive_merkle_tree(const hash256_t seed, const uint8_t I[16], int height, hash256_t *tree); -void sm3_lms_derive_merkle_root(const hash256_t seed, const uint8_t I[16], int height, hash256_t root); - - -typedef struct { - int lms_type; - int lmots_type; - uint8_t I[16]; // lms key identifier - hash256_t root; // merkle tree root -} SM3_LMS_PUBLIC_KEY; - -#define SM3_LMS_PUBLIC_KEY_SIZE (4 + 4 + 16 + 32) // = 56 bytes - -typedef struct { - SM3_LMS_PUBLIC_KEY public_key; - hash256_t *tree; - hash256_t seed; - uint32_t q; // in [0, 2^h - 1], q++ after every sign -} SM3_LMS_KEY; - -#define SM3_LMS_PRIVATE_KEY_SIZE (SM3_LMS_PUBLIC_KEY_SIZE + 32 + 4) // = 92 bytes - -// FIXME: do we need a function to update lms_key->q ? - -int sm3_lms_key_generate_ex(SM3_LMS_KEY *key, int lms_type, const hash256_t seed, const uint8_t I[16], int cache_tree); -int sm3_lms_key_generate(SM3_LMS_KEY *key, int lms_type); -int sm3_lms_key_check(const SM3_LMS_KEY *key, const SM3_LMS_PUBLIC_KEY *pub); -int sm3_lms_key_remaining_signs(const SM3_LMS_KEY *key, size_t *count); -int sm3_lms_public_key_to_bytes(const SM3_LMS_KEY *key, uint8_t **out, size_t *outlen); -int sm3_lms_public_key_from_bytes_ex(const SM3_LMS_PUBLIC_KEY **key, const uint8_t **in, size_t *inlen); -int sm3_lms_public_key_from_bytes(SM3_LMS_KEY *key, const uint8_t **in, size_t *inlen); -int sm3_lms_private_key_to_bytes(const SM3_LMS_KEY *key, uint8_t **out, size_t *outlen); -int sm3_lms_private_key_from_bytes(SM3_LMS_KEY *key, const uint8_t **in, size_t *inlen); -int sm3_lms_public_key_print(FILE *fp, int fmt, int ind, const char *label, const SM3_LMS_PUBLIC_KEY *pub); -int sm3_lms_key_print(FILE *fp, int fmt, int ind, const char *label, const SM3_LMS_KEY *key); -void sm3_lms_key_cleanup(SM3_LMS_KEY *key); - - - -typedef struct { - int q; // index of LMS tree leaf, in [0, 2^h - 1] - struct { - int lmots_type; // LMOTS_SM3_N32_W8 or LMOTS_SHA256_N32_W8 in compile time - hash256_t C; // randomness of every LMOTS signature - hash256_t y[34]; // for w = 8 and hash256, 34 winternitz chains - } lmots_sig; - int lms_type; - hash256_t path[25]; // max tree height = 25 when LMS_SM3_M32_H25 -} SM3_LMS_SIGNATURE; - -// encoded size, SHOULD be changed when supporting text/der encoding -#define SM3_LMS_SIGNATURE_MIN_SIZE (4 + 4 + 32 + 32*34 + 4 + 32*5) // = 1292 bytes -#define SM3_LMS_SIGNATURE_MAX_SIZE (4 + 4 + 32 + 32*34 + 4 + 32*25) // = 1932 bytes - - -int sm3_lms_signature_to_merkle_root(const uint8_t I[16], size_t h, int q, - const hash256_t y[34], const hash256_t *path, - const hash256_t dgst, hash256_t root); - - -/* - * LMS_HASH256_M32_H5 1292 - * LMS_HASH256_M32_H10 1452 - * LMS_HASH256_M32_H15 1612 - * LMS_HASH256_M32_H20 1772 - * LMS_HASH256_M32_H25 1932 - */ -int sm3_lms_signature_size(int lms_type, size_t *siglen); -int sm3_lms_key_get_signature_size(const SM3_LMS_KEY *key, size_t *siglen); - -int sm3_lms_signature_to_bytes(const SM3_LMS_SIGNATURE *sig, uint8_t **out, size_t *outlen); -int sm3_lms_signature_from_bytes_ex(const SM3_LMS_SIGNATURE **sig, size_t *siglen, const uint8_t **in, size_t *inlen); -int sm3_lms_signature_from_bytes(SM3_LMS_SIGNATURE *sig, const uint8_t **in, size_t *inlen); -int sm3_lms_signature_print_ex(FILE *fp, int fmt, int ind, const char *label, const SM3_LMS_SIGNATURE *sig); -int sm3_lms_signature_print(FILE *fp, int fmt, int ind, const char *label, const uint8_t *sig, size_t siglen); - - -typedef struct { - HASH256_CTX hash256_ctx; - SM3_LMS_PUBLIC_KEY lms_public_key; // FIXME: or use LMS_PUBLIC_KEY to re-use tree? - SM3_LMS_SIGNATURE lms_sig; -} SM3_LMS_SIGN_CTX; - -int sm3_lms_sign_init(SM3_LMS_SIGN_CTX *ctx, SM3_LMS_KEY *key); -int sm3_lms_sign_update(SM3_LMS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen); -int sm3_lms_sign_finish(SM3_LMS_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen); -int sm3_lms_sign_finish_ex(SM3_LMS_SIGN_CTX *ctx, SM3_LMS_SIGNATURE *sig); -int sm3_lms_verify_init_ex(SM3_LMS_SIGN_CTX *ctx, const SM3_LMS_KEY *key, const SM3_LMS_SIGNATURE *sig); -int sm3_lms_verify_init(SM3_LMS_SIGN_CTX *ctx, const SM3_LMS_KEY *key, const uint8_t *sigbuf, size_t siglen); -int sm3_lms_verify_update(SM3_LMS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen); -int sm3_lms_verify_finish(SM3_LMS_SIGN_CTX *ctx); - -// `sm3_lms_sign_init` copy lmots private to ctx->lms_sig.y -// call `sm3_lms_sign_ctx_cleanup` incase `sm3_lms_sign_finish` not called nor finished -void sm3_lms_sign_ctx_cleanup(SM3_LMS_SIGN_CTX *ctx); - - -/* -// just for reference, HSS_PUBLIC_KEY memory layout might not compatible with HSS_KEY -typedef struct { - uint32_t levels; - SM3_LMS_PUBLIC_KEY lms_public_key; -} SM3_HSS_PUBLIC_KEY; -*/ - -// SM3_HSS_PUBLIC_KEY: { level, lms_key[0].public_key } -#define SM3_HSS_PUBLIC_KEY_SIZE (4 + SM3_LMS_PUBLIC_KEY_SIZE) - - -// TODO: LMS_KEY should be a tree other than a vector -// when updated, low level lms keys will lost, maybe a good feature -typedef struct { - uint32_t levels; // should be checked to prevent memory error - SM3_LMS_KEY lms_key[5]; - SM3_LMS_SIGNATURE lms_sig[4]; -} SM3_HSS_KEY; - - -#define SM3_HSS_PRIVATE_KEY_MAX_SIZE sizeof(SM3_HSS_KEY) -int sm3_hss_private_key_size(const int *lms_types, size_t levels, size_t *len); - -int sm3_hss_key_generate(SM3_HSS_KEY *key, const int *lms_types, size_t levels); -int sm3_hss_key_update(SM3_HSS_KEY *key); - -int sm3_hss_public_key_digest(const SM3_HSS_KEY *key, uint8_t dgst[32]); -int sm3_hss_public_key_to_bytes(const SM3_HSS_KEY *key, uint8_t **out, size_t *outlen); -int sm3_hss_private_key_to_bytes(const SM3_HSS_KEY *key, uint8_t **out, size_t *outlen); -int sm3_hss_public_key_from_bytes(SM3_HSS_KEY *key, const uint8_t **in, size_t *inlen); -int sm3_hss_private_key_from_bytes(SM3_HSS_KEY *key, const uint8_t **in, size_t *inlen); -int sm3_hss_public_key_print(FILE *fp, int fmt, int ind, const char *label, const SM3_HSS_KEY *key); -int sm3_hss_key_print(FILE *fp, int fmt, int ind, const char *label, const SM3_HSS_KEY *key); -void sm3_hss_key_cleanup(SM3_HSS_KEY *key); - - -typedef struct { - uint32_t num_signed_public_keys; // = hss_key->levels - 1 - struct { - SM3_LMS_SIGNATURE lms_sig; // lms_sig[i] = sign(hss_key->lms_key[i], lms_public_key[i]) - SM3_LMS_PUBLIC_KEY lms_public_key; // signed_public_keys[i] = hss_key->lms_key[i+1].public_key - } signed_public_keys[SM3_HSS_MAX_LEVELS - 1]; - SM3_LMS_SIGNATURE msg_lms_sig; // = sign(hss->lms_key[levels-1], msg) -} SM3_HSS_SIGNATURE; - - -#define SM3_HSS_SIGNATURE_MAX_SIZE sizeof(SM3_HSS_SIGNATURE) -int sm3_hss_signature_size(const int *lms_types, size_t levels, size_t *len); -int sm3_hss_key_get_signature_size(const SM3_HSS_KEY *key, size_t *siglen); - -int sm3_hss_signature_to_bytes(const SM3_HSS_SIGNATURE *sig, uint8_t **out, size_t *outlen); -int sm3_hss_signature_from_bytes(SM3_HSS_SIGNATURE *sig, const uint8_t **in, size_t *inlen); -int sm3_hss_signature_print_ex(FILE *fp, int fmt, int ind, const char *label, const SM3_HSS_SIGNATURE *sig); -int sm3_hss_signature_print(FILE *fp, int fmt, int ind, const char *label, const uint8_t *sig, size_t siglen); - - -typedef struct { - SM3_LMS_SIGN_CTX lms_ctx; - uint32_t levels; - SM3_LMS_SIGNATURE lms_sigs[SM3_HSS_MAX_LEVELS - 1]; - SM3_LMS_PUBLIC_KEY lms_public_keys[SM3_HSS_MAX_LEVELS - 1]; -} SM3_HSS_SIGN_CTX; - - -int sm3_hss_sign_init(SM3_HSS_SIGN_CTX *ctx, SM3_HSS_KEY *key); -int sm3_hss_sign_update(SM3_HSS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen); -int sm3_hss_sign_finish(SM3_HSS_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen); -int sm3_hss_sign_finish_ex(SM3_HSS_SIGN_CTX *ctx, SM3_HSS_SIGNATURE *sig); -int sm3_hss_verify_init_ex(SM3_HSS_SIGN_CTX *ctx, const SM3_HSS_KEY *key, const SM3_HSS_SIGNATURE *sig); -int sm3_hss_verify_init(SM3_HSS_SIGN_CTX *ctx, const SM3_HSS_KEY *key, const uint8_t *sigbuf, size_t siglen); -int sm3_hss_verify_update(SM3_HSS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen); -int sm3_hss_verify_finish(SM3_HSS_SIGN_CTX *ctx); - - -// X.509 related -#define SM3_HSS_PUBLIC_KEY_DER_SIZE 63 -#define SM3_HSS_PUBLIC_KEY_INFO_SIZE 82 - -int sm3_hss_public_key_to_der(const SM3_HSS_KEY *key, uint8_t **out, size_t *outlen); -int sm3_hss_public_key_from_der(SM3_HSS_KEY *key, const uint8_t **in, size_t *inlen); -int sm3_hss_public_key_algor_to_der(uint8_t **out, size_t *outlen); -int sm3_hss_public_key_algor_from_der(const uint8_t **in, size_t *inlen); -int sm3_hss_public_key_info_to_der(const SM3_HSS_KEY *key, uint8_t **out, size_t *outlen); -int sm3_hss_public_key_info_from_der(SM3_HSS_KEY *key, const uint8_t **in, size_t *inlen); - - -#ifdef __cplusplus -} -#endif -#endif diff --git a/src/sm3_lms.c b/src/lms.c similarity index 65% rename from src/sm3_lms.c rename to src/lms.c index 8e977ef5..b494e818 100644 --- a/src/sm3_lms.c +++ b/src/lms.c @@ -11,7 +11,7 @@ #include #include #include -#include +#include #include /* @@ -27,7 +27,7 @@ static const uint8_t D_LEAF[2] = { 0x82, 0x82 }; static const uint8_t D_INTR[2] = { 0x83, 0x83 }; -char *sm3_lmots_type_name(int lmots_type) +char *lmots_type_name(int lmots_type) { switch (lmots_type) { case LMOTS_HASH256_N32_W8: @@ -36,7 +36,7 @@ char *sm3_lmots_type_name(int lmots_type) return NULL; } -char *sm3_lms_type_name(int lms_type) +char *lms_type_name(int lms_type) { switch (lms_type) { case LMS_HASH256_M32_H5: @@ -53,7 +53,7 @@ char *sm3_lms_type_name(int lms_type) return NULL; } -int sm3_lms_type_from_name(const char *name) +int lms_type_from_name(const char *name) { if (!strcmp(name, LMS_HASH256_M32_H5_NAME)) { return LMS_HASH256_M32_H5; @@ -69,7 +69,7 @@ int sm3_lms_type_from_name(const char *name) return 0; } -int sm3_lms_type_to_height(int type, size_t *height) +int lms_type_to_height(int type, size_t *height) { switch (type) { case LMS_HASH256_M32_H5: @@ -94,7 +94,7 @@ int sm3_lms_type_to_height(int type, size_t *height) return 1; } -void sm3_lmots_derive_secrets(const hash256_t seed, const uint8_t I[16], int q, hash256_t x[34]) +void lmots_derive_secrets(const hash256_t seed, const uint8_t I[16], int q, hash256_t x[34]) { HASH256_CTX ctx; uint8_t qbytes[4]; @@ -120,7 +120,7 @@ void sm3_lmots_derive_secrets(const hash256_t seed, const uint8_t I[16], int q, gmssl_secure_clear(&ctx, sizeof(ctx)); } -void sm3_lmots_secrets_to_public_hash(const uint8_t I[16], int q, const hash256_t x[34], hash256_t pub) +void lmots_secrets_to_public_hash(const uint8_t I[16], int q, const hash256_t x[34], hash256_t pub) { HASH256_CTX ctx; uint8_t qbytes[4]; @@ -172,7 +172,7 @@ static void winternitz_checksum(const hash256_t dgst, uint8_t checksum[2]) } // signed digest Q = H(I || u32str(q) || u16str(D_MESG) || C || message) -void sm3_lmots_compute_signature(const uint8_t I[16], int q, const hash256_t dgst, const hash256_t x[34], hash256_t y[34]) +void lmots_compute_signature(const uint8_t I[16], int q, const hash256_t dgst, const hash256_t x[34], hash256_t y[34]) { HASH256_CTX ctx; uint8_t checksum[2]; @@ -205,7 +205,7 @@ void sm3_lmots_compute_signature(const uint8_t I[16], int q, const hash256_t dgs } } -void sm3_lmots_signature_to_public_hash(const uint8_t I[16], int q, const hash256_t y[34], const hash256_t dgst, hash256_t pub) +void lmots_signature_to_public_hash(const uint8_t I[16], int q, const hash256_t y[34], const hash256_t dgst, hash256_t pub) { uint8_t checksum[2]; HASH256_CTX ctx; @@ -250,7 +250,7 @@ void sm3_lmots_signature_to_public_hash(const uint8_t I[16], int q, const hash25 } // derive full merkle tree[2^h * 2 - 1] from seed, tree[0] is the root -void sm3_lms_derive_merkle_tree(const hash256_t seed, const uint8_t I[16], int h, hash256_t *tree) +void lms_derive_merkle_tree(const hash256_t seed, const uint8_t I[16], int h, hash256_t *tree) { int r, n = (1 << h); uint8_t rbytes[4]; @@ -265,8 +265,8 @@ void sm3_lms_derive_merkle_tree(const hash256_t seed, const uint8_t I[16], int h if (r >= n) { int q = r - n; - sm3_lmots_derive_secrets(seed, I, q, x); - sm3_lmots_secrets_to_public_hash(I, q, x, pub); + lmots_derive_secrets(seed, I, q, x); + lmots_secrets_to_public_hash(I, q, x, pub); // H(I||u32str(r)||u16str(D_LEAF)||OTS_PUB_HASH[r-2^h]) hash256_init(&ctx); @@ -289,7 +289,7 @@ void sm3_lms_derive_merkle_tree(const hash256_t seed, const uint8_t I[16], int h } } -void sm3_lms_derive_merkle_root(const hash256_t seed, const uint8_t I[16], int h, hash256_t root) +void lms_derive_merkle_root(const hash256_t seed, const uint8_t I[16], int h, hash256_t root) { int q, r, n = 1 << h; int qbits; @@ -301,8 +301,8 @@ void sm3_lms_derive_merkle_root(const hash256_t seed, const uint8_t I[16], int h for (q = 0; q < n; q++) { - sm3_lmots_derive_secrets(seed, I, q, x); - sm3_lmots_secrets_to_public_hash(I, q, x, stack[num]); + lmots_derive_secrets(seed, I, q, x); + lmots_secrets_to_public_hash(I, q, x, stack[num]); r = q + n; PUTU32(rbytes, r); @@ -339,7 +339,7 @@ void sm3_lms_derive_merkle_root(const hash256_t seed, const uint8_t I[16], int h memcpy(root, stack[0], 32); } -int sm3_lms_public_key_to_bytes(const SM3_LMS_KEY *key, uint8_t **out, size_t *outlen) +int lms_public_key_to_bytes(const LMS_KEY *key, uint8_t **out, size_t *outlen) { if (!key || !outlen) { error_print(); @@ -355,13 +355,13 @@ int sm3_lms_public_key_to_bytes(const SM3_LMS_KEY *key, uint8_t **out, size_t *o memcpy(*out, key->public_key.root, 32); *out += 32; } - *outlen += SM3_LMS_PUBLIC_KEY_SIZE; + *outlen += LMS_PUBLIC_KEY_SIZE; return 1; } -int sm3_lms_private_key_to_bytes(const SM3_LMS_KEY *key, uint8_t **out, size_t *outlen) +int lms_private_key_to_bytes(const LMS_KEY *key, uint8_t **out, size_t *outlen) { - if (sm3_lms_public_key_to_bytes(key, out, outlen) != 1) { + if (lms_public_key_to_bytes(key, out, outlen) != 1) { error_print(); return -1; } @@ -375,13 +375,13 @@ int sm3_lms_private_key_to_bytes(const SM3_LMS_KEY *key, uint8_t **out, size_t * return 1; } -int sm3_lms_public_key_from_bytes(SM3_LMS_KEY *key, const uint8_t **in, size_t *inlen) +int lms_public_key_from_bytes(LMS_KEY *key, const uint8_t **in, size_t *inlen) { if (!key || !in || !(*in) || !inlen) { error_print(); return -1; } - if (*inlen < SM3_LMS_PUBLIC_KEY_SIZE) { + if (*inlen < LMS_PUBLIC_KEY_SIZE) { error_print(); return -1; } @@ -389,7 +389,7 @@ int sm3_lms_public_key_from_bytes(SM3_LMS_KEY *key, const uint8_t **in, size_t * memset(key, 0, sizeof(*key)); key->public_key.lms_type = GETU32(*in); - if (!sm3_lms_type_name(key->public_key.lms_type)) { + if (!lms_type_name(key->public_key.lms_type)) { error_print(); return -1; } @@ -397,7 +397,7 @@ int sm3_lms_public_key_from_bytes(SM3_LMS_KEY *key, const uint8_t **in, size_t * *inlen -= 4; key->public_key.lmots_type = GETU32(*in); - if (!sm3_lmots_type_name(key->public_key.lmots_type)) { + if (!lmots_type_name(key->public_key.lmots_type)) { error_print(); return -1; } @@ -415,13 +415,13 @@ int sm3_lms_public_key_from_bytes(SM3_LMS_KEY *key, const uint8_t **in, size_t * return 1; } -int sm3_lms_key_check(const SM3_LMS_KEY *key, const SM3_LMS_PUBLIC_KEY *pub) +int lms_key_check(const LMS_KEY *key, const LMS_PUBLIC_KEY *pub) { // FIXME: implement this return 1; } -int sm3_lms_key_remaining_signs(const SM3_LMS_KEY *key, size_t *count) +int lms_key_remaining_signs(const LMS_KEY *key, size_t *count) { size_t height; size_t n; @@ -430,7 +430,7 @@ int sm3_lms_key_remaining_signs(const SM3_LMS_KEY *key, size_t *count) error_print(); return -1; } - if (sm3_lms_type_to_height(key->public_key.lms_type, &height) != 1) { + if (lms_type_to_height(key->public_key.lms_type, &height) != 1) { error_print(); return -1; } @@ -443,7 +443,7 @@ int sm3_lms_key_remaining_signs(const SM3_LMS_KEY *key, size_t *count) return 1; } -int sm3_lms_private_key_from_bytes(SM3_LMS_KEY *key, const uint8_t **in, size_t *inlen) +int lms_private_key_from_bytes(LMS_KEY *key, const uint8_t **in, size_t *inlen) { size_t height; int cache_tree = 1; @@ -452,12 +452,12 @@ int sm3_lms_private_key_from_bytes(SM3_LMS_KEY *key, const uint8_t **in, size_t error_print(); return -1; } - if (*inlen < SM3_LMS_PRIVATE_KEY_SIZE) { + if (*inlen < LMS_PRIVATE_KEY_SIZE) { error_print(); return -1; } - if (sm3_lms_public_key_from_bytes(key, in, inlen) != 1) { + if (lms_public_key_from_bytes(key, in, inlen) != 1) { error_print(); return -1; } @@ -470,7 +470,7 @@ int sm3_lms_private_key_from_bytes(SM3_LMS_KEY *key, const uint8_t **in, size_t *in += 4; *inlen -= 4; - if (sm3_lms_type_to_height(key->public_key.lms_type, &height) != 1) { + if (lms_type_to_height(key->public_key.lms_type, &height) != 1) { error_print(); return -1; } @@ -485,29 +485,29 @@ int sm3_lms_private_key_from_bytes(SM3_LMS_KEY *key, const uint8_t **in, size_t error_print(); return -1; } - sm3_lms_derive_merkle_tree(key->seed, key->public_key.I, height, key->tree); + lms_derive_merkle_tree(key->seed, key->public_key.I, height, key->tree); memcpy(key->public_key.root, key->tree[0], 32); } return 1; } -int sm3_lms_public_key_print(FILE *fp, int fmt, int ind, const char *label, const SM3_LMS_PUBLIC_KEY *pub) +int lms_public_key_print(FILE *fp, int fmt, int ind, const char *label, const LMS_PUBLIC_KEY *pub) { format_print(fp, fmt, ind, "%s\n", label); ind += 4; - format_print(fp, fmt, ind, "lms_type: %s\n", sm3_lms_type_name(pub->lms_type)); - format_print(fp, fmt, ind, "lmots_type: %s\n", sm3_lmots_type_name(pub->lmots_type)); + format_print(fp, fmt, ind, "lms_type: %s\n", lms_type_name(pub->lms_type)); + format_print(fp, fmt, ind, "lmots_type: %s\n", lmots_type_name(pub->lmots_type)); format_bytes(fp, fmt, ind, "I", pub->I, 16); format_bytes(fp, fmt, ind, "root", pub->root, 32); return 1; } -int sm3_lms_key_print(FILE *fp, int fmt, int ind, const char *label, const SM3_LMS_KEY *key) +int lms_key_print(FILE *fp, int fmt, int ind, const char *label, const LMS_KEY *key) { format_print(fp, fmt, ind, "%s\n", label); ind += 4; - sm3_lms_public_key_print(fp, fmt, ind, "lms_public_key", &key->public_key); + lms_public_key_print(fp, fmt, ind, "lms_public_key", &key->public_key); format_bytes(fp, fmt, ind, "seed", key->seed, 32); format_print(fp, fmt, ind, "q = %d\n", key->q); if (key->tree && fmt) { @@ -521,7 +521,7 @@ int sm3_lms_key_print(FILE *fp, int fmt, int ind, const char *label, const SM3_L return 1; } -void sm3_lms_key_cleanup(SM3_LMS_KEY *key) +void lms_key_cleanup(LMS_KEY *key) { if (key) { gmssl_secure_clear(key->seed, 32); @@ -529,11 +529,11 @@ void sm3_lms_key_cleanup(SM3_LMS_KEY *key) free(key->tree); key->tree = NULL; } - memset(key, 0, sizeof(SM3_LMS_KEY)); + memset(key, 0, sizeof(LMS_KEY)); } } -int sm3_lms_key_generate_ex(SM3_LMS_KEY *key, int lms_type, const hash256_t seed, const uint8_t I[16], int cache_tree) +int lms_key_generate_ex(LMS_KEY *key, int lms_type, const hash256_t seed, const uint8_t I[16], int cache_tree) { size_t h, n; @@ -542,7 +542,7 @@ int sm3_lms_key_generate_ex(SM3_LMS_KEY *key, int lms_type, const hash256_t seed return -1; } - if (sm3_lms_type_to_height(lms_type, &h) != 1) { + if (lms_type_to_height(lms_type, &h) != 1) { error_print(); return -1; } @@ -559,18 +559,18 @@ int sm3_lms_key_generate_ex(SM3_LMS_KEY *key, int lms_type, const hash256_t seed error_print(); return -1; } - sm3_lms_derive_merkle_tree(key->seed, key->public_key.I, h, key->tree); + lms_derive_merkle_tree(key->seed, key->public_key.I, h, key->tree); memcpy(key->public_key.root, key->tree[0], 32); } else { key->tree = NULL; - sm3_lms_derive_merkle_root(key->seed, key->public_key.I, h, key->public_key.root); + lms_derive_merkle_root(key->seed, key->public_key.I, h, key->public_key.root); } key->q = 0; return 1; } -int sm3_lms_key_generate(SM3_LMS_KEY *key, int lms_type) +int lms_key_generate(LMS_KEY *key, int lms_type) { hash256_t seed; uint8_t I[16]; @@ -584,14 +584,14 @@ int sm3_lms_key_generate(SM3_LMS_KEY *key, int lms_type) error_print(); return -1; } - if (sm3_lms_key_generate_ex(key, lms_type, seed, I, cache_tree) != 1) { + if (lms_key_generate_ex(key, lms_type, seed, I, cache_tree) != 1) { error_print(); return -1; } return 1; } -int sm3_lms_signature_size(int lms_type, size_t *len) +int lms_signature_size(int lms_type, size_t *len) { size_t height; @@ -599,7 +599,7 @@ int sm3_lms_signature_size(int lms_type, size_t *len) error_print(); return -1; } - if (sm3_lms_type_to_height(lms_type, &height) != 1) { + if (lms_type_to_height(lms_type, &height) != 1) { error_print(); return -1; } @@ -612,25 +612,25 @@ int sm3_lms_signature_size(int lms_type, size_t *len) return 1; } -int sm3_lms_key_get_signature_size(const SM3_LMS_KEY *key, size_t *siglen) +int lms_key_get_signature_size(const LMS_KEY *key, size_t *siglen) { if (!key || !siglen) { error_print(); return -1; } - if (sm3_lms_signature_size(key->public_key.lms_type, siglen) != 1) { + if (lms_signature_size(key->public_key.lms_type, siglen) != 1) { error_print(); return -1; } return 1; } -int sm3_lms_signature_print_ex(FILE *fp, int fmt, int ind, const char *label, const SM3_LMS_SIGNATURE *sig) +int lms_signature_print_ex(FILE *fp, int fmt, int ind, const char *label, const LMS_SIGNATURE *sig) { size_t h; size_t i; - if (sm3_lms_type_to_height(sig->lms_type, &h) != 1) { + if (lms_type_to_height(sig->lms_type, &h) != 1) { error_print(); return -1; } @@ -638,14 +638,14 @@ int sm3_lms_signature_print_ex(FILE *fp, int fmt, int ind, const char *label, co format_print(fp, fmt, ind, "%s\n", label); ind += 4; format_print(fp, fmt, ind, "q: %d\n", sig->q); - format_print(fp, fmt, ind, "lmots_type: %s\n", sm3_lmots_type_name(sig->lmots_sig.lmots_type)); + format_print(fp, fmt, ind, "lmots_type: %s\n", lmots_type_name(sig->lmots_sig.lmots_type)); format_bytes(fp, fmt, ind, "lmots_sig.C", sig->lmots_sig.C, 32); format_print(fp, fmt, ind, "lmots_sig.y\n"); for (i = 0; i < 34; i++) { format_print(fp, fmt, ind + 4, "zu", i); format_bytes(fp, fmt, 0, "", sig->lmots_sig.y[i], 32); } - format_print(fp, fmt, ind, "lms_type: %s\n", sm3_lms_type_name(sig->lms_type)); + format_print(fp, fmt, ind, "lms_type: %s\n", lms_type_name(sig->lms_type)); format_print(fp, fmt, ind, "path\n"); for (i = 0; i < h; i++) { format_print(fp, fmt, ind + 4, "%zu", i); @@ -654,7 +654,7 @@ int sm3_lms_signature_print_ex(FILE *fp, int fmt, int ind, const char *label, co return 1; } -int sm3_lms_signature_print(FILE *fp, int fmt, int ind, const char *label, const uint8_t *sig, size_t siglen) +int lms_signature_print(FILE *fp, int fmt, int ind, const char *label, const uint8_t *sig, size_t siglen) { uint32_t q, lmots_type, lms_type; size_t height, i; @@ -678,7 +678,7 @@ int sm3_lms_signature_print(FILE *fp, int fmt, int ind, const char *label, const lmots_type = GETU32(sig); sig += 4; siglen -= 4; - format_print(fp, fmt, ind, "lmots_type: %s\n", sm3_lmots_type_name(lmots_type)); + format_print(fp, fmt, ind, "lmots_type: %s\n", lmots_type_name(lmots_type)); if (siglen < 32) { error_print(); @@ -705,8 +705,8 @@ int sm3_lms_signature_print(FILE *fp, int fmt, int ind, const char *label, const return -1; } lms_type = GETU32(sig); - format_print(fp, fmt, ind, "lms_type: %s\n", sm3_lms_type_name(lms_type)); - if (sm3_lms_type_to_height(lms_type, &height) != 1) { + format_print(fp, fmt, ind, "lms_type: %s\n", lms_type_name(lms_type)); + if (lms_type_to_height(lms_type, &height) != 1) { error_print(); return -1; } @@ -729,7 +729,7 @@ int sm3_lms_signature_print(FILE *fp, int fmt, int ind, const char *label, const return 1; } -int sm3_lms_signature_to_bytes(const SM3_LMS_SIGNATURE *sig, uint8_t **out, size_t *outlen) +int lms_signature_to_bytes(const LMS_SIGNATURE *sig, uint8_t **out, size_t *outlen) { size_t height; @@ -737,7 +737,7 @@ int sm3_lms_signature_to_bytes(const SM3_LMS_SIGNATURE *sig, uint8_t **out, size error_print(); return -1; } - if (sm3_lms_type_to_height(sig->lms_type, &height) != 1) { + if (lms_type_to_height(sig->lms_type, &height) != 1) { error_print(); return -1; } @@ -759,7 +759,7 @@ int sm3_lms_signature_to_bytes(const SM3_LMS_SIGNATURE *sig, uint8_t **out, size return 1; } -int sm3_lms_signature_from_bytes(SM3_LMS_SIGNATURE *sig, const uint8_t **in, size_t *inlen) +int lms_signature_from_bytes(LMS_SIGNATURE *sig, const uint8_t **in, size_t *inlen) { size_t height; @@ -768,7 +768,7 @@ int sm3_lms_signature_from_bytes(SM3_LMS_SIGNATURE *sig, const uint8_t **in, siz return -1; } - if (*inlen < SM3_LMS_SIGNATURE_MIN_SIZE) { + if (*inlen < LMS_SIGNATURE_MIN_SIZE) { error_print(); return -1; } @@ -779,7 +779,7 @@ int sm3_lms_signature_from_bytes(SM3_LMS_SIGNATURE *sig, const uint8_t **in, siz *inlen -= 4; sig->lmots_sig.lmots_type = GETU32(*in); - if (!sm3_lmots_type_name(sig->lmots_sig.lmots_type)) { + if (!lmots_type_name(sig->lmots_sig.lmots_type)) { error_print(); return -1; } @@ -795,7 +795,7 @@ int sm3_lms_signature_from_bytes(SM3_LMS_SIGNATURE *sig, const uint8_t **in, siz *inlen -= 32*34; sig->lms_type = GETU32(*in); - if (sm3_lms_type_to_height(sig->lms_type, &height) != 1) { + if (lms_type_to_height(sig->lms_type, &height) != 1) { error_print(); return -1; } @@ -817,7 +817,7 @@ int sm3_lms_signature_from_bytes(SM3_LMS_SIGNATURE *sig, const uint8_t **in, siz return 1; } -int sm3_lms_signature_to_merkle_root(const uint8_t I[16], size_t h, int q, +int lms_signature_to_merkle_root(const uint8_t I[16], size_t h, int q, const hash256_t y[34], const hash256_t *path, const hash256_t dgst, hash256_t root) { @@ -834,7 +834,7 @@ int sm3_lms_signature_to_merkle_root(const uint8_t I[16], size_t h, int q, r = n + q; PUTU32(rbytes, r); - sm3_lmots_signature_to_public_hash(I, q, y, dgst, root); + lmots_signature_to_public_hash(I, q, y, dgst, root); // leaf[q] = H(I||u32str(r)||u16str(D_LEAF)||OTS_PUB_HASH[r-2^h]) hash256_init(&ctx); @@ -865,16 +865,16 @@ int sm3_lms_signature_to_merkle_root(const uint8_t I[16], size_t h, int q, return 1; } -void sm3_lms_sign_ctx_cleanup(SM3_LMS_SIGN_CTX *ctx) +void lms_sign_ctx_cleanup(LMS_SIGN_CTX *ctx) { if (ctx) { gmssl_secure_clear(ctx->lms_sig.lmots_sig.y, sizeof(hash256_t)*34); } } -int sm3_lms_sign_init(SM3_LMS_SIGN_CTX *ctx, SM3_LMS_KEY *key) +int lms_sign_init(LMS_SIGN_CTX *ctx, LMS_KEY *key) { - SM3_LMS_SIGNATURE *lms_sig; + LMS_SIGNATURE *lms_sig; uint8_t qbytes[4]; const hash256_t *T; size_t height, r, i; @@ -885,7 +885,7 @@ int sm3_lms_sign_init(SM3_LMS_SIGN_CTX *ctx, SM3_LMS_KEY *key) } // check key state - if (sm3_lms_type_to_height(key->public_key.lms_type, &height) != 1) { + if (lms_type_to_height(key->public_key.lms_type, &height) != 1) { error_print(); return -1; } @@ -910,7 +910,7 @@ int sm3_lms_sign_init(SM3_LMS_SIGN_CTX *ctx, SM3_LMS_KEY *key) } // cache lmots private in lmots_sig.y, overwitten by sign_finish - sm3_lmots_derive_secrets(key->seed, key->public_key.I, key->q, lms_sig->lmots_sig.y); + lmots_derive_secrets(key->seed, key->public_key.I, key->q, lms_sig->lmots_sig.y); // update key state, SHOULD not use the updated key->q (key->q)++; @@ -938,7 +938,7 @@ int sm3_lms_sign_init(SM3_LMS_SIGN_CTX *ctx, SM3_LMS_KEY *key) return 1; } -int sm3_lms_sign_update(SM3_LMS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen) +int lms_sign_update(LMS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen) { if (!ctx) { error_print(); @@ -950,9 +950,9 @@ int sm3_lms_sign_update(SM3_LMS_SIGN_CTX *ctx, const uint8_t *data, size_t datal return 1; } -int sm3_lms_sign_finish_ex(SM3_LMS_SIGN_CTX *ctx, SM3_LMS_SIGNATURE *sig) +int lms_sign_finish_ex(LMS_SIGN_CTX *ctx, LMS_SIGNATURE *sig) { - SM3_LMS_SIGNATURE *lms_sig; + LMS_SIGNATURE *lms_sig; uint8_t dgst[32]; if (!ctx || !sig) { @@ -963,15 +963,15 @@ int sm3_lms_sign_finish_ex(SM3_LMS_SIGN_CTX *ctx, SM3_LMS_SIGNATURE *sig) hash256_finish(&ctx->hash256_ctx, dgst); lms_sig = &ctx->lms_sig; - sm3_lmots_compute_signature(ctx->lms_public_key.I, lms_sig->q, dgst, lms_sig->lmots_sig.y, lms_sig->lmots_sig.y); + lmots_compute_signature(ctx->lms_public_key.I, lms_sig->q, dgst, lms_sig->lmots_sig.y, lms_sig->lmots_sig.y); *sig = *lms_sig; return 1; } -int sm3_lms_sign_finish(SM3_LMS_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen) +int lms_sign_finish(LMS_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen) { - SM3_LMS_SIGNATURE *lms_sig; + LMS_SIGNATURE *lms_sig; uint8_t dgst[32]; if (!ctx || !sig || !siglen) { @@ -982,19 +982,19 @@ int sm3_lms_sign_finish(SM3_LMS_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen) hash256_finish(&ctx->hash256_ctx, dgst); lms_sig = &ctx->lms_sig; - sm3_lmots_compute_signature(ctx->lms_public_key.I, lms_sig->q, dgst, lms_sig->lmots_sig.y, lms_sig->lmots_sig.y); + lmots_compute_signature(ctx->lms_public_key.I, lms_sig->q, dgst, lms_sig->lmots_sig.y, lms_sig->lmots_sig.y); *siglen = 0; - if (sm3_lms_signature_to_bytes(lms_sig, &sig, siglen) != 1) { + if (lms_signature_to_bytes(lms_sig, &sig, siglen) != 1) { error_print(); return -1; } return 1; } -int sm3_lms_verify_init_ex(SM3_LMS_SIGN_CTX *ctx, const SM3_LMS_KEY *key, const SM3_LMS_SIGNATURE *sig) +int lms_verify_init_ex(LMS_SIGN_CTX *ctx, const LMS_KEY *key, const LMS_SIGNATURE *sig) { - SM3_LMS_SIGNATURE *lms_sig; + LMS_SIGNATURE *lms_sig; uint8_t qbytes[4]; if (!ctx || !key || !sig) { @@ -1029,9 +1029,9 @@ int sm3_lms_verify_init_ex(SM3_LMS_SIGN_CTX *ctx, const SM3_LMS_KEY *key, const return 1; } -int sm3_lms_verify_init(SM3_LMS_SIGN_CTX *ctx, const SM3_LMS_KEY *key, const uint8_t *sig, size_t siglen) +int lms_verify_init(LMS_SIGN_CTX *ctx, const LMS_KEY *key, const uint8_t *sig, size_t siglen) { - SM3_LMS_SIGNATURE *lms_sig; + LMS_SIGNATURE *lms_sig; uint8_t qbytes[4]; if (!ctx || !key || !sig || !siglen) { @@ -1044,7 +1044,7 @@ int sm3_lms_verify_init(SM3_LMS_SIGN_CTX *ctx, const SM3_LMS_KEY *key, const uin ctx->lms_public_key = key->public_key; lms_sig = &ctx->lms_sig; - if (sm3_lms_signature_from_bytes(lms_sig, &sig, &siglen) != 1) { + if (lms_signature_from_bytes(lms_sig, &sig, &siglen) != 1) { error_print(); return -1; } @@ -1073,7 +1073,7 @@ int sm3_lms_verify_init(SM3_LMS_SIGN_CTX *ctx, const SM3_LMS_KEY *key, const uin return 1; } -int sm3_lms_verify_update(SM3_LMS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen) +int lms_verify_update(LMS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen) { if (!ctx) { error_print(); @@ -1085,9 +1085,9 @@ int sm3_lms_verify_update(SM3_LMS_SIGN_CTX *ctx, const uint8_t *data, size_t dat return 1; } -int sm3_lms_verify_finish(SM3_LMS_SIGN_CTX *ctx) +int lms_verify_finish(LMS_SIGN_CTX *ctx) { - SM3_LMS_SIGNATURE *lms_sig; + LMS_SIGNATURE *lms_sig; hash256_t dgst; size_t height; hash256_t root; @@ -1098,14 +1098,14 @@ int sm3_lms_verify_finish(SM3_LMS_SIGN_CTX *ctx) } lms_sig = &ctx->lms_sig; - if (sm3_lms_type_to_height(lms_sig->lms_type, &height) != 1) { + if (lms_type_to_height(lms_sig->lms_type, &height) != 1) { error_print(); return -1; } hash256_finish(&ctx->hash256_ctx, dgst); - if (sm3_lms_signature_to_merkle_root(ctx->lms_public_key.I, height, + if (lms_signature_to_merkle_root(ctx->lms_public_key.I, height, lms_sig->q, lms_sig->lmots_sig.y, lms_sig->path, dgst, root) != 1) { error_print(); return -1; @@ -1119,14 +1119,14 @@ int sm3_lms_verify_finish(SM3_LMS_SIGN_CTX *ctx) } } -int sm3_hss_public_key_digest(const SM3_HSS_KEY *key, uint8_t dgst[32]) +int hss_public_key_digest(const HSS_KEY *key, uint8_t dgst[32]) { SM3_CTX ctx; - uint8_t bytes[SM3_HSS_PUBLIC_KEY_SIZE]; + uint8_t bytes[HSS_PUBLIC_KEY_SIZE]; uint8_t *p = bytes; size_t len; - if (sm3_hss_public_key_to_bytes(key, &p, &len) != 1) { + if (hss_public_key_to_bytes(key, &p, &len) != 1) { error_print(); return -1; } @@ -1136,16 +1136,16 @@ int sm3_hss_public_key_digest(const SM3_HSS_KEY *key, uint8_t dgst[32]) return 1; } -int sm3_hss_public_key_print(FILE *fp, int fmt, int ind, const char *label, const SM3_HSS_KEY *key) +int hss_public_key_print(FILE *fp, int fmt, int ind, const char *label, const HSS_KEY *key) { format_print(fp, fmt, ind, "%s\n", label); ind += 4; format_print(fp, fmt, ind, "levels: %d\n", key->levels); - sm3_lms_public_key_print(fp, fmt, ind, "lms_public_key", &key->lms_key[0].public_key); + lms_public_key_print(fp, fmt, ind, "lms_public_key", &key->lms_key[0].public_key); return 1; } -int sm3_hss_public_key_to_bytes(const SM3_HSS_KEY *key, uint8_t **out, size_t *outlen) +int hss_public_key_to_bytes(const HSS_KEY *key, uint8_t **out, size_t *outlen) { if (!key || !outlen) { error_print(); @@ -1163,17 +1163,17 @@ int sm3_hss_public_key_to_bytes(const SM3_HSS_KEY *key, uint8_t **out, size_t *o memcpy(*out, key->lms_key[0].public_key.root, 32); *out += 32; } - *outlen += SM3_HSS_PUBLIC_KEY_SIZE; + *outlen += HSS_PUBLIC_KEY_SIZE; return 1; } -int sm3_hss_public_key_from_bytes(SM3_HSS_KEY *key, const uint8_t **in, size_t *inlen) +int hss_public_key_from_bytes(HSS_KEY *key, const uint8_t **in, size_t *inlen) { if (!key || !in || !(*in) || !inlen) { error_print(); return -1; } - if (*inlen < SM3_HSS_PUBLIC_KEY_SIZE) { + if (*inlen < HSS_PUBLIC_KEY_SIZE) { error_print(); return -1; } @@ -1181,14 +1181,14 @@ int sm3_hss_public_key_from_bytes(SM3_HSS_KEY *key, const uint8_t **in, size_t * memset(key, 0, sizeof(*key)); key->levels = GETU32(*in); - if (key->levels > SM3_HSS_MAX_LEVELS) { + if (key->levels > HSS_MAX_LEVELS) { error_print(); return -1; } *in += 4; *inlen -= 4; - if (sm3_lms_public_key_from_bytes(&key->lms_key[0], in, inlen) != 1) { + if (lms_public_key_from_bytes(&key->lms_key[0], in, inlen) != 1) { error_print(); return -1; } @@ -1196,7 +1196,7 @@ int sm3_hss_public_key_from_bytes(SM3_HSS_KEY *key, const uint8_t **in, size_t * return 1; } -int sm3_hss_private_key_to_bytes(const SM3_HSS_KEY *key, uint8_t **out, size_t *outlen) +int hss_private_key_to_bytes(const HSS_KEY *key, uint8_t **out, size_t *outlen) { size_t len = 0; @@ -1204,7 +1204,7 @@ int sm3_hss_private_key_to_bytes(const SM3_HSS_KEY *key, uint8_t **out, size_t * error_print(); return -1; } - if (key->levels < 1 || key->levels > SM3_HSS_MAX_LEVELS) { + if (key->levels < 1 || key->levels > HSS_MAX_LEVELS) { error_print(); return -1; } @@ -1216,17 +1216,17 @@ int sm3_hss_private_key_to_bytes(const SM3_HSS_KEY *key, uint8_t **out, size_t * *out += 4; len += 4; - if (sm3_lms_private_key_to_bytes(&key->lms_key[0], out, &len) != 1) { + if (lms_private_key_to_bytes(&key->lms_key[0], out, &len) != 1) { error_print(); return -1; } for (i = 1; i < key->levels; i++) { - if (sm3_lms_private_key_to_bytes(&key->lms_key[i], out, &len) != 1) { + if (lms_private_key_to_bytes(&key->lms_key[i], out, &len) != 1) { error_print(); return -1; } - if (sm3_lms_signature_to_bytes(&key->lms_sig[i - 1], out, &len) != 1) { + if (lms_signature_to_bytes(&key->lms_sig[i - 1], out, &len) != 1) { error_print(); return -1; } @@ -1237,7 +1237,7 @@ int sm3_hss_private_key_to_bytes(const SM3_HSS_KEY *key, uint8_t **out, size_t * return 1; } -int sm3_hss_private_key_from_bytes(SM3_HSS_KEY *key, const uint8_t **in, size_t *inlen) +int hss_private_key_from_bytes(HSS_KEY *key, const uint8_t **in, size_t *inlen) { size_t i; @@ -1252,41 +1252,41 @@ int sm3_hss_private_key_from_bytes(SM3_HSS_KEY *key, const uint8_t **in, size_t } key->levels = GETU32(*in); - if (key->levels < 1 || key->levels > SM3_HSS_MAX_LEVELS) { + if (key->levels < 1 || key->levels > HSS_MAX_LEVELS) { error_print(); return -1; } *in += 4; *inlen -= 4; - if (sm3_lms_private_key_from_bytes(&key->lms_key[0], in, inlen) != 1) { + if (lms_private_key_from_bytes(&key->lms_key[0], in, inlen) != 1) { error_print(); return -1; } for (i = 1; i < key->levels; i++) { - SM3_LMS_SIGN_CTX ctx; - uint8_t buf[SM3_LMS_PUBLIC_KEY_SIZE]; + LMS_SIGN_CTX ctx; + uint8_t buf[LMS_PUBLIC_KEY_SIZE]; uint8_t *p = buf; size_t len = 0; - if (sm3_lms_private_key_from_bytes(&key->lms_key[i], in, inlen) != 1) { + if (lms_private_key_from_bytes(&key->lms_key[i], in, inlen) != 1) { error_print(); return -1; } - if (sm3_lms_signature_from_bytes(&key->lms_sig[i - 1], in, inlen) != 1) { + if (lms_signature_from_bytes(&key->lms_sig[i - 1], in, inlen) != 1) { error_print(); return -1; } // verify public_key[i] by key[i - 1] - if (sm3_lms_public_key_to_bytes(&key->lms_key[i], &p, &len) != 1) { + if (lms_public_key_to_bytes(&key->lms_key[i], &p, &len) != 1) { error_print(); return -1; } - if (sm3_lms_verify_init_ex(&ctx, &key->lms_key[i - 1], &key->lms_sig[i - 1]) != 1 - || sm3_lms_verify_update(&ctx, buf, len) != 1 - || sm3_lms_verify_finish(&ctx) != 1) { + if (lms_verify_init_ex(&ctx, &key->lms_key[i - 1], &key->lms_sig[i - 1]) != 1 + || lms_verify_update(&ctx, buf, len) != 1 + || lms_verify_finish(&ctx) != 1) { error_print(); return -1; } @@ -1295,7 +1295,7 @@ int sm3_hss_private_key_from_bytes(SM3_HSS_KEY *key, const uint8_t **in, size_t return 1; } -int sm3_hss_key_print(FILE *fp, int fmt, int ind, const char *label, const SM3_HSS_KEY *key) +int hss_key_print(FILE *fp, int fmt, int ind, const char *label, const HSS_KEY *key) { int i; @@ -1303,37 +1303,37 @@ int sm3_hss_key_print(FILE *fp, int fmt, int ind, const char *label, const SM3_H ind += 4; format_print(fp, fmt, ind, "levels: %d\n", key->levels); - sm3_lms_key_print(fp, fmt, ind, "lms_key[0]", &key->lms_key[0]); + lms_key_print(fp, fmt, ind, "lms_key[0]", &key->lms_key[0]); for (i = 1; i < key->levels; i++) { char title[64]; snprintf(title, sizeof(title), "lms_signature[%d]", i - 1); - sm3_lms_signature_print_ex(fp, fmt, ind, title, &key->lms_sig[i - 1]); + lms_signature_print_ex(fp, fmt, ind, title, &key->lms_sig[i - 1]); snprintf(title, sizeof(title), "lms_key[%d]", i); - sm3_lms_key_print(fp, fmt, ind, title, &key->lms_key[i]); + lms_key_print(fp, fmt, ind, title, &key->lms_key[i]); } return 1; } -void sm3_hss_key_cleanup(SM3_HSS_KEY *key) +void hss_key_cleanup(HSS_KEY *key) { if (key) { int i; for (i = 0; i < key->levels; i++) { - sm3_lms_key_cleanup(&key->lms_key[i]); + lms_key_cleanup(&key->lms_key[i]); } - memset(key, 0, sizeof(SM3_HSS_KEY)); + memset(key, 0, sizeof(HSS_KEY)); } } -int sm3_hss_key_generate(SM3_HSS_KEY *key, const int *lms_types, size_t levels) +int hss_key_generate(HSS_KEY *key, const int *lms_types, size_t levels) { int ret = -1; hash256_t seed; uint8_t I[16]; - SM3_LMS_SIGN_CTX ctx; - uint8_t buf[SM3_LMS_SIGNATURE_MAX_SIZE]; // SM3_LMS_SIGNATURE_MAX_SIZE > SM3_PUBLIC_KEY_SIZE + LMS_SIGN_CTX ctx; + uint8_t buf[LMS_SIGNATURE_MAX_SIZE]; // LMS_SIGNATURE_MAX_SIZE > SM3_PUBLIC_KEY_SIZE int cache_tree = 1; const int q = 0; @@ -1343,12 +1343,12 @@ int sm3_hss_key_generate(SM3_HSS_KEY *key, const int *lms_types, size_t levels) error_print(); return -1; } - if (levels > SM3_HSS_MAX_LEVELS) { + if (levels > HSS_MAX_LEVELS) { error_print(); return -1; } for (i = 0; i < levels; i++) { - if (!sm3_lms_type_name(lms_types[i])) { + if (!lms_type_name(lms_types[i])) { error_print(); return -1; } @@ -1367,7 +1367,7 @@ int sm3_hss_key_generate(SM3_HSS_KEY *key, const int *lms_types, size_t levels) error_print(); goto end; } - if (sm3_lms_key_generate_ex(&key->lms_key[0], lms_types[0], seed, I, cache_tree) != 1) { + if (lms_key_generate_ex(&key->lms_key[0], lms_types[0], seed, I, cache_tree) != 1) { error_print(); goto end; } @@ -1384,35 +1384,35 @@ int sm3_hss_key_generate(SM3_HSS_KEY *key, const int *lms_types, size_t levels) error_print(); goto end; } - if (sm3_lms_key_generate_ex(&key->lms_key[i], lms_types[i], seed, I, cache_tree) != 1) { + if (lms_key_generate_ex(&key->lms_key[i], lms_types[i], seed, I, cache_tree) != 1) { error_print(); goto end; } // sign public_key[i] by key[i - 1] - if (sm3_lms_public_key_to_bytes(&key->lms_key[i], &p, &len) != 1) { + if (lms_public_key_to_bytes(&key->lms_key[i], &p, &len) != 1) { error_print(); goto end; } - if (sm3_lms_sign_init(&ctx, &key->lms_key[i - 1]) != 1 - || sm3_lms_sign_update(&ctx, buf, len) != 1 - || sm3_lms_sign_finish(&ctx, buf, &len) != 1) { + if (lms_sign_init(&ctx, &key->lms_key[i - 1]) != 1 + || lms_sign_update(&ctx, buf, len) != 1 + || lms_sign_finish(&ctx, buf, &len) != 1) { error_print(); goto end; } - // save SM3_LMS_SIGNATURE struct + // save LMS_SIGNATURE struct key->lms_sig[i - 1] = ctx.lms_sig; } ret = 1; end: gmssl_secure_clear(seed, sizeof(seed)); - sm3_lms_sign_ctx_cleanup(&ctx); - if (ret != 1) sm3_hss_key_cleanup(key); + lms_sign_ctx_cleanup(&ctx); + if (ret != 1) hss_key_cleanup(key); return ret; } -int sm3_hss_signature_size(const int *lms_types, size_t levels, size_t *siglen) +int hss_signature_size(const int *lms_types, size_t levels, size_t *siglen) { size_t i; @@ -1420,7 +1420,7 @@ int sm3_hss_signature_size(const int *lms_types, size_t levels, size_t *siglen) error_print(); return -1; } - if (levels < 1 || levels > SM3_HSS_MAX_LEVELS) { + if (levels < 1 || levels > HSS_MAX_LEVELS) { error_print(); return -1; } @@ -1428,18 +1428,18 @@ int sm3_hss_signature_size(const int *lms_types, size_t levels, size_t *siglen) *siglen = 4; for (i = 0; i < levels; i++) { size_t lms_siglen; - if (sm3_lms_signature_size(lms_types[i], &lms_siglen) != 1) { + if (lms_signature_size(lms_types[i], &lms_siglen) != 1) { error_print(); return -1; } *siglen += lms_siglen; } - *siglen += SM3_LMS_PUBLIC_KEY_SIZE * (levels - 1); + *siglen += LMS_PUBLIC_KEY_SIZE * (levels - 1); return 1; } -int sm3_hss_key_get_signature_size(const SM3_HSS_KEY *key, size_t *siglen) +int hss_key_get_signature_size(const HSS_KEY *key, size_t *siglen) { int lms_types[5]; int i; @@ -1452,7 +1452,7 @@ int sm3_hss_key_get_signature_size(const SM3_HSS_KEY *key, size_t *siglen) for (i = 0; i < key->levels; i++) { lms_types[i] = key->lms_key[i].public_key.lms_type; } - if (sm3_hss_signature_size(lms_types, key->levels, siglen) != 1) { + if (hss_signature_size(lms_types, key->levels, siglen) != 1) { error_print(); return -1; } @@ -1460,7 +1460,7 @@ int sm3_hss_key_get_signature_size(const SM3_HSS_KEY *key, size_t *siglen) return 1; } -int sm3_hss_signature_from_bytes(SM3_HSS_SIGNATURE *sig, const uint8_t **in, size_t *inlen) +int hss_signature_from_bytes(HSS_SIGNATURE *sig, const uint8_t **in, size_t *inlen) { size_t i; @@ -1474,7 +1474,7 @@ int sm3_hss_signature_from_bytes(SM3_HSS_SIGNATURE *sig, const uint8_t **in, siz } sig->num_signed_public_keys = GETU32(*in); - if (sig->num_signed_public_keys >= SM3_HSS_MAX_LEVELS) { + if (sig->num_signed_public_keys >= HSS_MAX_LEVELS) { error_print(); return -1; } @@ -1482,26 +1482,26 @@ int sm3_hss_signature_from_bytes(SM3_HSS_SIGNATURE *sig, const uint8_t **in, siz *inlen -= 4; for (i = 0; i < sig->num_signed_public_keys; i++) { - SM3_LMS_SIGNATURE *lms_sig = &sig->signed_public_keys[i].lms_sig; - SM3_LMS_KEY *lms_key = (SM3_LMS_KEY *)&sig->signed_public_keys[i].lms_public_key; + LMS_SIGNATURE *lms_sig = &sig->signed_public_keys[i].lms_sig; + LMS_KEY *lms_key = (LMS_KEY *)&sig->signed_public_keys[i].lms_public_key; - if (sm3_lms_signature_from_bytes(lms_sig, in, inlen) != 1) { + if (lms_signature_from_bytes(lms_sig, in, inlen) != 1) { error_print(); return -1; } - if (sm3_lms_public_key_from_bytes(lms_key, in, inlen) != 1) { + if (lms_public_key_from_bytes(lms_key, in, inlen) != 1) { error_print(); return -1; } } - if (sm3_lms_signature_from_bytes(&sig->msg_lms_sig, in, inlen) != 1) { + if (lms_signature_from_bytes(&sig->msg_lms_sig, in, inlen) != 1) { error_print(); return -1; } return 1; } -int sm3_hss_signature_to_bytes(const SM3_HSS_SIGNATURE *sig, uint8_t **out, size_t *outlen) +int hss_signature_to_bytes(const HSS_SIGNATURE *sig, uint8_t **out, size_t *outlen) { size_t len = 0; @@ -1509,7 +1509,7 @@ int sm3_hss_signature_to_bytes(const SM3_HSS_SIGNATURE *sig, uint8_t **out, size error_print(); return -1; } - if (sig->num_signed_public_keys >= SM3_HSS_MAX_LEVELS) { + if (sig->num_signed_public_keys >= HSS_MAX_LEVELS) { error_print(); return -1; } @@ -1522,17 +1522,17 @@ int sm3_hss_signature_to_bytes(const SM3_HSS_SIGNATURE *sig, uint8_t **out, size len += 4; for (i = 0; i < sig->num_signed_public_keys; i++) { - if (sm3_lms_signature_to_bytes(&sig->signed_public_keys[i].lms_sig, out, &len) != 1) { + if (lms_signature_to_bytes(&sig->signed_public_keys[i].lms_sig, out, &len) != 1) { error_print(); return -1; } - if (sm3_lms_public_key_to_bytes((SM3_LMS_KEY *)&sig->signed_public_keys[i].lms_public_key, out, &len) != 1) { + if (lms_public_key_to_bytes((LMS_KEY *)&sig->signed_public_keys[i].lms_public_key, out, &len) != 1) { error_print(); return -1; } } - if (sm3_lms_signature_to_bytes(&sig->msg_lms_sig, out, &len) != 1) { + if (lms_signature_to_bytes(&sig->msg_lms_sig, out, &len) != 1) { error_print(); return -1; } @@ -1543,16 +1543,16 @@ int sm3_hss_signature_to_bytes(const SM3_HSS_SIGNATURE *sig, uint8_t **out, size } -int sm3_hss_key_update(SM3_HSS_KEY *key) +int hss_key_update(HSS_KEY *key) { int level; - SM3_LMS_KEY *lms_key; + LMS_KEY *lms_key; size_t count; for (level = key->levels; level > 0; level--) { lms_key = &key->lms_key[level - 1]; - if (sm3_lms_key_remaining_signs(lms_key, &count) != 1) { + if (lms_key_remaining_signs(lms_key, &count) != 1) { error_print(); return -1; } @@ -1577,31 +1577,31 @@ int sm3_hss_key_update(SM3_HSS_KEY *key) for (; level < key->levels; level++) { int lms_type = key->lms_key[level].public_key.lms_type; - SM3_LMS_SIGN_CTX ctx; - uint8_t buf[SM3_LMS_PUBLIC_KEY_SIZE]; + LMS_SIGN_CTX ctx; + uint8_t buf[LMS_PUBLIC_KEY_SIZE]; uint8_t *p = buf; size_t len = 0; - sm3_lms_key_cleanup(&key->lms_key[level]); + lms_key_cleanup(&key->lms_key[level]); - if (sm3_lms_key_generate(&key->lms_key[level], lms_type) != 1) { + if (lms_key_generate(&key->lms_key[level], lms_type) != 1) { error_print(); return -1; } - if (sm3_lms_public_key_to_bytes(&key->lms_key[level], &p, &len) != 1) { + if (lms_public_key_to_bytes(&key->lms_key[level], &p, &len) != 1) { error_print(); return -1; } - if (sm3_lms_sign_init(&ctx, &key->lms_key[level - 1]) != 1) { + if (lms_sign_init(&ctx, &key->lms_key[level - 1]) != 1) { error_print(); return -1; } - if (sm3_lms_sign_update(&ctx, buf, len) != 1) { + if (lms_sign_update(&ctx, buf, len) != 1) { error_print(); return -1; } - if (sm3_lms_sign_finish_ex(&ctx, &key->lms_sig[level - 1]) != 1) { + if (lms_sign_finish_ex(&ctx, &key->lms_sig[level - 1]) != 1) { error_print(); return -1; } @@ -1610,7 +1610,7 @@ int sm3_hss_key_update(SM3_HSS_KEY *key) return 1; } -int sm3_hss_sign_init(SM3_HSS_SIGN_CTX *ctx, SM3_HSS_KEY *key) +int hss_sign_init(HSS_SIGN_CTX *ctx, HSS_KEY *key) { size_t count; size_t i; @@ -1619,14 +1619,14 @@ int sm3_hss_sign_init(SM3_HSS_SIGN_CTX *ctx, SM3_HSS_KEY *key) error_print(); return -1; } - if (key->levels < 1 || key->levels > SM3_HSS_MAX_LEVELS) { + if (key->levels < 1 || key->levels > HSS_MAX_LEVELS) { error_print(); return -1; } memset(ctx, 0, sizeof(*ctx)); - if (sm3_lms_sign_init(&ctx->lms_ctx, &key->lms_key[key->levels - 1]) != 1) { + if (lms_sign_init(&ctx->lms_ctx, &key->lms_key[key->levels - 1]) != 1) { error_print(); return -1; } @@ -1638,12 +1638,12 @@ int sm3_hss_sign_init(SM3_HSS_SIGN_CTX *ctx, SM3_HSS_KEY *key) ctx->lms_sigs[i] = key->lms_sig[i]; } - if (sm3_lms_key_remaining_signs(&key->lms_key[key->levels - 1], &count) != 1) { + if (lms_key_remaining_signs(&key->lms_key[key->levels - 1], &count) != 1) { error_print(); return -1; } if (count == 0) { - if (sm3_hss_key_update(key) != 1) { + if (hss_key_update(key) != 1) { error_print(); return -1; } @@ -1652,14 +1652,14 @@ int sm3_hss_sign_init(SM3_HSS_SIGN_CTX *ctx, SM3_HSS_KEY *key) return 1; } -int sm3_hss_sign_update(SM3_HSS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen) +int hss_sign_update(HSS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen) { if (!ctx) { error_print(); return -1; } if (data && datalen) { - if (sm3_lms_sign_update(&ctx->lms_ctx, data, datalen) != 1) { + if (lms_sign_update(&ctx->lms_ctx, data, datalen) != 1) { error_print(); return -1; } @@ -1667,29 +1667,29 @@ int sm3_hss_sign_update(SM3_HSS_SIGN_CTX *ctx, const uint8_t *data, size_t datal return 1; } -int sm3_hss_sign_finish(SM3_HSS_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen) +int hss_sign_finish(HSS_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen) { - SM3_HSS_SIGNATURE signature; + HSS_SIGNATURE signature; uint8_t *p = sig; if (!ctx || !sig || !siglen) { error_print(); return -1; } - if (sm3_hss_sign_finish_ex(ctx, &signature) != 1) { + if (hss_sign_finish_ex(ctx, &signature) != 1) { error_print(); return -1; } *siglen = 0; - if (sm3_hss_signature_to_bytes(&signature, &p, siglen) != 1) { + if (hss_signature_to_bytes(&signature, &p, siglen) != 1) { error_print(); return -1; } return 1; } -int sm3_hss_sign_finish_ex(SM3_HSS_SIGN_CTX *ctx, SM3_HSS_SIGNATURE *sig) +int hss_sign_finish_ex(HSS_SIGN_CTX *ctx, HSS_SIGNATURE *sig) { size_t i; @@ -1705,7 +1705,7 @@ int sm3_hss_sign_finish_ex(SM3_HSS_SIGN_CTX *ctx, SM3_HSS_SIGNATURE *sig) sig->signed_public_keys[i].lms_public_key = ctx->lms_public_keys[i]; } - if (sm3_lms_sign_finish_ex(&ctx->lms_ctx, &sig->msg_lms_sig) != 1) { + if (lms_sign_finish_ex(&ctx->lms_ctx, &sig->msg_lms_sig) != 1) { error_print(); return -1; } @@ -1715,9 +1715,9 @@ int sm3_hss_sign_finish_ex(SM3_HSS_SIGN_CTX *ctx, SM3_HSS_SIGNATURE *sig) // optimize this function, -int sm3_hss_verify_init_ex(SM3_HSS_SIGN_CTX *ctx, const SM3_HSS_KEY *key, const SM3_HSS_SIGNATURE *sig) +int hss_verify_init_ex(HSS_SIGN_CTX *ctx, const HSS_KEY *key, const HSS_SIGNATURE *sig) { - uint8_t buf[SM3_LMS_PUBLIC_KEY_SIZE]; + uint8_t buf[LMS_PUBLIC_KEY_SIZE]; uint8_t *p = buf; size_t len = 0; size_t i; @@ -1727,7 +1727,7 @@ int sm3_hss_verify_init_ex(SM3_HSS_SIGN_CTX *ctx, const SM3_HSS_KEY *key, const return -1; } - if (key->levels < 1 || key->levels > SM3_HSS_MAX_LEVELS) { + if (key->levels < 1 || key->levels > HSS_MAX_LEVELS) { error_print(); return -1; } @@ -1737,7 +1737,7 @@ int sm3_hss_verify_init_ex(SM3_HSS_SIGN_CTX *ctx, const SM3_HSS_KEY *key, const } if (sig->num_signed_public_keys == 0) { - if (sm3_lms_verify_init_ex(&ctx->lms_ctx, &key->lms_key[0], + if (lms_verify_init_ex(&ctx->lms_ctx, &key->lms_key[0], &sig->msg_lms_sig) != 1) { error_print(); return -1; @@ -1746,22 +1746,22 @@ int sm3_hss_verify_init_ex(SM3_HSS_SIGN_CTX *ctx, const SM3_HSS_KEY *key, const } // verify(public_root, sig->pk[0], sig[0]) - if (sm3_lms_public_key_to_bytes((SM3_LMS_KEY *)&sig->signed_public_keys[0].lms_public_key, &p, &len) != 1) { + if (lms_public_key_to_bytes((LMS_KEY *)&sig->signed_public_keys[0].lms_public_key, &p, &len) != 1) { error_print(); return -1; } - if (sm3_lms_verify_init_ex(&ctx->lms_ctx, &key->lms_key[0], + if (lms_verify_init_ex(&ctx->lms_ctx, &key->lms_key[0], &sig->signed_public_keys[0].lms_sig) != 1) { error_print(); return -1; } - if (sm3_lms_verify_update(&ctx->lms_ctx, buf, len) != 1) { + if (lms_verify_update(&ctx->lms_ctx, buf, len) != 1) { error_print(); return -1; } - if (sm3_lms_verify_finish(&ctx->lms_ctx) != 1) { + if (lms_verify_finish(&ctx->lms_ctx) != 1) { error_print(); return -1; } @@ -1770,31 +1770,31 @@ int sm3_hss_verify_init_ex(SM3_HSS_SIGN_CTX *ctx, const SM3_HSS_KEY *key, const for (i = 1; i < sig->num_signed_public_keys; i++) { p = buf; len = 0; - if (sm3_lms_public_key_to_bytes((SM3_LMS_KEY *)&sig->signed_public_keys[i].lms_public_key, &p, &len) != 1) { + if (lms_public_key_to_bytes((LMS_KEY *)&sig->signed_public_keys[i].lms_public_key, &p, &len) != 1) { error_print(); return -1; } - if (sm3_lms_verify_init_ex(&ctx->lms_ctx, - (SM3_LMS_KEY *)&sig->signed_public_keys[i - 1].lms_public_key, + if (lms_verify_init_ex(&ctx->lms_ctx, + (LMS_KEY *)&sig->signed_public_keys[i - 1].lms_public_key, &sig->signed_public_keys[i].lms_sig) != 1) { error_print(); return -1; } - if (sm3_lms_verify_update(&ctx->lms_ctx, buf, len) != 1) { + if (lms_verify_update(&ctx->lms_ctx, buf, len) != 1) { error_print(); return -1; } - if (sm3_lms_verify_finish(&ctx->lms_ctx) != 1) { + if (lms_verify_finish(&ctx->lms_ctx) != 1) { error_print(); return -1; } } // verify(pk[last], msg, msg_sig) - if (sm3_lms_verify_init_ex(&ctx->lms_ctx, - (SM3_LMS_KEY *)&sig->signed_public_keys[sig->num_signed_public_keys - 1].lms_public_key, + if (lms_verify_init_ex(&ctx->lms_ctx, + (LMS_KEY *)&sig->signed_public_keys[sig->num_signed_public_keys - 1].lms_public_key, &sig->msg_lms_sig) != 1) { error_print(); return -1; @@ -1803,15 +1803,15 @@ int sm3_hss_verify_init_ex(SM3_HSS_SIGN_CTX *ctx, const SM3_HSS_KEY *key, const return 1; } -int sm3_hss_verify_init(SM3_HSS_SIGN_CTX *ctx, const SM3_HSS_KEY *key, const uint8_t *sig, size_t siglen) +int hss_verify_init(HSS_SIGN_CTX *ctx, const HSS_KEY *key, const uint8_t *sig, size_t siglen) { - SM3_HSS_SIGNATURE signature; + HSS_SIGNATURE signature; if (!ctx || !key || !sig) { error_print(); return -1; } - if (sm3_hss_signature_from_bytes(&signature, &sig, &siglen) != 1) { + if (hss_signature_from_bytes(&signature, &sig, &siglen) != 1) { error_print(); return -1; } @@ -1820,7 +1820,7 @@ int sm3_hss_verify_init(SM3_HSS_SIGN_CTX *ctx, const SM3_HSS_KEY *key, const uin return -1; } - if (sm3_hss_verify_init_ex(ctx, key, &signature) != 1) { + if (hss_verify_init_ex(ctx, key, &signature) != 1) { error_print(); return -1; } @@ -1828,14 +1828,14 @@ int sm3_hss_verify_init(SM3_HSS_SIGN_CTX *ctx, const SM3_HSS_KEY *key, const uin return 1; } -int sm3_hss_verify_update(SM3_HSS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen) +int hss_verify_update(HSS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen) { if (!ctx) { error_print(); return -1; } if (data && datalen) { - if (sm3_lms_verify_update(&ctx->lms_ctx, data, datalen) != 1) { + if (lms_verify_update(&ctx->lms_ctx, data, datalen) != 1) { error_print(); return -1; } @@ -1843,21 +1843,21 @@ int sm3_hss_verify_update(SM3_HSS_SIGN_CTX *ctx, const uint8_t *data, size_t dat return 1; } -int sm3_hss_verify_finish(SM3_HSS_SIGN_CTX *ctx) +int hss_verify_finish(HSS_SIGN_CTX *ctx) { int ret = -1; if (!ctx) { error_print(); return -1; } - if ((ret = sm3_lms_verify_finish(&ctx->lms_ctx)) != 1) { + if ((ret = lms_verify_finish(&ctx->lms_ctx)) != 1) { error_print(); return ret; } return 1; } -int sm3_hss_signature_print_ex(FILE *fp, int fmt, int ind, const char *label, const SM3_HSS_SIGNATURE *sig) +int hss_signature_print_ex(FILE *fp, int fmt, int ind, const char *label, const HSS_SIGNATURE *sig) { size_t i; @@ -1869,20 +1869,20 @@ int sm3_hss_signature_print_ex(FILE *fp, int fmt, int ind, const char *label, co for (i = 0; i < sig->num_signed_public_keys; i++) { char title[64]; snprintf(title, sizeof(title), "lms_signature[%zu]", i); - sm3_lms_signature_print_ex(fp, fmt, ind, title, &sig->signed_public_keys[0].lms_sig); + lms_signature_print_ex(fp, fmt, ind, title, &sig->signed_public_keys[0].lms_sig); snprintf(title, sizeof(title), "lms_public_key[%zu]", i + 1); - sm3_lms_public_key_print(fp, fmt, ind, title, &sig->signed_public_keys[0].lms_public_key); + lms_public_key_print(fp, fmt, ind, title, &sig->signed_public_keys[0].lms_public_key); } - sm3_lms_signature_print_ex(fp, fmt, ind, "message_signature", &sig->msg_lms_sig); + lms_signature_print_ex(fp, fmt, ind, "message_signature", &sig->msg_lms_sig); return 1; } -int sm3_hss_signature_print(FILE *fp, int fmt, int ind, const char *label, const uint8_t *sig, size_t siglen) +int hss_signature_print(FILE *fp, int fmt, int ind, const char *label, const uint8_t *sig, size_t siglen) { - SM3_LMS_SIGNATURE lms_sig; + LMS_SIGNATURE lms_sig; size_t lms_siglen; - SM3_LMS_PUBLIC_KEY lms_pub; + LMS_PUBLIC_KEY lms_pub; int num; int i; @@ -1904,31 +1904,31 @@ int sm3_hss_signature_print(FILE *fp, int fmt, int ind, const char *label, const for (i = 0; i < num; i++) { char title[64]; - if (sm3_lms_signature_from_bytes(&lms_sig, &sig, &siglen) != 1) { + if (lms_signature_from_bytes(&lms_sig, &sig, &siglen) != 1) { error_print(); return -1; } snprintf(title, sizeof(title), "lms_signature[%d]", i); - sm3_lms_signature_print_ex(fp, fmt, ind, title, &lms_sig); + lms_signature_print_ex(fp, fmt, ind, title, &lms_sig); - if (sm3_lms_public_key_from_bytes((SM3_LMS_KEY *)&lms_pub, &sig, &siglen) != 1) { + if (lms_public_key_from_bytes((LMS_KEY *)&lms_pub, &sig, &siglen) != 1) { error_print(); return -1; } snprintf(title, sizeof(title), "lms_public_key[%d]", i + 1); - sm3_lms_public_key_print(fp, fmt, ind, title, &lms_pub); + lms_public_key_print(fp, fmt, ind, title, &lms_pub); } - if (sm3_lms_signature_from_bytes(&lms_sig, &sig, &siglen) != 1) { + if (lms_signature_from_bytes(&lms_sig, &sig, &siglen) != 1) { error_print(); return -1; } - sm3_lms_signature_print_ex(fp, fmt, ind, "message_signature", &lms_sig); + lms_signature_print_ex(fp, fmt, ind, "message_signature", &lms_sig); return 1; } -int sm3_hss_private_key_size(const int *lms_types, size_t levels, size_t *len) +int hss_private_key_size(const int *lms_types, size_t levels, size_t *len) { size_t i; @@ -1936,15 +1936,15 @@ int sm3_hss_private_key_size(const int *lms_types, size_t levels, size_t *len) error_print(); return -1; } - if (levels < 1 || levels > SM3_HSS_MAX_LEVELS) { + if (levels < 1 || levels > HSS_MAX_LEVELS) { error_print(); return -1; } - *len = sizeof(uint32_t) + SM3_LMS_PRIVATE_KEY_SIZE * levels; + *len = sizeof(uint32_t) + LMS_PRIVATE_KEY_SIZE * levels; for (i = 0; i < levels - 1; i++) { size_t siglen; - if (sm3_lms_signature_size(lms_types[i], &siglen) != 1) { + if (lms_signature_size(lms_types[i], &siglen) != 1) { error_print(); return -1; } @@ -1955,9 +1955,9 @@ int sm3_hss_private_key_size(const int *lms_types, size_t levels, size_t *len) } // X.509 related -int sm3_hss_public_key_to_der(const SM3_HSS_KEY *key, uint8_t **out, size_t *outlen) +int hss_public_key_to_der(const HSS_KEY *key, uint8_t **out, size_t *outlen) { - uint8_t octets[SM3_HSS_PUBLIC_KEY_SIZE]; + uint8_t octets[HSS_PUBLIC_KEY_SIZE]; uint8_t *p = octets; size_t len = 0; @@ -1965,7 +1965,7 @@ int sm3_hss_public_key_to_der(const SM3_HSS_KEY *key, uint8_t **out, size_t *out return 0; } - if (sm3_hss_public_key_to_bytes(key, &p, &len) != 1) { + if (hss_public_key_to_bytes(key, &p, &len) != 1) { error_print(); return -1; } @@ -1980,7 +1980,7 @@ int sm3_hss_public_key_to_der(const SM3_HSS_KEY *key, uint8_t **out, size_t *out return 1; } -int sm3_hss_public_key_from_der(SM3_HSS_KEY *key, const uint8_t **in, size_t *inlen) +int hss_public_key_from_der(HSS_KEY *key, const uint8_t **in, size_t *inlen) { int ret; const uint8_t *d; @@ -1990,12 +1990,12 @@ int sm3_hss_public_key_from_der(SM3_HSS_KEY *key, const uint8_t **in, size_t *in if (ret < 0) error_print(); return ret; } - if (dlen != SM3_HSS_PUBLIC_KEY_SIZE) { + if (dlen != HSS_PUBLIC_KEY_SIZE) { error_print(); return -1; } - if (sm3_hss_public_key_from_bytes(key, &d, &dlen) != 1) { + if (hss_public_key_from_bytes(key, &d, &dlen) != 1) { error_print(); return -1; } @@ -2007,7 +2007,7 @@ int sm3_hss_public_key_from_der(SM3_HSS_KEY *key, const uint8_t **in, size_t *in return 1; } -int sm3_hss_public_key_algor_to_der(uint8_t **out, size_t *outlen) +int hss_public_key_algor_to_der(uint8_t **out, size_t *outlen) { if (x509_public_key_algor_to_der(OID_hss_lms_hashsig, OID_undef, out, outlen) != 1) { error_print(); @@ -2016,7 +2016,7 @@ int sm3_hss_public_key_algor_to_der(uint8_t **out, size_t *outlen) return 1; } -int sm3_hss_public_key_algor_from_der(const uint8_t **in, size_t *inlen) +int hss_public_key_algor_from_der(const uint8_t **in, size_t *inlen) { int ret; int oid; @@ -2036,21 +2036,21 @@ int sm3_hss_public_key_algor_from_der(const uint8_t **in, size_t *inlen) return 1; } -int sm3_hss_public_key_info_to_der(const SM3_HSS_KEY *key, uint8_t **out, size_t *outlen) +int hss_public_key_info_to_der(const HSS_KEY *key, uint8_t **out, size_t *outlen) { size_t len = 0; - if (sm3_hss_public_key_algor_to_der(NULL, &len) != 1 - || sm3_hss_public_key_to_der(key, NULL, &len) != 1 + if (hss_public_key_algor_to_der(NULL, &len) != 1 + || hss_public_key_to_der(key, NULL, &len) != 1 || asn1_sequence_header_to_der(len, out, outlen) != 1 - || sm3_hss_public_key_algor_to_der(out, outlen) != 1 - || sm3_hss_public_key_to_der(key, out, outlen) != 1) { + || hss_public_key_algor_to_der(out, outlen) != 1 + || hss_public_key_to_der(key, out, outlen) != 1) { error_print(); return -1; } return 1; } -int sm3_hss_public_key_info_from_der(SM3_HSS_KEY *key, const uint8_t **in, size_t *inlen) +int hss_public_key_info_from_der(HSS_KEY *key, const uint8_t **in, size_t *inlen) { int ret; const uint8_t *d; @@ -2060,13 +2060,11 @@ int sm3_hss_public_key_info_from_der(SM3_HSS_KEY *key, const uint8_t **in, size_ if (ret < 0) error_print(); return ret; } - if (sm3_hss_public_key_algor_from_der(&d, &dlen) != 1 - || sm3_hss_public_key_from_der(key, &d, &dlen) != 1 + if (hss_public_key_algor_from_der(&d, &dlen) != 1 + || hss_public_key_from_der(key, &d, &dlen) != 1 || asn1_length_is_zero(dlen) != 1) { error_print(); return -1; } return 1; } - - diff --git a/src/x509_alg.c b/src/x509_alg.c index d74910ec..67e53356 100644 --- a/src/x509_alg.c +++ b/src/x509_alg.c @@ -16,9 +16,7 @@ #include #include #include -#ifdef ENABLE_SM3_LMS -#include -#endif + static uint32_t oid_sm3[] = { 1,2,156,10197,1,401 }; static uint32_t oid_md5[] = { 1,2,840,113549,2,5 }; @@ -357,7 +355,7 @@ static const ASN1_OID_INFO x509_sign_algors[] = { { OID_rsasign_with_sha256, "sha256WithRSAEncryption", oid_rsasign_with_sha256, sizeof(oid_rsasign_with_sha256)/sizeof(int), 1 }, { OID_rsasign_with_sha384, "sha384WithRSAEncryption", oid_rsasign_with_sha384, sizeof(oid_rsasign_with_sha384)/sizeof(int), 1 }, { OID_rsasign_with_sha512, "sha512WithRSAEncryption", oid_rsasign_with_sha512, sizeof(oid_rsasign_with_sha512)/sizeof(int), 1 }, -#ifdef ENABLE_SM3_LMS +#ifdef ENABLE_LMS_HSS { OID_hss_lms_hashsig, "hss-lms-hashsig", oid_hss_lms_hashsig, sizeof(oid_hss_lms_hashsig)/sizeof(int), 1 }, #endif }; @@ -577,7 +575,7 @@ static uint32_t oid_ec_public_key[] = { oid_x9_62,2,1 }; static const ASN1_OID_INFO x509_public_key_algors[] = { { OID_ec_public_key, "ecPublicKey", oid_ec_public_key, sizeof(oid_ec_public_key)/sizeof(int), 0, "X9.62 ecPublicKey" }, { OID_rsa_encryption, "rsaEncryption", oid_rsa_encryption, sizeof(oid_rsa_encryption)/sizeof(int), 0, "RSAEncryption" }, -#ifdef ENABLE_SM3_LMS +#ifdef ENABLE_LMS_HSS { OID_hss_lms_hashsig, "hss-lms-hashsig", oid_hss_lms_hashsig, sizeof(oid_hss_lms_hashsig)/sizeof(int), 0, "HSS/LMS HashSig" }, #endif }; @@ -630,7 +628,7 @@ int x509_public_key_algor_to_der(int oid, int curve_or_null, uint8_t **out, size return -1; } break; -#ifdef ENABLE_SM3_LMS +#ifdef ENABLE_LMS_HSS case OID_hss_lms_hashsig: if (asn1_object_identifier_to_der(oid_hss_lms_hashsig, sizeof(oid_hss_lms_hashsig)/sizeof(int), NULL, &len) != 1 || asn1_null_to_der(NULL, &len) != 1 @@ -676,7 +674,7 @@ int x509_public_key_algor_from_der(int *oid , int *curve_or_null, const uint8_t } break; case OID_rsa_encryption: -#ifdef ENABLE_SM3_LMS +#ifdef ENABLE_LMS_HSS case OID_hss_lms_hashsig: #endif if ((*curve_or_null = asn1_null_from_der(&d, &dlen)) < 0 @@ -709,7 +707,7 @@ int x509_public_key_algor_print(FILE *fp, int fmt, int ind, const char *label, c format_print(fp, fmt, ind, "namedCurve: %s\n", ec_named_curve_name(val)); break; case OID_rsa_encryption: -#ifdef ENABLE_SM3_LMS +#ifdef ENABLE_LMS_HSS case OID_hss_lms_hashsig: #endif if ((val = asn1_null_from_der(&d, &dlen)) < 0) goto err; diff --git a/tests/sm3_lmstest.c b/tests/lmstest.c similarity index 69% rename from tests/sm3_lmstest.c rename to tests/lmstest.c index 568e7467..0f8c70e9 100644 --- a/tests/sm3_lmstest.c +++ b/tests/lmstest.c @@ -13,7 +13,7 @@ #include #include #include -#include +#include static int lms_types[] = { @@ -23,7 +23,7 @@ static int lms_types[] = { }; -#if defined(ENABLE_SM3_LMS_CROSSCHECK) && defined(ENABLE_SHA2) +#if defined(ENABLE_LMS_CROSSCHECK) && defined(ENABLE_SHA2) static int test_rfc8554_test1(void) { size_t i; @@ -150,10 +150,10 @@ static int test_rfc8554_test1(void) "09ab3034911fe125631051df0408b3946b0bde790911e8978ba07dd56c73e7ee", }; - SM3_HSS_KEY key; - SM3_HSS_SIGNATURE sig; - SM3_LMS_SIGNATURE *lms_sig; - SM3_LMS_PUBLIC_KEY *lms_pub; + HSS_KEY key; + HSS_SIGNATURE sig; + LMS_SIGNATURE *lms_sig; + LMS_PUBLIC_KEY *lms_pub; size_t len; // hss public key @@ -202,25 +202,25 @@ static int test_rfc8554_test1(void) hex_to_bytes(sig1_path[i], 64, lms_sig->path[i], &len); } - sm3_hss_public_key_print(stderr, 0, 0, "hss_public_key", &key); + hss_public_key_print(stderr, 0, 0, "hss_public_key", &key); - sm3_hss_signature_print_ex(stderr, 0, 0, "hss_signature", &sig); + hss_signature_print_ex(stderr, 0, 0, "hss_signature", &sig); - SM3_HSS_SIGN_CTX ctx; + HSS_SIGN_CTX ctx; uint8_t data[162]; hex_to_bytes(msg, strlen(msg), data, &len); - if (sm3_hss_verify_init_ex(&ctx, &key, &sig) != 1) { + if (hss_verify_init_ex(&ctx, &key, &sig) != 1) { error_print(); return -1; } - if (sm3_hss_verify_update(&ctx, data, len) != 1) { + if (hss_verify_update(&ctx, data, len) != 1) { error_print(); return -1; } - if (sm3_hss_verify_finish(&ctx) != 1) { + if (hss_verify_finish(&ctx) != 1) { error_print(); return -1; } @@ -242,11 +242,11 @@ static int test_sm3_lmots(void) hash256_t pub; hash256_t pub2; - sm3_lmots_derive_secrets(seed, I, q, x); // TODO: compare results with test vector - sm3_lmots_secrets_to_public_hash(I, q, x, pub); // TODO: compare results with test vector + lmots_derive_secrets(seed, I, q, x); // TODO: compare results with test vector + lmots_secrets_to_public_hash(I, q, x, pub); // TODO: compare results with test vector - sm3_lmots_compute_signature(I, q, dgst, x, y); // TODO: compare results with test vector - sm3_lmots_signature_to_public_hash(I, q, y, dgst, pub2); + lmots_compute_signature(I, q, dgst, x, y); // TODO: compare results with test vector + lmots_signature_to_public_hash(I, q, y, dgst, pub2); if (memcmp(pub, pub2, 32) != 0) { error_print(); @@ -257,7 +257,7 @@ static int test_sm3_lmots(void) return 1; } -static int test_sm3_lms_derive_merkle_root(void) +static int test_lms_derive_merkle_root(void) { hash256_t seed = {0}; // TODO: change to test vector uint8_t I[16] = {0}; @@ -271,8 +271,8 @@ static int test_sm3_lms_derive_merkle_root(void) return -1; } - sm3_lms_derive_merkle_tree(seed, I, h, tree); - sm3_lms_derive_merkle_root(seed, I, h, root); + lms_derive_merkle_tree(seed, I, h, tree); + lms_derive_merkle_root(seed, I, h, root); if (memcmp(tree[0], root, 32) != 0) { free(tree); @@ -285,69 +285,69 @@ static int test_sm3_lms_derive_merkle_root(void) return 1; } -static int test_sm3_lms_key_generate(void) +static int test_lms_key_generate(void) { - SM3_LMS_KEY lms_key; + LMS_KEY lms_key; int lms_type = lms_types[0]; - if (sm3_lms_key_generate(&lms_key, lms_type) != 1) { + if (lms_key_generate(&lms_key, lms_type) != 1) { error_print(); return -1; } - //sm3_lms_key_print(stdout, 0, 0, "lms_key", &lms_key); + //lms_key_print(stdout, 0, 0, "lms_key", &lms_key); printf("%s() ok\n", __FUNCTION__); return 1; } -static int test_sm3_lms_key_to_bytes(void) +static int test_lms_key_to_bytes(void) { - SM3_LMS_KEY key; + LMS_KEY key; int lms_type = lms_types[0]; - uint8_t buf[sizeof(SM3_LMS_KEY) * 2]; + uint8_t buf[sizeof(LMS_KEY) * 2]; uint8_t *p = buf; const uint8_t *cp = buf; size_t len; - if (sm3_lms_key_generate(&key, lms_type) != 1) { + if (lms_key_generate(&key, lms_type) != 1) { error_print(); return -1; } p = buf; len = 0; - if (sm3_lms_public_key_to_bytes(&key, &p, &len) != 1) { + if (lms_public_key_to_bytes(&key, &p, &len) != 1) { error_print(); return -1; } - if (len != SM3_LMS_PUBLIC_KEY_SIZE) { + if (len != LMS_PUBLIC_KEY_SIZE) { error_print(); return -1; } - if (sm3_lms_private_key_to_bytes(&key, &p, &len) != 1) { + if (lms_private_key_to_bytes(&key, &p, &len) != 1) { error_print(); return -1; } - if (len != SM3_LMS_PUBLIC_KEY_SIZE + SM3_LMS_PRIVATE_KEY_SIZE) { + if (len != LMS_PUBLIC_KEY_SIZE + LMS_PRIVATE_KEY_SIZE) { error_print(); return -1; } cp = buf; - if (sm3_lms_public_key_from_bytes(&key, &cp, &len) != 1) { + if (lms_public_key_from_bytes(&key, &cp, &len) != 1) { error_print(); return -1; } - sm3_lms_key_print(stdout, 0, 4, "lms_public_key", &key); + lms_key_print(stdout, 0, 4, "lms_public_key", &key); - if (sm3_lms_private_key_from_bytes(&key, &cp, &len) != 1) { + if (lms_private_key_from_bytes(&key, &cp, &len) != 1) { error_print(); return -1; } - sm3_lms_key_print(stdout, 0, 4, "lms_private_key", &key); + lms_key_print(stdout, 0, 4, "lms_private_key", &key); if (len != 0) { error_print(); return -1; @@ -357,7 +357,7 @@ static int test_sm3_lms_key_to_bytes(void) return 1; } -static int test_sm3_lms_signature_size(void) +static int test_lms_signature_size(void) { int lms_types[] = { LMS_HASH256_M32_H5, @@ -377,7 +377,7 @@ static int test_sm3_lms_signature_size(void) size_t i; for (i = 0; i < sizeof(lms_types)/sizeof(lms_types[0]); i++) { - if (sm3_lms_signature_size(lms_types[i], &siglen) != 1) { + if (lms_signature_size(lms_types[i], &siglen) != 1) { error_print(); return -1; } @@ -391,7 +391,7 @@ static int test_sm3_lms_signature_size(void) return 1; } -static int test_sm3_hss_signature_size(void) +static int test_hss_signature_size(void) { int lms_types[] = { LMS_HASH256_M32_H5, @@ -402,17 +402,17 @@ static int test_sm3_hss_signature_size(void) }; size_t siglens[] = { 4 + 1292, - 4 + 1292 + SM3_LMS_PUBLIC_KEY_SIZE*1 + 1452, - 4 + 1292 + SM3_LMS_PUBLIC_KEY_SIZE*2 + 1452 + 1612, - 4 + 1292 + SM3_LMS_PUBLIC_KEY_SIZE*3 + 1452 + 1612 + 1772, - 4 + 1292 + SM3_LMS_PUBLIC_KEY_SIZE*4 + 1452 + 1612 + 1772 + 1932, + 4 + 1292 + LMS_PUBLIC_KEY_SIZE*1 + 1452, + 4 + 1292 + LMS_PUBLIC_KEY_SIZE*2 + 1452 + 1612, + 4 + 1292 + LMS_PUBLIC_KEY_SIZE*3 + 1452 + 1612 + 1772, + 4 + 1292 + LMS_PUBLIC_KEY_SIZE*4 + 1452 + 1612 + 1772 + 1932, }; size_t siglen; size_t i; for (i = 0; i < sizeof(lms_types)/sizeof(lms_types[0]); i++) { - if (sm3_hss_signature_size(lms_types, i+1, &siglen) != 1) { + if (hss_signature_size(lms_types, i+1, &siglen) != 1) { error_print(); return -1; } @@ -431,17 +431,17 @@ static int test_sm3_hss_signature_size(void) return 1; } -static int test_sm3_lms_sign(void) +static int test_lms_sign(void) { int lms_type = lms_types[0]; - SM3_LMS_KEY key; - SM3_LMS_SIGN_CTX ctx; + LMS_KEY key; + LMS_SIGN_CTX ctx; uint8_t msg[200]; - uint8_t sig[SM3_LMS_SIGNATURE_MAX_SIZE]; + uint8_t sig[LMS_SIGNATURE_MAX_SIZE]; size_t siglen; int ret; - if (sm3_lms_key_generate(&key, lms_type) != 1) { + if (lms_key_generate(&key, lms_type) != 1) { error_print(); return -1; } @@ -449,33 +449,33 @@ static int test_sm3_lms_sign(void) memset(&ctx, 0, sizeof(ctx)); memset(sig, 0, sizeof(sig)); - if (sm3_lms_sign_init(&ctx, &key) != 1) { + if (lms_sign_init(&ctx, &key) != 1) { error_print(); return -1; } - if (sm3_lms_sign_update(&ctx, msg, 100) != 1) { + if (lms_sign_update(&ctx, msg, 100) != 1) { error_print(); return -1; } - if (sm3_lms_sign_update(&ctx, msg + 100, 100) != 1) { + if (lms_sign_update(&ctx, msg + 100, 100) != 1) { error_print(); return -1; } - if (sm3_lms_sign_finish(&ctx, sig, &siglen) != 1) { + if (lms_sign_finish(&ctx, sig, &siglen) != 1) { error_print(); return -1; } if (1) { - SM3_LMS_SIGNATURE signature; + LMS_SIGNATURE signature; const uint8_t *cp = sig; size_t len = siglen; - if (sm3_lms_signature_from_bytes(&signature, &cp, &len) != 1) { + if (lms_signature_from_bytes(&signature, &cp, &len) != 1) { error_print(); return -1; } - sm3_lms_signature_print_ex(stderr, 0, 4, "lms_signature", &signature); + lms_signature_print_ex(stderr, 0, 4, "lms_signature", &signature); if (len) { error_print(); return -1; @@ -484,19 +484,19 @@ static int test_sm3_lms_sign(void) memset(&ctx, 0, sizeof(ctx)); - if (sm3_lms_verify_init(&ctx, &key, sig, siglen) != 1) { + if (lms_verify_init(&ctx, &key, sig, siglen) != 1) { error_print(); return -1; } - if (sm3_lms_verify_update(&ctx, msg, 100) != 1) { + if (lms_verify_update(&ctx, msg, 100) != 1) { error_print(); return -1; } - if (sm3_lms_verify_update(&ctx, msg + 100, 100) != 1) { + if (lms_verify_update(&ctx, msg + 100, 100) != 1) { error_print(); return -1; } - if ((ret = sm3_lms_verify_finish(&ctx)) != 1) { + if ((ret = lms_verify_finish(&ctx)) != 1) { error_print(); return -1; } @@ -505,22 +505,22 @@ static int test_sm3_lms_sign(void) return 1; } -static int test_sm3_lms_max_sigs(void) +static int test_lms_max_sigs(void) { int lms_type = LMS_HASH256_M32_H5; int height = 5; - SM3_LMS_KEY key; - SM3_LMS_SIGN_CTX ctx; + LMS_KEY key; + LMS_SIGN_CTX ctx; int i; - if (sm3_lms_key_generate(&key, lms_type) != 1) { + if (lms_key_generate(&key, lms_type) != 1) { error_print(); return -1; } key.q = 1 << height; - if (sm3_lms_sign_init(&ctx, &key) == 1) { + if (lms_sign_init(&ctx, &key) == 1) { error_print(); return -1; } @@ -529,17 +529,17 @@ static int test_sm3_lms_max_sigs(void) return 1; } -static int test_sm3_hss_key_generate(void) +static int test_hss_key_generate(void) { - SM3_HSS_KEY key; + HSS_KEY key; - if (sm3_hss_key_generate(&key, lms_types, sizeof(lms_types)/sizeof(lms_types[0])) != 1) { + if (hss_key_generate(&key, lms_types, sizeof(lms_types)/sizeof(lms_types[0])) != 1) { error_print(); return -1; } - sm3_hss_public_key_print(stdout, 0, 4, "sm3_hss_public_key", &key); - sm3_hss_key_print(stdout, 0, 4, "sm3_hss_key", &key); + hss_public_key_print(stdout, 0, 4, "hss_public_key", &key); + hss_key_print(stdout, 0, 4, "hss_key", &key); printf("%s() ok\n", __FUNCTION__); return 1; @@ -547,11 +547,11 @@ static int test_sm3_hss_key_generate(void) -static int test_sm3_hss_key_update_level1(void) +static int test_hss_key_update_level1(void) { - SM3_HSS_KEY key; + HSS_KEY key; - memset(&key, 0, sizeof(SM3_HSS_KEY)); + memset(&key, 0, sizeof(HSS_KEY)); key.levels = 1; key.lms_key[0].public_key.lms_type = LMS_HASH256_M32_H25; @@ -559,7 +559,7 @@ static int test_sm3_hss_key_update_level1(void) key.lms_key[0].q = (1 << 25); // out of keys - if (sm3_hss_key_update(&key) != 0) { + if (hss_key_update(&key) != 0) { error_print(); return -1; } @@ -568,23 +568,23 @@ static int test_sm3_hss_key_update_level1(void) return 1; } -static int test_sm3_hss_key_update_level2(void) +static int test_hss_key_update_level2(void) { int lms_types[] = { LMS_HASH256_M32_H5, LMS_HASH256_M32_H5, }; - SM3_HSS_KEY key; + HSS_KEY key; int i; - if (sm3_hss_key_generate(&key, lms_types, 2) != 1) { + if (hss_key_generate(&key, lms_types, 2) != 1) { error_print(); return -1; } key.lms_key[1].q = 32; // update 1 - if (sm3_hss_key_update(&key) != 1) { + if (hss_key_update(&key) != 1) { error_print(); return -1; } @@ -597,7 +597,7 @@ static int test_sm3_hss_key_update_level2(void) // update 2 key.lms_key[1].q = 32; - if (sm3_hss_key_update(&key) != 1) { + if (hss_key_update(&key) != 1) { error_print(); return -1; } @@ -611,7 +611,7 @@ static int test_sm3_hss_key_update_level2(void) // update 31 key.lms_key[0].q = 31; key.lms_key[1].q = 32; - if (sm3_hss_key_update(&key) != 1) { + if (hss_key_update(&key) != 1) { error_print(); return -1; } @@ -624,7 +624,7 @@ static int test_sm3_hss_key_update_level2(void) // update 32, key space exhausted, return 0 key.lms_key[1].q = 32; - if (sm3_hss_key_update(&key) != 0) { + if (hss_key_update(&key) != 0) { error_print(); return -1; } @@ -635,7 +635,7 @@ static int test_sm3_hss_key_update_level2(void) -static int test_sm3_hss_key_update_level5(void) +static int test_hss_key_update_level5(void) { int lms_types[] = { LMS_HASH256_M32_H5, @@ -644,10 +644,10 @@ static int test_sm3_hss_key_update_level5(void) LMS_HASH256_M32_H5, LMS_HASH256_M32_H5, }; - SM3_HSS_KEY key; + HSS_KEY key; int i; - if (sm3_hss_key_generate(&key, lms_types, 5) != 1) { + if (hss_key_generate(&key, lms_types, 5) != 1) { error_print(); return -1; } @@ -667,7 +667,7 @@ static int test_sm3_hss_key_update_level5(void) // level-4 update key.lms_key[4].q = 32; - if (sm3_hss_key_update(&key) != 1) { + if (hss_key_update(&key) != 1) { error_print(); return -1; } @@ -694,7 +694,7 @@ static int test_sm3_hss_key_update_level5(void) key.lms_key[3].q = 32; key.lms_sig[3].q = 31; key.lms_key[4].q = 32; - if (sm3_hss_key_update(&key) != 1) { + if (hss_key_update(&key) != 1) { error_print(); return -1; } @@ -721,7 +721,7 @@ static int test_sm3_hss_key_update_level5(void) key.lms_key[3].q = 32; key.lms_sig[3].q = 31; key.lms_key[4].q = 32; - if (sm3_hss_key_update(&key) != 1) { + if (hss_key_update(&key) != 1) { error_print(); return -1; } @@ -748,7 +748,7 @@ static int test_sm3_hss_key_update_level5(void) key.lms_key[3].q = 32; key.lms_sig[3].q = 31; key.lms_key[4].q = 32; - if (sm3_hss_key_update(&key) != 0) { + if (hss_key_update(&key) != 0) { error_print(); return -1; } @@ -757,16 +757,16 @@ static int test_sm3_hss_key_update_level5(void) return 1; } -static int test_sm3_hss_key_to_bytes(void) +static int test_hss_key_to_bytes(void) { - SM3_HSS_KEY key; + HSS_KEY key; - uint8_t buf[SM3_HSS_PUBLIC_KEY_SIZE + sizeof(SM3_HSS_KEY)]; + uint8_t buf[HSS_PUBLIC_KEY_SIZE + sizeof(HSS_KEY)]; uint8_t *p = buf; const uint8_t *cp = buf; size_t len; - if (sm3_hss_key_generate(&key, + if (hss_key_generate(&key, lms_types, sizeof(lms_types)/sizeof(lms_types[0])) != 1) { error_print(); return -1; @@ -774,32 +774,32 @@ static int test_sm3_hss_key_to_bytes(void) p = buf; len = 0; - if (sm3_hss_public_key_to_bytes(&key, &p, &len) != 1) { + if (hss_public_key_to_bytes(&key, &p, &len) != 1) { error_print(); return -1; } - if (len != SM3_HSS_PUBLIC_KEY_SIZE) { + if (len != HSS_PUBLIC_KEY_SIZE) { error_print(); return -1; } - if (sm3_hss_private_key_to_bytes(&key, &p, &len) != 1) { + if (hss_private_key_to_bytes(&key, &p, &len) != 1) { error_print(); return -1; } cp = buf; - if (sm3_hss_public_key_from_bytes(&key, &cp, &len) != 1) { + if (hss_public_key_from_bytes(&key, &cp, &len) != 1) { error_print(); return -1; } - sm3_hss_public_key_print(stdout, 0, 4, "lms_public_key", &key); + hss_public_key_print(stdout, 0, 4, "lms_public_key", &key); - if (sm3_hss_private_key_from_bytes(&key, &cp, &len) != 1) { + if (hss_private_key_from_bytes(&key, &cp, &len) != 1) { error_print(); return -1; } - sm3_hss_key_print(stdout, 0, 4, "lms_private_key", &key); + hss_key_print(stdout, 0, 4, "lms_private_key", &key); if (len != 0) { error_print(); return -1; @@ -809,43 +809,43 @@ static int test_sm3_hss_key_to_bytes(void) return 1; } -static int test_sm3_hss_sign_level1(void) +static int test_hss_sign_level1(void) { int levels = 1; - SM3_HSS_KEY key; - SM3_HSS_SIGN_CTX ctx; - SM3_HSS_SIGNATURE sig; + HSS_KEY key; + HSS_SIGN_CTX ctx; + HSS_SIGNATURE sig; uint8_t msg[200]; - uint8_t buf[sizeof(SM3_HSS_SIGNATURE)]; + uint8_t buf[sizeof(HSS_SIGNATURE)]; size_t len; - if (sm3_hss_key_generate(&key, lms_types, levels) != 1) { + if (hss_key_generate(&key, lms_types, levels) != 1) { error_print(); return -1; } - if (sm3_hss_sign_init(&ctx, &key) != 1) { + if (hss_sign_init(&ctx, &key) != 1) { error_print(); return -1; } - if (sm3_hss_sign_update(&ctx, msg, sizeof(msg)) != 1) { + if (hss_sign_update(&ctx, msg, sizeof(msg)) != 1) { error_print(); return -1; } - if (sm3_hss_sign_finish(&ctx, buf, &len) != 1) { + if (hss_sign_finish(&ctx, buf, &len) != 1) { error_print(); return -1; } - if (sm3_hss_verify_init(&ctx, &key, buf, len) != 1) { + if (hss_verify_init(&ctx, &key, buf, len) != 1) { error_print(); return -1; } - if (sm3_hss_verify_update(&ctx, msg, sizeof(msg)) != 1) { + if (hss_verify_update(&ctx, msg, sizeof(msg)) != 1) { error_print(); return -1; } - if (sm3_hss_verify_finish(&ctx) != 1) { + if (hss_verify_finish(&ctx) != 1) { error_print(); return -1; } @@ -854,47 +854,47 @@ static int test_sm3_hss_sign_level1(void) return 1; } -static int test_sm3_hss_sign_level2(void) +static int test_hss_sign_level2(void) { int levels = 2; - SM3_HSS_KEY key; - SM3_HSS_SIGN_CTX ctx; - SM3_HSS_SIGNATURE sig; + HSS_KEY key; + HSS_SIGN_CTX ctx; + HSS_SIGNATURE sig; uint8_t msg[200]; - uint8_t buf[sizeof(SM3_HSS_SIGNATURE)]; + uint8_t buf[sizeof(HSS_SIGNATURE)]; size_t len; - if (sm3_hss_key_generate(&key, lms_types, levels) != 1) { + if (hss_key_generate(&key, lms_types, levels) != 1) { error_print(); return -1; } - sm3_hss_key_print(stderr, 0, 4, "sm3_hss_key", &key); + hss_key_print(stderr, 0, 4, "hss_key", &key); - if (sm3_hss_sign_init(&ctx, &key) != 1) { + if (hss_sign_init(&ctx, &key) != 1) { error_print(); return -1; } - if (sm3_hss_sign_update(&ctx, msg, sizeof(msg)) != 1) { + if (hss_sign_update(&ctx, msg, sizeof(msg)) != 1) { error_print(); return -1; } - if (sm3_hss_sign_finish(&ctx, buf, &len) != 1) { + if (hss_sign_finish(&ctx, buf, &len) != 1) { error_print(); return -1; } - sm3_hss_signature_print(stderr, 0, 4, "sm3_hss_signature", buf, len); + hss_signature_print(stderr, 0, 4, "hss_signature", buf, len); - if (sm3_hss_verify_init(&ctx, &key, buf, len) != 1) { + if (hss_verify_init(&ctx, &key, buf, len) != 1) { error_print(); return -1; } - if (sm3_hss_verify_update(&ctx, msg, sizeof(msg)) != 1) { + if (hss_verify_update(&ctx, msg, sizeof(msg)) != 1) { error_print(); return -1; } - if (sm3_hss_verify_finish(&ctx) != 1) { + if (hss_verify_finish(&ctx) != 1) { error_print(); return -1; } @@ -903,46 +903,46 @@ static int test_sm3_hss_sign_level2(void) return 1; } -static int test_sm3_hss_sign(void) +static int test_hss_sign(void) { - SM3_HSS_KEY key; - SM3_HSS_SIGN_CTX ctx; - SM3_HSS_SIGNATURE sig; + HSS_KEY key; + HSS_SIGN_CTX ctx; + HSS_SIGNATURE sig; uint8_t msg[200]; - uint8_t buf[sizeof(SM3_HSS_SIGNATURE)]; + uint8_t buf[sizeof(HSS_SIGNATURE)]; size_t len; - if (sm3_hss_key_generate(&key, lms_types, sizeof(lms_types)/sizeof(lms_types[0])) != 1) { + if (hss_key_generate(&key, lms_types, sizeof(lms_types)/sizeof(lms_types[0])) != 1) { error_print(); return -1; } - sm3_hss_key_print(stderr, 0, 4, "sm3_hss_key", &key); + hss_key_print(stderr, 0, 4, "hss_key", &key); - if (sm3_hss_sign_init(&ctx, &key) != 1) { + if (hss_sign_init(&ctx, &key) != 1) { error_print(); return -1; } - if (sm3_hss_sign_update(&ctx, msg, sizeof(msg)) != 1) { + if (hss_sign_update(&ctx, msg, sizeof(msg)) != 1) { error_print(); return -1; } - if (sm3_hss_sign_finish(&ctx, buf, &len) != 1) { + if (hss_sign_finish(&ctx, buf, &len) != 1) { error_print(); return -1; } - sm3_hss_signature_print(stderr, 0, 4, "sm3_hss_signature", buf, len); + hss_signature_print(stderr, 0, 4, "hss_signature", buf, len); - if (sm3_hss_verify_init(&ctx, &key, buf, len) != 1) { + if (hss_verify_init(&ctx, &key, buf, len) != 1) { error_print(); return -1; } - if (sm3_hss_verify_update(&ctx, msg, sizeof(msg)) != 1) { + if (hss_verify_update(&ctx, msg, sizeof(msg)) != 1) { error_print(); return -1; } - if (sm3_hss_verify_finish(&ctx) != 1) { + if (hss_verify_finish(&ctx) != 1) { error_print(); return -1; } @@ -951,33 +951,33 @@ static int test_sm3_hss_sign(void) return 1; } -static int test_sm3_hss_public_key_algor(void) +static int test_hss_public_key_algor(void) { int lms_types[] = { LMS_HASH256_M32_H5 }; - SM3_HSS_KEY key; + HSS_KEY key; uint8_t buf[512]; const uint8_t *cp; uint8_t *p; size_t len; - if (sm3_hss_key_generate(&key, lms_types, sizeof(lms_types)/sizeof(lms_types[0])) != 1) { + if (hss_key_generate(&key, lms_types, sizeof(lms_types)/sizeof(lms_types[0])) != 1) { error_print(); return -1; } cp = p = buf; len = 0; - if (sm3_hss_public_key_to_der(&key, &p, &len) != 1) { + if (hss_public_key_to_der(&key, &p, &len) != 1) { error_print(); return -1; } fprintf(stderr, "HSS-LMS-HashSig-PublicKey ::= OCTET STRING\n"); fprintf(stderr, "hss_public_key der size = %zu\n", len); - memset(&key, 0, sizeof(SM3_HSS_KEY)); - if (sm3_hss_public_key_from_der(&key, &cp, &len) != 1) { + memset(&key, 0, sizeof(HSS_KEY)); + if (hss_public_key_from_der(&key, &cp, &len) != 1) { error_print(); return -1; } @@ -989,11 +989,11 @@ static int test_sm3_hss_public_key_algor(void) cp = p = buf; len = 0; - if (sm3_hss_public_key_algor_to_der(&p, &len) != 1) { + if (hss_public_key_algor_to_der(&p, &len) != 1) { error_print(); return -1; } - if (sm3_hss_public_key_algor_from_der(&cp, &len) != 1) { + if (hss_public_key_algor_from_der(&cp, &len) != 1) { error_print(); return -1; } @@ -1005,13 +1005,13 @@ static int test_sm3_hss_public_key_algor(void) cp = p = buf; len = 0; - if (sm3_hss_public_key_info_to_der(&key, &p, &len) != 1) { + if (hss_public_key_info_to_der(&key, &p, &len) != 1) { error_print(); return -1; } fprintf(stderr, "HSSPublicKeyInfo DER size = %zu\n", len); - memset(&key, 0, sizeof(SM3_HSS_KEY)); - if (sm3_hss_public_key_info_from_der(&key, &cp, &len) != 1) { + memset(&key, 0, sizeof(HSS_KEY)); + if (hss_public_key_info_from_der(&key, &cp, &len) != 1) { error_print(); return -1; } @@ -1029,26 +1029,26 @@ static int test_sm3_hss_public_key_algor(void) int main(void) { -#if defined(ENABLE_SM3_LMS_CROSSCHECK) && defined(ENABLE_SHA2) +#if defined(ENABLE_LMS_CROSSCHECK) && defined(ENABLE_SHA2) if (test_rfc8554_test1() != 1) goto err; #endif if (test_sm3_lmots() != 1) goto err; - if (test_sm3_lms_derive_merkle_root() != 1) goto err; - if (test_sm3_lms_key_generate() != 1) goto err; - if (test_sm3_lms_key_to_bytes() != 1) goto err; - if (test_sm3_lms_signature_size() != 1) goto err; - if (test_sm3_lms_sign() != 1) goto err; - if (test_sm3_lms_max_sigs() != 1) goto err; - if (test_sm3_hss_key_generate() != 1) goto err; - if (test_sm3_hss_key_to_bytes() != 1) goto err; - if (test_sm3_hss_key_update_level1() != 1) goto err; - if (test_sm3_hss_key_update_level2() != 1) goto err; - if (test_sm3_hss_key_update_level5() != 1) goto err; - if (test_sm3_hss_signature_size() != 1) goto err; - if (test_sm3_hss_sign_level1() != 1) goto err; - if (test_sm3_hss_sign_level2() != 1) goto err; - if (test_sm3_hss_sign() != 1) goto err; - if (test_sm3_hss_public_key_algor() != 1) goto err; + if (test_lms_derive_merkle_root() != 1) goto err; + if (test_lms_key_generate() != 1) goto err; + if (test_lms_key_to_bytes() != 1) goto err; + if (test_lms_signature_size() != 1) goto err; + if (test_lms_sign() != 1) goto err; + if (test_lms_max_sigs() != 1) goto err; + if (test_hss_key_generate() != 1) goto err; + if (test_hss_key_to_bytes() != 1) goto err; + if (test_hss_key_update_level1() != 1) goto err; + if (test_hss_key_update_level2() != 1) goto err; + if (test_hss_key_update_level5() != 1) goto err; + if (test_hss_signature_size() != 1) goto err; + if (test_hss_sign_level1() != 1) goto err; + if (test_hss_sign_level2() != 1) goto err; + if (test_hss_sign() != 1) goto err; + if (test_hss_public_key_algor() != 1) goto err; printf("%s all tests passed\n", __FILE__); return 0; diff --git a/tools/gmssl.c b/tools/gmssl.c index 0f3ddf70..23ee35ab 100644 --- a/tools/gmssl.c +++ b/tools/gmssl.c @@ -64,13 +64,13 @@ extern int tls12_client_main(int argc, char **argv); extern int tls12_server_main(int argc, char **argv); extern int tls13_client_main(int argc, char **argv); extern int tls13_server_main(int argc, char **argv); -#ifdef ENABLE_SM3_LMS -extern int sm3lmskeygen_main(int argc, char **argv); -extern int sm3lmssign_main(int argc, char **argv); -extern int sm3lmsverify_main(int argc, char **argv); -extern int sm3hsskeygen_main(int argc, char **argv); -extern int sm3hsssign_main(int argc, char **argv); -extern int sm3hssverify_main(int argc, char **argv); +#ifdef ENABLE_LMS_HSS +extern int lmskeygen_main(int argc, char **argv); +extern int lmssign_main(int argc, char **argv); +extern int lmsverify_main(int argc, char **argv); +extern int hsskeygen_main(int argc, char **argv); +extern int hsssign_main(int argc, char **argv); +extern int hssverify_main(int argc, char **argv); #endif #ifdef ENABLE_SM3_XMSS extern int sm3xmss_keygen_main(int argc, char **argv); @@ -139,13 +139,13 @@ static const char *options = " cmsdecrypt Decrypt CMS EnvelopedData\n" " cmssign Generate CMS SignedData\n" " cmsverify Verify CMS SignedData\n" -#ifdef ENABLE_SM3_LMS - " sm3lmskeygen Generate SM3-LMS keypair\n" - " sm3lmssign Generate LMS signature\n" - " sm3lmsverify Verify LMS signature\n" - " sm3hsskeygen Generate SM3-HSS keypair\n" - " sm3hsssign Generate HSS signature\n" - " sm3hssverify Verify HSS signature\n" +#ifdef ENABLE_LMS_HSS + " lmskeygen Generate SM3-LMS keypair\n" + " lmssign Generate LMS signature\n" + " lmsverify Verify LMS signature\n" + " hsskeygen Generate SM3-HSS keypair\n" + " hsssign Generate HSS signature\n" + " hssverify Verify HSS signature\n" #endif #ifdef ENABLE_SM3_XMSS " sm3xmss_keygen Generate SM3-XMSS keypair\n" @@ -304,19 +304,19 @@ int main(int argc, char **argv) return tls13_client_main(argc, argv); } else if (!strcmp(*argv, "tls13_server")) { return tls13_server_main(argc, argv); -#ifdef ENABLE_SM3_LMS - } else if (!strcmp(*argv, "sm3lmskeygen")) { - return sm3lmskeygen_main(argc, argv); - } else if (!strcmp(*argv, "sm3lmssign")) { - return sm3lmssign_main(argc, argv); - } else if (!strcmp(*argv, "sm3lmsverify")) { - return sm3lmsverify_main(argc, argv); - } else if (!strcmp(*argv, "sm3hsskeygen")) { - return sm3hsskeygen_main(argc, argv); - } else if (!strcmp(*argv, "sm3hsssign")) { - return sm3hsssign_main(argc, argv); - } else if (!strcmp(*argv, "sm3hssverify")) { - return sm3hssverify_main(argc, argv); +#ifdef ENABLE_LMS_HSS + } else if (!strcmp(*argv, "lmskeygen")) { + return lmskeygen_main(argc, argv); + } else if (!strcmp(*argv, "lmssign")) { + return lmssign_main(argc, argv); + } else if (!strcmp(*argv, "lmsverify")) { + return lmsverify_main(argc, argv); + } else if (!strcmp(*argv, "hsskeygen")) { + return hsskeygen_main(argc, argv); + } else if (!strcmp(*argv, "hsssign")) { + return hsssign_main(argc, argv); + } else if (!strcmp(*argv, "hssverify")) { + return hssverify_main(argc, argv); #endif #ifdef ENABLE_SM3_XMSS } else if (!strcmp(*argv, "sm3xmss_keygen")) { diff --git a/tools/sm3hsskeygen.c b/tools/hsskeygen.c similarity index 88% rename from tools/sm3hsskeygen.c rename to tools/hsskeygen.c index cbdd8df9..0015861e 100644 --- a/tools/sm3hsskeygen.c +++ b/tools/hsskeygen.c @@ -14,7 +14,7 @@ #include #include #include -#include +#include static const char *usage = "-lms_types types -out file [-pubout file] [-verbose]\n"; @@ -36,7 +36,7 @@ static const char *options = #define LMS_TYPES_STR_MAX_SIZE (sizeof("LMS_SM3_M32_H20_NAME") * 5) -int sm3hsskeygen_main(int argc, char **argv) +int hsskeygen_main(int argc, char **argv) { int ret = 1; char *prog = argv[0]; @@ -49,9 +49,9 @@ int sm3hsskeygen_main(int argc, char **argv) int levels = 0; FILE *outfp = NULL; FILE *puboutfp = stdout; - SM3_HSS_KEY key; - uint8_t out[SM3_HSS_PRIVATE_KEY_MAX_SIZE]; - uint8_t pubout[SM3_HSS_PUBLIC_KEY_SIZE]; + HSS_KEY key; + uint8_t out[HSS_PRIVATE_KEY_MAX_SIZE]; + uint8_t pubout[HSS_PUBLIC_KEY_SIZE]; uint8_t *pout = out; uint8_t *ppubout = pubout; size_t outlen = 0, puboutlen = 0; @@ -78,7 +78,7 @@ int sm3hsskeygen_main(int argc, char **argv) tok = strtok(lms_types_str, ":"); while (tok) { - if (!(lms_types_val[levels] = sm3_lms_type_from_name(tok))) { + if (!(lms_types_val[levels] = lms_type_from_name(tok))) { fprintf(stderr, "%s: invalid lms_type `%s`\n", prog, tok); goto end; } @@ -122,15 +122,15 @@ bad: goto end; } - if (sm3_hss_key_generate(&key, lms_types_val, levels) != 1) { + if (hss_key_generate(&key, lms_types_val, levels) != 1) { error_print(); return -1; } if (verbose) { - sm3_hss_public_key_print(stderr, 0, 0, "hss_public_key", &key); + hss_public_key_print(stderr, 0, 0, "hss_public_key", &key); } - if (sm3_hss_private_key_to_bytes(&key, &pout, &outlen) != 1) { + if (hss_private_key_to_bytes(&key, &pout, &outlen) != 1) { error_print(); goto end; } @@ -139,7 +139,7 @@ bad: goto end; } - if (sm3_hss_public_key_to_bytes(&key, &ppubout, &puboutlen) != 1) { + if (hss_public_key_to_bytes(&key, &ppubout, &puboutlen) != 1) { error_print(); goto end; } diff --git a/tools/sm3hsssign.c b/tools/hsssign.c similarity index 83% rename from tools/sm3hsssign.c rename to tools/hsssign.c index 538aa464..47a26b16 100644 --- a/tools/sm3hsssign.c +++ b/tools/hsssign.c @@ -14,7 +14,7 @@ #include #include #include -#include +#include static const char *usage = "-key file [-in file] [-out file] [-verbose]\n"; @@ -26,7 +26,7 @@ static const char *options = " -verbose Print public key and signature\n" "\n"; -int sm3hsssign_main(int argc, char **argv) +int hsssign_main(int argc, char **argv) { int ret = 1; char *prog = argv[0]; @@ -37,13 +37,13 @@ int sm3hsssign_main(int argc, char **argv) FILE *keyfp = NULL; FILE *infp = stdin; FILE *outfp = stdout; - uint8_t keybuf[SM3_HSS_PRIVATE_KEY_MAX_SIZE]; - size_t keylen = SM3_HSS_PRIVATE_KEY_MAX_SIZE; + uint8_t keybuf[HSS_PRIVATE_KEY_MAX_SIZE]; + size_t keylen = HSS_PRIVATE_KEY_MAX_SIZE; const uint8_t *cp = keybuf; uint8_t *p = keybuf; - SM3_HSS_KEY key; - SM3_HSS_SIGN_CTX ctx; - uint8_t sig[SM3_HSS_SIGNATURE_MAX_SIZE]; + HSS_KEY key; + HSS_SIGN_CTX ctx; + uint8_t sig[HSS_SIGNATURE_MAX_SIZE]; size_t siglen; argc--; @@ -104,7 +104,7 @@ bad: fprintf(stderr, "%s: read private key failure\n", prog); goto end; } - if (sm3_hss_private_key_from_bytes(&key, &cp, &keylen) != 1) { + if (hss_private_key_from_bytes(&key, &cp, &keylen) != 1) { error_print(); goto end; } @@ -114,17 +114,17 @@ bad: } if (verbose) { - sm3_hss_public_key_print(stderr, 0, 0, "hss_public_key", &key); + hss_public_key_print(stderr, 0, 0, "hss_public_key", &key); } - if (sm3_hss_sign_init(&ctx, &key) != 1) { + if (hss_sign_init(&ctx, &key) != 1) { error_print(); goto end; } // write updated key back to file // TODO: write back `q` only - if (sm3_hss_private_key_to_bytes(&key, &p, &keylen) != 1) { + if (hss_private_key_to_bytes(&key, &p, &keylen) != 1) { error_print(); return -1; } @@ -140,12 +140,12 @@ bad: if (len == 0) { break; } - if (sm3_hss_sign_update(&ctx, buf, len) != 1) { + if (hss_sign_update(&ctx, buf, len) != 1) { error_print(); goto end; } } - if (sm3_hss_sign_finish(&ctx, sig, &siglen) != 1) { + if (hss_sign_finish(&ctx, sig, &siglen) != 1) { error_print(); goto end; } @@ -154,7 +154,7 @@ bad: goto end; } if (verbose) { - sm3_hss_signature_print(stderr, 0, 0, "hss_signature", sig, siglen); + hss_signature_print(stderr, 0, 0, "hss_signature", sig, siglen); } ret = 0; diff --git a/tools/sm3hssverify.c b/tools/hssverify.c similarity index 82% rename from tools/sm3hssverify.c rename to tools/hssverify.c index 83e13da5..bafc4e6d 100644 --- a/tools/sm3hssverify.c +++ b/tools/hssverify.c @@ -14,7 +14,7 @@ #include #include #include -#include +#include static const char *usage = "-pubkey file [-in file] -sig file [-verbose]\n"; @@ -26,7 +26,7 @@ static const char *options = " -verbose Print public key and signature\n" "\n"; -int sm3hssverify_main(int argc, char **argv) +int hssverify_main(int argc, char **argv) { int ret = 1; char *prog = argv[0]; @@ -37,13 +37,13 @@ int sm3hssverify_main(int argc, char **argv) FILE *pubkeyfp = NULL; FILE *infp = stdin; FILE *sigfp = NULL; - uint8_t pubkeybuf[SM3_HSS_PUBLIC_KEY_SIZE]; - size_t pubkeylen = SM3_HSS_PUBLIC_KEY_SIZE; + uint8_t pubkeybuf[HSS_PUBLIC_KEY_SIZE]; + size_t pubkeylen = HSS_PUBLIC_KEY_SIZE; const uint8_t *cp = pubkeybuf; - uint8_t sig[SM3_HSS_SIGNATURE_MAX_SIZE]; + uint8_t sig[HSS_SIGNATURE_MAX_SIZE]; size_t siglen; - SM3_HSS_KEY key; - SM3_HSS_SIGN_CTX ctx; + HSS_KEY key; + HSS_SIGN_CTX ctx; int vr; argc--; @@ -108,23 +108,23 @@ bad: fprintf(stderr, "%s: read public key failure\n", prog); goto end; } - if (sm3_hss_public_key_from_bytes(&key, &cp, &pubkeylen) != 1) { + if (hss_public_key_from_bytes(&key, &cp, &pubkeylen) != 1) { error_print(); goto end; } if (verbose) { - sm3_hss_public_key_print(stderr, 0, 0, "lms_public_key", &key); + hss_public_key_print(stderr, 0, 0, "lms_public_key", &key); } // read signature even if signature not compatible with the public key - if ((siglen = fread(sig, 1, SM3_HSS_SIGNATURE_MAX_SIZE, sigfp)) <= 0) { + if ((siglen = fread(sig, 1, HSS_SIGNATURE_MAX_SIZE, sigfp)) <= 0) { fprintf(stderr, "%s: read signature failure\n", prog); goto end; } if (verbose) { - sm3_hss_signature_print(stderr, 0, 0, "lms_signature", sig, siglen); + hss_signature_print(stderr, 0, 0, "lms_signature", sig, siglen); } - if (sm3_hss_verify_init(&ctx, &key, sig, siglen) != 1) { + if (hss_verify_init(&ctx, &key, sig, siglen) != 1) { error_print(); goto end; } @@ -135,12 +135,12 @@ bad: if (len == 0) { break; } - if (sm3_hss_verify_update(&ctx, buf, len) != 1) { + if (hss_verify_update(&ctx, buf, len) != 1) { error_print(); goto end; } } - if ((vr = sm3_hss_verify_finish(&ctx)) < 0) { + if ((vr = hss_verify_finish(&ctx)) < 0) { error_print(); goto end; } diff --git a/tools/sm3lmskeygen.c b/tools/lmskeygen.c similarity index 86% rename from tools/sm3lmskeygen.c rename to tools/lmskeygen.c index edcb5ff4..c125f819 100644 --- a/tools/sm3lmskeygen.c +++ b/tools/lmskeygen.c @@ -14,7 +14,7 @@ #include #include #include -#include +#include static const char *usage = "-lms_type type -out file [-pubout file] [-verbose]\n"; @@ -32,7 +32,7 @@ static const char *options = " -verbose Print public key\n" "\n"; -int sm3lmskeygen_main(int argc, char **argv) +int lmskeygen_main(int argc, char **argv) { int ret = 1; char *prog = argv[0]; @@ -43,9 +43,9 @@ int sm3lmskeygen_main(int argc, char **argv) int verbose = 0; FILE *outfp = NULL; FILE *puboutfp = stdout; - SM3_LMS_KEY key; - uint8_t out[SM3_LMS_PRIVATE_KEY_SIZE]; - uint8_t pubout[SM3_LMS_PUBLIC_KEY_SIZE]; + LMS_KEY key; + uint8_t out[LMS_PRIVATE_KEY_SIZE]; + uint8_t pubout[LMS_PUBLIC_KEY_SIZE]; uint8_t *pout = out; uint8_t *ppubout = pubout; size_t outlen = 0, puboutlen = 0; @@ -67,7 +67,7 @@ int sm3lmskeygen_main(int argc, char **argv) } else if (!strcmp(*argv, "-lms_type")) { if (--argc < 1) goto bad; lms_type = *(++argv); - if (!(lms_type_val = sm3_lms_type_from_name(lms_type))) { + if (!(lms_type_val = lms_type_from_name(lms_type))) { fprintf(stderr, "%s: invalid lms_type `%s`\n", prog, lms_type); goto end; } @@ -108,15 +108,15 @@ bad: goto end; } - if (sm3_lms_key_generate(&key, lms_type_val) != 1) { + if (lms_key_generate(&key, lms_type_val) != 1) { error_print(); return -1; } if (verbose) { - sm3_lms_public_key_print(stderr, 0, 0, "lms_public_key", &key.public_key); + lms_public_key_print(stderr, 0, 0, "lms_public_key", &key.public_key); } - if (sm3_lms_private_key_to_bytes(&key, &pout, &outlen) != 1) { + if (lms_private_key_to_bytes(&key, &pout, &outlen) != 1) { error_print(); goto end; } @@ -125,7 +125,7 @@ bad: goto end; } - if (sm3_lms_public_key_to_bytes(&key, &ppubout, &puboutlen) != 1) { + if (lms_public_key_to_bytes(&key, &ppubout, &puboutlen) != 1) { error_print(); goto end; } diff --git a/tools/sm3lmssign.c b/tools/lmssign.c similarity index 83% rename from tools/sm3lmssign.c rename to tools/lmssign.c index e367afb9..73d4fafd 100644 --- a/tools/sm3lmssign.c +++ b/tools/lmssign.c @@ -14,7 +14,7 @@ #include #include #include -#include +#include static const char *usage = "-key file [-in file] [-out file] [-verbose]\n"; @@ -26,7 +26,7 @@ static const char *options = " -verbose Print public key and signature\n" "\n"; -int sm3lmssign_main(int argc, char **argv) +int lmssign_main(int argc, char **argv) { int ret = 1; char *prog = argv[0]; @@ -37,13 +37,13 @@ int sm3lmssign_main(int argc, char **argv) FILE *keyfp = NULL; FILE *infp = stdin; FILE *outfp = stdout; - uint8_t keybuf[SM3_LMS_PRIVATE_KEY_SIZE]; - size_t keylen = SM3_LMS_PRIVATE_KEY_SIZE; + uint8_t keybuf[LMS_PRIVATE_KEY_SIZE]; + size_t keylen = LMS_PRIVATE_KEY_SIZE; const uint8_t *cp = keybuf; uint8_t *p = keybuf; - SM3_LMS_KEY key; - SM3_LMS_SIGN_CTX ctx; - uint8_t sig[SM3_LMS_SIGNATURE_MAX_SIZE]; + LMS_KEY key; + LMS_SIGN_CTX ctx; + uint8_t sig[LMS_SIGNATURE_MAX_SIZE]; size_t siglen; argc--; @@ -104,7 +104,7 @@ bad: fprintf(stderr, "%s: read private key failure\n", prog); goto end; } - if (sm3_lms_private_key_from_bytes(&key, &cp, &keylen) != 1) { + if (lms_private_key_from_bytes(&key, &cp, &keylen) != 1) { error_print(); goto end; } @@ -114,17 +114,17 @@ bad: } if (verbose) { - sm3_lms_public_key_print(stderr, 0, 0, "lms_public_key", &key.public_key); + lms_public_key_print(stderr, 0, 0, "lms_public_key", &key.public_key); } - if (sm3_lms_sign_init(&ctx, &key) != 1) { + if (lms_sign_init(&ctx, &key) != 1) { error_print(); goto end; } // write updated key back to file // TODO: write back `q` only - if (sm3_lms_private_key_to_bytes(&key, &p, &keylen) != 1) { + if (lms_private_key_to_bytes(&key, &p, &keylen) != 1) { error_print(); return -1; } @@ -140,12 +140,12 @@ bad: if (len == 0) { break; } - if (sm3_lms_sign_update(&ctx, buf, len) != 1) { + if (lms_sign_update(&ctx, buf, len) != 1) { error_print(); goto end; } } - if (sm3_lms_sign_finish(&ctx, sig, &siglen) != 1) { + if (lms_sign_finish(&ctx, sig, &siglen) != 1) { error_print(); goto end; } @@ -154,7 +154,7 @@ bad: goto end; } if (verbose) { - sm3_lms_signature_print(stderr, 0, 0, "lms_signature", sig, siglen); + lms_signature_print(stderr, 0, 0, "lms_signature", sig, siglen); } ret = 0; diff --git a/tools/sm3lmsverify.c b/tools/lmsverify.c similarity index 82% rename from tools/sm3lmsverify.c rename to tools/lmsverify.c index f492369f..e68d0638 100644 --- a/tools/sm3lmsverify.c +++ b/tools/lmsverify.c @@ -14,7 +14,7 @@ #include #include #include -#include +#include static const char *usage = "-pubkey file [-in file] -sig file [-verbose]\n"; @@ -26,7 +26,7 @@ static const char *options = " -verbose Print public key and signature\n" "\n"; -int sm3lmsverify_main(int argc, char **argv) +int lmsverify_main(int argc, char **argv) { int ret = 1; char *prog = argv[0]; @@ -37,13 +37,13 @@ int sm3lmsverify_main(int argc, char **argv) FILE *pubkeyfp = NULL; FILE *infp = stdin; FILE *sigfp = NULL; - uint8_t pubkeybuf[SM3_LMS_PUBLIC_KEY_SIZE]; - size_t pubkeylen = SM3_LMS_PUBLIC_KEY_SIZE; + uint8_t pubkeybuf[LMS_PUBLIC_KEY_SIZE]; + size_t pubkeylen = LMS_PUBLIC_KEY_SIZE; const uint8_t *cp = pubkeybuf; - uint8_t sig[SM3_LMS_SIGNATURE_MAX_SIZE]; + uint8_t sig[LMS_SIGNATURE_MAX_SIZE]; size_t siglen; - SM3_LMS_KEY key; - SM3_LMS_SIGN_CTX ctx; + LMS_KEY key; + LMS_SIGN_CTX ctx; int vr; argc--; @@ -108,23 +108,23 @@ bad: fprintf(stderr, "%s: read public key failure\n", prog); goto end; } - if (sm3_lms_public_key_from_bytes(&key, &cp, &pubkeylen) != 1) { + if (lms_public_key_from_bytes(&key, &cp, &pubkeylen) != 1) { error_print(); goto end; } if (verbose) { - sm3_lms_public_key_print(stderr, 0, 0, "lms_public_key", &key.public_key); + lms_public_key_print(stderr, 0, 0, "lms_public_key", &key.public_key); } // read signature even if signature not compatible with the public key - if ((siglen = fread(sig, 1, SM3_LMS_SIGNATURE_MAX_SIZE, sigfp)) <= 0) { + if ((siglen = fread(sig, 1, LMS_SIGNATURE_MAX_SIZE, sigfp)) <= 0) { fprintf(stderr, "%s: read signature failure\n", prog); goto end; } if (verbose) { - sm3_lms_signature_print(stderr, 0, 0, "lms_signature", sig, siglen); + lms_signature_print(stderr, 0, 0, "lms_signature", sig, siglen); } - if (sm3_lms_verify_init(&ctx, &key, sig, siglen) != 1) { + if (lms_verify_init(&ctx, &key, sig, siglen) != 1) { error_print(); goto end; } @@ -135,12 +135,12 @@ bad: if (len == 0) { break; } - if (sm3_lms_verify_update(&ctx, buf, len) != 1) { + if (lms_verify_update(&ctx, buf, len) != 1) { error_print(); goto end; } } - if ((vr = sm3_lms_verify_finish(&ctx)) < 0) { + if ((vr = lms_verify_finish(&ctx)) < 0) { error_print(); goto end; }