adapt to rippled change to uncompressed 33-byte key

yinyiqian1 · yinyiqian1 · commit 768a3630ad8c · 2026-02-20T19:58:05.000-05:00
diff --git a/include/utility/mpt_utility.h b/include/utility/mpt_utility.h
@@ -19,14 +19,14 @@ extern "C" {
 
 // General crypto primitive sizes in bytes
 #define kMPT_HALF_SHA_SIZE 32
-#define kMPT_PUBKEY_SIZE 64
+#define kMPT_PUBKEY_SIZE 33
 #define kMPT_PRIVKEY_SIZE 32
 #define kMPT_BLINDING_FACTOR_SIZE 32
 
 // Gamal & Pedersen primitive sizes in bytes
 #define kMPT_ELGAMAL_CIPHER_SIZE 33
 #define kMPT_ELGAMAL_TOTAL_SIZE 66
-#define kMPT_PEDERSEN_COMMIT_SIZE 64
+#define kMPT_PEDERSEN_COMMIT_SIZE 33
 
 // Proof sizes in bytes
 #define kMPT_SCHNORR_PROOF_SIZE 65
diff --git a/src/utility/mpt_utility.cpp b/src/utility/mpt_utility.cpp
@@ -333,7 +333,9 @@ mpt_generate_keypair(uint8_t* out_privkey, uint8_t* out_pubkey)
     if (secp256k1_elgamal_generate_keypair(ctx, out_privkey, &pub) != 1)
         return -1;
 
-    std::memcpy(out_pubkey, pub.data, kMPT_PUBKEY_SIZE);
+    size_t output_len = kMPT_PUBKEY_SIZE;
+    if (secp256k1_ec_pubkey_serialize(ctx, out_pubkey, &output_len, &pub, SECP256K1_EC_COMPRESSED) != 1)
+        return -1;
 
     return 0;
 }
