adopting PK::ECC to the new libtomcrypt API

Author: karel-m

inc/CryptX_PK_ECC.xs.inc

@@ -421,6 +421,7 @@ sign_hash(Crypt::PK::ECC self, SV * data, const char * hash_name = NULL, const c
         unsigned char buffer[1024], tmp[MAXBLOCKSIZE], *data_ptr = NULL;
         unsigned long tmp_len = MAXBLOCKSIZE, buffer_len = 1024;
         STRLEN data_len = 0;
+        ltc_ecc_sig_opts sig_opts = { .prng = &self->pstate, .wprng = self->pindex, .type = LTC_ECCSIG_ANSIX962 };
 
         // Handle dual signature modes for backward compatibility
         // For sign_hash_*: if only 2 params passed, treat second as RFC6979 hash
@@ -445,30 +446,28 @@ sign_hash(Crypt::PK::ECC self, SV * data, const char * hash_name = NULL, const c
         if (hash_rfc6979_name != NULL) {
           hash_rfc6979_id = cryptx_internal_find_hash(hash_rfc6979_name);
           if (hash_rfc6979_id == -1) croak("FATAL: find_hash failed for rfc6979 hash '%s'", hash_rfc6979_name);
-          ECC_SET_RFC6979_HASH_ALG(&self->key, hash_descriptor[hash_rfc6979_id].name);
+          sig_opts.rfc6979_hash_alg = hash_descriptor[hash_rfc6979_id].name;
         } else {
           // Clear any previously set RFC6979 hash to ensure non-deterministic signing
           // when RFC6979 parameter is not provided. This prevents hidden state from
           // previous method calls affecting current signature behavior.
-          ECC_SET_RFC6979_HASH_ALG(&self->key, NULL);
+          sig_opts.rfc6979_hash_alg = NULL;
         }
 
         if (ix == 2 || ix == 3) {
-          rv = ecc_sign_hash_rfc7518(data_ptr, (unsigned long)data_len, buffer, &buffer_len,
-                             &self->pstate, self->pindex,
-                             &self->key);
+          /* rfc7518 */
+          sig_opts.type = LTC_ECCSIG_RFC7518;
         }
         else if (ix == 4) {
-          rv = ecc_sign_hash_eth27(data_ptr, (unsigned long)data_len, buffer, &buffer_len,
-                             &self->pstate, self->pindex,
-                             &self->key);
+          /* eth27 */
+          sig_opts.type = LTC_ECCSIG_ETH27;
         }
         else {
-          rv = ecc_sign_hash(data_ptr, (unsigned long)data_len, buffer, &buffer_len,
-                             &self->pstate, self->pindex,
-                             &self->key);
+          /* default */
+          sig_opts.type = LTC_ECCSIG_ANSIX962;
         }
-        if (rv != CRYPT_OK) croak("FATAL: ecc_sign_hash_ex failed: %s", error_to_string(rv));
+        rv = ecc_sign_hash_v2(data_ptr, (unsigned long)data_len, buffer, &buffer_len, &sig_opts, &self->key);
+        if (rv != CRYPT_OK) croak("FATAL: ecc_sign_hash_v2 failed: %s", error_to_string(rv));
         RETVAL = newSVpvn((char*)buffer, buffer_len);
     }
     OUTPUT:
@@ -487,6 +486,7 @@ verify_hash(Crypt::PK::ECC self, SV * sig, SV * data, const char * hash_name = "
         unsigned char tmp[MAXBLOCKSIZE], *data_ptr = NULL, *sig_ptr = NULL;
         unsigned long tmp_len = MAXBLOCKSIZE;
         STRLEN data_len = 0, sig_len = 0;
+        ltc_ecc_sig_opts sig_opts = { .prng = &self->pstate, .wprng = self->pindex, .type = LTC_ECCSIG_ANSIX962 };
 
         data_ptr = (unsigned char *)SvPVbyte(data, data_len);
         sig_ptr = (unsigned char *)SvPVbyte(sig, sig_len);
@@ -501,14 +501,18 @@ verify_hash(Crypt::PK::ECC self, SV * sig, SV * data, const char * hash_name = "
         RETVAL = 1;
         stat = 0;
         if (ix == 2 || ix == 3) {
-          rv = ecc_verify_hash_rfc7518(sig_ptr, (unsigned long)sig_len, data_ptr, (unsigned long)data_len, &stat, &self->key);
+          /* rfc7518 */
+          sig_opts.type = LTC_ECCSIG_RFC7518;
         }
         else if (ix == 4) {
-          rv = ecc_verify_hash_eth27(sig_ptr, (unsigned long)sig_len, data_ptr, (unsigned long)data_len, &stat, &self->key);
+          /* eth27 */
+          sig_opts.type = LTC_ECCSIG_ETH27;
         }
         else {
-          rv = ecc_verify_hash(sig_ptr, (unsigned long)sig_len, data_ptr, (unsigned long)data_len, &stat, &self->key);
+          /* default */
+          sig_opts.type = LTC_ECCSIG_ANSIX962;
         }
+        rv = ecc_verify_hash_v2(sig_ptr, (unsigned long)sig_len, data_ptr, (unsigned long)data_len, &sig_opts, &stat, &self->key);
         if (rv != CRYPT_OK || stat != 1) RETVAL = 0;
     }
     OUTPUT:
@@ -536,38 +540,35 @@ recovery_pub(Crypt::PK::ECC self, SV * sig, SV* hash, SV* recid = NULL)
         recovery_pub_eth     = 2
     CODE:
     {
-        int rv;
+        int rv, r = -1;
         unsigned char *sig_ptr = NULL, *hash_ptr = NULL;
         STRLEN hash_len = 0, sig_len = 0;
-        int recovery_id = -1;
+        ltc_ecc_sig_opts sig_opts = { .prng = &self->pstate, .wprng = self->pindex, .type = LTC_ECCSIG_ANSIX962 };
 
         if (recid != NULL) {
-          recovery_id = (int) SvIV(recid);
-        } else if (ix != 2) {
+          r = (int) SvIV(recid);
+        }
+        else if (ix != 2) {
           if (ix == 1) {
             croak("FATAL: recovery_pub_rfc7518 requires recid argument");
           } else {
             croak("FATAL: recovery_pub requires recid argument");
           }
         }
+        sig_opts.recid = &r;
 
         sig_ptr = (unsigned char *)SvPVbyte(sig, sig_len);
         hash_ptr = (unsigned char *)SvPVbyte(hash, hash_len);
         if (ix == 1) {
-          rv = ecc_recover_key(sig_ptr, (unsigned long)sig_len, hash_ptr, (unsigned long) hash_len,
-                               recovery_id, LTC_ECCSIG_RFC7518, &self->key);
+          sig_opts.type = LTC_ECCSIG_RFC7518;
         }
         else if (ix == 2) {
-          /* Ethereum's signature contains the recovery id in the last byte of the signature
-           * don't need to pass it as a separate argument
-           */
-          rv = ecc_recover_key(sig_ptr, (unsigned long)sig_len, hash_ptr, (unsigned long) hash_len,
-                               recovery_id, LTC_ECCSIG_ETH27, &self->key);
+          sig_opts.type = LTC_ECCSIG_ETH27;
         }
         else {
-          rv = ecc_recover_key(sig_ptr, (unsigned long)sig_len, hash_ptr, (unsigned long) hash_len,
-                               recovery_id, LTC_ECCSIG_ANSIX962, &self->key);
+          sig_opts.type = LTC_ECCSIG_ANSIX962;
         }
+        rv = ecc_recover_key(sig_ptr, (unsigned long)sig_len, hash_ptr, (unsigned long) hash_len, &sig_opts, &self->key);
         if (rv != CRYPT_OK) croak("FATAL: ecc_recover_key failed: %s", error_to_string(rv));
         RETVAL = 1;
     }