secret_sharing 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 9edad808096f5d69277724baf3e5bda37c3508a4
-  data.tar.gz: c53c0ef4912e5c122e7bf762c8786fd06f096aa9
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MTU5NTYxM2RmYzRmOTdlMzVlYzczNTg1ODc2NDBmYTcwOGNiNWY2Yg==
+  data.tar.gz: !binary |-
+    NjA3MGFiOGNiYzlhOGQ0MWIxYjNkM2VlNDVkMGZiYmQ2MzgyZTgzZA==
 SHA512:
-  metadata.gz: d82ab5514fc4c4279e98b4020665d261fcbe51f931fcdd8e95df2d26851022ece62c2a907361f5f145d41c96fa6127c1b198621a6f687ea295c41da4e692fadd
-  data.tar.gz: 02b27fd7e5512185118e086c8b967e2bd1f3741dc51c2bccd7c6dfe6d73fb9025f690e19f01aa3b1abb0ef7fc0c9f27b3fa558b0130ac9b76bb10071306cf122
+  metadata.gz: !binary |-
+    NGM2YjkzZDQyMGYyNGU5NzhhMGUxZjAxMTVmZTg4MGJjNTRkNTI1NGJmYzkw
+    NzAwN2Y4NGQ3MmJkZWNlN2NiNjhkM2FkYTExZDFlNTNjMDM4MDYyNDdjNWNi
+    MmYyOGUwNTU1ZDE0MTAzZmU4NzUzZGViMmM2OTRiYTUxN2M4NTQ=
+  data.tar.gz: !binary |-
+    NzRmYjIwMzk2MWJmYTUxY2YxMjIzYzUyOWMwMDVhZGIwZGI5NTIxOTlhNDdl
+    OWNjYzczNzJkMmJhOTBjYzk2Yjc3ZWVmMmFmNjI4ZmI3ZWZhM2M0Y2RiNjIz
+    MDBkYTU0NGE3NGU3MTg1MmQyYmE4ZmE5MmZmMzI1MjQzNjI3ZWQ=

data/.rspec

@@ -1,2 +1,3 @@
 --color
 --require spec_helper
+--format documentation

data/.rubocop.yml

@@ -1,7 +1,3 @@
-Style/AsciiComments:
-  Enabled: false # not to comment in another language than english but to be
-                 # able to write tests for non ascii characters
-
 Documentation:
   Enabled: false # this is handled by yard and it is annoying since rubocop does
                  # not notice if a top level class documentation has already

data/.travis.yml

@@ -1,6 +1,14 @@
 language: ruby
 rvm:
-  - 2.2.0
-bundler_args: --without development
+- 2.2.2
+bundler_args: "--without development"
 cache: bundler
 sudo: false
+deploy:
+  provider: rubygems
+  api_key:
+    secure: aNkBOgCW7ZCsDHp/tSv1C2yxu1FVh9XoClyGNc6IXrvdJ/OouvuLucNXxazD53YnbaRqM5QxyJbl2wMNHrlp7aakjSmmPcHcYGWpZU0AzCaIvzCdoLPxL5GMR0K1CIdyL7KDTDv5ntmEA4iINACYcm20v0EBhY02Tbt1DI/nc9c=
+  gem: secret_sharing
+  on:
+    tags: true
+    repo: duse-io/secret_sharing_ruby

data/README.md

