sssa-ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3aecd0e42e5047d1532c46b18f66ec58a524bc18
+  data.tar.gz: 27e881caf6974a1fa15cd8193d17adf544a71195
+SHA512:
+  metadata.gz: 1af87f8d90b8f3424c7076398a04aeed005ccacfc96b8de5baef55de43ae34bb5b9bde7aee275a01745a884b7d88e1d982ec072f96213efe5826a6d96966139f
+  data.tar.gz: 487e533db0993f2ec11e29bd5cefe07703cc7e2394ac52ccd65617d872430f283613cd06ec80f52acd7c70878f3d5fd616a13bdb1c7d2a3cb8ad45e5cf6fd123

data/lib/sssa.rb

@@ -0,0 +1,82 @@
+require_relative './utils.rb'
+
+module SSSA
+    @prime = 99995644905598542077721161034987774965417302630805822064337798850767846245779
+    @util = SSSA::Utils.new
+
+    def self.create(minimum, shares, raw)
+        secret = @util.split_ints(raw)
+        numbers = [0]
+        polynomial = []
+        (0...secret.size).each do |i|
+            polynomial.push [secret[i]]
+            (1...minimum).each do |j|
+                value = @util.random()
+                while numbers.include? value
+                    value = @util.random()
+                end
+                numbers.push value
+                polynomial[i].push value
+            end
+        end
+
+        result = [""]*shares
+
+        (0...shares).each do |i|
+            (0...secret.size).each do |j|
+                value = @util.random()
+                while numbers.include? value
+                    value = @util.random()
+                end
+
+                y = @util.evaluate_polynomial(polynomial[j], value)
+
+                result[i] += @util.to_base64(value)
+                result[i] += @util.to_base64(y)
+            end
+        end
+
+        return result
+    end
+
+    def self.combine(shares)
+        secrets = []
+
+        shares.each_with_index do |share, index|
+            if share.size % 88 != 0
+                return
+            end
+
+            count = share.size / 88
+            secrets.push []
+
+            (0...count).each do |i|
+                cshare = share[i*88, (i+1)*88]
+                secrets[index][i] = [@util.from_base64(cshare[0...44]), @util.from_base64(cshare[44...88])]
+            end
+        end
+
+        secret = [0] * secrets[0].size
+
+        secret.each_with_index do |part, part_index|
+            secrets.each_with_index do |share, share_index|
+                origin = share[part_index][0]
+                originy = share[part_index][1]
+                numerator = 1
+                denominator = 1
+                secrets.each_with_index do |product, product_index|
+                    if product_index != share_index
+                        current = product[part_index][0]
+                        numerator = (numerator * (-1*current)) % @prime
+                        denominator = (denominator * (origin - current)) % @prime
+                    end
+                end
+
+                working = ((originy * numerator * @util.mod_inverse(denominator)) + @prime)
+                secret[part_index] = (secret[part_index] + working) % @prime
+            end
+        end
+
+        return @util.merge_ints(secret)
+    end
+end

data/lib/utils.rb

@@ -0,0 +1,96 @@
+require 'securerandom'
+require 'base64'
+
+module SSSA
+    class Utils
+        attr_accessor :prime
+
+        def initialize()
+            # 256-bit prime
+            @prime = 99995644905598542077721161034987774965417302630805822064337798850767846245779
+        end
+
+        def random()
+            return SecureRandom.random_number(@prime)
+        end
+
+        def split_ints(secret)
+            result = []
+
+            secret.scan(/.{1,32}/) do |part|
+                segment = part.split('').map do |x|
+                    if x.ord > 15
+                        x.ord.to_s(16)
+                    else
+                        "0" + x.ord.to_s(16)
+                    end
+                end
+                result.push (segment+["00"]*(32-segment.size)).join.hex
+            end
+
+            return result
+        end
+
+        def merge_ints(secrets)
+            result = ""
+
+            secrets.each_with_index do |secret, index|
+                if index == secrets.size-1
+                    result += ("0"*(64-secret.to_s(16).size) + secret.to_s(16)).scan(/../).map{|x| x.hex.chr}.join.gsub(/\x00*$/, '')
+                else
+                    result += ("0"*(64-secret.to_s(16).size) + secret.to_s(16)).scan(/../).map{|x| x.hex.chr}.join
+                end
+            end
+
+            return result
+        end
+
+        def evaluate_polynomial(coefficients, value)
+            result = 0
+            coefficients.each_with_index do |coefficient, exponent|
+                expmod = 1
+                (0...exponent).each do
+                    expmod = (expmod * value) % @prime
+                end
+                result += coefficient * expmod
+                result = result % @prime
+            end
+
+            return result
+        end
+
+        def to_base64(number)
+            return Base64.urlsafe_encode64(("0"*(64-number.to_s(16).size) + number.to_s(16)).scan(/../).map{|x| x.hex.chr}.join)
+        end
+
+        def from_base64(number)
+            segment = Base64.urlsafe_decode64(number).split('').map do |x|
+                if x.ord > 15
+                    x.ord.to_s(16)
+                else
+                    "0" + x.ord.to_s(16)
+                end
+            end
+            return (segment+["00"]*(32-segment.size)).join.hex
+        end
+
+        def gcd(a, b)
+            if b == 0
+                return [a, 1, 0]
+            else
+                n = (a*1.0/b).floor
+                c = a % b
+                r = gcd(b, c)
+                return [r[0], r[2], r[1]-r[2]*n]
+            end
+        end
+
+        def mod_inverse(number)
+            remainder = gcd(@prime, number % @prime)[2]
+            if (number < 0)
+                remainder *= -1
+            end
+            return (@prime + remainder) % @prime
+        end
+    end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: sssa-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alexander Scheel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-18 00:00:00.000000000 Z
+dependencies: []
+description: Helper cryptography module for Ruby
+email: alexander.m.scheel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sssa.rb
+- lib/utils.rb
+homepage: https://github.com/SSSAAS/sssa-ruby
+licenses:
+- MIT
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Shamir's Secret Sharing Algorithm
+test_files: []