vault-tree 0.3.4 → 0.6.0

data/lib/vault-tree/keywords/assembled_shamir_key.rb

@@ -32,7 +32,7 @@ module VaultTree
 
     def retrieve_key_shares
       @collected_shares = []
-      vault_ids.each{|id| @collected_shares << contract.retrieve_contents(id) }
+      vault_ids.each{|id| @collected_shares << contract.open_vault(id) }
       return @collected_shares
     end
 

data/lib/vault-tree/keywords/contents.rb

@@ -7,7 +7,7 @@ module VaultTree
     end
 
     def evaluate
-      contract.retrieve_contents(vault_id)
+      contract.open_vault(vault_id)
     end
   end
 end

data/lib/vault-tree/keywords/dh_key.rb

@@ -14,11 +14,11 @@ module VaultTree
     private
 
     def public_key_vault_contents
-      contract.retrieve_contents(public_key_vault_id)
+      contract.open_vault(public_key_vault_id)
     end
 
     def secret_key_vault_contents
-      contract.retrieve_contents(secret_key_vault_id)
+      contract.open_vault(secret_key_vault_id)
     end
   end
 end

data/lib/vault-tree/keywords/external_input.rb

@@ -0,0 +1,58 @@
+module VaultTree
+  class ExternalInput < Keyword
+    attr_reader :input_name
+
+    def post_initialize(arg_array)
+      @input_name = arg_array[0]
+    end
+
+    def evaluate
+      validate_external_input
+      contract.external_input[input_name_symbol]
+    end
+
+    private
+
+    def id
+      vault.id
+    end
+
+    def input_name_symbol
+      input_name.to_sym
+    end
+
+    def validate_external_input
+      input_hash_present
+      input_value_not_nil
+      input_value_not_empty
+    end
+
+    def input_hash_present
+      raise_error unless contract.external_input.kind_of?(Hash)
+    end
+
+    def input_value_not_nil
+      raise_error if (input_key_present? && nil_input_value?)
+    end
+
+    def input_value_not_empty
+      raise_error if (input_key_present? && empty_input_value?)
+    end
+
+    def input_key_present?
+      contract.external_input.has_key?(input_name_symbol)
+    end
+
+    def nil_input_value?
+      contract.external_input[input_name_symbol].nil?
+    end
+
+    def empty_input_value?
+      contract.external_input[input_name_symbol].empty?
+    end
+
+    def raise_error
+      raise Exceptions::InvalidExternalInput.new(nil, vault_id: id)
+    end
+  end
+end

data/lib/vault-tree/keywords/external_key.rb

@@ -0,0 +1,20 @@
+module VaultTree
+  class ExternalKey < Keyword
+    attr_reader :input_name
+
+    def post_initialize(arg_array)
+      @input_name = arg_array[0]
+    end
+
+    def evaluate
+      LockSmith.new(message: raw_external_input).secure_hash
+    end
+
+    private
+
+    def raw_external_input
+      KeywordInterpreter.new("EXTERNAL_INPUT['#{input_name}']", vault).evaluate
+    end
+
+  end
+end

data/lib/vault-tree/keywords/key.rb

@@ -7,7 +7,13 @@ module VaultTree
     end
 
     def evaluate
-      contract.retrieve_contents(vault_id)
+      LockSmith.new(message: raw_contents).secure_hash
+    end
+
+    private
+
+    def raw_contents
+      contract.open_vault(vault_id)
     end
   end
 end

data/lib/vault-tree/keywords/keyword_interpreter.rb

@@ -3,15 +3,17 @@ module VaultTree
     attr_reader :word, :vault
 
     def initialize(word,vault)
-      @word = word 
+      @word = word
       @vault = vault
     end
 
     def evaluate # start here
       begin
         keyword_class_name.new(vault, arg_array).evaluate
-      rescue NameError
-        raise Exceptions::UnsupportedKeyword
+      rescue NameError => e
+        raise Exceptions::UnsupportedKeyword.new(e,
+                                                 vault_id: vault.id,
+                                                 keyword: word)
       end
     end
 

data/lib/vault-tree/keywords/public_encryption_key.rb

@@ -13,11 +13,7 @@ module VaultTree
     private
 
     def decryption_key
-      begin
-        contract.retrieve_contents(vault_id)
-      rescue Exceptions::EmptyVault
-        raise Exceptions::MissingPartnerDecryptionKey
-      end
+      contract.open_vault(vault_id)
     end
   end
 end

data/lib/vault-tree/keywords/shamir_key_shares.rb

@@ -0,0 +1,18 @@
+module VaultTree
+  class ShamirKeyShares < Keyword
+    attr_reader :outstanding_shares, :recovery_threshold
+
+    def post_initialize(arg_array)
+      @outstanding_shares = arg_array[0]
+      @recovery_threshold = arg_array[1]
+    end
+
+    def evaluate
+      Crypto::ShamirKeyShares.new(
+        outstanding_shares: outstanding_shares,
+        recovery_threshold: recovery_threshold
+      ).generate
+    end
+
+  end
+end

data/lib/vault-tree/keywords/shamir_share.rb

@@ -0,0 +1,18 @@
+module VaultTree
+  class ShamirShare < Keyword
+    attr_reader :share_collection_vault, :collection_index
+
+    def post_initialize(arg_array)
+      @share_collection_vault = arg_array[0]
+      @collection_index = arg_array[1]
+    end
+
+    def evaluate
+      share_collection[collection_index]
+    end
+
+    def share_collection
+      JSON.parse contract.open_vault(share_collection_vault)
+    end
+  end
+end

data/lib/vault-tree/keywords/split_key.rb

@@ -13,7 +13,7 @@ module VaultTree
     private
 
     def required_keys
-      required_key_vaults.map {|id| contract.retrieve_contents(id) }
+      required_key_vaults.map {|id| contract.open_vault(id) }
     end
   end
 end

data/lib/vault-tree/lock_smith.rb

@@ -1,4 +1,5 @@
 require 'rbnacl'
+require_relative 'lock_smith/assembled_shamir_key'
 
 module VaultTree
   # VaultTree::LockSmith Interface to Crypto Primatives
@@ -135,19 +136,17 @@ module VaultTree
     # Recovers the shared secret from the shares provided
     # in the initializer.
     #
-    # @return [String] Secure Hash digest of the assembled secret
-    def combine_secret_shares
-    end
-
-    # Secret Shares associated with the split message
-    #
-    # @return [Array] Array of strings
-    def split_secret
+    # @return [String] assembled secret key
+    def assemble_shamir_key
+      VaultTree::Crypto::AssembledShamirKey.new( key_shares: secret_shares).assemble
     end
 
     private
 
     def message; @message end
+    def outstanding_secret_shares; @outstanding_secret_shares end
+    def secret_recovery_threshold; @secret_recovery_threshold end
+    def secret_shares; @secret_shares end
 
     # Locksmith always expects hex representations
     # of keys and ciphertext. Convert to binary to

data/lib/vault-tree/lock_smith/{generated_shamir_key.rb → shamir_key_shares.rb}

@@ -2,27 +2,17 @@ require 'secretsharing'
 
 module VaultTree
   module Crypto
-    class GeneratedShamirKey
+    class ShamirKeyShares
 
       def initialize(params)
         @outstanding_shares = params[:outstanding_shares]
         @recovery_threshold = params[:recovery_threshold]
       end
 
-      # String representation of the newly generated sharmir key
+      # JSON representation of a collection of secret shares
       #
-      # @return [String] Secure Hash digest of the generated secret integer
-      def key
-        create_secret
-        LockSmith.new(message: secret_string).secure_hash
-      end
-
-      # Shares associated with the newly generated Sharmir key
-      #
-      # @return [Array] Array of strings
-      def shares
-        create_secret
-        shares_array.map{|s| s.to_s}
+      def generate
+        json_shares_mapping
       end
 
       # Fixnum representation if string value given
@@ -39,20 +29,26 @@ module VaultTree
         @recovery_threshold.to_i
       end
 
-      private
-
-      def secret_string
-        shamir_object.secret.to_s
-      end
+      protected
 
-      def shares_array
-        shamir_object.shares
+      def json_shares_mapping
+        sh = {}
+        i = 1; shares.each{ |s| sh[i.to_s] = s; i = i + 1;}
+        JSON.generate(sh)
       end
 
       def shamir_object
         @shamir_object ||= SecretSharing::Shamir.new(outstanding_shares, recovery_threshold)
       end
 
+      # Shares associated with the newly generated Sharmir key
+      #
+      # @return [Array] Array of strings
+      def shares
+        create_secret
+        shares_array.map{|s| s.to_s}
+      end
+
       def create_secret
         shamir_object.create_random_secret unless secret_set?
       end
@@ -60,6 +56,11 @@ module VaultTree
       def secret_set?
         shamir_object.secret_set?
       end
+
+      def shares_array
+        shamir_object.shares
+      end
+
     end
   end
 end

