vault-tree 0.3.4 → 0.6.0

data/lib/vault-tree/contract/contract_header.rb

@@ -0,0 +1,11 @@
+module VaultTree
+  class ContractHeader
+    def initialize(header_hash)
+      @header_hash = header_hash
+    end
+
+    def to_hash
+      @header_hash
+    end
+  end
+end

data/lib/vault-tree/contract/vault.rb

@@ -9,104 +9,54 @@ module VaultTree
     end
 
     def close
-      close_ancestors
-      close_self
+      @properties['contents'] = locked_contents
+      self
     end
 
-    def retrieve_contents
+    def open
+      self.close
       unlocked_contents
     end
 
-    def fill_with
-      properties['fill_with']
-    end
-
-    def lock_with
-      properties['lock_with']
-    end
-
-    def unlock_with
-      properties['unlock_with']
-    end
-
-    def contents
-      properties['contents']
-    end
-
-    def empty?
-      contents.empty?
-    end
-
     def filler
-      KeywordInterpreter.new(fill_with, self).evaluate
+      KeywordInterpreter.new(properties['fill_with'], self).evaluate
     end
 
     def locking_key
-      KeywordInterpreter.new(lock_with, self).evaluate
+      VaultKey.new KeywordInterpreter.new(properties['lock_with'], self).evaluate
     end
 
     def unlocking_key
-      KeywordInterpreter.new(unlock_with, self).evaluate
-    end
-
-    private
-
-    def close_ancestors
-      close_lock_ancestor
-      close_fill_ancestor
-    end
-
-    def close_self
-      @properties['contents'] = locked_contents
-      self
-    end
-
-    def unlocked_contents
-      Doorman.new(self).unlocked_contents
+      VaultKey.new KeywordInterpreter.new(properties['unlock_with'], self).evaluate
     end
 
     def locked_contents
-      Doorman.new(self).locked_contents
-    end
-
-    def close_lock_ancestor
-      contract.close_vault(lock_ancestor_id)
-    end
-
-    def close_fill_ancestor
-      contract.close_vault(fill_ancestor_id)
+      begin
+        already_locked? ? properties['contents'] : ciphertext(filler)
+      rescue RbNaCl::CryptoError => e
+        raise Exceptions::FailedLockAttempt.new(e, vault_id: id)
+      end
     end
 
-    def has_lock_ancestor?
-      lock_with_key_or_contents?
-    end
-
-    def has_fill_ancestor?
-      fill_with_key_or_contents?
-    end
-
-    def lock_with_key_or_contents?
-      (locking_word_base == 'CONTENTS') || (locking_word_base == 'KEY')
-    end
-
-    def locking_word_base
-      KeywordInterpreter.new(lock_with,self).word_base
+    def unlocked_contents
+      begin
+        plaintext properties['contents']
+      rescue RbNaCl::CryptoError => e
+        raise Exceptions::FailedUnlockAttempt.new(e, vault_id: id)
+      end
     end
 
-    def fill_with_key_or_contents?
-      (filling_word_base == 'CONTENTS') || (filling_word_base == 'KEY')
+    def ciphertext(m)
+      ContentCiphertext.new(m, locking_key).evaluate
     end
 
-    def filling_word_base
-      KeywordInterpreter.new(fill_with,self).word_base
+    def plaintext(c)
+      ContentPlaintext.new(c, unlocking_key).evaluate
     end
 
-    def lock_ancestor_id
-      lock_with.extract_ancestor_id if has_lock_ancestor?
+    def already_locked?
+      ! (properties['contents'].nil? || properties['contents'].empty?)
     end
 
-    def fill_ancestor_id
-      fill_with.extract_ancestor_id if has_fill_ancestor?
-    end
   end
 end

data/lib/vault-tree/contract/vault_key.rb

@@ -0,0 +1,21 @@
+module VaultTree
+  class VaultKey
+    attr_reader :k
+
+    def initialize(k)
+      @k = k
+    end
+
+    def secret
+      asymmetric? ? k.secret_key : k
+    end
+
+    def public
+      asymmetric? ? k.public_key : nil
+    end
+
+    def asymmetric?
+      k.kind_of?(DHKeyPair)
+    end
+  end
+end

data/lib/vault-tree/contract/vault_list.rb

@@ -0,0 +1,56 @@
+module VaultTree
+  class VaultList
+    attr_reader :vaults_hash, :contract
+
+    def initialize(vaults_hash, contract)
+      @vaults_hash = vaults_hash
+      @contract = contract
+    end
+
+    def close_vault(id)
+      validate_vault(id)
+      update_vaults vault(id).close
+      self
+    end
+
+    def open_vault(id)
+      validate_vault(id)
+      vault(id).open
+    end
+
+    def vault_closed?(id)
+      non_empty_contents?(id)
+    end
+
+    def to_hash
+      @vaults_hash
+    end
+
+    private
+
+    def non_empty_contents?(id)
+      ! empty_contents?(id)
+    end
+
+    def empty_contents?(id)
+      vaults_hash[id]['contents'].nil? || vaults_hash[id]['contents'].empty?
+    end
+
+    def update_vaults(vault)
+      @vaults_hash[vault.id] = vault.properties unless vault.kind_of?(NullVault)
+    end
+
+    def vault(id)
+      id.nil? ? NullVault.new : Vault.new(id, vaults_hash[id], contract)
+    end
+
+    def validate_vault(id)
+      raise Exceptions::VaultDoesNotExist.new(nil,vault_id: id) unless valid_id?(id)
+    end
+
+    def valid_id?(id)
+      id.nil? || vaults_hash.include?(id)
+    end
+  end
+end
+

data/lib/vault-tree/exceptions/empty_vault.rb

@@ -1,8 +1,23 @@
 module VaultTree
   module Exceptions
