bitcoin-ruby 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac6c9d01c48a263a569a401541007093dbd82e33
-  data.tar.gz: a27f352d83e4a7958004d8d6ff1eee46d12656b2
+  metadata.gz: fa1430d4dfa8bcf7f4e23a098341ef1803797d8b
+  data.tar.gz: 1d4f1c0a5b163c7d42d07e4056d6a497719167b4
 SHA512:
-  metadata.gz: dfcdaf331ed1a47de70e8557c7de2acdd04e255da1fb5ffbd787f83c4f84ba7963b122924e4a7c61f9e36a407dbcc57294ebf122a614afc9134f118b388811f0
-  data.tar.gz: c7909f9e27da531aa015701342559ec39a742c73171e3f8c8bc5de82f699d57c3be1318bce9f0b71caae24b5226d6f48d002cddcc32ed37bc33d5b430d98029e
+  metadata.gz: a790a81f8a5bd8a94e8794e599b0ab5ca62f2b4568efce9924ffbc1fabd2805307ef9e8695cb2c9383907eff3ab62081fc8dd798d1985bcd11623e0155070c84
+  data.tar.gz: 5ab37c03ed8b4ba6f15a95c1ab29d564c2b5200309b75ef5667f9dc9f3003e267f8bf7c14ddf42fe9b56f53c6e26e221850e0f74af81e1fa731cfdd88e87218f

data/.travis.yml

@@ -1,5 +1,4 @@
 language: ruby
 rvm:
-  - 2.0.0
-  - 2.1.2
   - 2.2.0
+  - 2.3.2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bitcoin-ruby (0.0.9)
+    bitcoin-ruby (0.0.8)
 
 GEM
   remote: https://rubygems.org/

data/lib/bitcoin/ffi/openssl.rb

@@ -277,6 +277,8 @@ module OpenSSL_EC
   end
 
   def self.sign_compact(hash, private_key, public_key_hex = nil, pubkey_compressed = nil)
+    msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, hash)
+
     private_key = [private_key].pack("H*") if private_key.bytesize >= 64
     private_key_hex = private_key.unpack("H*")[0]
 
@@ -295,7 +297,7 @@ module OpenSSL_EC
     EC_KEY_set_private_key(eckey, priv_key)
     EC_KEY_set_public_key(eckey, pub_key)
 
-    signature = ECDSA_do_sign(hash, hash.bytesize, eckey)
+    signature = ECDSA_do_sign(msg32, msg32.size, eckey)
 
     BN_free(order)
     BN_CTX_free(ctx)
@@ -309,7 +311,7 @@ module OpenSSL_EC
     if signature.get_array_of_pointer(0, 2).all?{|i| BN_num_bits(i) <= 256 }
       4.times{|i|
         head = [ 27 + i + (pubkey_compressed ? 4 : 0) ].pack("C")
-        if public_key_hex == recover_public_key_from_signature(hash, [head, r, s].join, i, pubkey_compressed)
+        if public_key_hex == recover_public_key_from_signature(msg32.read_string(32), [head, r, s].join, i, pubkey_compressed)
           rec_id = i; break
         end
       }
@@ -322,14 +324,13 @@ module OpenSSL_EC
 
   def self.recover_compact(hash, signature)
     return false if signature.bytesize != 65
-    #i = signature.unpack("C")[0] - 27
-    #pubkey = recover_public_key_from_signature(hash, signature, (i & ~4), i >= 4)
+    msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, hash)
 
     version = signature.unpack('C')[0]
     return false if version < 27 or version > 34
 
     compressed = (version >= 31) ? (version -= 4; true) : false
-    pubkey = recover_public_key_from_signature(hash, signature, version-27, compressed)
+    pubkey = recover_public_key_from_signature(msg32.read_string(32), signature, version-27, compressed)
   end
 
   # lifted from https://github.com/GemHQ/money-tree

data/lib/bitcoin/ffi/secp256k1.rb

@@ -1,8 +1,15 @@
 # encoding: ascii-8bit
 
