The hash type is passed by parameter replace of existing global variable

Author: joii2020

Makefile

@@ -6,7 +6,7 @@ LD := $(TARGET)gcc
 CFLAGS := -fPIC -O3 -fno-builtin-printf -fno-builtin-memcmp -nostdinc -nostartfiles -fvisibility=hidden -fdata-sections -ffunction-sections -nostdlib -Wno-nonnull-compare -DCKB_VM -DCKB_DECLARATION_ONLY
 LDFLAGS := -fdata-sections -ffunction-sections
 
-CFLAGS := $(CFLAGS) -Wall -Werror -Wno-nonnull  -Wno-unused-function -g
+CFLAGS := $(CFLAGS) -Wall -Werror -Wno-nonnull  -Wno-unused-function
 LDFLAGS := $(LDFLAGS) -Wl,-static -Wl,--gc-sections
 
 CFLAGS := $(CFLAGS) -I c -I deps/ckb-c-stdlib/libc -I deps/ckb-c-stdlib -I deps/ckb-c-stdlib/molecule
@@ -69,7 +69,7 @@ SOURCES += \
 HEADERS += \
 	c/$(SOURCES_DIR)/haraka.h
 
-CFLAGS := $(CFLAGS) -DCKB_C_STDLIB_PRINTF
+CFLAGS := $(CFLAGS) -g -DCKB_C_STDLIB_PRINTF
 
 # docker pull nervos/ckb-riscv-gnu-toolchain:gnu-bionic-20191012
 BUILDER_DOCKER := nervos/ckb-riscv-gnu-toolchain@sha256:aae8a3f79705f67d505d1f1d5ddc694a4fd537ed1c7e9622420a470d59ba2ec3

c/ckb-sphincsplus-lock.c

@@ -226,9 +226,9 @@ int make_witness(WitnessArgsType *witness) {
   return 0;
 }
 