-    class EmptyVault < VaultTreeException
-      # Cant open emtpy vaults
-      # Attempted to open an empty vault
+    class EmptyVault < LibraryException
+
+      def post_initialize(params)
+        @vault_id = params[:vault_id]
+      end
+
+      def runtime_information
+        %Q{The following vault was empty: #{@vault_id}
+
+          Vault Tree does not allow you to open an empty vault.
+          An empty vault means the the vault contents field is an empty
+          string.
+
+          * Are you closing the vaults in the right order?
+          * Are you attempting to open a vault before all
+            of the vaults that it references have been closed?
+        }
+      end
     end
   end
 end

data/lib/vault-tree/exceptions/failed_lock_attempt.rb

@@ -0,0 +1,18 @@
+module VaultTree
+  module Exceptions
+    class FailedLockAttempt < LibraryException
+
+      def post_initialize(params)
+        @vault_id = params[:vault_id]
+        @locking_key = params[:locking_key]
+      end
+
+      def runtime_information
+        %Q{
+          Attempted to Lock Vault:
+            #{@vault_id}
+        }
+      end
+    end
+  end
+end

data/lib/vault-tree/exceptions/failed_unlock_attempt.rb

@@ -1,6 +1,28 @@
 module VaultTree
   module Exceptions
-    class FailedUnlockAttempt < VaultTreeException
+    class FailedUnlockAttempt < LibraryException
+
+      def post_initialize(params)
+        @vault_id = params[:vault_id]
+        @unlocking_key = params[:unlocking_key]
+      end
+
+      def runtime_information
+        %Q{
+          Attempted to Unlock Vault:
+            #{@vault_id}
+
+        * Can you access the vault key?
+         - Does the CPU that is executing this particular contract
+           have access to the vault key? It could be the case that
+           this contract does not permit you to open this particular vault.
+         - Are you providing the correct key to the Vault Tree Contract? It
+           could be that your are trying to open the vault with the wrong key.
+        * Invalid Ciphertext?
+          - Have the encrypted contents of the vault been tampered with?
+            The underlying Vault Tree Cryto library (NaCl) uses authenticated
+            encryption. This ensures that ciphertext cannot be modified.}
+      end
     end
   end
 end

data/lib/vault-tree/exceptions/invalid_external_input.rb

@@ -0,0 +1,16 @@
+module VaultTree
+  module Exceptions
+    class InvalidExternalInput  < LibraryException
+      def post_initialize(params)
+        @vault_id = params[:vault_id]
+      end
+
+      def runtime_information
+        %Q{
+          Vault:
+          #{@vault_id}
+        }
+      end
+    end
+  end
+end

data/lib/vault-tree/exceptions/{missing_passphrase.rb → invalid_shamir_split.rb}

@@ -1,6 +1,7 @@
 module VaultTree
   module Exceptions
-    class MissingPassphrase < VaultTreeException
+    class InvalidShamirSplit < LibraryException
     end
   end
 end
+

data/lib/vault-tree/exceptions/library_exception.rb

@@ -0,0 +1,64 @@
+module VaultTree
+  module Exceptions
+    class LibraryException < StandardError
+      attr_reader :original_exception
+
+      def initialize(original_exception = nil, runtime_information = {})
+        @original_exception = original_exception
+        post_initialize(runtime_information)
+      end
+
+      def post_initialize(opts)
+        nil
+      end
+
+      def runtime_information
+        {}
+      end
+
+      def exception
+        self
+      end
+
+      def message
+        output_exception_message
+      end
+
+      def background
+        nil
+      end
+
+      def troubleshooting_questions
+        nil
+      end
+
+      def name
+        self.class
+      end
+
+      private
+
+      def output_exception_message
+        STDOUT.write(full_exception_message)
+      end
+
+      def full_exception_message
+        %Q{
+          #{message_banner}
+          #{name}
+          #{message_banner}
+          #{present_runtime_information}
+        }
+      end
+
+      def message_banner
+        %Q{####################################################}
+      end
+
+      def present_runtime_information
+        "#{runtime_information}" unless runtime_information.empty?
+      end
+
+    end
+  end
+end

data/lib/vault-tree/exceptions/missing_partner_decryption_key.rb

@@ -1,6 +1,16 @@
 module VaultTree
   module Exceptions
-    class MissingPartnerDecryptionKey < VaultTreeException
+    class MissingPartnerDecryptionKey < LibraryException
+      def post_initialize(params)
+        @vault_id = params[:vault_id]
+      end
+
+      def runtime_information
+        %Q{
+          Missing Decryption Key For:
+            #{@vault_id}
+        }
+      end
     end
   end
 end

data/lib/vault-tree/exceptions/unsupported_keyword.rb

@@ -1,6 +1,22 @@
 module VaultTree
   module Exceptions
-    class UnsupportedKeyword < VaultTreeException
+    class UnsupportedKeyword < LibraryException
+      def post_initialize(params)
+        @vault_id = params[:vault_id]
+        @keyword = params[:keyword]
+      end
+
+      def runtime_information
+        %Q{
+          It looks like you have used an unsupported Keyword.
+
+          Attempted Keyword:
+          #{@keyword}
+
+          Vault:
+          #{@vault_id}
+        }
+      end
     end
   end
 end

data/lib/vault-tree/exceptions/vault_does_not_exist.rb

@@ -1,6 +1,13 @@
 module VaultTree
   module Exceptions
-    class VaultDoesNotExist < VaultTreeException
+    class VaultDoesNotExist < LibraryException
+      def post_initialize(params)
+        @vault_id = params[:vault_id]
+      end
+
+      def runtime_information
+        %Q{Can not find vault #{@vault_id}}
+      end
     end
   end
 end