bitcoin-secp256k1 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07e0b24c6a5eff2bebfa1287f30299e3e20516a9
-  data.tar.gz: 64b92f4a1274272b62a2b4f8447f7f97b3726e05
+  metadata.gz: 35c4817fc53d1512f07b574c444ac2ff39d723b7
+  data.tar.gz: 2c0acf62b066d43caf45ba96530b330ef8db2927
 SHA512:
-  metadata.gz: f4123386a3b2add1c25e711eae40013a418fad7d614f0283caa0f5f8e961889de623be103b023035d441d42d4823b964ea129218d857ad66c722560b29f910f1
-  data.tar.gz: 45abd20b35e91cbf4ac5b33fa3b472a32383f140426edce77eabab58180f39ea9afc4e63b85f4cfc6a59f257e6e1dfe6ed8bca1ac3199e8239dedae860ada7bb
+  metadata.gz: 4f831335807714f0cbd888e0adf8846293a3187ab7bde70306d61dce530947ab192b01770f6cfd43a1185c35417493c951af5dd08eb69ab8d63efc769f73d44f
+  data.tar.gz: 9e9b0e898a4db87c076921fbc50a4614ed411e2505a218d28380d8afc2ba18a261faa20ec84186c010376d4c2c28e87eb833b9fdab0c33f4ff5a82e0f82472eb

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bitcoin-secp256k1 (0.1.1)
+    bitcoin-secp256k1 (0.2.0)
       ffi (>= 1.9.10)
 
 GEM

data/README.md

