hdet-ec-key 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fcb033ee0743d2afde945e3751dcd25cdad97aa555b96eb1fe5019b8cc209005
+  data.tar.gz: 00e91fabee3f2e82741a7e51ed2906c2952aa03e5bf949e6693cd728470052a4
+SHA512:
+  metadata.gz: 9ded3bcc9aee7b1c52519ee9da5650b26ddcc10e05d1c3dc1c4316c36491dfe7295bfd5034a971fed7ce8ecbae51852791859c2dda8e175a229f942476a1057a
+  data.tar.gz: dda56d995c45047886960bb2424e1fa6fea72ec8a42a45fae2b6f05a20d89e73f18be9cecfcc9e9564a8319ae94bbdcae8b2646fbee9cadda4938add23aae673

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Stéphane Clérambault
+
+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.adoc

@@ -0,0 +1,88 @@
+= HDetEcKey
+
+HDetEcKey is a Ruby implement of https://en.bitcoin.it/wiki/Deterministic_Wallet[Hierachical Deterministic wallets] according to the specification https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki[BIP0032].
+
+== What is use for ?
+
+
+== How to get it !
+
+[source, bash]
+----
+git clone https://gitlab.com/elionne/hdet-ec-key.git
+----
+
+Or in a neer future:
+
+[source, bash]
+----
+gem install hdet-ec-key
+----
+
+=== Prerequistes
+
+- Ruby 2.5.0
+- Openssl (ruby included)
+
+Support of other version of Ruby should be possible.
+
+== Usage
+
+For more details about how Herarchical Deterministic Wallet works, please see the https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki[BIP0032] specifications.
+
+=== Generate master key
+
+First you need to generate the first key.
+The point where all keys starts.
+The BIP32 standard specify simple method with `HMAC512`.
+The default key is _Bitcoin seed_ and the seed is choosen by the user.
+
+To generate a master key:
+
+[source, ruby]
+----
+seed = ["000102030405060708090a0b0c0d0e0f"].pack("H*")
+master_key = HDetEc::Key.generate_master_key(seed)
+----
+
+No convertion of the given string is operated, the `seed` is used _as is_.
+The `key` can be change by setting the second parameter:
+
+[source, ruby]
+----
+master_key = HDetEc::Key.generate_master_key(seed, "my special key")
+----
+
+=== Public key, private and public derivation
+
+To get the public key from the a key:
+
+[source, ruby]
+----
+pub = master_key.public_key
+
+# or a more verbose version
+pub = master.public_key_from_private
+----
+
+Then you can derive, ether public or private key:
+
+[source, ruby]
+----
+pub.derive([0, 1, 2000])
+master_key.derive(0, 1.h, 2000)
+----
+
+The _derivation path_ is determined by an array of index.
+the _#h_ function for interger means *harderned* index, only available for private key derivation.
+
+=== Serialization
+
+Each keys can be serialized in BIP32 specified form:
+
+[source,ruby]
+----
+pub.serialize # xpub.....
+master_key.serialize # xprv.....
+----
+

data/VERSION

@@ -0,0 +1 @@
+1.0

data/lib/hdet-ec-key.rb

@@ -0,0 +1,18 @@
+require 'openssl'
+require 'digest'
+require 'base58'
+
+# @abstract Use for hardened index
+#
+# @return the self plus 2^31
+class Integer
+  def h
+    2**31 + self
+  end
+end
+
+module HDetEc
+  autoload :DataManipulation, 'hdet-ec-key/data_manipulation'
+  autoload :ECManipulation, 'hdet-ec-key/ec_manipulation'
+  autoload :Key, 'hdet-ec-key/key'
+end

data/lib/hdet-ec-key/data_manipulation.rb