@@ -365,7 +367,8 @@ mpt_encrypt_amount(
         return -1;
 
     secp256k1_pubkey c1, c2, pk;
-    std::memcpy(pk.data, pubkey, kMPT_PUBKEY_SIZE);
+    if (secp256k1_ec_pubkey_parse(ctx, &pk, pubkey, kMPT_PUBKEY_SIZE) != 1)
+        return -1;
 
     if (!secp256k1_elgamal_encrypt(ctx, &c1, &c2, &pk, amount, blinding_factor))
         return -1;
@@ -415,7 +418,8 @@ mpt_get_convert_proof(
         return -1;
 
     secp256k1_pubkey pk;
-    std::memcpy(pk.data, pubkey, kMPT_PUBKEY_SIZE);
+    if (secp256k1_ec_pubkey_parse(ctx, &pk, pubkey, kMPT_PUBKEY_SIZE) != 1)
+        return -1;
 
     if (secp256k1_mpt_pok_sk_prove(ctx, out_proof, &pk, privkey, ctx_hash) != 1)
         return -1;
@@ -447,7 +451,9 @@ mpt_get_pedersen_commitment(
     if (secp256k1_mpt_pedersen_commit(ctx, &commitment, amount, blinding_factor) != 1)
         return -1;
 
-    std::memcpy(out_commitment, commitment.data, kMPT_PEDERSEN_COMMIT_SIZE);
+    size_t output_len = kMPT_PEDERSEN_COMMIT_SIZE;
+    if (secp256k1_ec_pubkey_serialize(ctx, out_commitment, &output_len, &commitment, SECP256K1_EC_COMPRESSED) != 1)
+        return -1;
 
     return 0;
 }
@@ -467,17 +473,19 @@ mpt_get_amount_linkage_proof(
     if (!ctx)
         return -1;
 
-    secp256k1_pubkey c1, c2;
+    secp256k1_pubkey c1, c2, pk, pcm;
     if (!secp256k1_ec_pubkey_parse(ctx, &c1, params->encrypted_amount, kMPT_ELGAMAL_CIPHER_SIZE))
         return -1;
 
     if (!secp256k1_ec_pubkey_parse(
             ctx, &c2, params->encrypted_amount + kMPT_ELGAMAL_CIPHER_SIZE, kMPT_ELGAMAL_CIPHER_SIZE))
         return -1;
 
-    secp256k1_pubkey pk, pcm;
-    std::memcpy(pk.data, pubkey, kMPT_PUBKEY_SIZE);
-    std::memcpy(pcm.data, params->pedersen_commitment, kMPT_PEDERSEN_COMMIT_SIZE);
+    if (secp256k1_ec_pubkey_parse(ctx, &pk, pubkey, kMPT_PUBKEY_SIZE) != 1)
+        return -1;
+
+    if (secp256k1_ec_pubkey_parse(ctx, &pcm, params->pedersen_commitment, kMPT_PEDERSEN_COMMIT_SIZE) != 1)
+        return -1;
 
     if (secp256k1_elgamal_pedersen_link_prove(
             ctx,
@@ -512,17 +520,19 @@ mpt_get_balance_linkage_proof(
     if (!ctx)
         return -1;
 
-    secp256k1_pubkey c1, c2;
+    secp256k1_pubkey c1, c2, pk, pcm;
     if (!secp256k1_ec_pubkey_parse(ctx, &c1, params->encrypted_amount, kMPT_ELGAMAL_CIPHER_SIZE))
         return -1;
 
     if (!secp256k1_ec_pubkey_parse(
             ctx, &c2, params->encrypted_amount + kMPT_ELGAMAL_CIPHER_SIZE, kMPT_ELGAMAL_CIPHER_SIZE))
         return -1;
 
-    secp256k1_pubkey pk, pcm;
-    std::memcpy(pk.data, pub, kMPT_PUBKEY_SIZE);
-    std::memcpy(pcm.data, params->pedersen_commitment, kMPT_PEDERSEN_COMMIT_SIZE);
+    if (secp256k1_ec_pubkey_parse(ctx, &pk, pub, kMPT_PUBKEY_SIZE) != 1)
+        return -1;
+
+    if (secp256k1_ec_pubkey_parse(ctx, &pcm, params->pedersen_commitment, kMPT_PEDERSEN_COMMIT_SIZE) != 1)
+        return -1;
 
     if (secp256k1_elgamal_pedersen_link_prove(
             ctx,
@@ -580,7 +590,9 @@ mpt_get_confidential_send_proof(
                 ctx, &s[i], rec.encrypted_amount + kMPT_ELGAMAL_CIPHER_SIZE, kMPT_ELGAMAL_CIPHER_SIZE))
             return -1;
 
-        std::memcpy(pk[i].data, rec.pubkey, kMPT_PUBKEY_SIZE);
+        if (secp256k1_ec_pubkey_parse(ctx, &pk[i], rec.pubkey, kMPT_PUBKEY_SIZE) != 1)
+            return -1;
+
         sr.insert(sr.end(), tx_blinding_factor, tx_blinding_factor + kMPT_BLINDING_FACTOR_SIZE);
     }
 
@@ -609,14 +621,14 @@ mpt_get_confidential_send_proof(
     // Amount Linkage Proof
     uint8_t* amt_ptr = out_proof + size_equality;
     if (mpt_get_amount_linkage_proof(
-            pk[0].data, tx_blinding_factor, context_hash, amount_params, amt_ptr) != 0)
+            recipients[0].pubkey, tx_blinding_factor, context_hash, amount_params, amt_ptr) != 0)
     {
         return -1;
     }
 
     // Balance Linkage Proof
     uint8_t* bal_ptr = amt_ptr + kMPT_PEDERSEN_LINK_SIZE;
-    if (mpt_get_balance_linkage_proof(priv, pk[0].data, context_hash, balance_params, bal_ptr) != 0)
+    if (mpt_get_balance_linkage_proof(priv, recipients[0].pubkey, context_hash, balance_params, bal_ptr) != 0)
     {
         return -1;
     }
@@ -657,7 +669,8 @@ mpt_get_clawback_proof(
         return -1;
 
     secp256k1_pubkey pk;
-    std::memcpy(pk.data, pub, kMPT_PUBKEY_SIZE);
+    if (secp256k1_ec_pubkey_parse(ctx, &pk, pub, kMPT_PUBKEY_SIZE) != 1)
+        return -1;
 
     secp256k1_pubkey c1, c2;
     if (!mpt_make_ec_pair(encrypted_amount, c1, c2))
diff --git a/tests/test_mpt_utility.cpp b/tests/test_mpt_utility.cpp
@@ -68,7 +68,7 @@ test_mpt_confidential_convert()
         secp256k1_ec_pubkey_parse(
             ctx, &c2, ciphertext + kMPT_ELGAMAL_CIPHER_SIZE, kMPT_ELGAMAL_CIPHER_SIZE) == 1);
 
-    std::memcpy(pk.data, pub, kMPT_PUBKEY_SIZE);
+    EXPECT(secp256k1_ec_pubkey_parse(ctx, &pk, pub, kMPT_PUBKEY_SIZE) == 1);
     EXPECT(secp256k1_elgamal_verify_encryption(ctx, &c1, &c2, &pk, convert_amount, bf) == 1);
     EXPECT(secp256k1_mpt_pok_sk_verify(ctx, proof, &pk, tx_hash) == 1);
 }
@@ -192,7 +192,7 @@ test_mpt_confidential_send()
     for (size_t i = 0; i < n_recipients; ++i)
     {
         EXPECT(mpt_make_ec_pair(recipients[i].encrypted_amount, r_list[i], s_list[i]));
-        std::memcpy(pk_list[i].data, recipients[i].pubkey, 64);
+        EXPECT(secp256k1_ec_pubkey_parse(ctx, &pk_list[i], recipients[i].pubkey, kMPT_PUBKEY_SIZE) == 1);
     }
 
     EXPECT(
@@ -212,8 +212,8 @@ test_mpt_confidential_send()
     secp256k1_pubkey pk, amt_pcm;
     secp256k1_pubkey amt_c1, amt_c2;
 
-    std::memcpy(pk.data, sender_pub, kMPT_PUBKEY_SIZE);
-    std::memcpy(amt_pcm.data, amount_comm, kMPT_PEDERSEN_COMMIT_SIZE);
+    EXPECT(secp256k1_ec_pubkey_parse(ctx, &pk, sender_pub, kMPT_PUBKEY_SIZE) == 1);
+    EXPECT(secp256k1_ec_pubkey_parse(ctx, &amt_pcm, amount_comm, kMPT_PEDERSEN_COMMIT_SIZE) == 1);
 
     EXPECT(mpt_make_ec_pair(sender_ct, amt_c1, amt_c2));
     EXPECT(
@@ -227,7 +227,7 @@ test_mpt_confidential_send()
     secp256k1_pubkey bal_pcm;
     secp256k1_pubkey bal_c1, bal_c2;
 
-    std::memcpy(bal_pcm.data, balance_comm, kMPT_PEDERSEN_COMMIT_SIZE);
+    EXPECT(secp256k1_ec_pubkey_parse(ctx, &bal_pcm, balance_comm, kMPT_PEDERSEN_COMMIT_SIZE) == 1);
     EXPECT(mpt_make_ec_pair(prev_bal_ct, bal_c1, bal_c2));
 
     EXPECT(
@@ -296,8 +296,8 @@ test_mpt_convert_back()
     secp256k1_pubkey c1, c2, pk, pcm;
 
     EXPECT(mpt_make_ec_pair(pc_params.encrypted_amount, c1, c2));
-    std::memcpy(pk.data, pub, kMPT_PUBKEY_SIZE);
-    std::memcpy(pcm.data, pcm_comm, kMPT_PEDERSEN_COMMIT_SIZE);
+    EXPECT(secp256k1_ec_pubkey_parse(ctx, &pk, pub, kMPT_PUBKEY_SIZE) == 1);
+    EXPECT(secp256k1_ec_pubkey_parse(ctx, &pcm, pcm_comm, kMPT_PEDERSEN_COMMIT_SIZE) == 1);
 
     int verify_result =
         secp256k1_elgamal_pedersen_link_verify(ctx, proof, &pk, &c2, &c1, &pcm, context_hash);
@@ -348,7 +348,7 @@ test_mpt_clawback()
     secp256k1_pubkey c1, c2, pk;
 
     EXPECT(mpt_make_ec_pair(issuer_encrypted_bal, c1, c2));
-    std::memcpy(pk.data, issuer_pub, kMPT_PUBKEY_SIZE);
+    EXPECT(secp256k1_ec_pubkey_parse(ctx, &pk, issuer_pub, kMPT_PUBKEY_SIZE) == 1);
 
     int verify_result =
         secp256k1_equality_plaintext_verify(ctx, proof, &pk, &c2, &c1, claw_amount, context_hash);
