sharing 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2741454d22738f53a151a7720d1dec3efe64728e32b92efe103392c7ec46c2f
-  data.tar.gz: '02118b02fe47723227a04e9203d28b248cdccc3b2ab9e747675b63f465856bf3'
+  metadata.gz: 719563755ad21ee302ca5c4cdf7dc99d5392f03f5a42af56a38a9199a76e5d31
+  data.tar.gz: f58c948f6c1c26cc2cc0f7f6e0c318a2c46d2c219952757bf43d092328f5b6ec
 SHA512:
-  metadata.gz: e122938b94ee0077b3c90825df2afb2d3bbee50d474779876cf7ad0867f82b27f353303dfa9d6840b9aa6b15f4eb485cad154587811531add995fe5180ef3314
-  data.tar.gz: 39487860406b1583b7d16beedb2dc0bec498058524972b16167d859d34a48f8e26f5d12218164ccd163690c678c1806615f90a9beb9e1b405c0f4e8e535c6629
+  metadata.gz: 678102cac63e5994565e6b7628e7ebd5865b696d996684a4ccfb1c073d8f028270989fc7f8771f0010df25529aaf97cb8265133b61e22b3188d11654c37ee851
+  data.tar.gz: a7903a1cdb18224fba5ceca2443c8856fca3368534c839bc5daf50a09dcbfdd8bb953c3d715534ec21d5f16b662d8f8d9e2a3162461b90a1763607c932447914

data/.codecov.yml

@@ -0,0 +1,6 @@
+coverage:
+  status:
+    project:
+      default:
+        target: 99%    # the required coverage value
+        threshold: 1%  # the leniency in hitting the target

data/.rubocop.yml

@@ -1,6 +1,9 @@
 AllCops:
   NewCops: enable
   TargetRubyVersion: 2.6
+  Exclude:
+    - 'lab/**/*'
+    - 'vendor/**/*'
 
 Style/StringLiterals:
   Enabled: true

data/CHANGELOG.md

@@ -1,5 +1,15 @@
-## [Unreleased]
+## [0.3.0] - 2022-05-23
 
-## [0.1.0] - 2022-03-10
+- Add division to Shamir's secret sharing implementation.
+
+## [0.2.0] - 2022-03-25
+
+- Add multiplication to Shamir's secret sharing implementation and overall improvements.
+
+## [0.1.1] - 2022-03-25
+
+- Fix threshold setting on Shamir's scheme v1
+
+## [0.1.0] - 2022-03-25
 
 - Initial release

data/Gemfile

@@ -4,13 +4,9 @@ ruby ">= 2.6.0"
 
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in secret_sharing.gemspec
+# Specify your gem"s dependencies in sharing.gemspec
 gemspec
 
-gem "hensel_code", "~> 0.3.0"
-
-gem "prime", "~> 0.1.2"
-
 gem "rake", "~> 13.0"
 
 gem "minitest", "~> 5.0"
@@ -24,3 +20,5 @@ gem "rubocop-rake", "~> 0.6"
 gem "minitest-reporters", "~> 1.5"
 
 gem "codecov", require: false, group: :test
+
+gem "simplecov-console", "~>0.9", require: false

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    secret_sharing (0.1.0)
-      hensel_code (~> 0.3.0)
+    sharing (0.2.0)
+      hensel_code (~> 0.3.1)
       prime (~> 0.1.2)
 
 GEM
@@ -15,13 +15,16 @@ GEM
       simplecov (>= 0.15, < 0.22)
     docile (1.4.0)
     forwardable (1.3.2)
-    hensel_code (0.3.0)
+    hensel_code (0.3.1)
+      openssl (~> 3.0.0)
+      prime (~> 0.1.2)
     minitest (5.15.0)
     minitest-reporters (1.5.0)
       ansi
       builder
       minitest (>= 5.0)
       ruby-progressbar
+    openssl (3.0.0)
     parallel (1.21.0)
     parser (3.1.1.0)
       ast (~> 2.4.1)
@@ -52,25 +55,31 @@ GEM
       docile (~> 1.1)
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
+    simplecov-console (0.9.1)
+      ansi
+      simplecov
+      terminal-table
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
     singleton (0.1.1)
+    terminal-table (3.0.2)
+      unicode-display_width (>= 1.1.1, < 3)
     unicode-display_width (2.1.0)
 
 PLATFORMS
   x86_64-darwin-19
+  x86_64-linux
 
 DEPENDENCIES
   codecov
-  hensel_code (~> 0.3.0)
   minitest (~> 5.0)
   minitest-reporters (~> 1.5)
-  prime (~> 0.1.2)
   rake (~> 13.0)
   rubocop (~> 1.21)
   rubocop-minitest (~> 0.17.2)
   rubocop-rake (~> 0.6)
-  secret_sharing!
+  sharing!
+  simplecov-console (~> 0.9)
 
 RUBY VERSION
    ruby 3.1.0p0

data/README.md

@@ -1,6 +1,10 @@
-# Secret Sharing
+# Sharing
 
-A secret sharing Ruby library.
+![GitHub Workflow Status](https://github.com/davidwilliam/sharing/actions/workflows/main.yml/badge.svg) [![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop/rubocop) ![GitHub](https://img.shields.io/github/license/davidwilliam/sharing) ![Gem](https://img.shields.io/gem/v/sharing) ![GitHub release (latest by date)](https://img.shields.io/github/v/release/davidwilliam/sharing)
+
+Sharing is a Ruby gem with implmementations of secret sharing schemes with homomorphic properties. Although secret sharing schemes and multiparty computation protocols are distinct notions, multiparty computation protocols are typically enabled by secret sharing schemes. In this setting, security comes from the use of multiple parties. If they collude, all security is lost, but satisfactory levels of security can be established by trusting a subset of them will not to collude. In many settings where corrupting security requires corrupting all the parties, and considering you are one of the computing parties, security  is guaranteed if you are one of the parties.
+
+Computing linear functions is trivial. Each non-linear operation however requires interaction between the parties/extra steps (for most secret sharing schemes).
 
 ## Installation
 
@@ -27,6 +31,13 @@ Secret Sharing currently supports two schemes:
 
 # Usage
 
+In the examples below, there are two main levels of execution:
+
+- Computations performed by the owner of the secrets (those are computations using instance methods)
+- Computations performed over the secret shares (those are computations using class methods)
+
+This distiction is important since we are showing everything at once here, for completeness and for clarity. However it is important to keep in mind that after the secret shares are generated, the computations over the shares are intended to be computed independetly by each participant (party), each one with their corresponding shares.
+
 ## Shamir's Secret Sharing V1
 
 The Shamir's secret sharing v1 scheme is based on the work of Adi Shamir in [How to Share a Secret](https://web.mit.edu/6.857/OldStuff/Fall03/ref/Shamir-HowToShareASecret.pdf).
@@ -58,9 +69,9 @@ We reconstruct the secrets as follows:
 
 ```ruby
 reconstructed_secret1 = sss.reconstruct_secret(shares1)
-# => (22/1)
+# => 22
 reconstructed_secret2 = sss.reconstruct_secret(shares2)
-# => (36/1)
+# => 36
 ```
 
 We can compute linear functions without requiring communication between the share holders: 
@@ -80,18 +91,18 @@ and we can check that:
 
 ```ruby
 sss.reconstruct_secret(shares1_add_shares2)
-# => (58/1)
+# => 58
 sss.reconstruct_secret(shares2_sub_shares1)
-# => (14/1)
+# => 14
 sss.reconstruct_secret(shares1_smul_scalar)
-# => (44/1)
+# => 44
 sss.reconstruct_secret(shares1_sdiv_scalar)
-# => (11/1)
+# => 11
 ```
 
 ### Using Hensel Codes
 
-The gem Secret Sharing takes advantage of the gem [Hensel Codes](https://github.com/davidwilliam/hensel_code) for homomorphically encoding rational numbers as integers in order to compute over the integers and yet obtain results over the rationals.
+The gem Secret Sharing takes advantage of the gem [Hensel Code](https://github.com/davidwilliam/hensel_code) for homomorphically encoding rational numbers as integers in order to compute over the integers and yet obtain results over the rationals.
 
 As most (if not all) of secret sharing schemes over finite fields `F_p` for `p > 2`, the secret inputs are naturally required to be positive integers in `F_p`. In this way, if we compute subtraction and we end up with a result that is negative, the reconstruction will fail (provided we don't have any econding in place). Same will occur if we compute a scalar division involving a scalar that is not a divisor of the corresponding secret. For addressing this and many other arithmetic problems, we can use Hensel codes to allow secret inputs to be positive and negative rational numbers.
 
@@ -143,13 +154,13 @@ We reconstruct the secrets:
 
 ```ruby
 reconstruct_secret1_add_secret2 = sss.reconstruct_secret(shares1_add_shares2)
-# => 3361138990/1
+# => 3361138990
 reconstruct_secret1_sub_secret2 = sss.reconstruct_secret(shares1_sub_shares2)
-# => 2174854642/1
+# => 2174854642
 reconstruct_shares1_smul_scalar = sss.reconstruct_secret(shares1_smul_scalar)
-# => 1383998411/1
+# => 1383998411
 reconstruct_shares1_sdiv_scalar = sss.reconstruct_secret(shares1_sdiv_scalar)
-# => 3044796497/1
+# => 3044796497
 ```
 
 and we can check that:
@@ -165,6 +176,178 @@ HenselCode::TruncatedFinitePadicExpansion.new(sss.p, 1, reconstructed_shares1_sd
 # => 2/15
 ```
 
+### Multiplication
+
+As we previously saw, linear functions are easy to compute with shares created by an instance of Shamir's secret sharing scheme. Non-linear functions need some strategy that require extra steps in other to successfuly achieve the desired results. We implement multiplication in the context of Shamir's secret sharing scheme following the approach discussed by Dan Bognadov in [Foundations and properties of Shamir's secret sharing scheme - Research Seminar in Cryptography](https://uuslepo.it.da.ut.ee/~peeter_l/teaching/seminar07k/bogdanov.pdf).
+
+We define an instance of Shamir's secret sharing scheme with the following parameters:
+
+```ruby
+params = { lambda_: 16, total_shares: 6, threshold: 3 }
+# => {:lambda_=>16, :total_shares=>6, :threshold=>3}
+sss = Sharing::Polynomial::Shamir::V1.new params
+# => #<Sharing::Polynomial::Shamir::V1:0x0000000105423640 @lambda_=16, @p=49367, @threshold=3, @total_shares=6>
+```
+
+As before, we define the secrets and create shares for them:
+
+```ruby
+secret1 = 13
+secret2 = 28
+shares1 = sss.create_shares(secret1)
+# => [[1, 43064], [2, 20333], [3, 30554], [4, 24360], [5, 1751], [6, 12094]]
+shares2 = sss.create_shares(secret2)
+# => [[1, 7983], [2, 18517], [3, 31630], [4, 47322], [5, 16226], [6, 37076]]
+``` 
+
+We combine both shares on a single array in preparation for the multiplication steps:
+
+```ruby
+operands_shares = [shares1, shares2]
+# => [[[1, 43064], [2, 20333], [3, 30554], [4, 24360], [5, 1751], [6, 12094]], [[1, 7983], [2, 18517], [3, 31630], [4, 47322], [5, 16226], [6, 37076]]]
+```
+
+Recall we are working with a t-out-of-n secret sharing scheme and this is actually required in this setting. We have a total of `n = 6` shares and threshold `t = 3`. In order to correctly recover the result of the multiplication over shares, we need to select any combination of `2 * t - 1` shares out of the total number of shares:
+
+```ruby
+selected_shares = Sharing::Polynomial::Shamir::V1.select_mul_shares(sss.total_shares, sss.threshold, operands_shares)
+# => => [[[2, 20333], [1, 43064], [5, 1751], [3, 30554], [4, 24360]], [[2, 18517], [1, 7983], [5, 16226], [3, 31630], [4, 47322]]]
+```
+
+Now we have everything we need to compute multiplication over the secret shares, which we do in two rounds. First round:
+
+```ruby
+mul_round1 = Sharing::Polynomial::Shamir::V1.mul_first_round(selected_shares, sss.total_shares, sss.threshold, sss.lambda_, sss.p)
+# => [[2, [[1, 25284], [2, 5881], [3, 2537], [4, 15252], [5, 44026], [6, 39492]]], [1, [[1, 36061], [2, 17299], [3, 32435], [4, 32102], [5, 16300], [6, 34396]]], [5, [[1, 30221], [2, 32724], [3, 33210], [4, 31679], [5, 28131], [6, 22566]]], [3, [[1, 46172], [2, 33017], [3, 8081], [4, 20731], [5, 21600], [6, 10688]]], [4, [[1, 12410], [2, 39133], [3, 5920], [4, 11505], [5, 6521], [6, 40335]]]]
+```
+
+Then we perform the second round:
+
+```ruby
+mul_round2 = Sharing::Polynomial::Shamir::V1.mul_second_round(mul_round1)
+# => [[1, 150148], [2, 128054], [3, 82183], [4, 111269], [5, 116578], [6, 147477]]
+```
+
+Then we only need a number equal to the threshold to reconstruct the result of the multipliction over the shares:
+
+```ruby
+selected_multiplication_shares = mul_round2.sample(sss.threshold)
+# => [[6, 147477], [2, 128054], [1, 150148]
+sss.reconstruct_secret(selected_multiplication_shares)
+# => 364
+```
+
+and we can check that
+
+```ruby
+secret1 * secret2
+# => 364
+```
+
+### t-out-of-n Secret Sharing
+
+Now we defined a threshold value that is less than the total number of shares:
+
+```ruby
+params = {total_shares: 5, threshold: 3, lambda_: 16}
+# => {:total_shares=>5, :threshold=>3, :lambda_=>16}
+sss = Sharing::Polynomial::Shamir::V1.new params
+# => #<Sharing::Polynomial::Shamir::V1:0x000000010b046e90 @lambda_=16, @p=61343, @threshold=3, @total_shares=5>
+secret = 25
+# => 25
+shares = sss.create_shares(secret)
+# => [[1, 54707], [2, 50401], [3, 48450], [4, 48854], [5, 51613]]
+selected_shares = shares.sample(3)
+reconstructed_secret = sss.reconstruct_secret(selected_shares)
+# => 25
+```
+
+Everything else works the sabe as before except the fact that only `3` shares are required to reconstruct the secret.
+
+### Division
+
+Here we simulate a division algorithm computed over the shares. Consider the following configuration:
+
+```ruby
+{:lambda_=>16, :total_shares=>6, :threshold=>3}
+sss = Sharing::Polynomial::Shamir::V1.new(params)
+```
+
+and the rational numbers
+
+```ruby
+rat1 = Rational(2, 3)
+rat2 = Rational(-5, 7)
+```
+
+We compute their Hensel code so we define our secrets:
+
+```ruby
+secret1 = HenselCode::TFPE.new(sss.p, 1, rat1).hensel_code
+# => 40896
+secret2 = HenselCode::TFPE.new(sss.p, 1, rat2).hensel_code
+# => 52579
+```
+
+We then comute the shares for each secret:
+
+```ruby
+shares1 = sss.create_shares(secret1)
+# => [[1, 22792], [2, 38518], [3, 26731], [4, 48774], [5, 43304], [6, 10321]]
+shares2 = sss.create_shares(secret2)
+# => [[1, 37982], [2, 294], [3, 858], [4, 39674], [5, 55399], [6, 48033]]
+```
+
+We select a subset of the shares of eacg secret based on the threshold:
+
+```ruby
+selected_shares1 = shares1.sample(sss.threshold)
+# => [[1, 22792], [5, 43304], [6, 10321]]
+selected_shares2 = shares2.sample(sss.threshold)
+# => [[6, 48033], [2, 294], [1, 37982]]
+```
+
+A party that is not one of the selected parties (a trusted party for instance) generates three random values that will later used:
+
+```ruby
+r1, r2, r3 = Sharing::Polynomial::Shamir::V1.generate_division_masking(sss.p)
+=> [23078, 18925, 18812]
+```
+
+Each party multiply their shares of the first operand by `r1` and the shares of the second operand by `r2`. For convenience (given our simulation), this step is here done all at once as follows:
+
+```ruby
+cs, ds = Sharing::Polynomial::Shamir::V1.compute_numerator_denominator(selected_shares1, selected_shares2, r1, r2, sss.p)
+=> [[[1, 38894], [5, 30899], [6, 54512]], [[6, 43951], [2, 43080], [1, 53419]]]
+```
+
+`cs` denote the shares representing the numerator of the division and `ds` represent the shares of the denominator of the division, as in `c/d`.
+
+Finally, in the reconstruction step, `c` and `d` are reconstructed and `r3` is used to invert the multiplication by `r1` and `r2` that was previously computed by the parties. With the correct values recovered, we compute the Hensel decoding and then we obtain the final result without revealing what the numerator and denominator were. For convenience, we execute these steps as follows:
+
+```ruby
+sss.reconstruct_division(cs, ds, r3)
+# => (-14/15)
+```
+
+We can also use only a subset of the shares:
+
+```ruby
+selected_cs = cs.sample(sss.threshold)
+=> [[5, 30899], [1, 38894], [6, 54512]]
+selected_ds = ds.sample(sss.threshold)
+# => [[2, 43080], [1, 53419], [6, 43951]]
+sss.reconstruct_division(selected_cs, selected_ds, r3)
+=> (-14/15)
+```
+
+And we can check that
+
+```ruby
+rat1 / rat2
+# => (-14/15)
+```
+
 ## Asmuth-Bloom V2
 
 The Asmuth-Bloom V2 was proposed by Ersoy et al. in in [Homomorphic extensions of CRT-based secret sharing](https://www.sciencedirect.com/science/article/pii/S0166218X20303012)). The reference is a CRT-based secret sharing scheme introduced by Asmuth-Bloom in [A modular approach to key safeguarding](https://ieeexplore.ieee.org/abstract/document/1056651).
@@ -227,6 +410,19 @@ crtss.reconstruct_secret(selected_shares1_add_shares2_add_shares1_mul_shares2)
 
 and we can check that 5 + 8 = 13, 5 * 8 = 40, and 13 + 40 = 53.
 
+## Author
+
+David William Silva
+
+## Contributors
+
+David William Silva (Algemetric)
+Marcio Junior (Algemetric)
+
+## Acknowledgements
+
+Luke Harmon (Algemetric) and Gaetan Delavignette (Algemetric) have been instrumental by providing/conducting mathematical analyses, tests, and overall recommendations for improving the gem. 
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/bin/console

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 require "bundler/setup"
-require "secret_sharing"
+require "sharing"
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.

data/lib/sharing/polynomial/shamir/v1.rb

@@ -28,15 +28,59 @@ module Sharing
           shares.map { |s| [s[0], (s[1] * mod_inverse(scalar, prime)) % prime] }
         end
 
+        def self.mul_first_round(shares, total_shares, threshold, lambda_, prime)
+          shares1, shares2 = shares
+          xs = shares1.map(&:first)
+          shares1.zip(shares2).map.with_index do |s, i|
+            share = prepare_share_for_multiplication(i, xs, prime, s)
+            reshares = create_shares(share, total_shares, threshold, lambda_, prime)
+            encode_reshares(reshares, prime, s)
+          end
+        end
+
+        def self.encode_reshares(reshares, prime, s_pair)
+          reshares_encoded = reshares.map do |ss|
+            [ss[0], (ss[1].numerator * mod_inverse(ss[1].denominator, prime)) % prime]
+          end
+          [s_pair[0][0], reshares_encoded]
+        end
+
+        def self.prepare_share_for_multiplication(index, xs_, prime, s_pair)
+          beta = lagrange_basis_polynomial_inner_loop(index, xs_)
+          (s_pair[0][1] * s_pair[1][1] * beta) % prime
+        end
+
+        def self.mul_second_round(mul_round1)
+          multiplication_shares = mul_round1.map(&:last).map { |m| m.map(&:last) }.transpose.map(&:sum)
+          multiplication_shares.map.with_index { |m, i| [i + 1, m] }
+        end
+
+        def self.select_mul_shares(total_shares, threshold, shares)
+          indices = (0..total_shares - 1).to_a.sample((2 * threshold) - 1)
+          shares.map { |shares_| shares_.values_at(*indices) }
+        end
+
         def self.generate_random_coefficients(total_shares, lambda_)
           random_distinct_numbers("integer", total_shares - 1, lambda_ - 1)
         end
 
-        def self.create_shares(secret, total_shares, lambda_, prime)
-          random_coefficients = generate_random_coefficients(total_shares, lambda_)
+        def self.create_shares(secret, total_shares, threshold, lambda_, prime)
+          random_coefficients = generate_random_coefficients(threshold, lambda_)
           (1..total_shares).map.with_index { |x, i| [i + 1, f(x, secret, random_coefficients) % prime] }
         end
 
+        def self.generate_division_masking(prime)
+          r1, r2 = random_distinct_numbers("integer", 2, prime.bit_length - 1)
+          r3 = (r2 * mod_inverse(r1, prime)) % prime
+          [r1, r2, r3]
+        end
+
+        def self.compute_numerator_denominator(shares1, shares2, r1_, r2_, prime)
+          cs = shares1.map { |i, share| [i, (share * r1_) % prime] }
+          ds = shares2.map { |i, share| [i, (share * r2_) % prime] }
+          [cs, ds]
+        end
+
         def initialize(params = {})
           @lambda_ = params[:lambda_]
           @total_shares = params[:total_shares]
@@ -44,16 +88,27 @@ module Sharing
           generate_prime
         end
 
+        def params
+          [lambda_, p, total_shares, threshold]
+        end
+
         def create_shares(secret)
           random_coefficients = generate_random_coefficients
-          (1..total_shares).map.with_index { |x, i| [i + 1, f(x, secret, random_coefficients) % p] }
+          (1..total_shares).map { |x| [x, f(x, secret, random_coefficients) % p] }
         end
 
         def reconstruct_secret(points)
           xs = points.map(&:first)
           ys = points.map(&:last)
           l0s = lagrange_basis_polynomial(xs)
-          l0s.zip(ys).map { |l, y| l * y }.sum % p
+          reconstructed_secret = l0s.zip(ys).map { |l, y| l * y }.sum % p
+          encode_to_integer(reconstructed_secret)
+        end
+
+        def reconstruct_division(cs_, ds_, r3_)
+          c, d = [cs_, ds_].map { |shares| reconstruct_secret(shares) }
+          c_d_encoded = (c * mod_inverse(d, p) * r3_) % p
+          HenselCode::TruncatedFinitePadicExpansion.new(p, 1, c_d_encoded).to_r
         end
 
         private
@@ -63,7 +118,11 @@ module Sharing
         end
 
         def generate_random_coefficients
-          random_distinct_numbers("integer", total_shares - 1, lambda_ - 1)
+          random_distinct_numbers("integer", threshold - 1, lambda_ - 1)
+        end
+
+        def encode_to_integer(reconstructed_secret)
+          (reconstructed_secret.numerator * mod_inverse(reconstructed_secret.denominator, p)) % p
         end
       end
     end

data/lib/sharing/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sharing
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/sharing.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Uncomment to register a new dependency of your gem
-  spec.add_dependency "hensel_code", "~> 0.3.0"
+  spec.add_dependency "hensel_code", "~> 0.3.1"
   spec.add_dependency "prime", "~> 0.1.2"
 
   # For more information and examples about making a new gem, check out our

data/sig/secret_sharing.rbs

@@ -1,4 +1,4 @@
-module SecretSharing
+module Sharing
   VERSION: String
   # See the writing guide of rbs: https://github.com/ruby/rbs#guides
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sharing
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - David William Silva
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-25 00:00:00.000000000 Z
+date: 2022-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hensel_code
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.3.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.3.1
 - !ruby/object:Gem::Dependency
   name: prime
   requirement: !ruby/object:Gem::Requirement
@@ -45,6 +45,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codecov.yml"
 - ".rubocop.yml"
 - CHANGELOG.md
 - Gemfile
@@ -54,6 +55,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- codecov
 - lib/sharing.rb
 - lib/sharing/crt/asmuth-bloom/v2.rb
 - lib/sharing/polynomial/shamir/v1.rb