bitcoin-secp256k1 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 07e0b24c6a5eff2bebfa1287f30299e3e20516a9
+  data.tar.gz: 64b92f4a1274272b62a2b4f8447f7f97b3726e05
+SHA512:
+  metadata.gz: f4123386a3b2add1c25e711eae40013a418fad7d614f0283caa0f5f8e961889de623be103b023035d441d42d4823b964ea129218d857ad66c722560b29f910f1
+  data.tar.gz: 45abd20b35e91cbf4ac5b33fa3b472a32383f140426edce77eabab58180f39ea9afc4e63b85f4cfc6a59f257e6e1dfe6ed8bca1ac3199e8239dedae860ada7bb

data/.gitignore

@@ -0,0 +1,4 @@
+.bundle
+tmp
+lib/ethash/ethash.so
+tags

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "secp256k1"]
+	path = secp256k1
+	url = git@github.com:bitcoin/secp256k1.git

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,25 @@
+PATH
+  remote: .
+  specs:
+    bitcoin-secp256k1 (0.1.1)
+      ffi (>= 1.9.10)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ffi (1.9.10)
+    minitest (5.8.3)
+    rake (10.5.0)
+    yard (0.8.7.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bitcoin-secp256k1!
+  minitest (= 5.8.3)
+  rake (~> 10.5)
+  yard (= 0.8.7.6)
+
+BUNDLED WITH
+   1.11.2

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jan Xie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# ruby-bitcoin-secp256k1
+
+## Prerequiste
+
+In order to use this gem, [libsecp256k1](https://github.com/bitcoin/secp256k1) with recovery module enabled must be in place.
+
+If you have cloned the project and in project root:
+
+```
+git submodule update --init --recursive
+./install_lib.sh
+```
+
+## Install
+
+```
+gem i bitcoin-secp256k1
+```
+
+Then require 'secp256k1' (without `bitcoin-` prefix) in your source code.
+
+## Usage
+
+Check [test](test) for examples.
+
+## LICENSE
+
+[MIT License](LICENSE)
+

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs += %w(lib test)
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+task default: [:test]

data/bitcoin-secp256k1.gemspec

@@ -0,0 +1,23 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'secp256k1/version'
+
+Gem::Specification.new do |s|
+  s.name        = "bitcoin-secp256k1"
+  s.version     = Secp256k1::VERSION
+  s.authors     = ["Jan Xie"]
+  s.email       = ["jan.h.xie@gmail.com"]
+  s.homepage    = "https://github.com/janx/ruby-bitcoin-secp256k1"
+  s.summary     = "Ruby binding to bitcoin's secp256k1 implementation."
+  s.description = "Ruby binding to bitcoin's secp256k1 implementation."
+  s.license     = 'MIT'
+
+  s.files      = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.add_dependency('ffi', '>= 1.9.10')
+
+  s.add_development_dependency('rake', '~> 10.5')
+  s.add_development_dependency('minitest', '5.8.3')
+  s.add_development_dependency('yard', '0.8.7.6')
+end

data/install_lib.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+pushd secp256k1
+./autogen.sh
+./configure --enable-module-recovery --enable-experimental --enable-module-ecdh --enable-module-schnorr
+make && sudo make install
+popd

data/lib/secp256k1.rb

@@ -0,0 +1,19 @@
+require 'secp256k1/version'
+require 'secp256k1/c'
+require 'secp256k1/utils'
+require 'secp256k1/ecdsa'
+require 'secp256k1/key'
+
+module Secp256k1
+
+  EC_COMPRESSED = C::Constants['SECP256K1_EC_COMPRESSED'].to_i
+  EC_UNCOMPRESSED = C::Constants['SECP256K1_EC_UNCOMPRESSED'].to_i
+
+  FLAG_SIGN = C::Constants['SECP256K1_CONTEXT_SIGN'].to_i
+  FLAG_VERIFY = C::Constants['SECP256K1_CONTEXT_VERIFY'].to_i
+  NO_FLAGS = C::Constants['SECP256K1_CONTEXT_NONE'].to_i
+  ALL_FLAGS = FLAG_SIGN | FLAG_VERIFY
+
+  class AssertError < StandardError; end
+
+end

data/lib/secp256k1/c.rb

@@ -0,0 +1,61 @@
+require 'ffi'
+require 'ffi/tools/const_generator'
+
+module Secp256k1
+  module C
+    extend FFI::Library
+
+    ffi_lib (ENV['LIBSECP256K1'] || 'libsecp256k1')
+
+    Constants = FFI::ConstGenerator.new('Secp256k1', required: true) do |gen|
+      gen.include 'secp256k1.h'
+
+      gen.const(:SECP256K1_EC_COMPRESSED)
+      gen.const(:SECP256K1_EC_UNCOMPRESSED)
+
+      gen.const(:SECP256K1_CONTEXT_SIGN)
+      gen.const(:SECP256K1_CONTEXT_VERIFY)
+      gen.const(:SECP256K1_CONTEXT_NONE)
+    end
+
+    class Pubkey < FFI::Struct
+      layout :data, [:uchar, 64]
+    end
+
+    class ECDSASignature < FFI::Struct
+      layout :data, [:uchar, 64]
+    end
+
+    class ECDSARecoverableSignature < FFI::Struct
+      layout :data, [:uchar, 65]
+    end
+
+    # secp256k1_context* secp256k1_context_create(unsigned int flags)
+    attach_function :secp256k1_context_create, [:uint], :pointer
+
+    # 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_seckey_verify(const secp256k1_context* ctx, const unsigned char *seckey)
+    attach_function :secp256k1_ec_seckey_verify, [: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_ecdsa_signature_serialize_compact(const secp256k1_context* ctx, unsigned char *output64, const secp256k1_ecdsa_signature* sig)
+    attach_function :secp256k1_ecdsa_signature_serialize_compact, [:pointer, :pointer, :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_ecdsa_signature_parse_compact(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input64)
+    attach_function :secp256k1_ecdsa_signature_parse_compact, [:pointer, :pointer, :pointer], :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_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
+
+  end
+end

data/lib/secp256k1/ecdsa.rb

@@ -0,0 +1,47 @@
+module Secp256k1
+  module ECDSA
+
+    SIZE_SERIALIZED = 74
+    SIZE_COMPACT = 64
+
+    def ecdsa_serialize(raw_sig)
+      output = FFI::MemoryPointer.new(:uchar, SIZE_SERIALIZED)
+      outputlen = FFI::MemoryPointer.new(:size_t).put_uint(0, SIZE_SERIALIZED)
+
+      res = C.secp256k1_ecdsa_signature_serialize_der(@ctx, output, outputlen, raw_sig)
+      raise AssertError, "failed to seriazlie signature" unless res == 1
+
+      output.read_bytes(outputlen.read_uint)
+    end
+
+    def ecdsa_deserialize(ser_sig)
+      raw_sig = C::ECDSASignature.new.pointer
+
+      res = C.secp256k1_ecdsa_signature_parse_der(@ctx, raw_sig, ser_sig, ser_sig.size)
+      raise AssertError, "raw signature parse failed" unless res == 1
+
+      raw_sig
+    end
+
+    def ecdsa_serialize_compact(raw_sig)
+      output = FFI::MemoryPointer.new(:uchar, SIZE_COMPACT)
+
+      res = C.secp256k1_ecdsa_signature_serialize_compact(@ctx, output, raw_sig)
+      raise AssertError, "failed to seriazlie compact signature" unless res == 1
+
+      output.read_bytes(SIZE_COMPACT)
+    end
+
+    def ecdsa_deserialize_compact(ser_sig)
+      raise ArgumentError, 'invalid signature length' unless ser_sig.size == 64
+
+      raw_sig = C::ECDSASignature.new.pointer
+
+      res = C.secp256k1_ecdsa_signature_parse_compact(@ctx, raw_sig, ser_sig)
+      raise AssertError, "failed to deserialize compact signature" unless res == 1
+
+      raw_sig
+    end
+
+  end
+end

data/lib/secp256k1/key.rb

@@ -0,0 +1,253 @@
+require 'digest'
+require 'securerandom'
+
+module Secp256k1
+
+  class BaseKey
+    def initialize(ctx, flags)
+      @destroy = false
+
+      unless ctx
+        raise ArgumentError, "invalid flags" unless [NO_FLAGS, FLAG_SIGN, FLAG_VERIFY, ALL_FLAGS].include?(flags)
+        ctx = C.secp256k1_context_create flags
+        @destroy = true
+      end
+
+      @flags = flags
+      @ctx = ctx
+
+      ObjectSpace.define_finalizer(self) do |id|
+        C.secp256k1_context_destroy @ctx if @destroy
+      end
+    end
+  end
+
+  class PublicKey < BaseKey
+    include ECDSA, Utils
+
+    attr :public_key
+
+    def initialize(pubkey: nil, raw: false, flags: FLAG_VERIFY, ctx: nil)
+      super(ctx, flags)
+
+      if pubkey
+        if raw
+          raise ArgumentError, 'raw pubkey must be bytes' unless pubkey.instance_of?(String)
+          @public_key = deserialize pubkey
+        else
+          #raise ArgumentError, 'pubkey must be an internal object' unless pubkey.instance_of?(String)
+          @public_key = pubkey
+        end
+      else
+        @public_key = nil
+      end
+    end
+
+    def serialize(compressed: true)
+      raise AssertError, 'No public key defined' unless @public_key
+
+      len_compressed = compressed ? 33 : 65
+      res_compressed = FFI::MemoryPointer.new :char, len_compressed
+      outlen = FFI::MemoryPointer.new(:size_t).write_uint(len_compressed)
+      compflag = compressed ? EC_COMPRESSED : EC_UNCOMPRESSED
+
+      res = C.secp256k1_ec_pubkey_serialize(@ctx, res_compressed, outlen, @public_key, compflag)
+      raise AssertError, 'pubkey serialization failed' unless res == 1
+
+      res_compressed.read_bytes(len_compressed)
+    end
+
+    def deserialize(pubkey_ser)
+      raise ArgumentError, 'unknown public key size (expected 33 or 65)' unless [33,65].include?(pubkey_ser.size)
+
+      pubkey = C::Pubkey.new.pointer
+
+      res = C.secp256k1_ec_pubkey_parse(@ctx, pubkey, pubkey_ser, pubkey_ser.size)
+      raise AssertError, 'invalid public key' unless res == 1
+
+      @public_key = pubkey
+      pubkey
+    end
+
+    ##
+    # Add a number of public keys together.
+    #
+    def combine(pubkeys)
+      raise ArgumentError, 'must give at least 1 pubkey' if pubkeys.empty?
+
+      outpub = FFI::Pubkey.new.pointer
+      #pubkeys.each {|item| }
+
+      res = C.secp256k1_ec_pubkey_combine(@ctx, outpub, pubkeys, pubkeys.size)
+      raise AssertError, 'failed to combine public keys' unless res == 1
+
+      @public_key = outpub
+      outpub
+    end
+
+    ##
+    # Tweak the current public key by adding a 32 byte scalar times the
+    # generator to it and return a new PublicKey instance.
+    #
+    def tweak_add(scalar)
+      tweak_public :secp256k1_ec_pubkey_tweak_add, scalar
+    end
+
+    ##
+    # Tweak the current public key by multiplying it by a 32 byte scalar and
+    # return a new PublicKey instance.
+    #
+    def tweak_mul(scalar)
+      tweak_public :secp256k1_ec_pubkey_tweak_mul, scalar
+    end
+
+    def ecdsa_verify(msg, raw_sig, raw: false, digest: Digest::SHA256)
+      raise AssertError, 'No public key defined' unless @public_key
+      raise AssertError, 'instance not configured for sig verification' if (@flags & FLAG_VERIFY) != FLAG_VERIFY
+
+      msg32 = hash32 msg, raw, digest
+
+      !!C.secp256k1_ecdsa_verify(@ctx, raw_sig, msg32, @public_key)
+    end
+
+    def ecdh(scalar)
+      raise AssertError, 'No public key defined' unless @public_key
+      raise ArgumentError, 'scalar must be composed of 32 bytes' unless scalar.instance_of?(String) && scalar.size == 32
+
+      result = FFI::MemoryPointer.new :char, 32
+
+      res = C.secp256k1_ecdh @ctx, result, @public_key, scalar
+      raise AssertError, "invalid scalar (#{scalar})" unless res == 1
+
+      result.read_bytes(32)
+    end
+
+    private
+
+    def tweak_public(meth, scalar)
+      raise ArgumentError, 'scalar must be composed of 32 bytes' unless scalar.instance_of?(String) && scalar.size == 32
+      raise AssertError, 'No public key defined.' unless @public_key
+
+      newpub = self.class.new serialize, raw: true
+
+      res = C.send meth, newpub.public_key, scalar
+      raise AssertError, 'Tweak is out of range' unless res == 1
+
+      newpub
+    end
+
+  end
+
+  class PrivateKey < BaseKey
+    include ECDSA, Utils
+
+    attr :pubkey
+
+    def initialize(privkey: nil, raw: true, flags: ALL_FLAGS, ctx: nil)
+      raise AssertError, "invalid flags" unless [ALL_FLAGS, FLAG_SIGN].include?(flags)
+
+      super(ctx, flags)
+
+      @pubkey = nil
+      @private_key = nil
+
+      if privkey
+        if raw
+          raise ArgumentError, "privkey must be composed of 32 bytes" unless privkey.instance_of?(String) && privkey.size == 32
+          set_raw_privkey privkey
+        else
+          deserialize privkey
+        end
+      else
+        set_raw_privkey generate_private_key
+      end
+    end
+
+    def ecdsa_sign(msg, raw: false, digest: Digest::SHA256)
+      msg32 = hash32 msg, raw, digest
+      raw_sig = C::ECDSASignature.new.pointer
+
+      res = C.secp256k1_ecdsa_sign @ctx, raw_sig, msg32, @private_key, nil, nil
+      raise AssertError, "failed to sign" unless res == 1
+
+      raw_sig
+    end
+
+    def ecdsa_sign_recoverable(msg, raw: false, digest: Digest::SHA256)
+      msg32 = hash32 msg, raw, digest
+      raw_sig = FFI::MemoryPointer.new :byte, C::ECDSARecoverableSignature, false
+
+      res = C.secp256k1_ecdsa_sign_recoverable @ctx, raw_sig, msg32, @private_key, nil, nil
+      raise AssertError, "failed to sign" unless res == 1
+
+      raw_sig
+    end
+
+    def set_raw_privkey(privkey)
+      raise ArgumentError, "invalid private key" unless C.secp256k1_ec_seckey_verify(@ctx, privkey)
+      @private_key = privkey
+      update_public_key
+    end
+
+    ##
+    # Tweak the current private key by adding a 32 bytes scalar to it and
+    # return a new raw private key composed of 32 bytes.
+    #
+    def tweak_add(scalar)
+      tweak_private :secp256k1_ec_privkey_tweak_add, scalar
+    end
+
+    ##
+    # Tweak the current private key by multiplying it by a 32 byte scalar and
+    # return a new raw private key composed of 32 bytes.
+    #
+    def tweak_mul(scalar)
+      tweak_private :secp256k1_ec_pubkey_tweak_mul, scalar
+    end
+
+    private
+
+    def tweak_private(meth, scalar)
+      raise ArgumentError, "scalar must be composed of 32 bytes" unless scalar.instance_of?(String) && scalar.size == 32
+
+      key = FFI::MemoryPointer.new(:uchar, 32).put_string(@private_key)
+
+      C.send meth, @ctx, key, scalar
+      raise AssertError, "Tweak is out of range" unless res == 1
+
+      key.read_string(32)
+    end
+
+    def update_public_key
+      public_key = generate_public_key @private_key
+      @pubkey = PublicKey.new pubkey: public_key, raw: false, ctx: @ctx, flags: @flags
+    end
+
+    def generate_public_key(privkey)
+      pubkey_ptr = C::Pubkey.new.pointer
+
+      res = C.secp256k1_ec_pubkey_create @ctx, pubkey_ptr, privkey
+      raise AssertError, "failed to generate public key" unless res == 1
+
+      pubkey_ptr
+    end
+
+    def generate_private_key
+      SecureRandom.random_bytes(32)
+    end
+
+    def serialize
+      encode_hex @private_key
+    end
+
+    def deserialize(privkey_serialized)
+      raise ArgumentError, "invalid private key" unless privkey_serialized.size == 64
+
+      rawkey = decode_hex privkey_serialized
+      set_raw_privkey rawkey
+
+      @private_key
+    end
+
+  end
+end