vault-tree 0.1.0

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

@@ -0,0 +1,16 @@
+module VaultTree
+  class NullVault
+
+    def properties
+      {}
+    end
+
+    def id
+      nil
+    end
+
+    def close
+      self
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module VaultTree
+  class OpenValidator
+    attr_reader :vault
+
+    def initialize(vault)
+      @vault = vault
+    end
+
+    def validate!
+      confirm_vault_not_empty
+      true
+    end
+
+    private
+
+    def confirm_vault_not_empty
+      raise Exceptions::EmptyVault if vault.empty?
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+module VaultTree
+  class Vault
+    attr_reader :id, :properties, :contract
+
+    def initialize(id, properties, contract)
+      @id = id
+      @properties = properties
+      @contract = contract
+    end
+
+    def close
+      close_ancestors
+      close_self
+    end
+
+    def retrieve_contents
+      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
+    end
+
+    def locking_key
+      KeywordInterpreter.new(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
+    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)
+    end
+
+    def has_lock_ancestor?
+      lock_with.include? 'CONTENTS'
+    end
+
+    def has_fill_ancestor?
+      fill_with.include? 'CONTENTS'
+    end
+
+    def lock_ancestor_id
+      lock_with.extract_ancestor_id if has_lock_ancestor?
+    end
+
+    def fill_ancestor_id
+      fill_with.extract_ancestor_id if has_fill_ancestor?
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module VaultTree
+  module Exceptions
+    class EmptyVault < VaultTreeException
+      # Cant open emtpy vaults
+      # Attempted to open an empty vault
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module VaultTree
+  module Exceptions
+    class FillAttemptMasterPassword < VaultTreeException
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module VaultTree
+  module Exceptions
+    class MissingExternalData < VaultTreeException
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module VaultTree
+  module Exceptions
+    class MissingPartnerDecryptionKey < VaultTreeException
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module VaultTree
+  module Exceptions
+    class MissingPassphrase < VaultTreeException
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module VaultTree
+  module Exceptions
+    class UnsupportedKeyword < VaultTreeException
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module VaultTree
+  module Exceptions
+    class VaultDoesNotExist < VaultTreeException
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module VaultTree
+  module Exceptions
+    class VaultTreeException < StandardError
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module VaultTree
+  class DecryptionKey < Keyword
+
+    def evaluate
+      key_pair.generate_private_key
+    end
+
+    private
+
+    def key_pair
+      LockSmith::EncryptionKeyPair.new
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module VaultTree
+  class ExternalData < Keyword
+
+    def evaluate
+      contract.external_data(id)
+    end
+
+    def id
+      vault.id
+    end
+
+  end
+end

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

@@ -0,0 +1,19 @@
+module VaultTree
+  class Keyword
+   attr_reader :vault, :arg_array
+
+    def initialize(vault, arg_array)
+      @vault = vault
+      @arg_array = arg_array
+      post_initialize(arg_array)
+    end
+
+    def contract
+      vault.contract
+    end
+
+    def post_initialize(arg_array = [])
+      nil
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module VaultTree
+  class KeywordInterpreter
+    attr_reader :word, :vault
+    
+    def initialize(word,vault)
+      @word = word 
+      @vault = vault
+    end
+
+    def evaluate # start here
+      begin
+        keyword_class_name.new(vault, arg_array).evaluate
+      rescue NameError
+        raise Exceptions::UnsupportedKeyword 
+      end
+    end
+
+    private
+
+    def keyword_class_name
+      instance_eval "VaultTree::#{word_base.downcase.camelize}"
+    end
+
+    def word_base
+      word.gsub(/(\[.*\])/,'').strip
+    end
+
+    def arg_array
+      if has_args?
+        instance_eval arg_array_string
+      else
+        []
+      end
+    end
+
+    def arg_array_string
+      word.gsub(word_base,'').strip
+    end
+
+    def has_args?
+      word.match(/\[/)
+    end
+
+  end
+end

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

@@ -0,0 +1,9 @@
+module VaultTree
+  class MasterPassphrase < Keyword
+
+    def evaluate
+      contract.master_passphrase
+    end
+
+  end
+end

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

@@ -0,0 +1,27 @@
+module VaultTree
+  class PublicEncryptionKey < Keyword
+    attr_reader :vault_id
+
+    def post_initialize(arg_array)
+      @vault_id = arg_array[0]
+    end
+
+    def evaluate
+      key_pair.public_key(decryption_key)
+    end
+
+    private
+
+    def key_pair
+      LockSmith::EncryptionKeyPair.new
+    end
+
+    def decryption_key
+      begin
+        contract.retrieve_contents(vault_id)
+      rescue Exceptions::EmptyVault
+        raise Exceptions::MissingPartnerDecryptionKey
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module VaultTree
+  class RandomNumber < Keyword
+
+    def evaluate
+      LockSmith::RandomNumber.compute
+    end
+
+  end
+end

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

@@ -0,0 +1,24 @@
+module VaultTree
+  class SharedKey < Keyword
+    attr_reader :public_key_vault_id, :secret_key_vault_id
+
+    def post_initialize(arg_array)
+      @public_key_vault_id = arg_array[0]
+      @secret_key_vault_id = arg_array[1]
+    end
+
+    def evaluate
+      LockSmith::SharedKeyPair.new(public_key: public_key_vault_contents, secret_key: secret_key_vault_contents)
+    end
+
+    private
+
+    def public_key_vault_contents
+      contract.retrieve_contents(public_key_vault_id)
+    end
+
+    def secret_key_vault_contents
+      contract.retrieve_contents(secret_key_vault_id)
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module VaultTree
+  class Unlocked < Keyword
+
+    def evaluate
+      LockSmith::CryptoHash.compute('UNLOCKED')
+    end
+
+  end
+end

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

@@ -0,0 +1,13 @@
+module VaultTree
+  class Contents < Keyword
+    attr_reader :vault_id
+
+    def post_initialize(arg_array)
+      @vault_id = arg_array[0]
+    end
+
+    def evaluate
+      contract.retrieve_contents(vault_id)
+    end
+  end
+end

data/lib/vault-tree/lock_smith/asymmetric_cipher.rb

@@ -0,0 +1,31 @@
+module VaultTree
+  module LockSmith
+    class AsymmetricCipher
+
+      def encrypt(opts)
+        crypto_box(opts[:public_key],opts[:secret_key]).box(opts[:plain_text], :base64)
+      end
+
+      def decrypt(opts)
+        crypto_box(opts[:public_key],opts[:secret_key]).open(opts[:cipher_text], :base64)
+      end
+
+      private
+
+      def crypto_box(public_key,private_key)
+        pub = public_key_object(public_key)
+        pri = private_key_object(private_key)
+        box = Crypto::Box.new(pub,pri, :base64)
+        Crypto::RandomNonceBox.new(box)
+      end
+
+      def private_key_object(pri_key)
+        Crypto::PrivateKey.new(pri_key,:base64)
+      end
+
+      def public_key_object(pub_key)
+        Crypto::PublicKey.new(pub_key,:base64)
+      end
+    end
+  end
+end

data/lib/vault-tree/lock_smith/crypto_hash.rb

@@ -0,0 +1,11 @@
+module VaultTree
+  module LockSmith
+    class CryptoHash
+
+      def self.compute(data)
+        Crypto::Hash.sha256("#{data}", :base64)
+      end
+
+    end
+  end
+end