@@ -0,0 +1,60 @@
+
+module HDetEc
+  module DataManipulation
+
+    # Serialize a 32-bit unsigned integer i as a 4-byte sequence, most
+    # significant byte first.
+    def ser32(i)
+      [i].pack("l>")
+    end
+
+    def to_binary(num, byte_length=1)
+      num = num.to_i if num.kind_of? OpenSSL::BN
+
+      hex_num = num.to_s(16).rjust(byte_length*2, "0")
+      hex_num = "0" + hex_num if hex_num.size.odd?
+
+      bin = [hex_num].pack("H*")
+    end
+
+    def to_number(bin)
+      bin.unpack1("H*").to_i 16
+    end
+
+    # Serializes the integer p as a 32-byte sequence, most significant byte first.
+    def ser256(p)
+      raise ArgumentError, "overflow" if p.bit_length > 256
+      to_binary(p, 256/8)
+    end
+
+    def left_hash(h)
+      h[0..31]
+    end
+
+    def right_hash(h)
+      h[32..63]
+    end
+
+    def split_hash(h)
+      [left_hash(h), right_hash(h)]
+    end
+
+    def rmd160_sha256(data)
+      Digest::RMD160.digest Digest::SHA256.digest(data)
+    end
+
+    alias :hash160 :rmd160_sha256
+
+    def double_sha256(data)
+      Digest::SHA256.digest Digest::SHA256.digest(data)
+    end
+
+    alias :hash256 :double_sha256
+
+
+    # Interprets a 32-byte sequence as a 256-bit number, most significant byte
+    # first.
+    alias :parse256 :to_number
+
+  end
+end

data/lib/hdet-ec-key/ec_manipulation.rb

@@ -0,0 +1,133 @@
+require 'openssl'
+
+module HDetEc
+  module ECManipulation
+
+    # The default group is the same as used by Bitcoin network, "secp256k1". But
+    # it can be change, just provide the a OpenSSL group string.
+    #
+    # example:
+    #  HDetEc::Key.group = "secp256r1"
+    #
+    def group=(openssl_group)
+      @@group = OpenSSL::PKey::EC.new(openssl_group).group
+      @@group.point_conversion_form = :compressed
+      @@group
+    end
+
+    def group
+      @@group ||= OpenSSL::PKey::EC.new("secp256k1").group
+      @@group.point_conversion_form = :compressed
+      @@group
+    end
+
+    # @abstract Generate public key from the private one
+    #
+    # The input parameter {#private_key} a binary string representation of the
+    # private key
+    #
+    # @return [String] The output is a binary representation of the public key
+    #   in the compressed form.
+    def generate_public_key_from_private(private_key)
+      bn_private_key = OpenSSL::BN.new private_key, 2
+
+      public_key = group.generator.mul(bn_private_key)
+      public_key.to_bn.to_s(2)
+    end
+
+    alias_method :point, :generate_public_key_from_private
+
+    # @abstract Generic derivation method for hardened keys
+    #
+    # Alogrithm to derive only hardened private key. That means no {#index}
+    # below 2^31 are allowed.
+    def child_key_derivation_hardened(extended_key, index)
+      k, c = extended_key
+      key = c
+      data = "\x00" + k + ser32(index)
+      OpenSSL::HMAC.digest('SHA512', key, data)
+    end
+
+    alias_method :CKDh, :child_key_derivation_hardened
+
+    # @abstract Generic derivation method for non-hardened keys
+    #
+    # Alogrithm to derive public and private key if it not hardened key. That
+    # means no {#index} above 2^31 - 1 are allowed.
+    def child_key_derivation(extended_key, index)
+      k, c = extended_key
+      key = c
+      data = serp(k) + ser32(index)
+      OpenSSL::HMAC.digest('SHA512', key, data)
+    end
+
+    alias_method :CKD, :child_key_derivation
+
+    # @abstract Derive a public key according to BIP32 specifications
+    #
+    # Public parent key → public child key.
+    #
+    # @param extended_key [Array] extended_key
+    # @param index [Integer]
+    #
+    # @note
+    #   https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#private-parent-key--private-child-key
+    def child_key_derivation_private(extended_key, index)
+      k, c = extended_key
+
+      if index >= 2**31
+        inter = child_key_derivation_hardened(extended_key, index)
+      else
+        inter = child_key_derivation([point(k), c], index)
+      end
+
+      iL, iR = split_hash(inter)
+
+      bn = parse256(iL) + parse256(k)
+      k_child = OpenSSL::BN.new(bn) % group.order
+
+      [k_child.to_s(2), iR]
+    end
+
+    alias_method :CKDpriv, :child_key_derivation_private
+
+
+    # @abstract Derive a public key according to BIP32 specifications
+    #
+    # Public parent key → public child key.
+    #
+    # @param extended_key [Array] extended_key
+    # @param index [Integer]
+    #
+    # @note
+    #   https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#public-parent-key--public-child-key
+    def child_key_derivation_public(extended_key, index)
+      k, c = extended_key
+      if index >= 2**31
+        raise "No hardened public key derivation possible"
+      end
+
+      inter = child_key_derivation(extended_key, index)
+
+      iL, iR = split_hash(inter)
+
+      bn = OpenSSL::BN.new(iL, 2)
+      pub_key = OpenSSL::PKey::EC::Point.new(group, k).mul(1, bn)
+      [pub_key.to_octet_string(:compressed), iR]
+    end
+
+    alias_method :CKDpub, :child_key_derivation_public
+
+    # Serializes the coordinate pair P = (x,y) as a byte sequence using SEC1's
+    # compressed form: (0x02 or 0x03) || ser256(x), where the header byte
+    # depends on the parity of the omitted y coordinate.
+    # input kp: public key
+    def serp(kp)
+      # ensure kp is in compressed form
+      point = OpenSSL::PKey::EC::Point.new(group, kp)
+      point.to_octet_string(:compressed)
+    end
+
+  end
+end
+

