sharing 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b091eefc1c0e4656e732cfdbc983177df829e0c646467227871bf2a3dfc18203
-  data.tar.gz: 493c97755883f09df9fd19b9e9f9dcb09f4a15756cd22401bce780e4b574123c
+  metadata.gz: 719563755ad21ee302ca5c4cdf7dc99d5392f03f5a42af56a38a9199a76e5d31
+  data.tar.gz: f58c948f6c1c26cc2cc0f7f6e0c318a2c46d2c219952757bf43d092328f5b6ec
 SHA512:
-  metadata.gz: 6405b3a080f2a669b1f0882d9baec0e29c7ffaa93cafb5738a1636fdf58f596129c7a8436470dfbb4fd059e78b15b9b060a557bfb789e1316dbf1605b031545b
-  data.tar.gz: 5a8096e9f83b122550d62cd97417b928bd37d64a5902c857a7d7c7f515ddb97264ab1b87cbde0590e9e7bdcda3acdb4c95a75cdaab0fb0bb9bad120f91373e6a
+  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,3 +1,7 @@
+## [0.3.0] - 2022-05-23
+
+- 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.

data/Gemfile

@@ -19,8 +19,6 @@ gem "rubocop-rake", "~> 0.6"
 
 gem "minitest-reporters", "~> 1.5"
 
-gem "simplecov", "~>0.21", require: false
+gem "codecov", require: false, group: :test
 
 gem "simplecov-console", "~>0.9", require: false
-
-gem "codecov", require: false, group: "test"

data/Gemfile.lock

@@ -79,7 +79,6 @@ DEPENDENCIES
   rubocop-minitest (~> 0.17.2)
   rubocop-rake (~> 0.6)
   sharing!
-  simplecov (~> 0.21)
   simplecov-console (~> 0.9)
 
 RUBY VERSION

data/README.md

@@ -1,6 +1,6 @@
 # Sharing
 
-![GitHub Workflow Status](https://img.shields.io/github/workflow/status/davidwilliam/sharing/Ruby)
+![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.
 
@@ -264,6 +264,90 @@ reconstructed_secret = sss.reconstruct_secret(selected_shares)
 
 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).
@@ -326,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.
@@ -338,4 +435,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/davidw
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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

@@ -69,6 +69,18 @@ module Sharing
           (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]
@@ -93,6 +105,12 @@ module Sharing
           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
 
         def generate_prime

data/lib/sharing/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sharing
 version: !ruby/object:Gem::Version
-  version: 0.2.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
@@ -45,6 +45,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codecov.yml"
 - ".rubocop.yml"
 - CHANGELOG.md
 - Gemfile