Merge branch 'main' into feat/get-public-key-ed25519-tests

Author: sethkfman

CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.0]
+
+### Added
+
+- feat: getPublicKeyEd25519 ([#26](https://github.com/MetaMask/native-utils/pull/26))
+
 ## [0.6.0]
 
 ### Added
@@ -44,7 +50,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - feat: add native public key generation ([#5](https://github.com/MetaMask/native-utils/pull/5))
 - feat: add Example app with tests cases ([#6](https://github.com/MetaMask/native-utils/pull/6))
 
-[Unreleased]: https://github.com/MetaMask/native-utils/compare/v0.6.0...HEAD
+[Unreleased]: https://github.com/MetaMask/native-utils/compare/v0.7.0...HEAD
+[0.7.0]: https://github.com/MetaMask/native-utils/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/MetaMask/native-utils/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/MetaMask/native-utils/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/MetaMask/native-utils/compare/v0.3.0...v0.4.0

cpp/HybridNativeUtils.cpp

@@ -1,77 +1,95 @@
 #include "HybridNativeUtils.hpp"
-#include "secp256k1_wrapper.h"
+#include "secp256k1/include/secp256k1.h"
 #include "hex_utils.hpp"
 #include "botan_conditional.h"
 #include <stdexcept>
+#include <mutex>
 
 namespace margelo::nitro::metamask_nativeutils {
 
-// Static global context for maximum performance
-static secp256k1_context* g_ctx = nullptr;
+// Static global context for maximum performance.
+// Made const and initialized with a call-once guard for thread safety.
+static std::once_flag g_ctx_once;
+static const secp256k1_context* g_ctx = nullptr;
 
-// Initialize context once (thread-safe)
 static void initializeContext() {
+    std::call_once(g_ctx_once, []() {
+        g_ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
+    });
+
     if (!g_ctx) {
-        g_ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
+        throw std::runtime_error("Failed to initialize secp256k1 context");
     }
 }
 
+// Helper that wraps secp256k1_ec_pubkey_serialize and enforces the expected output length.
+// libsecp256k1 treats the length parameter as an in/out value: on input it is the buffer
+// capacity, on output it is the actual number of bytes written. We defensively verify that
+// the actual length matches the format we requested (33 or 65 bytes) so that future changes
+// in libsecp256k1 cannot cause us to read uninitialized or truncated public key data.
+static void serializeSecp256k1PubkeyChecked(
+    const secp256k1_pubkey* pubkey,
+    uint8_t* output,
+    size_t expectedLen,
+    unsigned int flags) {
+  size_t outputLen = expectedLen;
+  if (!secp256k1_ec_pubkey_serialize(g_ctx, output, &outputLen, pubkey, flags)) {
+    throw std::runtime_error("Failed to serialize public key");
+  }
+  if (outputLen != expectedLen) {
+    throw std::runtime_error("Unexpected public key length from secp256k1");
+  }
+}
 
 // Common function to generate public key from raw private key bytes
 static std::shared_ptr<ArrayBuffer> generatePublicKeyFromBytes(const uint8_t* privateKeyBytes, bool isCompressed) {
   initializeContext();
 
   // Use secp256k1's built-in validation (checks if key is not 0 and < curve order)
   if (!secp256k1_ec_seckey_verify(g_ctx, privateKeyBytes)) {
-      throw std::runtime_error("private key invalid 3");
+      throw std::runtime_error("Private key is invalid");
   }
 
   // Create public key from private key
   secp256k1_pubkey pubkey;
   if (!secp256k1_ec_pubkey_create(g_ctx, &pubkey, privateKeyBytes)) {
-      throw std::runtime_error("private key invalid 3");
+      throw std::runtime_error("Failed to create public key from private key");
   }
 
   // Serialize the public key
   size_t keySize = isCompressed ? 33 : 65;
   auto buffer = ArrayBuffer::allocate(keySize);
   auto data = static_cast<uint8_t*>(buffer->data());
-  
-  size_t outputLen = keySize;
+
   unsigned int flags = isCompressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED;
-  
-  if (!secp256k1_ec_pubkey_serialize(g_ctx, data, &outputLen, &pubkey, flags)) {
-      throw std::runtime_error("private key invalid 3");
-  }
+
+  serializeSecp256k1PubkeyChecked(&pubkey, data, keySize, flags);
 
   return buffer;
 }
 
 std::shared_ptr<ArrayBuffer> HybridNativeUtils::toPublicKey(const std::string& privateKey, bool isCompressed) {
-  std::string hex = privateKey;
-  
   // Must be exactly 64 characters (32 bytes)
-  if (hex.length() != 64) {
-      throw std::runtime_error("Uint8Array expected");
+  if (privateKey.length() != 64) {
+      throw std::runtime_error("Private key must be 64 hex characters (32 bytes)");
   }
 
-  // Convert hex to bytes with validation
-  uint8_t seckey[32];
-  hexToBytes(hex, seckey, 32);
+  uint8_t privateKeyBytes[32];
+  hexToBytes(privateKey, privateKeyBytes, 32);
 
-  return generatePublicKeyFromBytes(seckey, isCompressed);
+  return generatePublicKeyFromBytes(privateKeyBytes, isCompressed);
 }
 
 std::shared_ptr<ArrayBuffer> HybridNativeUtils::toPublicKeyFromBytes(const std::shared_ptr<ArrayBuffer>& privateKey, bool isCompressed) {
   // Validate input size (must be exactly 32 bytes for secp256k1)
   if (privateKey->size() != 32) {
-      throw std::runtime_error("Uint8Array expected");
+      throw std::runtime_error("Private key must be 32 bytes");
   }
 
   // Get the private key bytes directly
-  const uint8_t* seckey = static_cast<const uint8_t*>(privateKey->data());
+  const uint8_t* privateKeyBytes = static_cast<const uint8_t*>(privateKey->data());
 
-  return generatePublicKeyFromBytes(seckey, isCompressed);
+  return generatePublicKeyFromBytes(privateKeyBytes, isCompressed);
 }
 
 // Common function to generate ed25519 public key from private key bytes (seed)
@@ -93,6 +111,9 @@ std::shared_ptr<ArrayBuffer> HybridNativeUtils::getPublicKeyEd25519(const std::s
 }
 
 std::shared_ptr<ArrayBuffer> HybridNativeUtils::getPublicKeyEd25519FromBytes(const std::shared_ptr<ArrayBuffer>& privateKey) {
+  if (privateKey->size() != 32) {
+    throw std::runtime_error("Private key must be 32 bytes");
+  }
   const uint8_t* seed = static_cast<const uint8_t*>(privateKey->data());
 
   return generateEd25519PublicKeyFromBytes(seed);
@@ -106,7 +127,6 @@ static std::shared_ptr<ArrayBuffer> keccak256Hash(const uint8_t* dataBytes, size
 
   hasher->update(dataBytes, dataLen);
 
-  // Convert hex string to bytes
   auto result = ArrayBuffer::allocate(32);
   hasher->final(static_cast<uint8_t*>(result->data()));
 
@@ -121,10 +141,7 @@ std::shared_ptr<ArrayBuffer> HybridNativeUtils::keccak256(const std::string& dat
   auto dataBuffer = ArrayBuffer::allocate(dataLen);
   uint8_t* dataBytes = static_cast<uint8_t*>(dataBuffer->data());
 
-  // Convert hex string to bytes
-  for (size_t i = 0; i < dataLen; i++) {
-      dataBytes[i] = (hexCharToByte(data[i * 2]) << 4) | hexCharToByte(data[i * 2 + 1]);
-  }
+  hexToBytes(data, dataBytes, dataLen);
 
   return keccak256FromBytes(dataBuffer);
 }
@@ -156,10 +173,11 @@ std::shared_ptr<ArrayBuffer> HybridNativeUtils::pubToAddress(const std::shared_p
 
       // Serialize to uncompressed format (65 bytes)
       uint8_t uncompressedKey[65];
-      size_t outputLen = 65;
-      if (!secp256k1_ec_pubkey_serialize(g_ctx, uncompressedKey, &outputLen, &parsedPubkey, SECP256K1_EC_UNCOMPRESSED)) {
-          throw std::runtime_error("Failed to serialize public key");
-      }
+      serializeSecp256k1PubkeyChecked(
+          &parsedPubkey,
+          uncompressedKey,
+          65,
+          SECP256K1_EC_UNCOMPRESSED);
 
       // Skip the 0x04 prefix byte for keccak hashing
       memcpy(uncompressedPubKeyBytes, uncompressedKey + 1, 64);
@@ -171,7 +189,7 @@ std::shared_ptr<ArrayBuffer> HybridNativeUtils::pubToAddress(const std::shared_p
       }
   }
 
-  auto hashResult = keccak256Hash(pubKeyBytes, pubKeySize);
+  auto hashResult = keccak256Hash(pubKeyBytes, 64);
 
   // Return the last 20 bytes (Ethereum address)
   auto result = ArrayBuffer::allocate(20);
@@ -181,7 +199,6 @@ std::shared_ptr<ArrayBuffer> HybridNativeUtils::pubToAddress(const std::shared_p
 }
 
 std::shared_ptr<ArrayBuffer> HybridNativeUtils::hmacSha512(const std::shared_ptr<ArrayBuffer>& key, const std::shared_ptr<ArrayBuffer>& data) {
-  // Get key and data pointers
   const uint8_t* keyBytes = static_cast<const uint8_t*>(key->data());
   const uint8_t* dataBytes = static_cast<const uint8_t*>(data->data());
 

cpp/hex_utils.cpp

@@ -9,12 +9,12 @@ bool isValidHexChar(char c) {
 
 void validateHexString(const std::string& hex) {
     if (hex.length() % 2 != 0) {
-        throw std::runtime_error("hex invalid");
+        throw std::runtime_error("Invalid hex string: odd length");
     }
 
     for (char c : hex) {
         if (!isValidHexChar(c)) {
-            throw std::runtime_error("hex invalid");
+            throw std::runtime_error("Invalid hex string: contains non-hex characters");
         }
     }
 }
@@ -23,14 +23,14 @@ uint8_t hexCharToByte(char c) {
     if (c >= '0' && c <= '9') return c - '0';
     if (c >= 'A' && c <= 'F') return c - 'A' + 10;
     if (c >= 'a' && c <= 'f') return c - 'a' + 10;
-    throw std::runtime_error("hex invalid");
+    throw std::runtime_error("Invalid hex character");
 }
 
 void hexToBytes(const std::string& hex, uint8_t* bytes, size_t expectedLen) {
     validateHexString(hex);
 
     if (hex.length() != expectedLen * 2) {
-        throw std::runtime_error("Uint8Array expected");
+        throw std::runtime_error("Invalid hex string length");
     }
 
     for (size_t i = 0; i < expectedLen; i++) {

cpp/secp256k1_wrapper.h

@@ -1,6 +1,6 @@
 {
   "name": "@metamask/native-utils",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "React Native Utils for MetaMask. This project is under development and that individuals should use it at their own risk.",
   "homepage": "https://github.com/MetaMask/native-utils",
   "bugs": {

package.json

@@ -1,7 +1,7 @@
 import { NitroModules } from 'react-native-nitro-modules';
 import type { NativeUtils } from './NativeUtils.nitro';
 import {
-  bigintToBytes,
+  bigintPrivateKeyToBytes,
   uint8ArrayToArrayBuffer,
   arrayBufferToUint8Array,
   numberArrayToUint8Array,
@@ -14,12 +14,12 @@ export function multiply(a: number, b: number): number {
   return NativeUtilsHybridObject.multiply(a, b);
 }
 
-/** Uint8Array alias for compatibility */
-export type Bytes = Uint8Array;
-/** Hex-encoded string or Uint8Array. */
-export type Hex = Bytes | string;
-/** Private key can be hex string, Uint8Array, or bigint. */
-export type PrivKey = Hex | bigint;
+/** Uint8Array of private key bytes. */
+export type BytesPrivateKey = Uint8Array;
+/** Hex-encoded string of private key. */
+export type HexPrivateKey = string;
+/** Private key can be hex string, bytes, or bigint. */
+export type PrivateKey = HexPrivateKey | BytesPrivateKey | bigint;
 
 /**
  * Generate a public key from a private key using the secp256k1 elliptic curve.
@@ -30,7 +30,7 @@ export type PrivKey = Hex | bigint;
  * @returns Uint8Array containing the public key bytes
  */
 export function getPublicKey(
-  privateKey: PrivKey,
+  privateKey: PrivateKey,
   isCompressed: boolean = true,
 ): Uint8Array {
   let result: ArrayBuffer;
@@ -40,7 +40,7 @@ export function getPublicKey(
     result = NativeUtilsHybridObject.toPublicKey(privateKey, isCompressed);
   } else if (typeof privateKey === 'bigint') {
     // Convert bigint to bytes (basic validation here, detailed validation in C++)
-    const privateKeyBytes = bigintToBytes(privateKey);
+    const privateKeyBytes = bigintPrivateKeyToBytes(privateKey);
     const privateKeyBuffer = uint8ArrayToArrayBuffer(privateKeyBytes);
     result = NativeUtilsHybridObject.toPublicKeyFromBytes(
       privateKeyBuffer,
@@ -144,7 +144,7 @@ export function hmacSha512(key: Uint8Array, data: Uint8Array): Uint8Array {
  * @returns Uint8Array containing 32-byte Ed25519 public key
  */
 export function getPublicKeyEd25519(
-  privateKey: Uint8Array | string,
+  privateKey: BytesPrivateKey | HexPrivateKey,
   _compressed?: boolean,
 ): Uint8Array {
   let result: ArrayBuffer;

src/index.tsx

@@ -5,7 +5,7 @@ export const N =
 /**
  * Convert bigint to 32-byte Uint8Array (big-endian)
  */
-export function bigintToBytes(num: bigint): Uint8Array {
+export function bigintPrivateKeyToBytes(num: bigint): Uint8Array {
   if (num < 0n) {
     throw new Error('Private key must be positive');
   }
@@ -46,5 +46,16 @@ export function arrayBufferToUint8Array(buffer: ArrayBuffer): Uint8Array {
  * Convert number array to Uint8Array
  */
 export function numberArrayToUint8Array(arr: number[]): Uint8Array {
+  // Dev-only validation to catch silent conversions
+  if (process.env.NODE_ENV !== 'production') {
+    for (let i = 0; i < arr.length; i++) {
+      const val = arr[i];
+      if (val === undefined || !Number.isInteger(val) || val < 0 || val > 255) {
+        throw new Error(
+          `Invalid byte value at index ${i}: expected integer 0-255, got ${val}`,
+        );
+      }
+    }
+  }
   return new Uint8Array(arr);
 }