data/lib/hdet-ec-key/key.rb

@@ -0,0 +1,198 @@
+
+module HDetEc
+
+  class Key
+
+    class << self
+      include DataManipulation
+      include ECManipulation
+
+      # @abstract Generate a master extended key from {#seed} and {#key}
+      #
+      # According to BIP32 specification, the master key is generated from a
+      # HMAC512 and splited in two vector of 256 bits each. The first is the
+      # master key and the later is the chain code.
+      #
+      # You just have to provide the {#seed}. The standard {#key} is
+      # "Bitcoin seed" but it can be overrided.
+      #
+      # The {#seed} could be any kind of string. No convertion is performed (idem
+      # for {#key}), so if you want a binary seed represented by the hex form you
+      # have to convert it like:
+      #
+      # @example: Binary seed with hex form
+      #   seed = ["000102030405060708090a0b0c0d0e0f"].pack("H*")
+      #
+      #
+      # @return [Key] A new master key.
+      # @note
+      #   https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#master-key-generation
+      def generate_master_key(seed, key = "Bitcoin seed")
+        inter = OpenSSL::HMAC.digest('SHA512', key, seed)
+        m = split_hash(inter)
+        Key.new(m, :private, 0, 0, "\x00" * 4)
+      end
+
+
+      # @abstract Import a serialized key in as describe in BIP32 specification
+      #
+      # Conforming to the BIP32 specification, the key should start with 'xpub'
+      # or 'xprv'. Other version of testnet is not supported.
+      #
+      # Because a checksum is stored in the key, this function check the
+      # integrety of imported data, if check sum could not be verified it raise
+      # an ArgumentError "Wrong checksum".
+      def import(serialized_key_string)
+        data = Base58.base58_to_binary(serialized_key_string, :bitcoin)
+
+        unpacked = data.unpack("L>Ca4L>a32a33a4")
+        version, depth, parent_fingerprint, index, c, k, checksum = unpacked
+
+        # Remove checksum from data
+        data.slice!(-4..-1)
+
+        raise ArgumentError, "Wrong checksum" unless hash256(data)[0..3] == checksum
+
+        case version
+        when 0x0488ADE4
+          k.slice!(0)
+          Key.new([k, c], :private, depth, index, parent_fingerprint)
+        when 0x0488B21E
+          Key.new([k, c], :public, depth, index, parent_fingerprint)
+        else raise "version not supported #{version.to_s(16)}"
+        end
+
+      end
+    end
+
+    include DataManipulation
+
+    attr_reader :key, :depth, :index, :public_or_private, :chain_code
+    attr_reader :parent_fingerprint, :fingerprint
+
+    def initialize(extended_k, public_or_private, depth, index, parent_fingerprint)
+      @depth = depth
+      @index = index
+      @key, @chain_code = extended_k
+      @public_or_private = public_or_private
+      @parent_fingerprint = parent_fingerprint
+    end
+
+    def public_key
+      case public_or_private
+      when :public
+        self
+      when :private
+        Key.new([Key.point(key), chain_code], :public, depth, index, parent_fingerprint)
+      end
+    end
+
+    alias_method :public_key_from_private, :public_key
+
+    def public?
+      public_or_private == :public
+    end
+
+    def private?
+      public_or_private == :private
+    end
+
+
+    # @abstract serialize key according to BIP32 specifications
+    #
+    # The serialization result is a string in Base58 that represents the public
+    # or the private extented key.
+    #
+    # @note
+    #   https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#serialization-format
+    def serialize_extended_key
+      k, c = key, chain_code
+
+      case public_or_private
+      when :private
+        data = ser32(0x0488ADE4) + to_binary(depth) + parent_fingerprint + ser32(index) + c + "\x00" + k
+      when :public then
+        data = ser32(0x0488B21E) + to_binary(depth) + parent_fingerprint + ser32(index) + c + Key.serp(public_key.key)
+      else raise "invalid property #{public_or_private}"
+      end
+
+      Base58.binary_to_base58(data + hash256(data)[0..3], :bitcoin)
+    end
+
+    alias_method :serialize, :serialize_extended_key
+
+    # @abstract Derive key by specifying derivation path
+    #
+    # Derive a private or a public key by applying multiple derivation definined
+    # by the derivation path.
+    #
+    # The {#path} is an Array of multiple indexes. For example to derive a key
+    # like m/0H/1/2H/2, use indexes [0.h, 1, 2.h, 2].
+    #
+    # @return [HDetEc] The returned object is an instance of the new derivated
+    #   key.
+    #
+    # @note
+    #   https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#the-key-tree
+    def derive(path)
+      return self if path.nil? || path.empty?
+
+      case public_or_private
+      when :public  then public_key_derivation(path)
+      when :private then private_key_derivation(path)
+      else
+        raise "Wrong key"
+      end
+    end
+
+    # @abstract Compute the key fingerprint
+    #
+    # @note
+    #   https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#key-identifiers
+    def fingerprint
+      key_fingerprint([key, chain_code])
+    end
+
+    def public_key_derivation(path)
+      ex_k = [key, chain_code]
+
+      ex_k_parent = ex_k
+      path.each do |i|
+        raise "No hardened derivation for public key" if i >= 2**31
+        ex_k_parent = ex_k
+        ex_k = HDetEc::Key.CKDpub(ex_k_parent, i)
+      end
+
+      HDetEc::Key.new(ex_k, :public, path.size, path.last, key_fingerprint(ex_k_parent))
+    end
+
+    private :public_key_derivation
+
+    def private_key_derivation(path)
+      ex_k = [key, chain_code]
+
+      ex_k_parent = ex_k
+      path.each do |i|
+        ex_k_parent = ex_k
+        ex_k = HDetEc::Key.CKDpriv(ex_k_parent, i)
+      end
+
+      HDetEc::Key.new(ex_k, :private, path.size, path.last, key_fingerprint(ex_k_parent))
+    end
+
+    private :private_key_derivation
+
+    def key_fingerprint(ex_k)
+      k, c = ex_k
+      case public_or_private
+      when :private then hash160(Key::point(k))[0..3]
+      when :public then hash160(k)[0..3]
+      end
+    end
+
+    private :key_fingerprint
+
+  end
+
+
+end

data/spec/bip32_vector_spec.rb

@@ -0,0 +1,39 @@
+require 'hdet-ec-key'
+
+require_relative 'test_vectors.rb'
+
+shared_examples "public and private key derivation" do |vector|
+  m = HDetEc::Key.generate_master_key([vector[:seed]].pack("H*"))
+  vector[:data].each do |data|
+
+    it data[:chain] + " private key" do
+      expect(m.derive(data[:path]).serialize).to eq(data[:priv_key])
+    end
+
+    it data[:chain] + " public key" do
+      expect(m.derive(data[:path]).public_key.serialize).to eq(data[:pub_key])
+    end
+
+    if data[:path].all? {|i| i < 2**31 }
+      it data[:chain] + " public key derivation" do
+        expect(m.public_key.derive(data[:path]).serialize).to eq(data[:pub_key])
+      end
+    end
+
+  end
+end
+
+describe "derivation key seed = 000102030405060708090a0b0c0d0e0f" do
+  vector = test_vector[0]
+  include_examples("public and private key derivation", vector)
+end
+
+describe "derivation key seed = fffcf9f6f3f0edeae7e4e1...484542" do
+  vector = test_vector[1]
+  include_examples("public and private key derivation", vector)
+end
+
+describe "derivation key seed = 4b381541583be4...3235be" do
+  vector = test_vector[2]
+  include_examples("public and private key derivation", vector)
+end

data/spec/data_manipulation_spec.rb

@@ -0,0 +1,78 @@
+require 'hdet-ec-key/data_manipulation'
+require 'openssl'
+
+describe HDetEc::DataManipulation do
+  let(:dm) {Class.new {include HDetEc::DataManipulation}.new }
+
+  context "#ser32" do
+    it "serialize 4 bytes length" do
+      expect(dm.ser32(0)).to eq("\x00\x00\x00\x00".b)
+    end
+
+    it "select least significant bytes when overflow" do
+      expect(dm.ser32(2**32+2)).to eq("\x00\x00\x00\x02".b)
+    end
+
+    it "serialize in big-endian" do
+      expect(dm.ser32(0xabcd)).to eq("\x00\x00\xab\xcd".b)
+      expect(dm.ser32(0xabcd00ef)).to eq("\xab\xcd\x00\xef".b)
+    end
+  end
+
+  context "#to_binary" do
+    it "autodetect bytes length" do
+      i2_38_33 = dm.to_binary(2**39 + 2**33)
+      expect(i2_38_33.size).to be 5
+      expect(i2_38_33).to eq("\x82\x00\x00\x00\x00".b)
+
+      i2_15 = dm.to_binary(2**15)
+      expect(i2_15.size).to be 2
+      expect(i2_15).to eq("\x80\x00".b)
+    end
+
+    it "left pad with 0" do
+      i2_33 = dm.to_binary(2**33)
+      expect(i2_33).to eq("\x02\x00\x00\x00\x00".b)
+
+      i2_127 = dm.to_binary(2**128)
+      expect(i2_127).to eq("\x01".b + "\x00".b * 16)
+    end
+
+    it "serialize in big-endian" do
+      expect(dm.to_binary(0x0123abcdef)).to eq("\x01\x23\xab\xcd\xef".b)
+      expect(dm.to_binary(0xabcd)).to eq("\xab\xcd".b)
+    end
+
+    it "could specify serialize byte size" do
+      expect(dm.to_binary(0, 8).size).to eq 8
+      expect(dm.to_binary(2**128-1, 2).size).to eq 16
+    end
+  end
+
+  context "#to_number" do
+    it "could convert number" do
+      expect(dm.to_number("\x01".b + "\x00".b * 16)).to eq(2**128)
+    end
+
+    it "deserialize in big-endian" do
+      expect(dm.to_number("\x01\x23\xab\xcd\xef")).to eq(0x0123abcdef)
+      expect(dm.to_number("\xab\xcd")).to eq(0xabcd)
+    end
+  end
+
+  context "#ser256" do
+    it "always 256 bits long (32 bytes)" do
+      expect(dm.ser256(1).size).to eq(32)
+      expect(dm.ser256(73927273964184847435527778358743529074551849469743120849858998083583072341153).size).to eq(32)
+    end
+
+    it "raise ArgumentError exception when overflow" do
+      expect{dm.ser256(2**256)}.to raise_error(ArgumentError)
+    end
+
+    it "serialize in big-endian" do
+      expect(dm.ser256(0x0123abcdef)).to eq( "\x00".b * 27 + "\x01\x23\xab\xcd\xef".b)
+    end
+  end
+
+end

data/spec/key_spec.rb

@@ -0,0 +1,19 @@
+require 'hdet-ec-key'
+
+describe HDetEc::Key do
+  context "#import" do
+    it "can import private key from BIP32 string" do
+      bip32_key = "xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM"
+      key = HDetEc::Key.import(bip32_key)
+
+      expect(key.serialize).to eq(bip32_key)
+    end
+
+    it "can import public key from BIP32 string" do
+      bip32_key = "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5"
+      key = HDetEc::Key.import(bip32_key)
+
+      expect(key.serialize).to eq(bip32_key)
+    end
+  end
+end

data/spec/test_vectors.rb