@@ -17,7 +17,7 @@ git submodule update --init --recursive
 gem i bitcoin-secp256k1
 ```
 
-Then require 'secp256k1' (without `bitcoin-` prefix) in your source code.
+Then `require 'secp256k1'` (without `bitcoin-` prefix) in your source code.
 
 ## Usage
 

data/lib/secp256k1/c.rb

@@ -36,6 +36,9 @@ module Secp256k1
     # int secp256k1_ec_pubkey_create(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *seckey)
     attach_function :secp256k1_ec_pubkey_create, [:pointer, :pointer, :pointer], :int
 
+    # int secp256k1_ec_pubkey_serialize(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_pubkey *pubkey, unsigned int flags)
+    attach_function :secp256k1_ec_pubkey_serialize, [:pointer, :pointer, :pointer, :pointer, :uint], :int
+
     # int secp256k1_ec_seckey_verify(const secp256k1_context* ctx, const unsigned char *seckey)
     attach_function :secp256k1_ec_seckey_verify, [:pointer, :pointer], :int
 
@@ -54,8 +57,25 @@ module Secp256k1
     # int secp256k1_ecdsa_sign(const secp256k1_context* ctx, secp256k1_ecdsa_signature *sig, const unsigned char *msg32, const unsigned char *seckey, secp256k1_nonce_function noncefp, const void *ndata)
     attach_function :secp256k1_ecdsa_sign, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int
 
+    # int secp256k1_ecdsa_sign_recoverable(const secp256k1_context* ctx, secp256k1_ecdsa_recoverable_signature *sig, const unsigned char *msg32, const unsigned char *seckey, secp256k1_nonce_function noncefp, const void *ndata)
+    attach_function :secp256k1_ecdsa_sign_recoverable, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int
+
+    # int secp256k1_ecdsa_recover(const secp256k1_context* ctx, secp256k1_pubkey* pubkey, secp256k1_ecdsa_recoverable_signature *sig, const unsigned char *msg32)
+    attach_function :secp256k1_ecdsa_recover, [:pointer, :pointer, :pointer, :pointer], :int
+
     # int secp256k1_ecdsa_verify(const secp256k1_context *ctx, const secp256k1_ecdsa_signature *sig, const unsigned char *msg32, const secp256k1_pubkey *pubkey)
     attach_function :secp256k1_ecdsa_verify, [:pointer, :pointer, :pointer, :pointer], :int
 
+    # int secp256k1_ecdsa_signature_normalize(const secp256k1_context *ctx, const secp256k1_ecdsa_signature *sigout, const secp256k1_ecdsa_signature *sigin)
+    attach_function :secp256k1_ecdsa_signature_normalize, [:pointer, :pointer, :pointer], :int
+
+    # int secp256k1_ecdsa_recoverable_signature_serialize_compact(const secp256k1_context *ctx, unsigned char *output64, int *recid, const secp256k1_ecdsa_recoverable_signature *sig)
+    attach_function :secp256k1_ecdsa_recoverable_signature_serialize_compact, [:pointer, :pointer, :pointer, :pointer], :int
+
+    # int secp256k1_ecdsa_recoverable_signature_parse_compact(const secp256k1_context *ctx, secp256k1_ecdsa_recoverable_signature *sig, const unsigned char *input64, int recid)
+    attach_function :secp256k1_ecdsa_recoverable_signature_parse_compact, [:pointer, :pointer, :pointer, :int], :int
+
+    # int secp256k1_ecdsa_recoverable_signature_convert(const secp256k1_context *ctx, secp256k1_ecdsa_signature *sig, const secp256k1_ecdsa_recoverable_signature *sigin)
+    attach_function :secp256k1_ecdsa_recoverable_signature_convert, [:pointer, :pointer, :pointer], :int
   end
 end

data/lib/secp256k1/ecdsa.rb

@@ -43,5 +43,59 @@ module Secp256k1
       raw_sig
     end
 
+    ##
+    # Check and optionally convert a signature to a normalized lower-S form. If
+    # check_only is `true` then the normalized signature is not returned.
+    #
+    # This function always return a tuple containing a boolean (`true` if not
+    # previously normalized or `false` if signature was already normalized),
+    # and the normalized signature. When check_only is `true`, the normalized
+    # signature returned is always `nil`.
+    #
+    def ecdsa_signature_normalize(raw_sig, check_only: false)
+      sigout = check_only ? nil : C::ECDSASignature.new.pointer
+      res = C.secp256k1_ecdsa_signature_normalize(@ctx, sigout, raw_sig)
+      [res == 1, sigout]
+    end
+
+    def ecdsa_recover(msg, recover_sig, raw: false, digest: Digest::SHA256)
+      raise AssertError, 'instance not configured for ecdsa recover' if (@flags & ALL_FLAGS) != ALL_FLAGS
+
+      msg32 = hash32 msg, raw, digest
+      pubkey = C::Pubkey.new.pointer
+
+      res = C.secp256k1_ecdsa_recover(@ctx, pubkey, recover_sig, msg32)
+      raise AssertError, 'failed to recover ECDSA public key' unless res == 1
+
+      pubkey
+    end
+
+    def ecdsa_recoverable_serialize(recover_sig)
+      output = FFI::MemoryPointer.new :uchar, SIZE_COMPACT
+      recid = FFI::MemoryPointer.new :int
+
+      C.secp256k1_ecdsa_recoverable_signature_serialize_compact(@ctx, output, recid, recover_sig)
+
+      [output.read_bytes(SIZE_COMPACT), recid.read_int]
+    end
+
+    def ecdsa_recoverable_deserialize(ser_sig, rec_id)
+      raise ArgumentError, 'invalid rec_id' if rec_id < 0 || rec_id > 3
+      raise ArgumentError, 'invalid signature length' if ser_sig.size != 64
+
+      recover_sig = C::ECDSARecoverableSignature.new.pointer
+
+      res = C.secp256k1_ecdsa_recoverable_signature_parse_compact(@ctx, recover_sig, ser_sig, rec_id)
+      raise AssertError, 'failed to parse ECDSA compact sig' unless res == 1
+
+      recover_sig
+    end
+
+    def ecdsa_recoverable_convert(recover_sig)
+      normal_sig = C::ECDSASignature.new.pointer
+      C.secp256k1_ecdsa_recoverable_signature_convert(@ctx, normal_sig, recover_sig)
+      normal_sig
+    end
+
   end
 end

data/lib/secp256k1/key.rb

@@ -175,7 +175,7 @@ module Secp256k1
 
     def ecdsa_sign_recoverable(msg, raw: false, digest: Digest::SHA256)
       msg32 = hash32 msg, raw, digest
-      raw_sig = FFI::MemoryPointer.new :byte, C::ECDSARecoverableSignature, false
+      raw_sig = C::ECDSARecoverableSignature.new.pointer
 
       res = C.secp256k1_ecdsa_sign_recoverable @ctx, raw_sig, msg32, @private_key, nil, nil
       raise AssertError, "failed to sign" unless res == 1

data/lib/secp256k1/version.rb

@@ -1,3 +1,3 @@
 module Secp256k1
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/test/secp256k1_test.rb

@@ -7,6 +7,14 @@ require 'secp256k1'
 
 require 'json'
 
+class MyECDSA < Secp256k1::BaseKey
+  include Secp256k1::Utils, Secp256k1::ECDSA
+
+  def initialize
+    super(nil, Secp256k1::ALL_FLAGS)
+  end
+end
+
 class Secp256k1Test < Minitest::Test
   include Secp256k1
 
@@ -42,6 +50,50 @@ class Secp256k1Test < Minitest::Test
     assert_equal true, pk.pubkey.ecdsa_verify('test', sig_raw)
   end
 
+  def test_ecdsa_normalize
+    pk = PrivateKey.new
+    raw_sig = pk.ecdsa_sign 'hi'
+
+    had_to_normalize, normsig = pk.ecdsa_signature_normalize raw_sig
+    assert_equal false, had_to_normalize
+    assert_equal pk.ecdsa_serialize(raw_sig), pk.ecdsa_serialize(normsig)
+    assert_equal pk.ecdsa_serialize_compact(raw_sig), pk.ecdsa_serialize_compact(normsig)
+
+    had_to_normalize, normsig = pk.ecdsa_signature_normalize(raw_sig, check_only: true)
+    assert_equal false, had_to_normalize
+    assert_equal nil, normsig
+
+    sig = "\xAA" + "\xFF"*31 + "\xAA" + "\xFF"*31
+    raw_sig = pk.ecdsa_deserialize_compact sig
+
+    normalized, normsig = pk.ecdsa_signature_normalize raw_sig
+    assert_equal true, normalized
+    assert pk.ecdsa_serialize(raw_sig) != pk.ecdsa_serialize(normsig)
+
+    normalized, normsig = pk.ecdsa_signature_normalize raw_sig, check_only: true
+    assert_equal true, normalized
+    assert_equal nil, normsig
+  end
+
+  def test_ecdsa_recover
+    pk = PrivateKey.new
+    unrelated = MyECDSA.new
+
+    recsig = pk.ecdsa_sign_recoverable 'hello'
+    pubkey = unrelated.ecdsa_recover 'hello', recsig
+    pubser = PublicKey.new(pubkey: pubkey).serialize
+    assert_equal pubser, pk.pubkey.serialize
+
+    recsig_ser = unrelated.ecdsa_recoverable_serialize recsig
+    recsig2 = unrelated.ecdsa_recoverable_deserialize *recsig_ser
+    pubkey2 = unrelated.ecdsa_recover 'hello', recsig2
+    pubser2 = PublicKey.new(pubkey: pubkey2).serialize
+    assert_equal pubser, pubser2
+
+    raw_sig = unrelated.ecdsa_recoverable_convert recsig2
+    unrelated.ecdsa_deserialize(unrelated.ecdsa_serialize(raw_sig))
+  end
+
   private
 
   def ecdsa_sig

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitcoin-secp256k1
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Jan Xie
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-24 00:00:00.000000000 Z
+date: 2016-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi