shamir-secret-sharing 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d07e642746c89a96dde0b5f5d66fa254b4cfe3d3
+  data.tar.gz: 613b4c2987524ee3fd2ee1a927dc49eb0ba98867
+SHA512:
+  metadata.gz: b12215854edfb42ed511d29f5e58548faef927cf785a5328690161de11ea948ee82d1232eb19831eead3e6ccb073b1e9fa1788de810c6e7677238efcf6fabc98
+  data.tar.gz: db8dae71854f87544628d1d78f4e76601c873e304c3398d84a889867dbb5c45ffae1fe1b1311e8dd877bddd7d3765d6fc962a6758875883d55c5e307d81119e2

data/README.rdoc

@@ -0,0 +1,75 @@
+= shamir-secret-sharing
+
+This is a ruby library for Shamir's Secret Sharing. ( http://en.wikipedia.org/wiki/Shamir's_Secret_Sharing )
+
+== Compatible with...
+
+* ruby 1.9.3
+* ruby 2.0.0
+
+
+== Installation
+
+We assume you already have a ruby 1.9 or 2.0 compatible interpreter and rubygems environment.
+
+ git clone https://github.com/lian/shamir-secret-sharing.git; cd shamir-secret-sharing
+ irb -Ilib -rshamir-secret-sharing
+
+If you want to have it available system-wide, just build the gem and install it:
+
+ gem build shamir-secret-sharing.gemspec && gem install shamir-secret-sharing-*.gem
+
+== Tests
+
+The tests can be run with
+
+ rake
+
+If you make changes to the code or add functionality, please also add tests.
+
+= Example
+
+== Split and Combine
+
+ # split a secret into 4 shares. 3 of them are needed to combine the secret again.
+ shares = ShamirSecretSharing::Base58.split(secret="hello", available=4, needed=3)
+ shares #=> ["FPGPdS98vRUCy9", "VmTjT28nES7Pck", "k9eRjVVpWP7uzj", "zXqDJNRpPttPjR"]
+
+ # combine the secret again using at least 3 shares
+ ShamirSecretSharing::Base58.combine( ["VmTjT28nES7Pck", "zXqDJNRpPttPjR", "k9eRjVVpWP7uzj"] )
+ #=> "hello"
+
+ # not enough shares
+ ShamirSecretSharing::Base58.combine( ["VmTjT28nES7Pck", "zXqDJNRpPttPjR"] )
+ #=> false
+
+ # wrong shares
+ ShamirSecretSharing::Base58.combine( ["VmTjT28nES7Pck", "zXqDJNRpPttPjR", "some-wrong-share"] )
+ #=> false
+
+== Encypt and Decrypt
+
+Split and combine only work with a secret length below 512 bytes and the resulting share lengths are equivalent to the secret length. That means a 128 byte secret has a very long (128 byte) share length.
+Encrypt and decrypt are used to encrypt a large piece of data while keeping the share lengths to a fixed and reasonable size. It does that by AES-256-CBC encrypting the data with a random key and only then splitting that fixed size key into shares.
+
+ # encrypt the data and create 4 shares. Later 3 shares and the encrypted data are needed to decrypt it again. This example uses a 96 bit random key for encryption.
+ shares, encrypted = ShamirSecretSharing::Base58.encrypt(data="Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 4, 3, 96)
+ shares #=> ["3QZNRFYZHKUpnv96cE6eVwPP", "5p611mjtxXBgPDx1m2SRwCKr", "8DcdGMD9i3kWGrYEVGtQLSWA", "Ad9NLPDVSnHfbqVhnmNn8YK4"]
+ encrypted #=> "4PHcPwzzk48EjmusQz27t3X1rS7hAi9kwKgZJ7UMDR99rJgi19aHM8e7syh6uVrJ6HbcbgRmEUcR7hmkDvrYaJXH"
+
+ # combine the shares and decrypt the encrypted data
+ ShamirSecretSharing::Base58.decrypt(["3QZNRFYZHKUpnv96cE6eVwPP", "8DcdGMD9i3kWGrYEVGtQLSWA", "Ad9NLPDVSnHfbqVhnmNn8YK4"], "4PHcPwzzk48EjmusQz27t3X1rS7hAi9kwKgZJ7UMDR99rJgi19aHM8e7syh6uVrJ6HbcbgRmEUcR7hmkDvrYaJXH")
+ #=> "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
+
+ # not enough shares
+ ShamirSecretSharing::Base58.decrypt(["3QZNRFYZHKUpnv96cE6eVwPP", "8DcdGMD9i3kWGrYEVGtQLSWA"], "4PHcPwzzk48EjmusQz27t3X1rS7hAi9kwKgZJ7UMDR99rJgi19aHM8e7syh6uVrJ6HbcbgRmEUcR7hmkDvrYaJXH")
+ #=> false
+
+ # wrong shares
+ ShamirSecretSharing::Base58.decrypt(["3QZNRFYZHKUpnv96cE6eVwPP", "8DcdGMD9i3kWGrYEVGtQLSWA", "some-wrong-share"], "4PHcPwzzk48EjmusQz27t3X1rS7hAi9kwKgZJ7UMDR99rJgi19aHM8e7syh6uVrJ6HbcbgRmEUcR7hmkDvrYaJXH")
+ #=> false
+
+ # wrong encrypted data
+ ShamirSecretSharing::Base58.decrypt(["3QZNRFYZHKUpnv96cE6eVwPP", "8DcdGMD9i3kWGrYEVGtQLSWA", "Ad9NLPDVSnHfbqVhnmNn8YK4"], "wrong-encrypted-data")
+ #=> false
+

data/Rakefile

@@ -0,0 +1,14 @@
+begin
+  require 'bundler/gem_tasks'
+rescue LoadError
+end
+
+RUBY = 'ruby' unless defined?(RUBY)
+
+task :default => :tests
+
+# test runner                                                                                                                                                                                                                [0/61]
+desc 'Run all bacon specs with pretty output'
+task :tests do
+  sh RUBY, 'lib/shamir-secret-sharing.rb'
+end

data/lib/shamir-secret-sharing.rb

@@ -0,0 +1,380 @@
+require 'openssl'
+require 'digest/sha1'
+
+class ShamirSecretSharing
+  VERSION = '0.0.1'
+
+  def self.pack(shares); shares; end
+  def self.unpack(shares); shares; end
+  def self.encode(string); string; end
+  def self.decode(string); string; end
+
+  def self.smallest_prime_of_bytelength(bytelength)
+    n = OpenSSL::BN.new((2**(bytelength*8)+1).to_s)
+    loop{ break if n.prime_fasttest?(20); n += 2 }
+    n
+  end
+
+  def self.split(secret, available, needed, do_data_checksum=true)
+    raise ArgumentError, "needed must be <= available" unless needed <= available
+    raise ArgumentError, "needed must be >= 2"         unless needed >= 2
+    raise ArgumentError, "available must be <= 250"    unless available <= 250
+
+    if do_data_checksum
+      checksum = Digest::SHA512.digest(secret)[0...2]
+      num_bytes = secret.bytesize+2
+      secret = OpenSSL::BN.new((checksum + secret).unpack("H*")[0], 16) rescue OpenSSL::BN.new("0")
+      #num_bytes = secret.to_s(0).unpack("N")[0]
+      raise ArgumentError, "bytelength of secret must be >= 1"   if num_bytes < 3
+      raise ArgumentError, "bytelength of secret must be <= 512" if num_bytes > 513
+    else
+      num_bytes = secret.bytesize
+      secret = OpenSSL::BN.new(secret.unpack("H*")[0], 16) rescue OpenSSL::BN.new("0") # without checksum
+      raise ArgumentError, "bytelength of secret must be >= 1"   if num_bytes < 1
+      raise ArgumentError, "bytelength of secret must be <= 512" if num_bytes > 512
+    end
+
+    prime  = smallest_prime_of_bytelength(num_bytes)
+    coef = [ secret ] + Array.new(needed-1){ OpenSSL::BN.rand(num_bytes * 8) }
+
+    shares = (1..available).map{|x|
+      x = OpenSSL::BN.new(x.to_s)
+      y = coef.each_with_index.inject(OpenSSL::BN.new("0")){|acc, (c, idx)|
+        acc + c * x.mod_exp(idx, prime)
+      } % prime
+      [x, num_bytes, y]
+    }
+    pack(shares)
+  end
+
+  def self.combine(shares, do_raise=false, do_data_checksum=true)
+    return false if shares.size < 2
+    shares = unpack(shares)
+    num_bytes = shares[0][1]
+    prime = smallest_prime_of_bytelength(num_bytes)
+
+    secret = shares.inject(OpenSSL::BN.new("0")){|secret,(x,num_bytes,y)|
+      l_x = l(x, shares, prime)
+      summand = OpenSSL::BN.new(y.to_s).mod_mul(l_x, prime)
+      secret = (secret + summand) % prime
+    }
+    if do_data_checksum
+      checksum, secret = [ secret.to_s(16).rjust(num_bytes*2, '0') ].pack("H*").unpack("a2a*")
+      checksum == Digest::SHA512.digest(secret)[0...2] ? secret : false
+    else
+      secret = [ secret.to_s(16).rjust(num_bytes*2, '0') ].pack("H*")
+    end
+  rescue ShareChecksumError, ShareDecodeError => ex
+    raise if do_raise
+    false
+  end
+
+  # Part of the Lagrange interpolation.
+  # This is l_j(0), i.e.  # \prod_{x_j \neq x_i} \frac{-x_i}{x_j - x_i}
+  # for more information compare Wikipedia: # http://en.wikipedia.org/wiki/Lagrange_form
+  def self.l(current_x, shares, prime)
+    shares.select{|x,num_bytes,y| x != current_x }.map{|x,num_bytes,y|
+      minus_xi = OpenSSL::BN.new((-x).to_s)
+      one_over_xj_minus_xi = OpenSSL::BN.new((current_x - x).to_s).mod_inverse(prime)
+      minus_xi.mod_mul(one_over_xj_minus_xi, prime)
+    }.inject{|p,f| p.mod_mul(f, prime) }
+  end
+
+  def self.encrypt(data, available, needed, key_bit_length=128)
+    key = key_bit_length.is_a?(String) ? key_bit_length : [ OpenSSL::BN.rand(key_bit_length).to_s(16) ].pack("H*")
+    c = OpenSSL::Cipher.new('aes-256-cbc').encrypt
+    c.key, c.iv = Digest::SHA512.digest(key).unpack("a32a16")
+    encrypted = c.update(data) << c.final
+    [ split(key, available, needed), encode(encrypted) ]
+  end
+
+  def self.decrypt(shares, encrypted, do_raise=false)
+    key = combine(shares, do_raise)
+    return false unless key
+
+    encrypted_decoded = decode(encrypted) rescue nil
+    raise ShareDecodeError, "encrypted_data: #{encrypted}" unless encrypted_decoded
+
+    return false unless encrypted and key
+    c = OpenSSL::Cipher.new('aes-256-cbc').decrypt
+    c.key, c.iv = Digest::SHA512.digest(key).unpack("a32a16")
+    data = c.update(encrypted_decoded) << c.final
+    data
+  rescue OpenSSL::Cipher::CipherError, ShareDecodeError
+    raise if do_raise
+    false
+  end
+
+  def self.split_with_sanity_check(secret, available, needed, do_data_checksum=true)
+    shares = split(secret, available, needed, do_data_checksum)
+    success = true
+    needed.upto(available).each{|n| shares.permutation(n).each{|shares| success = false if combine(shares) != secret } }
+    (needed-1).downto(2).each{|n| shares.permutation(n).each{|shares| success = false if combine(shares) != false } }
+    raise ShareSanityCheckError if success != true
+    shares
+  rescue ShareSanityCheckError
+    retry
+  end
+
+  def self.encrypt_with_sanity_check(data, available, needed, key_bit_length=128)
+    shares, encrypted = encrypt(data, available, needed, key_bit_length)
+    success = true
+    needed.upto(available).each{|n| shares.permutation(n).each{|shares| success = false if decrypt(shares, encrypted) != data } }
+    (needed-1).downto(2).each{|n| shares.permutation(n).each{|shares| success = false if decrypt(shares, encrypted) != false } }
+    raise ShareSanityCheckError if success != true
+    [shares, encrypted]
+  rescue ShareSanityCheckError
+    retry
+  end
+
+
+  class Number < ShamirSecretSharing
+    def self.split(secret, available, needed)
+      num = OpenSSL::BN.new(secret.to_s)
+      raise ArgumentError, "available must be <= 9"    unless available <= 9
+      raise ArgumentError, "num too large. bytelength must be <= 9" unless num.num_bytes <= 9
+      shares = ShamirSecretSharing.split([num.to_s(16)].pack("H*"), available, needed, do_data_checksum=nil)
+      shares.map{|i| i.join.to_i }
+    end
+
+    def self.combine(shares)
+      shares = shares.map{|i| i.to_s.match(/(\d)(\d)(\d+)/); [$1.to_i, $2.to_i, $3.to_i] }
+      ShamirSecretSharing.combine(shares, do_raise=false, do_data_checksum=nil).unpack("H*")[0].to_i(16)
+    end
+  end
+
+  class ShareChecksumError < ::StandardError; end
+  class ShareDecodeError < ::StandardError; end
+  class ShareSanityCheckError < ::StandardError; end
+
+  class Packed < ShamirSecretSharing # packing format and checkum
+    def self.pack(shares)
+      shares.map{|x,num_bytes,y|
+        buf = [ x, num_bytes, y.to_s(16) ].pack("CnH*")
+        checksum = Digest::SHA512.digest(buf)[0...2]
+        encode(checksum << buf)
+      }
+    end
+    def self.unpack(shares)
+      shares.map{|i|
+        buf = decode(i) rescue nil
+        raise ShareDecodeError, "share: #{i}" unless buf
+        checksum, buf = buf.unpack("a2a*")
+        raise ShareChecksumError, "share: #{i}" unless checksum == Digest::SHA512.digest(buf)[0...2]
+        i = buf.unpack("CnH*"); [ i[0], i[1], i[2].to_i(16) ]
+      }
+    end
+  end
+
+  class Base58 < Packed
+    def self.encode(string)
+      string = string.unpack("H*")[0]
+      leading_zero_bytes  = (string.match(/^([0]+)/) ? $1 : '').size / 2
+      ("1"*leading_zero_bytes) + int_to_base58( string.to_i(16) )
+    end
+    def self.decode(string)
+      leading_zero_bytes = (string.match(/^([1]+)/) ? $1 : '').size
+      buf = base58_to_int(string).to_s(16); buf = (buf.bytesize.odd? ? '0'+buf : buf)
+      [ ("00"*leading_zero_bytes) + buf ].pack("H*")
+    end
+    def self.int_to_base58(int_val, leading_zero_bytes=0)
+      alpha, base58_val, base = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz", "", 58
+      while int_val > 0
+        int_val, remainder = int_val.divmod(base)
+        base58_val = alpha[remainder] + base58_val
+      end; base58_val
+    end
+
+    def self.base58_to_int(base58_val)
+      alpha, base = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz", 58
+      base58_val.reverse.each_char.with_index.inject(0) do |int_val, (char,index)|
+        raise ArgumentError, 'Value not a valid Base58 String.' unless char_index = alpha.index(char)
+        int_val + char_index*(base**index)
+      end
+    end
+  end
+
+  class Base64 < Packed
+    def self.encode(string); [string].pack("m0"); end
+    def self.decode(string); string.unpack("m0")[0]; end
+  end
+
+  class Hex < Packed
+    def self.encode(string); string.unpack("H*")[0]; end
+    def self.decode(string); [string].pack("H*"); end
+  end
+end
+
+
+
+
+if $0 == __FILE__
+  require "minitest/autorun"
+
+  class MiniTest::Unit::TestCase
+    def assert_raises_and_message(klass, msg, &blk)
+      err = assert_raises(klass, &blk); assert_equal msg, err.message
+    end
+  end
+
+
+  class TestShamirSecretSharing < MiniTest::Unit::TestCase
+
+    def helper(&b)
+      [ [6,3], [10, 2], [3,2], [100, 30] ].each{|available,needed| b.call(available, needed) }
+    end
+
+
+    def test_shamir_base58
+      secret = "hello"
+      helper{|available,needed|
+        shares = ShamirSecretSharing::Base58.split(secret, available, needed)
+        assert_equal secret, ShamirSecretSharing::Base58.combine(shares.shuffle[0...needed])
+      }
+
+      shares = ShamirSecretSharing::Base58.split_with_sanity_check(secret, available=3, needed=2)
+      assert_equal secret, ShamirSecretSharing::Base58.combine(shares.shuffle[0...needed])
+    end
+
+    def test_shamir_base64
+      secret = "hello"
+      helper{|available,needed|
+        shares = ShamirSecretSharing::Base64.split(secret, available, needed)
+        assert_equal secret, ShamirSecretSharing::Base64.combine(shares.shuffle[0...needed])
+      }
+    end
+
+    def test_shamir_hex
+      secret = "hello"
+      helper{|available,needed|
+        shares = ShamirSecretSharing::Hex.split(secret, available, needed)
+        assert_equal secret, ShamirSecretSharing::Hex.combine(shares.shuffle[0...needed])
+      }
+    end
+
+    def test_shamir_number
+      secret = 123
+      shares = ShamirSecretSharing::Number.split(secret, 6, 3)
+      assert_equal secret, ShamirSecretSharing::Number.combine(shares.shuffle[0...3])
+    end
+
+    def test_shamir_base58_encrypt
+      text = "A"*32
+      helper{|available,needed|
+        shares, encrypted = ShamirSecretSharing::Base58.encrypt(text, available, needed, 96)
+        assert_equal text, ShamirSecretSharing::Base58.decrypt(shares.shuffle[0...needed], encrypted)
+      }
+
+      shares, encrypted = ShamirSecretSharing::Base58.encrypt_with_sanity_check(text, available=3, needed=2)
+      assert_equal text, ShamirSecretSharing::Base58.decrypt(shares.shuffle[0...needed], encrypted)
+    end
+
+    def test_shamir_base58_encrypt_sanity_checks
+      klass = ShamirSecretSharing::Base58
+      checks, success = 5, true
+      [
+        [2,3], [2,4], [3,5]
+      ].each{|needed,available|
+        checks.times{
+          data = "A"*32
+          shares, encrypted = klass.encrypt(data, available, needed, 96)
+          needed.upto(available).each{|n|
+            shares.permutation(n).each{|shares| success = false if klass.decrypt(shares, encrypted, true) != data }
+          }
+          (needed-1).downto(2).each{|n|
+            shares.permutation(n).each{|shares| success = false if klass.decrypt(shares, encrypted, true) != false }
+          }
+          break unless success
+        }
+      }
+      assert_equal true, success
+    end
+
+    def test_shamir_base64_encrypt
+      text = "A"*32
+      helper{|available,needed|
+        shares, encrypted = ShamirSecretSharing::Base64.encrypt(text, available, needed, 96)
+        assert_equal text, ShamirSecretSharing::Base64.decrypt(shares.shuffle[0...needed], encrypted)
+      }
+    end
+
+    def test_shamir_hex_encrypt
+      text = "A"*32
+      helper{|available,needed|
+        shares, encrypted = ShamirSecretSharing::Hex.encrypt(text, available, needed, 96)
+        assert_equal text, ShamirSecretSharing::Hex.decrypt(shares.shuffle[0...needed], encrypted)
+      }
+    end
+
+    def test_shamir_with_broken_share_checksum
+      secret = "hello"
+      share_with_broken_checksum = ShamirSecretSharing::Base58.encode("foobar")
+      share_with_broken_encoding = "1Il"
+      shares = ShamirSecretSharing::Base58.split(secret, 3, 2)
+      assert_equal false, ShamirSecretSharing::Base58.combine( [shares.shuffle.first, share_with_broken_checksum])
+      assert_equal false, ShamirSecretSharing::Base58.combine( [shares.shuffle.first, share_with_broken_encoding])
+
+      do_raise = true
+      err = assert_raises(ShamirSecretSharing::ShareChecksumError){ ShamirSecretSharing::Base58.combine( [shares.shuffle.first, share_with_broken_checksum], do_raise) }
+      assert_match /share: /, err.message
+      assert_raises(ShamirSecretSharing::ShareDecodeError){ ShamirSecretSharing::Base58.combine( [shares.shuffle.first, share_with_broken_encoding], do_raise) }
+      assert_match /share: /, err.message
+    end
+
+    def test_shamir_encrypt_with_broken_encypted_data
+      text = "A"*32
+      broken_encrypted_data = ShamirSecretSharing::Base58.encode("foobar")
+      broken_encrypted_data_encoding = "1Il"
+      share_with_broken_encoding = "1Il"
+      shares, encrypted = ShamirSecretSharing::Base58.encrypt(text, 3, 2, 96)
+      assert_equal false, ShamirSecretSharing::Base58.decrypt(shares.shuffle[0...2], broken_encrypted_data)
+      assert_equal false, ShamirSecretSharing::Base58.decrypt(shares.shuffle[0...2], broken_encrypted_data_encoding)
+
+      do_raise = true
+      assert_raises(OpenSSL::Cipher::CipherError) { ShamirSecretSharing::Base58.decrypt(shares.shuffle[0...2], broken_encrypted_data, do_raise) }
+      err = assert_raises(ShamirSecretSharing::ShareDecodeError){ ShamirSecretSharing::Base58.decrypt( [shares.shuffle.first, share_with_broken_encoding], encrypted, do_raise) }
+      assert_match /share: /, err.message
+      err = assert_raises(ShamirSecretSharing::ShareDecodeError){ ShamirSecretSharing::Base58.decrypt(shares.shuffle[0...2], broken_encrypted_data_encoding, do_raise) }
+      assert_match /encrypted_data: /, err.message
+    end
+
+    def test_shamir_split_argument_errors
+      assert_raises_and_message(ArgumentError, "needed must be <= available")            { ShamirSecretSharing::Base58.split("foobar", 2, 3)   }
+      assert_raises_and_message(ArgumentError, "needed must be >= 2")                    { ShamirSecretSharing::Base58.split("foobar", 3, 1)   }
+      assert_raises_and_message(ArgumentError, "available must be <= 250")               { ShamirSecretSharing::Base58.split("foobar", 251, 2) }
+      assert_raises_and_message(ArgumentError, "bytelength of secret must be >= 1")      { ShamirSecretSharing::Base58.split("", 3, 2)         }
+      assert_raises_and_message(ArgumentError, "bytelength of secret must be <= 512")    { ShamirSecretSharing::Base58.split("A"*513, 3, 2)    }
+    end
+
+  end
+
+=begin
+  require 'pp'
+
+  pp shares = ShamirSecretSharing::Base58.split("hello", 6, 3)
+  pp ShamirSecretSharing::Base58.combine(shares[0...3])
+
+  pp shares = ShamirSecretSharing::Base64.split("hello", 6, 3)
+  pp ShamirSecretSharing::Base64.combine(shares[0...3])
+
+  pp shares = ShamirSecretSharing::Hex.split("hello", 6, 3)
+  pp ShamirSecretSharing::Hex.combine(shares[0...3])
+
+  pp shares = ShamirSecretSharing::Number.split(123, 6, 3)
+  pp ShamirSecretSharing::Number.combine(shares[0...3])
+
+
+  shares, encrypted = ShamirSecretSharing::Base58.encrypt("A"*32, 6, 3, 96)
+  pp [shares, encrypted]
+  p ShamirSecretSharing::Base58.decrypt(shares.shuffle[0...3], encrypted)
+
+  shares, encrypted = ShamirSecretSharing::Base64.encrypt("A"*32, 6, 3, 96)
+  pp [shares, encrypted]
+  p ShamirSecretSharing::Base64.decrypt(shares.shuffle[0...3], encrypted)
+
+  shares, encrypted = ShamirSecretSharing::Hex.encrypt("A"*32, 6, 3, 96)
+  pp [shares, encrypted]
+  p ShamirSecretSharing::Hex.decrypt(shares.shuffle[0...3], encrypted)
+=end
+
+end

data/shamir-secret-sharing.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "shamir-secret-sharing"
+
+Gem::Specification.new do |s|
+  s.name        = "shamir-secret-sharing"
+  s.version     = ShamirSecretSharing::VERSION
+  s.authors     = ["lian"]
+  s.email       = ["meta.rb@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Gem for Shamir's Secret Sharing}
+  s.description = %q{Gem for Shamir's Secret Sharing}
+
+  s.rubyforge_project = "shamir-secret-sharing"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.required_rubygems_version = ">= 1.3.6"
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: shamir-secret-sharing
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- lian
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-21 00:00:00.000000000 Z
+dependencies: []
+description: Gem for Shamir's Secret Sharing
+email:
+- meta.rb@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.rdoc
+- Rakefile
+- lib/shamir-secret-sharing.rb
+- shamir-secret-sharing.gemspec
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: shamir-secret-sharing
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Gem for Shamir's Secret Sharing
+test_files: []