-# bindings for secp256k1 inside bitcoin (https://github.com/bitcoin/bitcoin/tree/v0.11.0/src/secp256k1)
-# tag: v0.11.0
-# commit: d26f951802c762de04fb68e1a112d611929920ba
+# bindings for secp256k1 inside bitcoin (https://github.com/bitcoin/bitcoin/tree/v0.13.1/src/secp256k1)
+# tag: v0.13.1
+# commit: 03422e564b552c1d3c16ae854f8471f7cb39e25d
+#  bitcoin@master% git checkout v0.13.1
+#  bitcoin@tags/v0.13.1^0% cd src/secp256k1
+#  bitcoin@tags/v0.13.1^0 src/secp256k1% ./autogen.sh
+#  bitcoin@tags/v0.13.1^0 src/secp256k1% ./configure --enable-module-recovery
+#  bitcoin@tags/v0.13.1^0 src/secp256k1% make libsecp256k1.la
+#  bitcoin@tags/v0.13.1^0 src/secp256k1% nm -D .libs/libsecp256k1.so.0.0.0 | grep secp
+#  export SECP256K1_LIB_PATH=/path/to/bitcoin/src/secp256k1/.libs/libsecp256k1.so.0.0.0
 
 require 'ffi'
 
@@ -10,70 +17,82 @@ module Bitcoin
   module Secp256k1
     extend FFI::Library
 
-    SECP256K1_START_VERIFY = (1 << 0)
-    SECP256K1_START_SIGN   = (1 << 1)
+    SECP256K1_FLAGS_TYPE_MASK = ((1 << 8) - 1)
+    SECP256K1_FLAGS_TYPE_CONTEXT = (1 << 0)
+    SECP256K1_FLAGS_TYPE_COMPRESSION = (1 << 1)
+
+    # The higher bits contain the actual data. Do not use directly.
+    SECP256K1_FLAGS_BIT_CONTEXT_VERIFY = (1 << 8)
+    SECP256K1_FLAGS_BIT_CONTEXT_SIGN = (1 << 9)
+    SECP256K1_FLAGS_BIT_COMPRESSION = (1 << 8)
+
+    # Flags to pass to secp256k1_context_create.
+    SECP256K1_CONTEXT_VERIFY = (SECP256K1_FLAGS_TYPE_CONTEXT | SECP256K1_FLAGS_BIT_CONTEXT_VERIFY)
+    SECP256K1_CONTEXT_SIGN = (SECP256K1_FLAGS_TYPE_CONTEXT | SECP256K1_FLAGS_BIT_CONTEXT_SIGN)
+
+    # Flag to pass to secp256k1_ec_pubkey_serialize and secp256k1_ec_privkey_export.
+    SECP256K1_EC_COMPRESSED = (SECP256K1_FLAGS_TYPE_COMPRESSION | SECP256K1_FLAGS_BIT_COMPRESSION)
+    SECP256K1_EC_UNCOMPRESSED = (SECP256K1_FLAGS_TYPE_COMPRESSION)
 
     def self.ffi_load_functions(file)
       class_eval <<-RUBY
         ffi_lib [ %[#{file}] ]
 
         ##
-        # source: https://github.com/bitcoin/bitcoin/blob/v0.11.0/src/secp256k1/include/secp256k1.h
+        # source: https://github.com/bitcoin/bitcoin/blob/v0.13.1/src/secp256k1/include/secp256k1.h
         ##
 
-        # secp256k1_context_t* secp256k1_context_create(int flags)
-        attach_function :secp256k1_context_create, [:int], :pointer
+        # secp256k1_context* secp256k1_context_create(unsigned int flags)
+        attach_function :secp256k1_context_create, [:uint], :pointer
 
-        # secp256k1_context_t* secp256k1_context_clone(const secp256k1_context_t* ctx)
-        attach_function :secp256k1_context_clone, [:pointer], :pointer
-
-        # void secp256k1_context_destroy(secp256k1_context_t* ctx)
+        # void secp256k1_context_destroy(secp256k1_context* ctx)
         attach_function :secp256k1_context_destroy, [:pointer], :void
 
-        # int secp256k1_ecdsa_verify(const secp256k1_context_t* ctx, const unsigned char *msg32, const unsigned char *sig, int siglen, const unsigned char *pubkey, int pubkeylen)
-        attach_function :secp256k1_ecdsa_verify, [:pointer, :pointer, :pointer, :int, :pointer, :int], :int
+        # int secp256k1_context_randomize(secp256k1_context* ctx, const unsigned char *seed32)
+        attach_function :secp256k1_context_randomize, [:pointer, :pointer], :int
 
-        # int secp256k1_ecdsa_sign(const secp256k1_context_t* ctx, const unsigned char *msg32, unsigned char *sig, int *siglen, const unsigned char *seckey, secp256k1_nonce_function_t noncefp, const void *ndata)
-        attach_function :secp256k1_ecdsa_sign, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int
+        # int secp256k1_ec_seckey_verify(const secp256k1_context* ctx, const unsigned char *seckey)
+        attach_function :secp256k1_ec_seckey_verify, [:pointer, :pointer], :int
 
-        # int secp256k1_ecdsa_sign_compact(const secp256k1_context_t* ctx, const unsigned char *msg32, unsigned char *sig64, const unsigned char *seckey, secp256k1_nonce_function_t noncefp, const void *ndata, int *recid)
-        attach_function :secp256k1_ecdsa_sign_compact, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int
+        # 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_ecdsa_recover_compact(const secp256k1_context_t* ctx, const unsigned char *msg32, const unsigned char *sig64, unsigned char *pubkey, int *pubkeylen, int compressed, int recid)
-        attach_function :secp256k1_ecdsa_recover_compact, [:pointer, :pointer, :pointer, :pointer, :pointer, :int, :int], :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_t* ctx, const unsigned char *seckey)
-        attach_function :secp256k1_ec_seckey_verify, [: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_ec_pubkey_verify(const secp256k1_context_t* ctx, const unsigned char *pubkey, int pubkeylen)
-        attach_function :secp256k1_ec_pubkey_verify, [:pointer, :pointer, :int], :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_ec_pubkey_create(const secp256k1_context_t* ctx, unsigned char *pubkey, int *pubkeylen, const unsigned char *seckey, int compressed)
-        attach_function :secp256k1_ec_pubkey_create, [:pointer, :pointer, :pointer, :pointer, :int], :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_ec_pubkey_decompress(const secp256k1_context_t* ctx, unsigned char *pubkey, int *pubkeylen)
-        attach_function :secp256k1_ec_pubkey_decompress, [:pointer, :pointer, :pointer], :int
+        # int secp256k1_ecdsa_recover(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const secp256k1_ecdsa_recoverable_signature *sig, const unsigned char *msg32)
+        attach_function :secp256k1_ecdsa_recover, [:pointer, :pointer, :pointer, :pointer], :int
 
-        # int secp256k1_ec_privkey_export(const secp256k1_context_t* ctx, const unsigned char *seckey, unsigned char *privkey, int *privkeylen, int compressed)
-        attach_function :secp256k1_ec_privkey_export, [:pointer, :pointer, :pointer, :pointer, :int], :int
+        # 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_ec_privkey_import(const secp256k1_context_t* ctx, unsigned char *seckey, const unsigned char *privkey, int privkeylen)
-        attach_function :secp256k1_ec_privkey_import, [:pointer, :pointer, :pointer, :pointer], :int
+        # int secp256k1_ecdsa_signature_serialize_der(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_ecdsa_signature* sig)
+        attach_function :secp256k1_ecdsa_signature_serialize_der, [:pointer, :pointer, :pointer, :pointer], :int
 
-        # int secp256k1_ec_privkey_tweak_add(const secp256k1_context_t* ctx, unsigned char *seckey, const unsigned char *tweak)
-        attach_function :secp256k1_ec_privkey_tweak_add, [:pointer, :pointer, :pointer], :int
+        # int secp256k1_ec_pubkey_parse(const secp256k1_context* ctx, secp256k1_pubkey* pubkey, const unsigned char *input, size_t inputlen)
+        attach_function :secp256k1_ec_pubkey_parse, [:pointer, :pointer, :pointer, :size_t], :int
 
-        # int secp256k1_ec_pubkey_tweak_add(const secp256k1_context_t* ctx, unsigned char *pubkey, int pubkeylen, const unsigned char *tweak)
-        attach_function :secp256k1_ec_pubkey_tweak_add, [:pointer, :pointer, :int, :pointer], :int
+        # int secp256k1_ecdsa_signature_normalize(const secp256k1_context* ctx, secp256k1_ecdsa_signature *sigout, const secp256k1_ecdsa_signature *sigin)
+        attach_function :secp256k1_ecdsa_signature_normalize, [:pointer, :pointer, :pointer], :int
 
-        # int secp256k1_ec_privkey_tweak_mul(const secp256k1_context_t* ctx, unsigned char *seckey, const unsigned char *tweak)
-        attach_function :secp256k1_ec_privkey_tweak_mul, [: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_ec_pubkey_tweak_mul(const secp256k1_context_t* ctx, unsigned char *pubkey, int pubkeylen, const unsigned char *tweak)
-        attach_function :secp256k1_ec_pubkey_tweak_mul, [:pointer, :pointer, :int, :pointer], :int
+        # int secp256k1_ecdsa_signature_parse_der(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen)
+        attach_function :secp256k1_ecdsa_signature_parse_der, [:pointer, :pointer, :pointer, :size_t], :int
 
-        # int secp256k1_context_randomize(secp256k1_context_t* ctx, const unsigned char *seed32)
-        attach_function :secp256k1_context_randomize, [:pointer, :pointer], :int
+        # TODO: add or port
+        # # int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) 
+        # attach_function :ecdsa_signature_parse_der_lax, [:pointer, :pointer, :pointer, :size_t], :int
       RUBY
     end
 
@@ -86,7 +105,7 @@ module Bitcoin
 
     def self.with_context(flags=nil, seed=nil)
       init
-      flags = flags || (SECP256K1_START_VERIFY | SECP256K1_START_SIGN )
+      flags = flags || (SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN)
       context = secp256k1_context_create(flags)
 
       ret, tries, max = 0, 0, 20
@@ -109,15 +128,25 @@ module Bitcoin
           raise "secp256k1_ec_seckey_verify in generate_key_pair failed." if tries >= max
           tries += 1
 
-          priv_key = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, SecureRandom.random_bytes(32))
-          ret = secp256k1_ec_seckey_verify(context, priv_key)
+          seckey = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, SecureRandom.random_bytes(32))
+          ret = secp256k1_ec_seckey_verify(context, seckey)
         end
 
-        pub_key, pub_key_length = FFI::MemoryPointer.new(:uchar, 65), FFI::MemoryPointer.new(:int)
-        result = secp256k1_ec_pubkey_create(context, pub_key, pub_key_length, priv_key, compressed ? 1 : 0)
+        internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
+        result = secp256k1_ec_pubkey_create(context, internal_pubkey, seckey)
         raise "error creating pubkey" unless result
 
-        [ priv_key.read_string(32), pub_key.read_string(pub_key_length.read_int) ]
+        pubkey, pubkey_len = FFI::MemoryPointer.new(:uchar, 65), FFI::MemoryPointer.new(:uint64)
+        result = if compressed
+          pubkey_len.put_uint64(0, 33)
+          secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_COMPRESSED)
+        else
+          pubkey_len.put_uint64(0, 65)
+          secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_UNCOMPRESSED)
+        end
+        raise "error serialize pubkey" unless result || pubkey_len.read_uint64 > 0
+
+        [ seckey.read_string(32), pubkey.read_string(pubkey_len.read_uint64) ]
       end
     end
 
@@ -128,53 +157,77 @@ module Bitcoin
 
     def self.sign(data, priv_key)
       with_context do |context|
-        msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
         seckey = FFI::MemoryPointer.new(:uchar, priv_key.bytesize).put_bytes(0, priv_key)
         raise "priv_key invalid" unless secp256k1_ec_seckey_verify(context, seckey)
 
-        sig, siglen = FFI::MemoryPointer.new(:uchar, 72), FFI::MemoryPointer.new(:int).write_int(72)
+        internal_signature = FFI::MemoryPointer.new(:uchar, 64)
+        msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
 
-        while true do
-          break if secp256k1_ecdsa_sign(context, msg32, sig, siglen, seckey, nil, nil)
+        ret, tries, max = 0, 0, 20
+        while ret != 1
+          raise "secp256k1_ecdsa_sign failed." if tries >= max
+          tries += 1
+
+          ret = secp256k1_ecdsa_sign(context, internal_signature, msg32, seckey, nil, nil)
         end
 
-        sig.read_string(siglen.read_int)
+        signature, signature_len = FFI::MemoryPointer.new(:uchar, 72), FFI::MemoryPointer.new(:uint64).put_uint64(0, 72)
+        result = secp256k1_ecdsa_signature_serialize_der(context, signature, signature_len, internal_signature)
+        raise "secp256k1_ecdsa_signature_serialize_der failed" unless result
+
+        signature.read_string(signature_len.read_uint64)
       end
     end
 