@@ -1,3 +1,4 @@
+[![Gem Version](https://badge.fury.io/rb/secret_sharing.svg)](http://badge.fury.io/rb/secret_sharing)
 [![Build Status](https://travis-ci.org/duse-io/secret_sharing_ruby.svg?branch=master)](https://travis-ci.org/duse-io/secret_sharing_ruby)
 [![Coverage Status](https://coveralls.io/repos/duse-io/secret_sharing_ruby/badge.svg?branch=master)](https://coveralls.io/r/duse-io/secret_sharing_ruby?branch=master)
 [![Code Climate](https://codeclimate.com/github/duse-io/secret_sharing_ruby/badges/gpa.svg)](https://codeclimate.com/github/duse-io/secret_sharing_ruby)

data/Rakefile

@@ -1,4 +1,7 @@
 require 'bundler/gem_tasks'
+# remove release task
+Rake::Task["release"].clear
+
 begin
   require 'rspec/core/rake_task'
   RSpec::Core::RakeTask.new(:spec)

data/lib/secret_sharing.rb

@@ -9,6 +9,8 @@ require 'secret_sharing/share'
 # connection to be consumed by a user. Do not use any other class/module of
 # this library unless you really know what you are doing.
 module SecretSharing
+  extend self
+
   # Split a secret using Shamir's Secret Sharing algorithm.
   #
   # Example
@@ -22,13 +24,13 @@ module SecretSharing
   #
   # @return [Array] Array of shares that can be used to recover the secret.
   def split_secret(secret_string, share_threshold, num_shares)
-    secret_int = Charset::ASCIICharset.new.s_to_i(secret_string)
+    secret_int = Charset::ASCIICharset.s_to_i(secret_string)
     points = Polynomial.points_from_secret(secret_int,
                                            share_threshold,
                                            num_shares)
 
     points.map do |point|
-      Share.new(point).to_s
+      Share.new(point).to_s(Math.log10(points.length).floor + 1)
     end
   end
 
@@ -47,9 +49,6 @@ module SecretSharing
     shares = raw_shares.map { |raw_share| Share.from_string raw_share }
     points = shares.map(&:point)
     secret_int = Polynomial.modular_lagrange_interpolation(points)
-    Charset::ASCIICharset.new.i_to_s(secret_int)
+    Charset::ASCIICharset.i_to_s(secret_int)
   end
-
-  module_function :split_secret,
-                  :recover_secret
 end

data/lib/secret_sharing/charset.rb

@@ -1,138 +1,123 @@
 require 'set'
 
 module SecretSharing
-  module Charset
-    # This objects of this class can represent a custom charset whenever the
-    # predefined charsets do not fit a situation.
-    class DynamicCharset
-      # A new instance of DynamicCharset. The constructor should only be used
-      # when you know what you are doing. Usually you only want to use this
-      # constructor when you recreate a charset and the order of the charset is
-      # important. The "null-byte" character is prepended to be the first
-      # character in the charset to avoid loosing the first character of the
-      # charset when it is also the first character in a string to convert.
-      #
-      # Example
-      #
-      #   SecretSharing::Charset::DynamicCharset.new ['a', 'b', 'c']
-      #   # => #<SecretSharing::Charset::DynamicCharset @charset=[...]>
-      #
-      # @param charset [Array] array of characters to use for the charset.
-      def initialize(charset)
-        @charset = charset.unshift("\u0000")
-      end
+  # Charset can represent any charset which does not have the null byte
+  class Charset
+    class NotInCharset < ArgumentError; end
+    class NotPositiveInteger < ArgumentError; end
 
-      # Calculate a string from an integer.
-      #
-      # Example
-      #
-      #   charset = SecretSharing::Charset.by_charset_string 'abc'
-      #   charset.i_to_s 6
-      #   # => "ab"
-      #
-      # @param x [Integer] integer to convert to string
-      # @return [String] converted string
-      def i_to_s(x)
-        unless x.is_a?(Integer) && x >= 0
-          fail ArgumentError, 'x must be a non-negative integer'
-        end
+    # @return [Array] internal representation of the charset
+    attr_reader :charset
 
-        output = ''
-        while x > 0
-          x, codepoint = x.divmod(length)
-          output.prepend(codepoint_to_char(codepoint))
-        end
-        output
-      end
+    # The "null-byte" character is prepended to be the first character in the
+    # charset to avoid loosing the first character of the charset when it is
+    # also the first character in a string to convert.
+    #
+    # Example
+    #
+    #   SecretSharing::Charset::DynamicCharset.new ['a', 'b', 'c'] # =>
+    #   #<SecretSharing::Charset::DynamicCharset @charset=[...]>
+    #
+    # @param charset [Array] array of characters to use for the charset.
+    def initialize(charset)
+      @charset = ["\u0000"] + charset
+      @charset.freeze
+    end
 
-      # Calculate an integer from a string.
-      #
-      # Example
-      #
-      #   charset = SecretSharing::Charset.by_charset_string 'abc'
-      #   charset.s_to_i "ab"
-      #   # => 6
-      #
-      # @param string [Integer] integer to convert to string
-      # @return [String] converted string
-      def s_to_i(string)
-        string.chars.reduce(0) do |output, char|
-          output * length + char_to_codepoint(char)
-        end
+    # Calculate a string from an integer.
+    #
+    # Example
+    #
+    #   charset = SecretSharing::Charset.by_charset_string 'abc'
+    #   charset.i_to_s 6
+    #   # => "ab"
+    #
+    # @param input [Integer] integer to convert to string
+    # @return [String] converted string
+    def i_to_s(input)
+      if !input.is_a?(Integer) || input < 0
+        fail NotPositiveInteger, 'input must be a non-negative integer'
       end
 
-      # Convert an integer into its string representation according to the
-      # charset. (only one character)
-      #
-      # Example
-      #
-      #   charset = SecretSharing::Charset.by_charset_string 'abc'
-      #   charset.codepoint_to_char 1
-      #   # => "a"
-      #
-      # @param codepoint [Integer] Codepoint to retrieve the character for
-      # @return [String] Retrieved character
-      def codepoint_to_char(codepoint)
-        char = @charset[codepoint]
-        return char unless char.nil?
-        fail ArgumentError, "Codepoint #{codepoint} does not exist in charset"
+      output = ''
+      while input > 0
+        input, codepoint = input.divmod(charset.length)
+        output.prepend(codepoint_to_char(codepoint))
       end
+      output
+    end
 
-      # Convert a single character into its integer representation according to
-      # the charset.
-      #
-      # Example
-      #
-      #   charset = SecretSharing::Charset.by_charset_string 'abc'
-      #   charset.char_to_codepoint 'a'
-      #   # => 1
-      #
-      # @param c [String] Character to retrieve its codepoint in the charset
-      # @return [Integer] Codepoint within the charset
-      def char_to_codepoint(c)
-        codepoint = @charset.rindex c
-        return codepoint unless codepoint.nil?
-        error_msg = "Character \"#{c}\" not part of the supported charset"
-        fail ArgumentError, error_msg
+    # Calculate an integer from a string.
+    #
+    # Example
+    #
+    #   charset = SecretSharing::Charset.by_charset_string 'abc'
+    #   charset.s_to_i "ab"
+    #   # => 6
+    #
+    # @param string [Integer] integer to convert to string
+    # @return [String] converted string
+    def s_to_i(string)
+      string.chars.reduce(0) do |output, char|
+        output * charset.length + char_to_codepoint(char)
       end
+    end
 
-      # Total length of the charset
-      #
-      # Example
-      #
-      #   charset = SecretSharing::Charset.by_charset_string 'abc'
-      #   charset.length
-      #   # => 4
-      def length
-        @charset.length
+    # Convert an integer into its string representation according to the
+    # charset. (only one character)
+    #
+    # Example
+    #
+    #   charset = SecretSharing::Charset.by_charset_string 'abc'
+    #   charset.codepoint_to_char 1
+    #   # => "a"
+    #
+    # @param codepoint [Integer] Codepoint to retrieve the character for
+    # @return [String] Retrieved character
+    def codepoint_to_char(codepoint)
+      if charset.at(codepoint).nil?
+        fail NotInCharset, "Codepoint #{codepoint} does not exist in charset"
       end
+      charset.at(codepoint)
+    end
 
-      # Check if the provided string can be represented by the charset.
-      #
-      # Example
-      #
-      #   charset = SecretSharing::Charset.by_charset_string 'abc'
-      #   charset.subset? 'd'
-      #   # => false
-      #   charset.subset? 'a'
-      #   # => true
-      #
-      # @param string [String] Character to retrieve the for codepoint
-      # @return [TrueClass|FalseClass]
-      def subset?(string)
-        (Set.new(string.chars.uniq) - Set.new(@charset)).empty?
+    # Convert a single character into its integer representation according to
+    # the charset.
+    #
+    # Example
+    #
+    #   charset = SecretSharing::Charset.by_charset_string 'abc'
+    #   charset.char_to_codepoint 'a'
+    #   # => 1
+    #
+    # @param c [String] Character to retrieve its codepoint in the charset
+    # @return [Integer] Codepoint within the charset
+    def char_to_codepoint(c)
+      codepoint = charset.index c
+      if codepoint.nil?
+        fail NotInCharset, "Char \"#{c}\" not part of the supported charset"
       end
+      codepoint
+    end
+
+    # Check if the provided string can be represented by the charset.
+    #
+    # Example
+    #
+    #   charset = SecretSharing::Charset.by_charset_string 'abc'
+    #   charset.subset? 'd'
+    #   # => false
+    #   charset.subset? 'a'
+    #   # => true
+    #
+    # @param string [String] Character to retrieve the for codepoint
+    # @return [TrueClass|FalseClass]
+    def subset?(string)
+      (string.chars - charset).empty?
     end
 
     # Charset that can represent any string that only consists of ASCII
     # characters.
-    class ASCIICharset < DynamicCharset
-      # An instance of an ASCIICharset is just a DynamicCharset with the ASCII
-      # characters.
-      def initialize
-        super((1..127).to_a.map(&:chr))
-      end
-    end
+    ASCIICharset = new((1..127).to_a.map(&:chr))
   end
 end
-

data/lib/secret_sharing/point.rb

@@ -1,7 +1,10 @@
 module SecretSharing
   # This class is used to store a two dimensional point consisting of integers.
   class Point
-    attr_accessor :x, :y
+    # @return [Integer] x value the point was instantiated with
+    attr_reader :x
+    # @return [Integer] y value the point was instantiated with
+    attr_reader :y
 
     # Create a Point object.
     #
@@ -17,18 +20,6 @@ module SecretSharing
       @y = y
     end
 
-    # A nicer inspection of a point object than by default.
-    #
-    # @return [String] String representation of a Point
-    #
-    # Examples
-    #
-    #   SecretSharing::Point.new(1, 2).inspect
-    #   # => "#<Point: @x=1 @y=2>"
-    def inspect
-      "#<Point: @x=#{x} @y=#{y}>"
-    end
-
     # An implementation similar to Array#transpose for Arrays of Points
     #
     # @return [Array] Two Arrays in an Array

data/lib/secret_sharing/polynomial.rb

@@ -4,17 +4,27 @@ module SecretSharing
   # The polynomial is used to represent the required random polynomials used in
   # Shamir's Secret Sharing algorithm.
   class Polynomial
+    attr_reader :coefficients
+
     # Create a new instance of a Polynomial with n coefficients, when having
     # the polynomial in standard polynomial form.
     #
     # Example
     #
+    #   For the polynomial f(x) = a0 + a1 * x + a2 * x^2 + ... + an * x^n the
+    #   coefficients are [a0, a1, a2, ..., an]
+    #
     #   Polynomial.new [1, 2, 3]
     #   # => #<SecretSharing::Polynomial:0x0000000 @coefficients=[1, 2, 3]>
     #
     # @param coefficients [Array] an array of integers as the coefficients
     def initialize(coefficients)
+      coefficients.each do |c|
+        not_an_int = 'One or more coefficents are not integers'
+        fail ArgumentError, not_an_int unless c.is_a?(Integer)
+      end
       @coefficients = coefficients
+      @coefficients.freeze
     end
 
     # Generate points on the polynomial, that can be used to reconstruct the
@@ -29,8 +39,9 @@ module SecretSharing
     # @param prime [Integer] prime for calculation in finite field
     # @return [Array] array of calculated points
     def points(num_points, prime)
+      intercept = @coefficients[0] # the first coefficient is the intercept
       (1..num_points).map do |x|
-        y = @coefficients[0]
+        y = intercept
         (1...@coefficients.length).each do |i|
           exponentiation = x**i % prime
           term = (@coefficients[i] * exponentiation) % prime
@@ -54,10 +65,10 @@ module SecretSharing
     def self.random(degree, intercept, upper_bound)
       fail ArgumentError, 'Degree must be a non-negative number' if degree < 0
 
-      coefficients = (0...degree).reduce([intercept]) do |accumulator, _i|
+      coefficients = (0...degree).reduce([intercept]) do |accumulator|
         accumulator << SecureRandom.random_number(upper_bound)
       end
-      Polynomial.new coefficients
+      new coefficients
     end
 
     # Generate points from a secret integer.
@@ -72,8 +83,7 @@ module SecretSharing
     # @param num_points [Integer] number of points to generate
     # @return [Polynomial] the generated polynomial
     def self.points_from_secret(secret_int, point_threshold, num_points)
-      prime = SecretSharing::Prime.large_enough_prime([secret_int, num_points])
-      fail ArgumentError, 'Secret is too long' if prime.nil?
+      prime = SecretSharing::Prime.large_enough_prime([secret_int, num_points].max)
       fail ArgumentError, 'Threshold must be at least 2' if point_threshold < 2
       fail ArgumentError, 'Threshold must be less than the total number of points' if point_threshold > num_points
 
@@ -81,12 +91,14 @@ module SecretSharing
                                                     secret_int,
                                                     prime)
       polynomial.points(num_points, prime)
+    rescue Prime::CannotFindLargeEnoughPrime
+      raise ArgumentError, 'Secret is too long'
     end
 
     # Modular lagrange interpolation
     def self.modular_lagrange_interpolation(points)
       y_values = Point.transpose(points)[1]
-      prime = SecretSharing::Prime.large_enough_prime(y_values)
+      prime = SecretSharing::Prime.large_enough_prime(y_values.max)
       points.reduce(0) do |f_x, point|
         numerator, denominator = lagrange_fraction(points, point, prime)
         lagrange_polynomial = numerator * mod_inverse(denominator, prime)

data/lib/secret_sharing/prime.rb

@@ -1,44 +1,46 @@
 module SecretSharing
   # This module is used to generate/calculate/retrieve primes.
   module Prime
+    class CannotFindLargeEnoughPrime < StandardError; end
+
+    extend self
+
     # Retrieves the next largest prime for the largest number in batch
     #
     # Example
     #
-    #   Prime.large_enough_prime [1, 2, 3, 4]
+    #   Prime.large_enough_prime 4
     #   # => 7
     #
-    # @param batch [Array] a list of integers
-    # @return [Integer] the next largest prime or nil if numbers too large
-    def large_enough_prime(batch)
-      standard_primes = mersenne_primes + [
-        # smallest 257, 321 and 385 bit primes
-        2**256 + 297, 2**320 + 27, 2**384 + 231
-      ].sort
-
+    # @param input [Integer] the integer to find the next largest prime for
+    # @return [Integer] the next largest prime
+    # @raise [CannotFindLargeEnoughPrime] raised when input is too large and
+    #   no large enough prime can be found
+    def large_enough_prime(input)
       standard_primes.each do |prime|
-        greater_than_prime = Array.new(batch).select { |i| i if i > prime }
-        return prime if greater_than_prime.empty?
+        return prime if prime > input
       end
-      nil
+      fail CannotFindLargeEnoughPrime, 'Input too large'
     end
 
     private
 
+    # Merges the mersenne primes with the smallst 257, 321, and 385 bit primes
+    def standard_primes
+      mersenne_primes + [
+        # smallest 257, 321 and 385 bit primes
+        2**256 + 297, 2**320 + 27, 2**384 + 231
+      ].sort
+    end
+
     # Calculates the first 15 mersenne primes
     def mersenne_primes
       mersenne_prime_exponents = [
         2, 3, 5, 7, 13, 17, 19, 31, 61, 89, 107, 127, 521, 607, 1279
       ]
       mersenne_prime_exponents.map do |exp|
-        prime = 1
-        prime *= 2**exp
-        prime -= 1
-        prime
+        (2**exp) - 1
       end
     end
-
-    module_function :mersenne_primes,
-                    :large_enough_prime
   end
 end

data/lib/secret_sharing/share.rb

@@ -2,6 +2,7 @@ module SecretSharing
   # A share is an object that encapsulates the properties of a share created by
   # Shamir's Secret Sharing algorithm.
   class Share
+    # @return [SecretSharing::Point] Point the share was instantiated with
     attr_reader :point
 
     # Create a share object
@@ -25,8 +26,8 @@ module SecretSharing
     #   SecretSharing::Share.new(point).to_s
     #   # => "1-2"
     #
-    def to_s
-      "#{point.x}-#{point.y.to_s(16)}"
+    def to_s(x_length)
+      "#{point.x.to_s.rjust(x_length, '0')}-#{point.y.to_s(16)}"
     end
 
     # Creates a share object from its string representation.
@@ -36,10 +37,12 @@ module SecretSharing
     #   SecretSharing::Share.from_string "1-2"
     #   # => #<SecretSharing::Share:0x0000000 @point=...>
     #
+    # @param share_string [String]
+    # @return [SecretSharing::Share] parsed share
     def self.from_string(share_string)
       x_string, y_string = share_string.split '-'
       point = Point.new x_string.to_i, y_string.to_i(16)
-      Share.new(point)
+      new(point)
     end
   end
 end

data/lib/secret_sharing/version.rb

@@ -1,4 +1,4 @@
 module SecretSharing
   # gem version
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/spec/charset_spec.rb

@@ -1,31 +1,113 @@
 require 'securerandom'
 
 describe SecretSharing::Charset do
-  context 'encode and decode' do
-    it 'should be able to decode randomly generated encoded strings' do
-      50.times do
-        str = SecureRandom.base64(100)
-        charset = SecretSharing::Charset::ASCIICharset.new
-        encoded = charset.s_to_i(str)
-        decoded = charset.i_to_s(encoded)
-        expect(decoded).to eq(str)
-      end
+  subject(:charset) { SecretSharing::Charset.new %w(a b c) }
+
+  describe '#initialize' do
+    it 'adds a non printable character in front of the charset' do
+      expect(charset.charset).to eq ["\u0000", 'a', 'b', 'c']
+    end
+
+    it 'makes the internal representation of the charset immutable' do
+      expect { charset.charset << 'x' }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '#i_to_s' do
+    it 'converts 0 to empty string' do
+      expect(charset.i_to_s(0)).to eq ''
+    end
+
+    it 'converts 1 to "a"' do
+      expect(charset.i_to_s(1)).to eq 'a'
+    end
+
+    it 'converts 6 to "ab"' do
+      expect(charset.i_to_s(6)).to eq 'ab'
+    end
+
+    it 'throws an error when trying to convert negative numbers' do
+      expect { charset.i_to_s(-1) }.to raise_error(
+        SecretSharing::Charset::NotPositiveInteger,
+        'input must be a non-negative integer'
+      )
+    end
+
+    it 'throws an error when trying to convert something non-integer' do
+      expect { charset.i_to_s('error') }.to raise_error(
+        SecretSharing::Charset::NotPositiveInteger,
+        'input must be a non-negative integer'
+      )
     end
+  end
 
-    it 'should throw errors when characters that are not in charset' do
-      charset = SecretSharing::Charset::ASCIICharset.new
-      expect { charset.codepoint_to_char(130) }.to raise_error(ArgumentError)
-      expect { charset.char_to_codepoint('ä') }.to raise_error(ArgumentError)
+  describe '#s_to_i' do
+    it 'converts "a" to 1' do
+      expect(charset.s_to_i('a')).to eq 1
     end
 
-    it 'should throw an error when trying to convert negative numbers' do
-      charset = SecretSharing::Charset::ASCIICharset.new
-      expect { charset.i_to_s(-1) }.to raise_error(ArgumentError)
+    it 'converts "ab" to 6' do
+      expect(charset.s_to_i('ab')).to eq 6
     end
+  end
 
-    it 'should throw an error when trying to convert something non-integer' do
-      charset = SecretSharing::Charset::ASCIICharset.new
-      expect { charset.i_to_s('error') }.to raise_error(ArgumentError)
+  describe '#codepoint_to_char' do
+    it 'returns "b" for 2' do
+      expect(charset.codepoint_to_char(2)).to eq 'b'
     end
+
+    it 'throws an error on an integer outside of the charset' do
+      expect { charset.codepoint_to_char(4) }.to raise_error(
+        SecretSharing::Charset::NotInCharset,
+        'Codepoint 4 does not exist in charset'
+      )
+    end
+  end
+
+  describe '#char_to_codepoint' do
+    it 'returns 2 for "b"' do
+      expect(charset.char_to_codepoint('b')).to eq 2
+    end
+
+    it 'throws an error on a character that is not in the charset' do
+      expect { charset.char_to_codepoint('d') }.to raise_error(
+        SecretSharing::Charset::NotInCharset,
+        "Char \"d\" not part of the supported charset"
+      )
+    end
+  end
+
+  describe '#subset?' do
+    context 'the input is a subset' do
+      it 'returns true' do
+        expect(charset.subset?('ab')).to be true
+      end
+    end
+
+    context 'the input is not a subset' do
+      it 'returns false' do
+        expect(charset.subset?('abcdef')).to be false
+      end
+    end
+
+    context 'the input does not only contain unique characters' do
+      it 'is still a subset' do
+        expect(charset.subset?('aabc')).to be true
+      end
+    end
+  end
+end
+
+describe 'SecretSharing::Charset::ASCIICharset' do
+  it 'is a 128 character long charset' do
+    expect(SecretSharing::Charset::ASCIICharset.charset.length).to eq 128
+  end
+
+  it 'supports all printable characters in ASCII' do
+    all_chars = " !\"#$%&'()*+,-./0123456789:;<=>?@" \
+                "ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`" \
+                "abcdefghijklmnopqrstuvwxyz{|}~\n"
+    int = SecretSharing::Charset::ASCIICharset.s_to_i all_chars
+    expect(SecretSharing::Charset::ASCIICharset.i_to_s(int)).to eq all_chars
   end
 end

data/spec/point_spec.rb

@@ -1,6 +1,31 @@
-describe SecretSharing::Point do
-  it 'should follow the ruby convention when inspecting' do
-    point = SecretSharing::Point.new(1, 2)
-    expect(point.inspect).to eq('#<Point: @x=1 @y=2>')
+RSpec.describe SecretSharing::Point do
+  describe '#initialize' do
+    it 'sets the coordinates correctly' do
+      point = SecretSharing::Point.new(1, 2)
+      expect(point.x).to be 1
+      expect(point.y).to be 2
+    end
+  end
+
+  describe '.transpose' do
+    it 'returns an array consisting of two further arrays' do
+      result = SecretSharing::Point.transpose []
+      expect(result).to be_an Array
+      expect(result.length).to be 2
+      expect(result.first).to be_an Array
+      expect(result.last).to be_an Array
+    end
+
+    it 'puts all x values in the first and all y values in the second array' do
+      result = SecretSharing::Point.transpose([
+        SecretSharing::Point.new(1, 2),
+        SecretSharing::Point.new(3, 4),
+        SecretSharing::Point.new(5, 6)
+      ])
+      expect(result).to eq([
+        [1, 3, 5],
+        [2, 4, 6]
+      ])
+    end
   end
 end

data/spec/polynomial_spec.rb

@@ -1,22 +1,114 @@
-describe SecretSharing::Charset do
-  it 'should error when trying to generate a polynomial with negative degree' do
-    random_generator = -> { SecretSharing::Polynomial.random(-1, 1, 12) }
-    expect(&random_generator).to raise_error(ArgumentError)
+RSpec.describe SecretSharing::Polynomial do
+  describe '#initialize' do
+    it 'does not error when all coefficients are integers' do
+      SecretSharing::Polynomial.new [1, 2, 3]
+    end
+
+    it 'makes the coefficients immutable' do
+      polynomial = SecretSharing::Polynomial.new [1, 2, 3]
+      expect(polynomial.coefficients).to eq [1, 2, 3]
+      expect { polynomial.coefficients << 4 }.to raise_error(RuntimeError)
+    end
+
+    it 'raises an error when a coefficient is not an integer' do
+      expect { SecretSharing::Polynomial.new(['']) }.to raise_error(
+        ArgumentError,
+        'One or more coefficents are not integers'
+      )
+    end
   end
 
-  it 'should error when the secret is to long' do
-    secret = 2**10_000
-    block = -> { SecretSharing::Polynomial.points_from_secret(secret, 2, 3) }
-    expect(&block).to raise_error(ArgumentError)
+  describe '#points' do
+    context '5 points for f(x)=x^4 + 2' do
+      subject(:polynomial) { SecretSharing::Polynomial.new([2, 0, 0, 0, 1]) }
+
+      it 'generates 5 points' do
+        expect(polynomial.points(5, 3).length).to eq 5
+      end
+
+      it 'generates points (1, 0), (2, 0) and (3, 2) for f(x)=x^4 + 2' do
+        points = polynomial.points(5, 7)
+        expect(points[0].x).to eq 1
+        expect(points[0].y).to eq 3
+        expect(points[1].x).to eq 2
+        expect(points[1].y).to eq 4
+        expect(points[2].x).to eq 3
+        expect(points[2].y).to eq 6
+        expect(points[3].x).to eq 4
+        expect(points[3].y).to eq 6
+        expect(points[4].x).to eq 5
+        expect(points[4].y).to eq 4
+      end
+    end
   end
 
-  it 'should error when the point threshold is too small' do
-    block = -> { SecretSharing::Polynomial.points_from_secret(123, 1, 3) }
-    expect(&block).to raise_error(ArgumentError)
+  describe '.random' do
+    it 'errors when trying to generate a polynomial with negative degree' do
+      random_generator = -> { SecretSharing::Polynomial.random(-1, 1, 12) }
+      expect(&random_generator).to raise_error(
+        ArgumentError,
+        'Degree must be a non-negative number'
+      )
+    end
+
+    it 'can create polynomials of degree 0' do
+      polynomial = SecretSharing::Polynomial.random(0, 5, 10)
+      expect(polynomial.coefficients).to eq [5]
+    end
+
+    it 'randomly generates coefficients' do
+      allow(SecureRandom).to receive(:random_number).and_return(3, 5, 2)
+      polynomial = SecretSharing::Polynomial.random(3, 5, 10)
+      expect(polynomial.coefficients).to eq [5, 3, 5 ,2]
+    end
+
+    it 'uses the intercept as the first coefficient' do
+      polynomial = SecretSharing::Polynomial.random(3, 5, 10)
+      expect(polynomial.coefficients.first).to eq 5
+    end
+
+    it 'creates a polynomial with degree as number of coefficients' do
+      polynomial = SecretSharing::Polynomial.random(3, 3, 10)
+      expect(polynomial.coefficients.length).to eq 4
+    end
   end
 
-  it 'should error when the point threshold is larger than total points' do
-    block = -> { SecretSharing::Polynomial.points_from_secret(123, 3, 2) }
-    expect(&block).to raise_error(ArgumentError)
+  describe '.points_from_secret' do
+    it 'generates points according to the num_points parameter' do
+      points = SecretSharing::Polynomial.points_from_secret(10, 2, 4)
+      expect(points.length).to eq 4
+    end
+
+    it 'requires threshold points to reconstruct' do
+      points = SecretSharing::Polynomial.points_from_secret(234234, 2, 3)
+      points = points[0, 2]
+      secret = SecretSharing::Polynomial.modular_lagrange_interpolation(points)
+      expect(secret).to eq 234234
+    end
+
+    it 'errors when the secret is to long' do
+      secret = 2**10_000
+      block = -> { SecretSharing::Polynomial.points_from_secret(secret, 2, 3) }
+      expect(&block).to raise_error(
+        ArgumentError,
+        'Secret is too long'
+      )
+    end
+
+    it 'errors when the point threshold is too small' do
+      block = -> { SecretSharing::Polynomial.points_from_secret(123, 1, 3) }
+      expect(&block).to raise_error(
+        ArgumentError,
+        'Threshold must be at least 2'
+      )
+    end
+
+    it 'errors when the point threshold is larger than total points' do
+      block = -> { SecretSharing::Polynomial.points_from_secret(123, 3, 2) }
+      expect(&block).to raise_error(
+        ArgumentError,
+        'Threshold must be less than the total number of points'
+      )
+    end
   end
 end

data/spec/prime_spec.rb

@@ -1,7 +1,7 @@
-describe SecretSharing::Prime do
-  context '#get_large_enough_prime' do
-    it 'should calc the correct prime' do
-      expect(SecretSharing::Prime.large_enough_prime([1, 2, 3, 4])).to eq(7)
+RSpec.describe SecretSharing::Prime do
+  describe '#get_large_enough_prime' do
+    it 'calc the correct prime' do
+      expect(SecretSharing::Prime.large_enough_prime(4)).to eq(7)
     end
   end
 end

data/spec/secret_sharing_spec.rb

@@ -1,6 +1,6 @@
 require 'securerandom'
 
-describe SecretSharing do
+RSpec.describe SecretSharing do
   it 'should encrypt and decrypt correctly' do
     50.times do
       secret = SecureRandom.base64(130)
@@ -9,4 +9,32 @@ describe SecretSharing do
       expect(SecretSharing.recover_secret(shares[0..1])).to eq(secret)
     end
   end
+
+  context 'threshold 2 out of 4 shares' do
+    subject(:shares) { SecretSharing.split_secret('secret', 2, 4) }
+
+    it 'generates 4 shares' do
+      expect(shares.length). to eq 4
+    end
+
+    it 'cannot reconstruct with only one share' do
+      expect(SecretSharing.recover_secret(shares[0, 1])).not_to eq 'secret'
+    end
+
+    it 'can reconstruct the secret with any combination of 2 shares' do
+      shares.permutation(2).each do |share_combination|
+        expect(SecretSharing.recover_secret(share_combination)).to eq 'secret'
+      end
+    end
+
+    it 'can reconstruct the secret with any combination of 3 shares' do
+      shares.permutation(3).each do |share_combination|
+        expect(SecretSharing.recover_secret(share_combination)).to eq 'secret'
+      end
+    end
+
+    it 'can reconstruct the secret with all shares' do
+      expect(SecretSharing.recover_secret(shares)).to eq 'secret'
+    end
+  end
 end

data/spec/share_spec.rb

@@ -1,13 +1,43 @@
-describe SecretSharing::Share do
-  it 'can create an instance from a string' do
-    share = SecretSharing::Share.from_string('1-2')
-    point = share.point
-    expect(point.x).to be 1
-    expect(point.y).to be 2
+RSpec.describe SecretSharing::Share do
+  describe '.from_string' do
+    it 'creates an instance from a string' do
+      share = SecretSharing::Share.from_string('1-2')
+      point = share.point
+      expect(point.x).to be 1
+      expect(point.y).to be 2
+    end
+
+    it 'correctly converts the y value from hex to integer' do
+      share = SecretSharing::Share.from_string('1-1b')
+      point = share.point
+      expect(point.x).to be 1
+      expect(point.y).to be 27
+    end
+
+    it 'correctly converts paddings' do
+      share = SecretSharing::Share.from_string('01-1b')
+      point = share.point
+      expect(point.x).to be 1
+      expect(point.y).to be 27
+    end
   end
 
-  it 'correctly stringifies' do
-    point = SecretSharing::Point.new(1, 2)
-    expect(SecretSharing::Share.new(point).to_s).to eq('1-2')
+  describe '#to_s' do
+    it 'stringifies the share by concatenating the x and y value' do
+      point = SecretSharing::Point.new(1, 2)
+      expect(SecretSharing::Share.new(point).to_s(1)).to eq('1-2')
+    end
+
+    it 'converts the y value to hex' do
+      point = SecretSharing::Point.new(1, 27)
+      expect(SecretSharing::Share.new(point).to_s(1)).to eq('1-1b')
+    end
+
+    context 'a x point length is specified' do
+      it 'adds 0 padding so all shares are equal length' do
+        point = SecretSharing::Point.new(1, 27)
+        expect(SecretSharing::Share.new(point).to_s(2)).to eq('01-1b')
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -27,6 +27,8 @@ if ENV['CI']
   Coveralls.wear!
 end
 
+require 'timeout'
+
 require 'secret_sharing'
 
 RSpec.configure do |config|
@@ -52,4 +54,8 @@ RSpec.configure do |config|
     # `true` in RSpec 4.
     mocks.verify_partial_doubles = true
   end
+
+  config.around :each do |block|
+    Timeout.timeout(1, &block)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: secret_sharing
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - flower-pot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-24 00:00:00.000000000 Z
+date: 2015-04-23 00:00:00.000000000 Z
 dependencies: []
 description: Divide, share and reconstruct secrets.
 email:
@@ -17,11 +17,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".rubocop.yml"
-- ".travis.yml"
-- ".yardops"
+- .gitignore
+- .rspec
+- .rubocop.yml
+- .travis.yml
+- .yardops
 - Gemfile
 - LICENSE
 - README.md
@@ -51,17 +51,17 @@ 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.4.6
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of sharmir's secret sharing
@@ -73,4 +73,3 @@ test_files:
 - spec/secret_sharing_spec.rb
 - spec/share_spec.rb
 - spec/spec_helper.rb
-has_rdoc: