secretsharing 0.2 → 0.3

data/README

@@ -43,11 +43,8 @@
    s2 << s.shares[4]
    puts s2.secret
 
-== Future Plans
-   Add support for using your own instead of a random secret.
-
 == Copyright
-   (c) 2010 Alexander Klink
+   (c) 2010-2011 Alexander Klink
 
 == License
    Licensed under the Apache License, Version 2.0 (the "License");

data/lib/secretsharing/shamir.rb

@@ -16,6 +16,10 @@ module SecretSharing
 	# then call the create_random_secret() method. The secret is now in
 	# the secret attribute and the shares are an array in the shares attribute.
 	#
+	# Alternatively, you can call the set_fixed_secret() method with an
+	# OpenSSL::BN object (or something that can be passed to OpenSSL::BN.new)
+	# to set your own secret.
+	#
 	# To recover a secret, create a SecretSharing::Shamir object and
 	# add the necessary shares to it using the '<<' method. Once enough
 	# shares have been added, the secret can be recovered in the secret
@@ -68,6 +72,22 @@ module SecretSharing
 			@secret
 		end
 
+		# Set the secret to a fixed OpenSSL::BN value. Stores it
+		# in the 'secret' attribute, creates the corresponding shares and
+		# returns the secret
+		def set_fixed_secret(secret)
+			raise 'secret already set' if secret_set?
+			if secret.class != OpenSSL::BN then
+				# create OpenSSL bignum
+				secret = OpenSSL::BN.new(secret)
+			end
+			raise 'max bitlength is 1024' if secret.num_bits > 1024
+			@secret = secret
+			@secret_bitlength = secret.num_bits
+			create_shares
+			@secret
+		end
+
 		# The secret in a password representation (Base64-encoded)
 		def secret_password
 			if ! secret_set? then
@@ -76,16 +96,18 @@ module SecretSharing
 			Base64.encode64([@secret.to_s(16)].pack('h*')).split("\n").join
 		end
 
-		# Add a secret share to the object. Accepts either a SecretSharing::Shamir::Share
-		# instance or a string representing one. Returns true if enough shares have
-		# been added to recover the secret, false otherweise.
+		# Add a secret share to the object. Accepts either a
+		# SecretSharing::Shamir::Share instance or a string representing one.
+		# Returns true if enough shares have been added to recover the secret,
+		# false otherweise.
 		def <<(share)
 			# convert from string if needed
 			if share.class != SecretSharing::Shamir::Share then
 				if share.class == String then
 					share = SecretSharing::Shamir::Share.from_string(share)
 				else
-					raise ArgumentError 'SecretSharing::Shamir::Share or String needed'
+					raise ArgumentError 'SecretSharing::Shamir::Share ' \
+					                  + 'or String needed'
 				end
 			end
 			if @received_shares.include? share then
@@ -111,7 +133,8 @@ module SecretSharing
 			prime_found = false
 			while (! prime_found) do
 				# prime_fasttest? 20 do be compatible to
-				# openssl prime, which is used in OpenXPKI::Crypto::Secret::Split
+				# openssl prime, which is used in
+				# OpenXPKI::Crypto::Secret::Split
 				prime_found = test_prime.prime_fasttest? 20
 				test_prime += 2
 			end
@@ -119,11 +142,12 @@ module SecretSharing
 		end
 
 		private
-		# Creates a random number of a certain bitlength, optionally ensuring the
-		# bitlength by setting the highest bit to 1.
+		# Creates a random number of a certain bitlength, optionally ensuring
+		# the bitlength by setting the highest bit to 1.
 		def get_random_number(bitlength, highest_bit_one = true)
 			byte_length = (bitlength / 8.0).ceil
-			rand_hex = OpenSSL::Random.random_bytes(byte_length).each_byte.to_a.map { |a| "%02x" % a }.join('')
+			rand_hex = OpenSSL::Random.random_bytes(byte_length).each_byte. \
+			                           to_a.map { |a| "%02x" % a }.join('')
 			rand = OpenSSL::BN.new(rand_hex, 16)
 			begin
 				rand.mask_bits!(bitlength)
@@ -144,7 +168,8 @@ module SecretSharing
 			@coefficients[0] = @secret
 
 			# round up to next nibble
-			next_nibble_bitlength = @secret_bitlength + (4 - (@secret_bitlength % 4))
+			next_nibble_bitlength = @secret_bitlength + \
+			                        (4 - (@secret_bitlength % 4))
 			prime_bitlength = next_nibble_bitlength + 1
 			@prime = self.class.smallest_prime_of_bitlength(prime_bitlength)
 
@@ -232,9 +257,11 @@ module SecretSharing
 			checksum = string[-6, 4]
 			computed_checksum = Digest::SHA1.hexdigest(p_x_str)[0,4].upcase
 			if checksum != computed_checksum then
-				raise "invalid checksum. expected #{checksum}, got #{computed_checksum}"
+				raise "invalid checksum. expected #{checksum}, " + \
+				      "got #{computed_checksum}"
 			end
-			prime = SecretSharing::Shamir.smallest_prime_of_bitlength(prime_bitlength)
+			prime = SecretSharing::Shamir. \
+			        smallest_prime_of_bitlength(prime_bitlength)
 			self.new(x, OpenSSL::BN.new(p_x_str, 16), prime, prime_bitlength)
 		end
 
@@ -244,15 +271,15 @@ module SecretSharing
 		# format: ABBC*DDDDEEEE, where
 		# * A (the first nibble) is the version number of the format, currently
 		#   fixed to 0.
-		# * B (the next byte, two hex characters) is the x coordinate of the point
-		#   on the polynomial.
-		# * C (the next variable length of bytes) is the y coordinate of the point
-		#   on the polynomial.
-		# * D (the next two bytes, four hex characters) is the two highest bytes of
-		#   the SHA1 hash on the string representing the y coordinate, it is used as
-		#   a checksum to guard against typos
-		# * E (the next two bytes, four hex characters) is the bitlength of the prime
-		#   number in nibbles.
+		# * B (the next byte, two hex characters) is the x coordinate of the
+		#   point on the polynomial.
+		# * C (the next variable length of bytes) is the y coordinate of the
+		#   point on the polynomial.
+		# * D (the next two bytes, four hex characters) is the two highest
+		#   bytes of the SHA1 hash on the string representing the y coordinate,
+		#   it is used as a checksum to guard against typos
+		# * E (the next two bytes, four hex characters) is the bitlength of the
+		#   prime number in nibbles.
 		def to_s
 			# bitlength in nibbles to save space
 			prime_nibbles = (@prime_bitlength - 1) / 4 
@@ -262,5 +289,10 @@ module SecretSharing
 				+ Digest::SHA1.hexdigest(p_x)[0,4].upcase \
 				+ ("%02x" % prime_nibbles).upcase
 		end
+
+		# Shares are equal if their string representation is the same.
+		def ==(share)
+			share.to_s == self.to_s
+		end
 	end	
 end

data/test/test_shamir.rb

@@ -37,6 +37,33 @@ class TestShamir < Test::Unit::TestCase
 		assert_equal(512, s2.secret_bitlength)
 	end
 
+	def test_set_fixed_secret
+		s = SecretSharing::Shamir.new(5)
+		s.set_fixed_secret(OpenSSL::BN.new('12345678901234567890'))
+		assert(s.secret_set?)
+		assert_not_nil(s.secret)
+		assert_not_nil(s.shares)
+		assert_equal(Array, s.shares.class)
+		assert_equal(5, s.shares.length)
+		assert_equal(SecretSharing::Shamir::Share, s.shares[0].class)
+		assert_equal(64, s.secret_bitlength)
+
+		# can only be called once
+		assert_raise( RuntimeError) { 
+			s.set_fixed_secret(OpenSSL::BN.new('12345678901234567891')) }
+
+		# test using string as parameter instead of OpenSSL::BN instance
+		s2 = SecretSharing::Shamir.new(5)
+		s2.set_fixed_secret('12345678901234567890')
+		assert(s2.secret_set?)
+		assert_not_nil(s2.secret)
+		assert_not_nil(s2.shares)
+		assert_equal(Array, s2.shares.class)
+		assert_equal(5, s2.shares.length)
+		assert_equal(SecretSharing::Shamir::Share, s2.shares[0].class)
+		assert_equal(64, s2.secret_bitlength)
+	end
+
 	def test_recover_secret_k_eq_n
 		s = SecretSharing::Shamir.new(5)
 		s.create_random_secret()
@@ -59,6 +86,30 @@ class TestShamir < Test::Unit::TestCase
 		assert_equal(s.secret, s2.secret)
 	end
 
+	def test_recover_secret_k_eq_n_fixed_secret
+		s = SecretSharing::Shamir.new(5)
+		secret = OpenSSL::BN.new('1234567890123456789012345678901234567890')
+
+		s.set_fixed_secret(secret)
+		
+		s2 = SecretSharing::Shamir.new(5)
+		s2 << s.shares[0]
+		assert(! s2.secret_set?)
+		assert_nil(s2.secret)
+		# adding the same share raises an error
+		assert_raise( RuntimeError ) { s2 << s.shares[0] }
+		# add more shares
+		s2 << s.shares[1]
+		assert(! s2.secret_set?)
+		s2 << s.shares[2]
+		assert(! s2.secret_set?)
+		s2 << s.shares[3]
+		assert(! s2.secret_set?)
+		s2 << s.shares[4]
+		assert(s2.secret_set?)
+		assert_equal(secret, s2.secret)
+	end
+
 	def test_recover_secret_k_eq_n_strings
 		s = SecretSharing::Shamir.new(2)
 		s.create_random_secret()

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: secretsharing
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 13
   prerelease: false
   segments: 
   - 0
-  - 2
-  version: "0.2"
+  - 3
+  version: "0.3"
 platform: ruby
 authors: 
 - Alexander Klink
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-26 00:00:00 +02:00
+date: 2011-06-27 00:00:00 +02:00
 default_executable: 
 dependencies: []