-    def self.verify(data, signature, pub_key)
+    def self.verify(data, sig, pub_key)
       with_context do |context|
-        data_buf = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
-        sig_buf  = FFI::MemoryPointer.new(:uchar, signature.bytesize).put_bytes(0, signature)
-        pub_buf  = FFI::MemoryPointer.new(:uchar, pub_key.bytesize).put_bytes(0, pub_key)
-
-        result = secp256k1_ecdsa_verify(context, data_buf, sig_buf, sig_buf.size, pub_buf, pub_buf.size)
-
-        case result
-        when  0; false
-        when  1; true
-        when -1; raise "error invalid pubkey"
-        when -2; raise "error invalid signature"
-        else   ; raise "error invalid result"
-        end
+        return false if data.bytesize == 0
+
+        pubkey = FFI::MemoryPointer.new(:uchar, pub_key.bytesize).put_bytes(0, pub_key)
+        internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
+        result = secp256k1_ec_pubkey_parse(context, internal_pubkey, pubkey, pubkey.size)
+        return false unless result
+
+        signature = FFI::MemoryPointer.new(:uchar, sig.bytesize).put_bytes(0, sig)
+        internal_signature = FFI::MemoryPointer.new(:uchar, 64)
+        result = secp256k1_ecdsa_signature_parse_der(context, internal_signature, signature, signature.size)
+        #result = ecdsa_signature_parse_der_lax(context, internal_signature, signature, signature.size)
+        return false unless result
+
+        # libsecp256k1's ECDSA verification requires lower-S signatures, which have not historically been enforced in Bitcoin, so normalize them first.
+        secp256k1_ecdsa_signature_normalize(context, internal_signature, internal_signature)
+
+        msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
+        result = secp256k1_ecdsa_verify(context, internal_signature, msg32, internal_pubkey)
+
+        return result ? true : false
       end
     end
 
     def self.sign_compact(message, priv_key, compressed=true)
       with_context do |context|
-        msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, message)
-        sig64 = FFI::MemoryPointer.new(:uchar, 64)
-        rec_id = FFI::MemoryPointer.new(:int)
-
         seckey = FFI::MemoryPointer.new(:uchar, priv_key.bytesize).put_bytes(0, priv_key)
         raise "priv_key invalid" unless secp256k1_ec_seckey_verify(context, seckey)
 
-        while true do
-          break if secp256k1_ecdsa_sign_compact(context, msg32, sig64, seckey, nil, nil, rec_id)
+        msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, message)
+        internal_recoverable_signature = FFI::MemoryPointer.new(:uchar, 65)
+        rec_id = FFI::MemoryPointer.new(:int).put_int(0, -1)
+
+        ret, tries, max = 0, 0, 20
+        while ret != 1
+          raise "secp256k1_ecdsa_sign_recoverable failed." if tries >= max
+          tries += 1
+
+          ret = secp256k1_ecdsa_sign_recoverable(context, internal_recoverable_signature, msg32, seckey, nil, nil)
         end
 
+        recoverable_signature = FFI::MemoryPointer.new(:uchar, 64)
+        result = secp256k1_ecdsa_recoverable_signature_serialize_compact(context, recoverable_signature, rec_id, internal_recoverable_signature)
+        raise "secp256k1_ecdsa_recoverable_signature_serialize_compact failed" unless result
+        raise "secp256k1_ecdsa_recoverable_signature_serialize_compact failed" unless rec_id.read_int != -1
+
         header = [27 + rec_id.read_int + (compressed ? 4 : 0)].pack("C")
-        [ header, sig64.read_string(64) ].join
+        [ header, recoverable_signature.read_string(64) ].join
       end
     end
 