-int get_sign(uint8_t *sign) {
+int get_sign(uint8_t *sign, crypto_context *cctx) {
   int err = CKB_SUCCESS;
-  size_t sign_size = sphincs_plus_get_sign_size();
+  size_t sign_size = sphincs_plus_get_sign_size(cctx);
   WitnessArgsType witness_args;
 
   uint8_t witness_data_source[MAX_WITNESS_SIZE] = {0};
@@ -252,7 +252,7 @@ int get_sign(uint8_t *sign) {
 // |  hash type 4 bytes  |  public key  |
 //
 // note: different hash types have different public key lengths
-int get_public_key(uint8_t *pub_key) {
+int get_public_key(uint8_t *pub_key, crypto_context *cctx) {
   int err = CKB_SUCCESS;
 
   uint8_t script[SCRIPT_SIZE];
@@ -269,9 +269,10 @@ int get_public_key(uint8_t *pub_key) {
   CHECK2((args_bytes_seg.size > sizeof(uint32_t)), ERROR_SPHINCSPLUS_ARGS);
   uint32_t hash_type = 0;
   memcpy(&hash_type, args_bytes_seg.ptr, sizeof(uint32_t));
-  CHECK2(!sphincs_plus_init(hash_type), ERROR_SPHINCSPLUS_HASH_TYPE);
+  CHECK2(!sphincs_plus_init_context(hash_type, cctx),
+         ERROR_SPHINCSPLUS_HASH_TYPE);
 
-  size_t pubkey_size = sphincs_plus_get_pk_size();
+  size_t pubkey_size = sphincs_plus_get_pk_size(cctx);
   CHECK2((args_bytes_seg.size == sizeof(uint32_t)) + pubkey_size,
          ERROR_SPHINCSPLUS_ARGS);
   memcpy(pub_key, args_bytes_seg.ptr + sizeof(uint32_t), pubkey_size);
@@ -285,19 +286,20 @@ int main() {
 
   // signature data size depends on args data(hash type)
   uint8_t pubkey[SPHINCSPLUS_PUBKEY_MAX_SIZE];
-  err = get_public_key(pubkey);
+  crypto_context cctx = {0};
+  err = get_public_key(pubkey, &cctx);
   if (err) {
     return err;
   }
 
   uint8_t message[BLAKE2B_BLOCK_SIZE];
-  uint8_t sign[sphincs_plus_get_sign_size()];
+  uint8_t sign[sphincs_plus_get_sign_size(&cctx)];
   CHECK(generate_sighash_all(message, BLAKE2B_BLOCK_SIZE));
 
-  CHECK(get_sign(sign));
-  err = sphincs_plus_verify(sign, sphincs_plus_get_sign_size(), message,
-                            BLAKE2B_BLOCK_SIZE, pubkey,
-                            sphincs_plus_get_pk_size());
+  CHECK(get_sign(sign, &cctx));
+  err = sphincs_plus_verify(&cctx, sign, sphincs_plus_get_sign_size(&cctx),
+                            message, BLAKE2B_BLOCK_SIZE, pubkey,
+                            sphincs_plus_get_pk_size(&cctx));
   CHECK2(err == 0, ERROR_SPHINCSPLUS_VERIFY);
 
 exit:

c/ckb-sphincsplus.c

@@ -20,45 +20,73 @@ enum SphincsPlusError {
   SphincsPlusError_Verify,
   SphincsPlusError_Verify_MsgLen,
   SphincsPlusError_Verify_MsgCmp,
-
 };
 
-uint32_t sphincs_plus_get_pk_size() { return SPX_PK_BYTES; }
-uint32_t sphincs_plus_get_sk_size() { return SPX_SK_BYTES; }
-uint32_t sphincs_plus_get_sign_size() { return SPX_BYTES + SPX_MLEN; }
+#ifndef CKB_VM
+
+#include <stdlib.h>
+
+crypto_context *sphincs_plus_new_context(crypto_type type) {
+  crypto_context *cctx = (crypto_context *)malloc(sizeof(crypto_context));
+  int err = crypto_init_context(type, cctx);
+  ASSERT(err == 0);
+  return cctx;
+}
+
+void sphincs_plus_del_context(crypto_context *cctx) { free(cctx); }
+
+#endif  // CKB_VM
+
+int sphincs_plus_init_context(crypto_type type, crypto_context *cctx) {
+  memset(cctx, 0, sizeof(crypto_context));
+  return crypto_init_context(type, cctx);
+}
+
+uint32_t sphincs_plus_get_pk_size(crypto_context *cctx) {
+  return cctx->spx_pk_bytes;
+}
+
+uint32_t sphincs_plus_get_sk_size(crypto_context *cctx) {
+  return cctx->spx_sk_bytes;
+}
 
-int sphincs_plus_init(crypto_type type) { return crypto_init_context(type); }
+uint32_t sphincs_plus_get_sign_size(crypto_context *cctx) {
+  return cctx->spx_bytes + SPX_MLEN;
+}
 
 #ifndef CKB_VM
 
-int sphincs_plus_generate_keypair(uint8_t *pk, uint8_t *sk) {
-  return crypto_sign_keypair(pk, sk);
+int sphincs_plus_generate_keypair(crypto_context *cctx, uint8_t *pk,
+                                  uint8_t *sk) {
+  return crypto_sign_keypair(cctx, pk, sk);
 }
 
-int sphincs_plus_sign(uint8_t *message, uint8_t *sk, uint8_t *out_sign) {
-  unsigned long long out_sign_len = sphincs_plus_get_sign_size();
-  int ret = crypto_sign(out_sign, (unsigned long long *)&out_sign_len, message,
-                        SPX_MLEN, sk);
-  if ((uint32_t)out_sign_len != sphincs_plus_get_sign_size()) {
+int sphincs_plus_sign(crypto_context *cctx, uint8_t *message, uint8_t *sk,
+                      uint8_t *out_sign) {
+  unsigned long long out_sign_len = sphincs_plus_get_sign_size(cctx);
+  int ret = crypto_sign(cctx, out_sign, (unsigned long long *)&out_sign_len,
+                        message, SPX_MLEN, sk);
+  if ((uint32_t)out_sign_len != sphincs_plus_get_sign_size(cctx)) {
     return 1;
   }
   return ret;
 }
 
 #endif  // CKB_VM
 
-int sphincs_plus_verify(uint8_t *sign, uint32_t sign_size, uint8_t *message,
-                        uint32_t message_size, uint8_t *pubkey,
-                        uint32_t pubkey_size) {
-  if (sign_size != sphincs_plus_get_sign_size() || message_size != SPX_MLEN ||
-      pubkey_size != sphincs_plus_get_pk_size()) {
+int sphincs_plus_verify(crypto_context *cctx, uint8_t *sign, uint32_t sign_size,
+                        uint8_t *message, uint32_t message_size,
+                        uint8_t *pubkey, uint32_t pubkey_size) {
+  size_t sign_len = sphincs_plus_get_sign_size(cctx);
+
+  if (sign_size != sign_len || message_size != SPX_MLEN ||
+      pubkey_size != sphincs_plus_get_pk_size(cctx)) {
     return SphincsPlusError_Params;
   }
   unsigned char mout[SPX_BYTES + SPX_MLEN];
   unsigned long long mlen = 0;
 
-  size_t sign_len = sphincs_plus_get_sign_size();
-  int err = crypto_sign_open(mout, &mlen, sign, sign_len, pubkey);
+  int err = crypto_sign_open(cctx, mout, &mlen, sign, sign_len, pubkey);
   if (err != 0) {
     return SphincsPlusError_Verify;
   }

c/ckb-sphincsplus.h

@@ -5,17 +5,26 @@
 
 #define SPX_MLEN 32
 
-uint32_t sphincs_plus_get_pk_size();
-uint32_t sphincs_plus_get_sk_size();
-uint32_t sphincs_plus_get_sign_size();
+#ifndef CKB_VM
+
+crypto_context *sphincs_plus_new_context(crypto_type type);
+void sphincs_plus_del_context(crypto_context *cctx);
+
+#endif  // CKB_VM
+
+uint32_t sphincs_plus_get_pk_size(crypto_context *cctx);
+uint32_t sphincs_plus_get_sk_size(crypto_context *cctx);
+uint32_t sphincs_plus_get_sign_size(crypto_context *cctx);
 
-int sphincs_plus_init(crypto_type type);
+int sphincs_plus_init_context(crypto_type type, crypto_context *cctx);
 
 #ifndef CKB_VM
-int sphincs_plus_generate_keypair(uint8_t *pk, uint8_t *sk);
-int sphincs_plus_sign(uint8_t *message, uint8_t *sk, uint8_t *out_sign);
+int sphincs_plus_generate_keypair(crypto_context *cctx, uint8_t *pk,
+                                  uint8_t *sk);
+int sphincs_plus_sign(crypto_context *cctx, uint8_t *message, uint8_t *sk,
+                      uint8_t *out_sign);
 #endif  // !CKB_VM
 
-int sphincs_plus_verify(uint8_t *sign, uint32_t sign_size, uint8_t *message,
-                        uint32_t message_size, uint8_t *pubkey,
-                        uint32_t pubkey_size);
+int sphincs_plus_verify(crypto_context *cctx, uint8_t *sign, uint32_t sign_size,
+                        uint8_t *message, uint32_t message_size,
+                        uint8_t *pubkey, uint32_t pubkey_size);

c/ref/address.c

@@ -9,15 +9,15 @@
 /*
  * Specify which level of Merkle tree (the "layer") we're working on
  */
-void set_layer_addr(uint32_t addr[8], uint32_t layer) {
+void set_layer_addr(crypto_context *cctx, uint32_t addr[8], uint32_t layer) {
   ((unsigned char *)addr)[SPX_OFFSET_LAYER] = (unsigned char)layer;
 }
 
 /*
  * Specify which Merkle tree within the level (the "tree address") we're working
  * on
  */
-void set_tree_addr(uint32_t addr[8], uint64_t tree) {
+void set_tree_addr(crypto_context *cctx, uint32_t addr[8], uint64_t tree) {
   ASSERT((SPX_TREE_HEIGHT * (SPX_D - 1)) <= 64);
   ull_to_bytes(&((unsigned char *)addr)[SPX_OFFSET_TREE], 8, tree);
 }
@@ -28,15 +28,16 @@ void set_tree_addr(uint32_t addr[8], uint64_t tree) {
  * hashes don't accidentally get the same address structure.  The type will be
  * one of the SPX_ADDR_TYPE constants
  */
-void set_type(uint32_t addr[8], uint32_t type) {
+void set_type(crypto_context *cctx, uint32_t addr[8], uint32_t type) {
   ((unsigned char *)addr)[SPX_OFFSET_TYPE] = (unsigned char)type;
 }
 
 /*
  * Copy the layer and tree fields of the address structure.  This is used
  * when we're doing multiple types of hashes within the same Merkle tree
  */
-void copy_subtree_addr(uint32_t out[8], const uint32_t in[8]) {
+void copy_subtree_addr(crypto_context *cctx, uint32_t out[8],
+                       const uint32_t in[8]) {
   memcpy(out, in, SPX_OFFSET_TREE + 8);
 }
 
@@ -46,7 +47,8 @@ void copy_subtree_addr(uint32_t out[8], const uint32_t in[8]) {
  * Specify which Merkle leaf we're working on; that is, which OTS keypair
  * we're talking about.
  */
-void set_keypair_addr(uint32_t addr[8], uint32_t keypair) {
+void set_keypair_addr(crypto_context *cctx, uint32_t addr[8],
+                      uint32_t keypair) {
   if (SPX_FULL_HEIGHT / SPX_D > 8) {
     /* We have > 256 OTS at the bottom of the Merkle tree; to specify */
     /* which one, we'd need to express it in two bytes */
@@ -60,7 +62,8 @@ void set_keypair_addr(uint32_t addr[8], uint32_t keypair) {
  * Copy the layer, tree and keypair fields of the address structure.  This is
  * used when we're doing multiple things within the same OTS keypair
  */
-void copy_keypair_addr(uint32_t out[8], const uint32_t in[8]) {
+void copy_keypair_addr(crypto_context *cctx, uint32_t out[8],
+                       const uint32_t in[8]) {
   memcpy(out, in, SPX_OFFSET_TREE + 8);
   if (SPX_FULL_HEIGHT / SPX_D > 8) {
     ((unsigned char *)out)[SPX_OFFSET_KP_ADDR2] =
@@ -74,15 +77,15 @@ void copy_keypair_addr(uint32_t out[8], const uint32_t in[8]) {
  * Specify which Merkle chain within the OTS we're working with
  * (the chain address)
  */
-void set_chain_addr(uint32_t addr[8], uint32_t chain) {
+void set_chain_addr(crypto_context *cctx, uint32_t addr[8], uint32_t chain) {
   ((unsigned char *)addr)[SPX_OFFSET_CHAIN_ADDR] = (unsigned char)chain;
 }
 
 /*
  * Specify where in the Merkle chain we are
  * (the hash address)
  */
-void set_hash_addr(uint32_t addr[8], uint32_t hash) {
+void set_hash_addr(crypto_context *cctx, uint32_t addr[8], uint32_t hash) {
   ((unsigned char *)addr)[SPX_OFFSET_HASH_ADDR] = (unsigned char)hash;
 }
 
@@ -92,14 +95,16 @@ void set_hash_addr(uint32_t addr[8], uint32_t hash) {
  * Specify the height of the node in the Merkle/FORS tree we are in
  * (the tree height)
  */
-void set_tree_height(uint32_t addr[8], uint32_t tree_height) {
+void set_tree_height(crypto_context *cctx, uint32_t addr[8],
+                     uint32_t tree_height) {
   ((unsigned char *)addr)[SPX_OFFSET_TREE_HGT] = (unsigned char)tree_height;
 }
 
 /*
  * Specify the distance from the left edge of the node in the Merkle/FORS tree
  * (the tree index)
  */
-void set_tree_index(uint32_t addr[8], uint32_t tree_index) {
+void set_tree_index(crypto_context *cctx, uint32_t addr[8],
+                    uint32_t tree_index) {
   u32_to_bytes(&((unsigned char *)addr)[SPX_OFFSET_TREE_INDEX], tree_index);
 }

c/ref/address.h

@@ -15,38 +15,42 @@
 #define SPX_ADDR_TYPE_FORSPRF 6
 
 #define set_layer_addr SPX_NAMESPACE(set_layer_addr)
-void set_layer_addr(uint32_t addr[8], uint32_t layer);
+void set_layer_addr(crypto_context *cctx, uint32_t addr[8], uint32_t layer);
 
 #define set_tree_addr SPX_NAMESPACE(set_tree_addr)
-void set_tree_addr(uint32_t addr[8], uint64_t tree);
+void set_tree_addr(crypto_context *cctx, uint32_t addr[8], uint64_t tree);
 
 #define set_type SPX_NAMESPACE(set_type)
-void set_type(uint32_t addr[8], uint32_t type);
+void set_type(crypto_context *cctx, uint32_t addr[8], uint32_t type);
 
 /* Copies the layer and tree part of one address into the other */
 #define copy_subtree_addr SPX_NAMESPACE(copy_subtree_addr)
-void copy_subtree_addr(uint32_t out[8], const uint32_t in[8]);
+void copy_subtree_addr(crypto_context *cctx, uint32_t out[8],
+                       const uint32_t in[8]);
 
 /* These functions are used for WOTS and FORS addresses. */
 
 #define set_keypair_addr SPX_NAMESPACE(set_keypair_addr)
-void set_keypair_addr(uint32_t addr[8], uint32_t keypair);
+void set_keypair_addr(crypto_context *cctx, uint32_t addr[8], uint32_t keypair);
 
 #define set_chain_addr SPX_NAMESPACE(set_chain_addr)
-void set_chain_addr(uint32_t addr[8], uint32_t chain);
+void set_chain_addr(crypto_context *cctx, uint32_t addr[8], uint32_t chain);
 
 #define set_hash_addr SPX_NAMESPACE(set_hash_addr)
-void set_hash_addr(uint32_t addr[8], uint32_t hash);
+void set_hash_addr(crypto_context *cctx, uint32_t addr[8], uint32_t hash);
 
 #define copy_keypair_addr SPX_NAMESPACE(copy_keypair_addr)
-void copy_keypair_addr(uint32_t out[8], const uint32_t in[8]);
+void copy_keypair_addr(crypto_context *cctx, uint32_t out[8],
+                       const uint32_t in[8]);
 
 /* These functions are used for all hash tree addresses (including FORS). */
 
 #define set_tree_height SPX_NAMESPACE(set_tree_height)
-void set_tree_height(uint32_t addr[8], uint32_t tree_height);
+void set_tree_height(crypto_context *cctx, uint32_t addr[8],
+                     uint32_t tree_height);
 
 #define set_tree_index SPX_NAMESPACE(set_tree_index)
-void set_tree_index(uint32_t addr[8], uint32_t tree_index);
+void set_tree_index(crypto_context *cctx, uint32_t addr[8],
+                    uint32_t tree_index);
 
 #endif