Merge pull request #18 from make-software/fix-secp256k1-sign

Fixed Secp256K1 sign method

Author: RomanovSci

.github/workflows/ci.yml

@@ -19,6 +19,25 @@ jobs:
         uses: shivammathur/setup-php@v2
         with:
           php-version: '7.4'
+          ini-values: extension=secp256k1.so
+
+      - name: Clone libsecp256k1 repository
+        uses: GuillaumeFalourd/clone-github-repo-action@v2
+        with:
+          owner: 'bitcoin-core'
+          repository: 'secp256k1'
+
+      - name: Configure secp256k1
+        run: cd secp256k1 && ./autogen.sh && ./configure --enable-experimental --enable-module-{ecdh,recovery} && make && sudo make install && cd ..
+
+      - name: Clone secp256k1-php repository
+        uses: GuillaumeFalourd/clone-github-repo-action@v2
+        with:
+          owner: 'Bit-Wasp'
+          repository: 'secp256k1-php'
+
+      - name: Install secp256k1-php
+        run: cd secp256k1-php/secp256k1 && phpize && ./configure --with-secp256k1 && make && sudo make install && cd ..
 
       - uses: actions/checkout@v3
 

README.md

@@ -6,6 +6,29 @@ The PHP SDK allows developers to interact with the Casper Network using PHP. Thi
 composer require make-software/casper-php-sdk
 ```
 
+### IMPORTANT
+For using `Secp256K1` keys you need to install and enable [secp256k1-php](https://github.com/Bit-Wasp/secp256k1-php) extension:
+```bash
+git clone git@github.com:bitcoin-core/secp256k1 && \
+    cd secp256k1 && \
+    ./autogen.sh && \
+    ./configure --enable-experimental --enable-module-{ecdh,recovery} && \
+    make && sudo make install && \
+    cd ../
+```
+```bash
+git clone git@github.com:Bit-Wasp/secp256k1-php && \
+    cd secp256k1-php/secp256k1 && \
+    phpize && \ 
+    ./configure --with-secp256k1 && \  
+    make && sudo make install && \
+    cd ../../
+```
+Enable extension by adding the following line to your `php.ini` file
+```
+extension=secp256k1.so
+```
+
 ## Usage
 ### Creating RpcClient
 Create `RpcClient` by passing node url to constructor

src/Rpc/RpcClient.php

@@ -414,8 +414,11 @@ private function rpcCallMethod(string $method, array $params = array()): array
 
         $decodedResponse = json_decode($response, true);
 
-        if (isset($decodedResponse['error'])) {
-            throw new RpcError($decodedResponse['error']['message'], $decodedResponse['error']['code']);
+        if ($decodedResponse === null || isset($decodedResponse['error'])) {
+            $message = $decodedResponse['error']['message'] ?? 'Empty response';
+            $code = $decodedResponse['error']['code'] ?? 0;
+
+            throw new RpcError($message, $code);
         }
 
         $this->lastApiVersion = $decodedResponse['result']['api_version'];

src/Service/DeployService.php

@@ -64,7 +64,10 @@ public static function makeDeploy(
     public static function signDeploy(Deploy $deploy, AsymmetricKey $key): Deploy
     {
         $signer = CLPublicKeySerializer::fromString(
-            KeysUtil::addPrefixToPublicKey($key->getSignatureAlgorithm(), $key->getPublicKey())
+            KeysUtil::addPrefixToPublicKey(
+                $key->getSignatureAlgorithm(),
+                $key->getPublicKey()
+            )
         );
         $signature = KeysUtil::addPrefixToPublicKey(
             $key->getSignatureAlgorithm(),

src/Util/CEP57ChecksumUtil.php

@@ -4,7 +4,6 @@
 
 class CEP57ChecksumUtil
 {
-    private const BLAKE2B_HASH_LENGTH = 64;
     private const HEX_CHARS = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
 
     /**
@@ -44,7 +43,7 @@ public static function hasChecksum(string $hex): bool
     public static function encode(array $bytes): string
     {
         $nibbles = self::byteToNibbles($bytes);
-        $hashBits = self::bytesToBitsCycle(HashUtil::blake2bHash($bytes, self::BLAKE2B_HASH_LENGTH));
+        $hashBits = self::bytesToBitsCycle(HashUtil::blake2bHash($bytes));
 
         $bitIndex = 0;
         foreach ($nibbles as $nibble) {

src/Util/Crypto/AsymmetricKey.php

@@ -88,9 +88,9 @@ abstract public function sign(string $message): string;
     /**
      * Verify hex-encoded signature
      *
-     * @param string $signature
+     * @param string $hexSignature
      * @param string $message
      * @return bool
      */
-    public abstract function verify(string $signature, string $message): bool;
+    public abstract function verify(string $hexSignature, string $message): bool;
 }

src/Util/Crypto/Ed25519Key.php

@@ -82,10 +82,10 @@ public function sign(string $message): string
      *
      * @throws \SodiumException
      */
-    public function verify(string $signature, string $message): bool
+    public function verify(string $hexSignature, string $message): bool
     {
-        $signature = ByteUtil::hexToString($signature);
-        return sodium_crypto_sign_verify_detached($signature, $message, $this->publicKey);
+        $hexSignature = ByteUtil::hexToString($hexSignature);
+        return sodium_crypto_sign_verify_detached($hexSignature, $message, $this->publicKey);
     }
 
     /**

src/Util/Crypto/Secp256K1Key.php

@@ -5,58 +5,33 @@
 use Casper\Util\ByteUtil;
 
 use Mdanter\Ecc\Crypto\Key\PrivateKeyInterface;
-use Mdanter\Ecc\Crypto\Key\PublicKeyInterface;
-use Mdanter\Ecc\Crypto\Signature\Signature;
-use Mdanter\Ecc\Crypto\Signature\SignatureInterface;
-use Mdanter\Ecc\Crypto\Signature\Signer;
-use Mdanter\Ecc\Crypto\Signature\SignHasher;
 use Mdanter\Ecc\EccFactory;
-use Mdanter\Ecc\Math\GmpMathInterface;
-use Mdanter\Ecc\Primitives\GeneratorPoint;
-use Mdanter\Ecc\Random\RandomGeneratorFactory;
 use Mdanter\Ecc\Serializer\PrivateKey\DerPrivateKeySerializer;
 use Mdanter\Ecc\Serializer\PrivateKey\PemPrivateKeySerializer;
 use Mdanter\Ecc\Serializer\PublicKey\DerPublicKeySerializer;
 use Mdanter\Ecc\Serializer\PublicKey\PemPublicKeySerializer;
-use Phactor\Math;
 
 /**
- * Secp255K1 key implementation
+ * Secp256K1 key implementation
  */
 final class Secp256K1Key extends AsymmetricKey
 {
-    use Math;
-
+    protected const RESULT_OK = 1;
     protected const HASHING_ALGORITHM = 'sha256';
 
-    protected GmpMathInterface $adapter;
-
-    protected GeneratorPoint $generator;
-
-    protected PemPrivateKeySerializer $privateKeySerializer;
-
-    protected PemPublicKeySerializer $publicKeySerializer;
-
-    protected PrivateKeyInterface $secpPrivateKey;
-
-    protected PublicKeyInterface $secpPublicKey;
+    protected PrivateKeyInterface $privateKeyObject;
 
-    public function __construct(PrivateKeyInterface $privateKey = null)
+    public function __construct(PrivateKeyInterface $privateKeyObject = null)
     {
-        $this->adapter = EccFactory::getAdapter();
-        $this->generator = EccFactory::getSecgCurves()->generator256k1();
-        $this->privateKeySerializer = new PemPrivateKeySerializer(new DerPrivateKeySerializer($this->adapter));
-        $this->publicKeySerializer = new PemPublicKeySerializer(new DerPublicKeySerializer($this->adapter));
+        $this->privateKeyObject = $privateKeyObject ??
+            EccFactory::getSecgCurves()
+                ->generator256k1()
+                ->createPrivateKey();
 
-        $this->secpPrivateKey = $privateKey ?? $this->generator->createPrivateKey();
-        $privateKeyString = ByteUtil::hexToString($this->encodeHex((string) $this->secpPrivateKey->getSecret(), false));
+        $privateKey = ByteUtil::hexToString(gmp_strval($this->privateKeyObject->getSecret(), 16));
+        $publicKey= ByteUtil::hexToString($this->getCompressedPublicKeyHex());
 
-        $this->secpPublicKey = $this->secpPrivateKey->getPublicKey();
-        $xHex = str_pad($this->encodeHex((string) $this->secpPublicKey->getPoint()->getX(), false), 64, "0", STR_PAD_LEFT);
-        $compressedPublicKeyPrefix = $this->Modulo((string) $this->secpPublicKey->getPoint()->getY(), '2') === '1' ? '03' : '02';
-        $publicKeyCompressedString = ByteUtil::hexToString($compressedPublicKeyPrefix . $xHex);
-
-        parent::__construct($publicKeyCompressedString, $privateKeyString, self::ALGO_SECP255K1);
+        parent::__construct($publicKey, $privateKey, self::ALGO_SECP255K1);
     }
 
     /**
@@ -65,11 +40,9 @@ public function __construct(PrivateKeyInterface $privateKey = null)
      */
     public static function createFromPrivateKeyFile(string $pathToPrivateKey): self
     {
-        $adapter = EccFactory::getAdapter();
-        $privateKeySerializer = new PemPrivateKeySerializer(new DerPrivateKeySerializer($adapter));
-
         return new self(
-            $privateKeySerializer->parse(file_get_contents($pathToPrivateKey))
+            (new PemPrivateKeySerializer(new DerPrivateKeySerializer()))
+                ->parse(file_get_contents($pathToPrivateKey))
         );
     }
 
@@ -79,7 +52,8 @@ public static function createFromPrivateKeyFile(string $pathToPrivateKey): self
      */
     public function exportPublicKeyInPem(): string
     {
-        return $this->publicKeySerializer->serialize($this->secpPublicKey) . PHP_EOL;
+        return (new PemPublicKeySerializer(new DerPublicKeySerializer()))
+                ->serialize($this->privateKeyObject->getPublicKey()) . PHP_EOL;
     }
 
     /**
@@ -88,73 +62,94 @@ public function exportPublicKeyInPem(): string
      */
     public function exportPrivateKeyInPem(): string
     {
-        return $this->privateKeySerializer->serialize($this->secpPrivateKey) . PHP_EOL;
+        return (new PemPrivateKeySerializer(new DerPrivateKeySerializer()))
+                ->serialize($this->privateKeyObject) . PHP_EOL;
     }
 
     /**
      * @inheritDoc
      * @param string $message
      * @return string
+     *
+     * @throws \Exception
      */
     public function sign(string $message): string
     {
-        $hasher = new SignHasher(self::HASHING_ALGORITHM, $this->adapter);
-        $hash = $hasher->makeHash($message, $this->generator);
+        $context = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
+
+        $signature = null;
+        $signResult = secp256k1_ecdsa_sign(
+            $context,
+            $signature,
+            hash(self::HASHING_ALGORITHM, $message, true),
+            $this->privateKey
+        );
 
-        $random = RandomGeneratorFactory::getRandomGenerator();
-        $randomK = $random->generate($this->generator->getOrder());
+        if ($signResult !== self::RESULT_OK) {
+            throw new \Exception("Failed to create signature");
+        }
 
-        $signature = (new Signer($this->adapter))
-            ->sign($this->secpPrivateKey, $hash, $randomK);
+        $signatureSerialized = '';
+        secp256k1_ecdsa_signature_serialize_compact($context, $signatureSerialized, $signature);
 
-        return $this->signatureToHex($signature);
+        return ByteUtil::stringToHex($signatureSerialized);
     }
 
     /**
      * @inheritDoc
-     * @param string $signature
+     * @param string $hexSignature
      * @param string $message
      * @return bool
+     *
+     * @throws \Exception
      */
-    public function verify(string $signature, string $message): bool
+    public function verify(string $hexSignature, string $message): bool
     {
-        try {
-            $signature = $this->hexToSignature($signature);
+        $context = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
 
-            $hasher = new SignHasher(self::HASHING_ALGORITHM);
-            $hash = $hasher->makeHash($message, $this->generator);
+        $publicKey = null;
+        $publicKeyParseResult = secp256k1_ec_pubkey_parse($context, $publicKey, $this->publicKey);
 
-            return (new Signer($this->adapter))
-                ->verify($this->secpPublicKey, $signature, $hash);
-        } catch (\Exception $e) {
-            return false;
+        if ($publicKeyParseResult !== self::RESULT_OK) {
+            throw new \Exception("Failed to parse public key");
         }
-    }
 
-    private function signatureToHex(SignatureInterface $signature): string
-    {
-        $r = $signature->getR();
-        $s = $signature->getS();
+        $signature = null;
+        $signatureParseResult = secp256k1_ecdsa_signature_parse_compact(
+            $context,
+            $signature,
+            ByteUtil::hexToString($hexSignature)
+        );
+
+        if ($signatureParseResult !== self::RESULT_OK) {
+            throw new \Exception("Failed to parse DER signature");
+        }
 
-        return gmp_strval($r, 16) . gmp_strval($s, 16);
+        $isVerified = secp256k1_ecdsa_verify(
+            $context,
+            $signature,
+            hash(self::HASHING_ALGORITHM, $message, true),
+            $publicKey
+        );
+
+        return $isVerified === self::RESULT_OK;
     }
 
-    private function hexToSignature(string $hex): SignatureInterface
+    private function getCompressedPublicKeyHex(): string
     {
-        $hex = mb_strtolower($hex);
+        $xPointValue = $this->privateKeyObject
+            ->getPublicKey()
+            ->getPoint()
+            ->getX();
 
-        if (strpos($hex, '0x') >= 0) {
-            $count = 1;
-            $hex = str_replace('0x', '', $hex, $count);
-        }
-
-        if (mb_strlen($hex) !== 128) {
-            throw new \InvalidArgumentException('Binary string was not correct.');
-        }
+        $yPointValue = $this->privateKeyObject
+            ->getPublicKey()
+            ->getPoint()
+            ->getY();
 
-        $r = mb_substr($hex, 0, 64);
-        $s = mb_substr($hex, 64, 64);
+        $xPointValueHex = str_pad(gmp_strval($xPointValue, 16), 64, '0', STR_PAD_LEFT);
+        $prefix = gmp_strval(gmp_mod($yPointValue, 2)) === '1' ? '03' : '02';
 
-        return new Signature(gmp_init($r, 16), gmp_init($s, 16));
+        return $prefix . $xPointValueHex;
     }
 }

tests/Functional/CEP57ChecksumUtilTest.php

@@ -14,7 +14,7 @@ class CEP57ChecksumUtilTest extends TestCase
      */
     public function testHasCheckSum(): void
     {
-        $hexWithCheckSum = 'de8649985929090b7CB225e35a5A7B4087fb8fcB3D18C8C9a58DA68e4edA8a2E';
+        $hexWithCheckSum = 'dE8649985929090B7Cb225e35a5a7B4087Fb8FCB3D18c8c9a58da68e4eDA8A2e';
         $this->assertTrue(CEP57ChecksumUtil::hasChecksum($hexWithCheckSum));
 
         $hexWithoutCheckSum = 'de8649985929090b7cb225e35a5a7b4087fb8fcb3d18c8c9a58da68e4eda8a2e';
@@ -26,7 +26,7 @@ public function testHasCheckSum(): void
      */
     public function testEncode(): void
     {
-        $hex = 'de8649985929090b7CB225e35a5A7B4087fb8fcB3D18C8C9a58DA68e4edA8a2E';
+        $hex = 'dE8649985929090B7Cb225e35a5a7B4087Fb8FCB3D18c8c9a58da68e4eDA8A2e';
         $bytes = ByteUtil::hexToByteArray($hex);
 
         $encodedHex = CEP57ChecksumUtil::encode($bytes);
@@ -38,7 +38,7 @@ public function testEncode(): void
      */
     public function testDecode(): void
     {
-        $hex = 'de8649985929090b7CB225e35a5A7B4087fb8fcB3D18C8C9a58DA68e4edA8a2E';
+        $hex = 'dE8649985929090B7Cb225e35a5a7B4087Fb8FCB3D18c8c9a58da68e4eDA8A2e';
 
         $decodedByteArray = CEP57ChecksumUtil::decode($hex);
         $this->assertIsArray($decodedByteArray);