@@ -186,19 +239,26 @@ module Bitcoin
         return nil if version < 27 || version > 34
 
         compressed = version >= 31 ? true : false
+        flag = compressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED
         version -= 4 if compressed
 
         recid = version - 27
         msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, message)
-        sig64 = FFI::MemoryPointer.new(:uchar, 64).put_bytes(0, signature[1..-1])
-        pubkey = FFI::MemoryPointer.new(:uchar, pub_key_len = compressed ? 33 : 65)
-        pubkeylen = FFI::MemoryPointer.new(:int).write_int(pub_key_len)
+        recoverable_signature = FFI::MemoryPointer.new(:uchar, 64).put_bytes(0, signature[1..-1])
 
-        result = secp256k1_ecdsa_recover_compact(context, msg32, sig64, pubkey, pubkeylen, (compressed ? 1 : 0), recid)
+        internal_recoverable_signature = FFI::MemoryPointer.new(:uchar, 65)
+        result = secp256k1_ecdsa_recoverable_signature_parse_compact(context, internal_recoverable_signature, recoverable_signature, recid)
+        return nil unless result
 
+        internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
+        result = secp256k1_ecdsa_recover(context, internal_pubkey, internal_recoverable_signature, msg32)
         return nil unless result
 
-        pubkey.read_bytes(pubkeylen.read_int)
+        pubkey, pubkey_len = FFI::MemoryPointer.new(:uchar, 65), FFI::MemoryPointer.new(:uint64).put_uint64(0, 65)
+        result = secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, flag)
+        raise "error serialize pubkey" unless result || pubkey_len.read_uint64 > 0
+
+        pubkey.read_string(pubkey_len.read_uint64)
       end
     end
 

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.0.9"
+  VERSION = "0.0.10"
 end

data/spec/bitcoin/secp256k1_spec.rb

@@ -27,6 +27,7 @@ describe 'libsecp256k1' do
     priv, pub = Bitcoin::Secp256k1.generate_key_pair
     signature = Bitcoin::Secp256k1.sign("derp", priv)
     Bitcoin::Secp256k1.verify("derp", signature, pub).should == true
+    Bitcoin::Secp256k1.verify("DERP", signature, pub).should == true
   end
 
   it 'sign compact and recover' do
@@ -51,6 +52,27 @@ describe 'libsecp256k1' do
     first  = Bitcoin::Secp256k1.sign("derp", priv)
     second = Bitcoin::Secp256k1.sign("derp", priv)
     first.should == second
+
+    priv, pub = Bitcoin::Secp256k1.generate_key_pair
+    second = Bitcoin::Secp256k1.sign("derp", priv)
+    first.should != second
+  end
+
+  it 'openssl vs Secp256k1' do
+    k = Bitcoin::Key.new("82a0c421a0f67c7a88a329b2c15f2849aa1c8cfa9c9a6513f056f80ee8eaacc4", nil, compresed=false); k.pub
+    k.pub.should == "0490b0854581a291b83c1945775f156da22445df99e445581321ac3aa62535ff369334316dfd157acc7bb2e4d3eb85951f6d1b7f62f6f60a09e0dbd5c87d3ffae9"
+
+    message = "hello world"
+    priv = [k.priv].pack("H*")
+
+    sig1 = Bitcoin::OpenSSL_EC.sign_compact(message, priv, nil, compressed=false)
+    sig2 = Bitcoin::Secp256k1.sign_compact(message, priv, compressed=false)
+
+    Bitcoin::OpenSSL_EC.recover_compact(message, sig1).should == k.pub
+    Bitcoin::Secp256k1.recover_compact(message, sig1).unpack("H*")[0].should == k.pub
+
+    Bitcoin::OpenSSL_EC.recover_compact(message, sig2).should == k.pub
+    Bitcoin::Secp256k1.recover_compact(message, sig2).unpack("H*")[0] == k.pub
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitcoin-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - lian
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-13 00:00:00.000000000 Z
+date: 2017-01-16 00:00:00.000000000 Z
 dependencies: []
 description: This is a ruby library for interacting with the bitcoin protocol/network
 email:
@@ -245,7 +245,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: bitcoin-ruby
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: bitcoin utils and protocol in ruby