data/lib/vault-tree/version.rb

@@ -1,3 +1,3 @@
 module VaultTree
-  VERSION = '0.3.4'
+  VERSION = '0.6.0'
 end

data/spec/assembled_shamir_key_spec.rb

@@ -1,5 +1,4 @@
 require 'rspec'
-RSpec.configure{ |config| config.color_enabled = true }
 require_relative '../lib/vault-tree/lock_smith/assembled_shamir_key'
 
 module VaultTree

data/spec/custom_exception_spec.rb

@@ -0,0 +1,81 @@
+require 'rspec'
+require_relative '../lib/vault-tree'
+
+module VaultTree
+  module Exceptions
+    describe 'Raising a Custom Exception' do
+
+      def example_code
+        begin
+          raise 'Some Random Runtime Error'
+        rescue => e
+          raise FailedUnlockAttempt.new(e,
+                                        vault_id: 'a_specific_vault',
+                                        unlocking_key: 'EXTERNAL_DATA')
+        end
+      end
+
+      it 'can catch an exception and reraise a custom exception' do
+        expect{example_code}.to raise_error(FailedUnlockAttempt)
+      end
+
+      it 'Outputs message nicely to standard out' do
+        begin
+          example_code
+        rescue
+          STDOUT.write('Hopefully this looks good.')
+        end
+      end
+    end
+
+    describe 'Output of various custom exceptions' do
+
+      it 'Failed Unlock Attempt' do
+        begin
+          raise 'Some Random Runtime Error'
+        rescue => e
+          begin
+            raise FailedUnlockAttempt.new(e,
+                                          vault_id: 'a_specific_vault',
+                                          unlocking_key: 'EXTERNAL_DATA')
+          rescue
+          end
+        end
+      end
+
+      it 'Empty Vault' do
+        begin
+          raise 'Some Random Runtime Error'
+        rescue => e
+          begin
+            raise EmptyVault.new(e, vault_id: 'a_specific_vault')
+          rescue
+          end
+        end
+      end
+
+      it 'Vault Does Not Exist' do
+        begin
+          raise 'Some Random Runtime Error'
+        rescue => e
+          begin
+            raise VaultDoesNotExist.new(e, vault_id: 'some_none_existant_vault')
+          rescue
+          end
+        end
+      end
+
+      it 'Unsupported Keyword' do
+        begin
+          raise 'Some Random Runtime Error'
+        rescue => e
+          begin
+            raise UnsupportedKeyword.new(e, vault_id: 'some_vault', keyword: 'some_keyword')
+          rescue
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/lock_smith_spec.rb

@@ -1,5 +1,4 @@
 require 'rspec'
-RSpec.configure{ |config| config.color_enabled = true }
 
 require_relative '../lib/vault-tree/lock_smith'
 
@@ -39,52 +38,5 @@ module VaultTree
       end
     end
 
-    describe '#split_secret | #combine_secret_shares' do
-
-      context 'with 3 out of 5 secrets' do
-        it 'recovers the shared secret' do
-          pending
-          secret_key = LockSmith.new().generate_secret_key
-          secret_shares = LockSmith.new(message: secret_key, outstanding_secret_shares: 5, secret_recovery_threshold: 3).split_secret
-          combined_secret = LockSmith.new(message: secret_key, secret_shares: secret_shares).combine_secret_shares
-          combined_secret.should == secret_key
-        end
-      end
-
-      context 'with 5 out of 5 secrets' do
-        it 'recovers the shared secret' do
-          pending
-        end
-      end
-
-      context 'with 2 out of 2 secrets' do
-        it 'recovers the shared secret' do
-          pending
-        end
-      end
-
-      context 'in exceptional situations' do
-
-        it 'throws an exception on init if one of the shares is not a string' do
-          pending
-          s = SecretSharing::Shamir.new(5,3)
-          s.create_random_secret
-          @established_secret = s.secret.to_s
-          @expected_digest = LockSmith.new(message: @established_secret).secure_hash
-          @key_shares = s.shares[0..2].map{|s| s.to_s}
-
-          # Replace the last string with just an object
-          @key_shares[2] = Object.new
-          expect{AssembledShamirKey.new(key_shares: @key_shares)}.to raise_error(TypeError)
-        end
-
-        it 'throws an exception if the key shares are nil' do
-          pending
-          @key_shares = nil
-          expect{AssembledShamirKey.new(key_shares: @key_shares)}.to raise_error(TypeError)
-        end
-      end
-    end
-
   end
 end