@@ -0,0 +1,82 @@
+def test_vector
+[{
+  seed: "000102030405060708090a0b0c0d0e0f",
+  data: [{
+    chain: "Chain m",
+    path: [],
+    pub_key:  "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8",
+    priv_key: "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi",
+  }, {
+    chain: "Chain m/0h",
+    path: [0.h],
+    pub_key:  "xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw",
+    priv_key: "xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7",
+  },{
+    chain: "Chain m/0h/1",
+    path: [0.h, 1],
+    pub_key:  "xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ",
+    priv_key: "xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs",
+  }, {
+    chain: "Chain m/0h/1/2h",
+    path: [0.h, 1, 2.h],
+    pub_key:  "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5",
+    priv_key: "xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM",
+  }, {
+    chain: "Chain m/0h/1/2h/2",
+    path: [0.h, 1, 2.h, 2],
+    pub_key:  "xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJAyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV",
+    priv_key: "xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Tyh8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334",
+  },  {
+    chain: "Chain m/0h/1/2h/2/1000000000",
+    path: [0.h, 1, 2.h, 2, 1000000000],
+    pub_key:  "xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy",
+    priv_key: "xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76",
+  }]
+}, {
+  seed: "fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542",
+  data: [{
+    chain: "Chain m",
+    path: [],
+    pub_key:  "xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB",
+    priv_key: "xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U",
+  }, {
+    chain: "Chain m/0",
+    path: [0],
+    pub_key:  "xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH",
+    priv_key: "xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt",
+  }, {
+    chain: "Chain m/0/2147483647h",
+    path: [0, 2147483647.h],
+    pub_key:  "xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a",
+    priv_key: "xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYEeEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9",
+  },  {
+    chain: "Chain m/0/2147483647h/1",
+    path: [0, 2147483647.h, 1],
+    pub_key:  "xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5EwVvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon",
+    priv_key: "xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef",
+  },  {
+    chain: "Chain m/0/2147483647h/1/2147483646h",
+    path: [0, 2147483647.h, 1, 2147483646.h],
+    pub_key:  "xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL",
+    priv_key: "xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc",
+  },  {
+    chain: "Chain m/0/2147483647h/1/2147483646h/2",
+    path: [0, 2147483647.h, 1, 2147483646.h, 2],
+    pub_key:  "xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt",
+    priv_key: "xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j",
+  }]
+}, {
+  seed: "4b381541583be4423346c643850da4b320e46a87ae3d2a4e6da11eba819cd4acba45d239319ac14f863b8d5ab5a0d0c64d2e8a1e7d1457df2e5a3c51c73235be",
+  data: [{
+    chain: "Chain m",
+    path: [],
+    pub_key: "xpub661MyMwAqRbcEZVB4dScxMAdx6d4nFc9nvyvH3v4gJL378CSRZiYmhRoP7mBy6gSPSCYk6SzXPTf3ND1cZAceL7SfJ1Z3GC8vBgp2epUt13",
+    priv_key: "xprv9s21ZrQH143K25QhxbucbDDuQ4naNntJRi4KUfWT7xo4EKsHt2QJDu7KXp1A3u7Bi1j8ph3EGsZ9Xvz9dGuVrtHHs7pXeTzjuxBrCmmhgC6",
+  }, {
+    chain: "Chain m/0h",
+    path: [0.h],
+    pub_key: "xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y",
+    priv_key: "xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L",
+  }]
+}]
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: hdet-ec-key
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Stéphane Clérambault
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base58
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  Provide an easy implementation of the BIP32
+                            specification. This implementation is not related to
+                            bitcoin and can be use for any propose.
+email:
+- stephane@clerambault.fr
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.adoc
+files:
+- LICENSE
+- README.adoc
+- VERSION
+- lib/hdet-ec-key.rb
+- lib/hdet-ec-key/data_manipulation.rb
+- lib/hdet-ec-key/ec_manipulation.rb
+- lib/hdet-ec-key/key.rb
+- spec/bip32_vector_spec.rb
+- spec/data_manipulation_spec.rb
+- spec/key_spec.rb
+- spec/test_vectors.rb
+homepage: https://gitlab.com/elionne/hdet-ec-key
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Implements Herarchical Deterministic Key wallet.
+test_files: []