opensecret 0.0.962 → 0.0.988

data/lib/{plugins/usecases/unlock.rb → interprete/export.rb}

@@ -4,31 +4,31 @@ module OpenSecret
 
   require 'openssl'
 
-  # The <tt>unlock use case</tt> moves doubly encrypted material <b>from the frozen</b>
+  # The <tt>export use case</tt> moves doubly encrypted material <b>from the frozen</b>
   # (key and crypt) stores, <b>into an (encrypted) session envelope</b>.
   #
   # Material within the auspices of the session envelope can be manipulated by commands
   # like {OpenSecret::Put} and remove and also read by commands like peep, look and update.
   #
-  # <b>Unlock | Pre-Conditions</b>
+  # <b>Export | Pre-Conditions</b>
   #
   # To deliver on its core promise of moving the encrypted (key and crypt) stores
-  # to an encrypted session envelope, <b>unlock</b> expects
+  # to an encrypted session envelope, <b>export</b> expects
   #
   # - the local key and crypt stores to be pulled (refreshed) from remote
   # - the destination session path to either be empty (or)
   # - a populated session path containing equivalent data (ie cannot be overwritten)
   # - both the human (agent) password and workstation key to be correct
   #
-  # <b>Unlock | Alternate Flows</b>
+  # <b>Export | Alternate Flows</b>
   #
   # This use case requires the human (agent) password unless the <tt>--no-human-password</tt>
   # flag was posted along with the <tt>init</tt> command. In this instance an agent password
   # will have been generated and encrypted with the user's home tree.
   #
-  # <b>Unlock | Observable Value</b>
+  # <b>Export | Observable Value</b>
   #
-  # The observable value proffered by unlock is
+  # The observable value proffered by export is
   #
   # - validating the existence of the requested secret path
   # - validation of the human password and workstation key
@@ -46,7 +46,7 @@ module OpenSecret
   #     $ opensecret put france/capital paris
   #     $ opensecret put france/population 23000000
   #     $ opensecret lock
-  #     $ opensecret unlock geo/countries --with=asdfasdf
+  #     $ opensecret export geo/countries --with=asdfasdf
   #
   #     Below are future examples with use cases like list and print
   #     which curently have not been implemented.
@@ -62,7 +62,7 @@ module OpenSecret
   #     $ opensecret lock
   #     $ opensecret list
   #
-  #     $ opensecret unlock my/gadgets --with="hUM4n-0pen$3cr3t"
+  #     $ opensecret export my/gadgets --with="hUM4n-0pen$3cr3t"
   #     $ opensecret print
   #
   #     $ opensecret put wifi/ssid Virgin-HGPAS
@@ -71,10 +71,9 @@ module OpenSecret
   #     $ opensecret print
   #     $ opensecret lock
   #
-  class Unlock < SecretsUseCase
+  class Export < Command
 
     attr_writer :outer_path, :master_p4ss
-    @@context_name = "opensecret"
 
 
     # The <tt>lock use case</tt> is called after {OpenSecret::Open} and {OpenSecret::Put}
@@ -110,76 +109,39 @@ module OpenSecret
     # - deletion of {Open}ed session data to locate and decrypt envelope
     def execute
 
-      main_store = ColdStore.new @c[:global][:store_mainpath]
-      keys_store = ColdStore.new @c[:global][:store_keyspath]
+      instantiate_collateral
+
+      keys_store = Store::ColdStore.new( @collateral.frontend_keystore_path )
+      main_store = Store::ColdStore.new( @collateral.backend_cryptstore_path )
 
       keys_crypt = keys_store.read @outer_path
       main_crypt = main_store.read @outer_path
 
       unless @master_p4ss
-        @master_p4ss = Collect.secret_text(
+        @master_p4ss = ToolBelt::Collect.secret_text(
           @c[:global][:min_passwd_len],
           false,
           "Enter Master Password "
         )
       end
 
-      workstation_rawkey = OpenSession::Attributes.instance.get_value @c[:global][:name], @c[:global][:name], @c[:global][:machine_key_x]
-      original_timestamp = OpenSession::Attributes.instance.get_value @c[:global][:name], @c[:global][:name], @c[:global][:stamp_key]
+      workstation_rawkey = Mapper::Settings.read @collateral.domain_name, @c[:global][:machine_key_id]
+      original_timestamp = Mapper::Settings.read @collateral.domain_name, @c[:global][:time_stamp_id]
       workstation_cipher = Base64.urlsafe_decode64( workstation_rawkey )
-      crypt_key_segments = [ @master_p4ss, @c[:global][:separator_a], @email_addr, @c[:global][:separator_a], original_timestamp ]
+      crypt_key_segments = [ @master_p4ss, @c[:global][:separator_a], original_timestamp ]
       workstation_lock_x = crypt_key_segments.alphanumeric_union.concat_length
 
-      workstation_string = Blowfish.new.decryptor workstation_cipher, workstation_lock_x
-      private_key_lock_x = Amalgam.passwords @master_p4ss, workstation_string, @c[:global][:ratio]
-      private_key_cipher = File.read @c[:global][:master_prv_key]
+      workstation_string = ToolBelt::Blowfish.decryptor workstation_cipher, workstation_lock_x
+      private_key_lock_x = ToolBelt::Amalgam.passwords @master_p4ss, workstation_string, @c[:global][:ratio]
+      private_key_cipher = @collateral.read_private_key
       private_key_object = unlock_private_key( private_key_cipher, private_key_lock_x )
 
-      string_private_key = Cipher.decrypt_it( private_key_object, keys_crypt )
-      plain_message_text = Cipher.decrypt_it( to_private_key(string_private_key), main_crypt )
-
-      puts ""
-      puts "==== ======================================= ===="
-      puts "==== The Exported Plain Text Structured Data ===="
-      puts "==== ======================================= ===="
-      puts ""
-      puts plain_message_text
-      puts ""
-      puts ""
-      puts JSON.pretty_generate( JSON.parse( plain_message_text ) )
-      puts ""
-
-      exit
-
-#############################################################################################
-#############################################################################################
-
-      rel_filepath = OpenSession::Attributes.instance.get_value @@context_name, @c[:open][:open_name], @c[:open][:open_pathname]
-      master_public_key = Base64.urlsafe_decode64( OpenSession::Attributes.instance.get_value @c[:global][:name], @c[:global][:name], "public.key" )
-
-
-#############################################################################################
-#############################################################################################
-
-=begin
-      Crypto.print_secret_env_var @p[:env_var_name], machine_key
-      GitFlow.do_clone_repo @p[:public_gitrepo], @p[:local_gitrepo]
-      FileUtils.mkdir_p @p[:public_keydir]
-      File.write @p[:public_keypath], public_key_text
-      GitFlow.push @p[:local_gitrepo], @p[:public_keyname], @c[:time][:stamp]
-=end
+      string_private_key = ToolBelt::Cipher.decrypt_it( private_key_object, keys_crypt )
+      plain_message_text = ToolBelt::Cipher.decrypt_it( to_private_key(string_private_key), main_crypt )
 
-
-# key4_pem = File.read 'private.secure.pem'
-# pass_phrase = 'superduperpasswordistoBeENTEREDRIGHT1234HereandRightNOW'
-# key4 = OpenSSL::PKey::RSA.new key4_pem, pass_phrase
-# decrypted_text = key4.private_decrypt(Base64.urlsafe_decode64(encrypted_string))
-
-# print "\nHey we have done the decryption.\n", "\n"
-# print decrypted_text, "\n"
-
-#############################################################################################
-#############################################################################################
+      puts
+      puts JSON.pretty_generate( JSON.parse( plain_message_text ) )
+      puts
 
     end
 
@@ -192,11 +154,6 @@ module OpenSecret
     # @raise [StoreUrlNotConfigured] if the crypt store url is not configured
     def pre_validation
 
-      @email_addr = OpenSession::Attributes.instance.get_value @@context_name, @@context_name, "email"
-      email_configured = !@email_addr.nil? && !@email_addr.empty? && @email_addr.length > 4
-      @err_msg = "viable [email address] not configured. Try =>] opensecret email joe@example.com"
-      raise EmailAddrNotConfigured.new @err_msg, @email_addr unless email_configured
-
     end
 
 
@@ -204,5 +161,3 @@ module OpenSecret
 
 
 end
-
-

data/lib/interprete/init.rb

@@ -0,0 +1,205 @@
+#!/usr/bin/ruby
+	
+module OpenSecret
+
+  require 'openssl'
+
+  # The <b>init use case</b> initializes opensecret thus preparing it
+  # for the ability to lock secrets, unlock them, transport their keys and
+  # much more.
+  #
+  # Like all use cases, +init+ validates to ensure that the pre-conditions
+  # have been met and then proceeds to execute its core offering and deliver
+  # observable value.
+  #
+  # == RAGE | Resource Allocation Geography
+  #
+  # Resources are situated in a manner that delivers the maximum possible
+  # security, with as much usability and simplicity that can be accomodated
+  # and all the while ensuring the owner retains access to the secrets in
+  # the face of multiple disasters befalling the environment.
+  #
+  # The session concept married with public/private key cryptology are the
+  # main vehicles for delivering both simplicity and security. A system that
+  # enables one to lock away secrets without exposing the master password
+  # is more secure than those that don't.
+  #
+  #
+  # == Frontend Store | USB Connected Device ( eg Keys, Phones )
+  #
+  # The frontend store (usually on a USB or other external but filesystem accessible
+  # drive) contains the
+  #
+  # - encrypted private key | created by {Init}, updated by {ReKey}, read by {Open} {Export}
+  # - public key | created by {Init}, updated by {ReKey}, read by {Seal} {Post} {Open}
+  # - encrypted open envelopes tree | created/read/updated by {Put} {Add}, deleted by {Discard}
+  # - encrypted libary keys tree | created by {Seal}, updated by {ReKey}, read by {Open} {Export}
+  #
+  #
+  # == Workstation Configuration File
+  #
+  # The global configuration filepath is <tt>~/.opensecret.io/opensecret.io.configuration.ini</tt>
+  #
+  # The global configuration file is managed through the {OpenSecret::Mapper::Settings} and
+  # the {OpenSecret::Mapper::Collateral.config_file} classes and points to the
+  #
+  # - current domain | created/updated by {Init}, updated by {Set}, read by most
+  # - domain frontend path | created by {Init}, updated by {Set} and read by most
+  # - domain store id | created/updated by {Set}, read by {Post}
+  # - the domain's initialization time stamp | created by {Init}, read by {Seal}
+  # - the encrypted machine (workstation) key | created by {Init}, read by {Seal}
+  #
+  # As well as the global config file, the workstation store contains the logs and most
+  # importantly the mirrored departures/arrival lounge.
+  #
+  #
+  # == Workstation Departure/Arrival Lounge
+  #
+  # The departures and arrivals lounge holds sealed envelopes that are either
+  #
+  # - waiting to (depart) be posted to the remote mirror
+  # - waiting to be read/updated after (arrival) from the remote mirror
+  # - posing as the remote mirror whilst no backend store exists
+  #
+  # The contents of the backend mirror (aka departure/arrival lounge) are
+  #
+  # - created by {Seal} and two-way {Post}
+  # - read by {Open}
+  # - deleted by {Delete}
+  #
+  #
+  # == Workstation | Share and Transfers Lounge
+  #
+  # The self-evident power of opensecret blooms when you share secrets with others in
+  # and out of a domain. The simplest application is when two users belong to the same
+  # domain - the only thing they actually share is the remote back-end store and their
+  # public keys. The lounge tree contains
+  #
+  # - key envelopes for ownership transfer
+  # - key envelopes for sharing
+  # - key envelopes for telling (sender never actual owns the sealed envelope)
+  #
+  #
+  # == Observable Value
+  #
+  # The observable value from the <b>init use case</b> init boils down to
+  #
+  # - the public key and <b>8192 bit encrypted private key</b> in the safe
+  # - the <b>encrypted workstation key</b> in the user's configuration file
+  # - the <b>encrypted public key signature</b> in the user's configuration file
+  # - a robust password (for unlocking secrets) +stashed in a human brain+
+  # - successful test of the open, put, list, lock, read and tell use cases
+  #
+  # No cloud or other external access occurs as per the opensecret policy.
+  #
+  # == Thwart Public Key Switch Attacks
+  #
+  # A <b><em>public key switch attack</em></b> tries to access <b>future secrets</b>
+  # (not the ones already encrypted) via unwitting encryption using a public key
+  # the attacker controls.
+  #
+  # <b>opensecret</b> thwarts this by continual verification against an
+  # encrypted <em>public key signature</em> aboard the workstation.
+  class Init < Command
+
+    attr_writer :master_p4ss, :domain_name, :base_path
+
+
+    # The init use case prepares <b>opensecret</b> so that you can <b>open</b> a packet,
+    # <b>put</b> secrets into it and then <b>lock</b> it, effectively writing the crypt
+    # material into the backend store.
+    #
+    # <b>Main Flow of Events</b>
+    #
+    # So to prepare for the <b><em>modus operandi</em></b> that encrypts, decrypts and if
+    # required transports secrets, we
+    #
+    # - if the base path exists, look for base.opensecret.io below, in and above the path
+    # - if found we configure the config path as appropriate
+    #
+    #
+    #
+    # - collect the human password (twice) and verify its robustness
+    # - manufacture workstation key that will be encrypted b4 it rests on machine
+    # - create amalgamated human/workstation password for locking the private key
+    # - create a long cryptographically strong symmetric encryption key
+    # - encrypt workstation key and put crypt into the opensecret configuration file
+    # - create a super sized 8192 bit private key (and its asymmetric public key)
+    # - write the AES 256bit encrypted private key into safe-store's master keys
+    # - create a text bundle for signing composed of the keys, email and date/time
+    # - sign the bundle and save the signature in the master keys store
+    # - put the public key in the configuration file (off the homedirectory)
+    # - test the core open, put, list, lock, read and tell use case commands
+    #
+    # <b>Observable (Configuration) Value</b>
+    #
+    # The <tt>init use case</tt> observable value post-conditions are
+    #
+    # - the domain_name (group) and domain_path (key) exist in configuration file
+    # - a directory  called <tt>ops.<domain_name></tt> exists at/below or above domain_path
+    #
+    #
+    # - the <b>8192 bit encrypted private key</b> in the master keys safe
+    # - the <b>public key</b>, time stamp and encrypted workstation key in config
+    # - the <b>encrypted workstation key</b> in the user's configuration file
+    # - the <b>asymmetric keys, time stamp and email</b> signature in master keys safe
+    # - a robust password (for unlocking secrets) +stashed in a human brain+
+    #
+    # <b>Alternate Flows</b>
+    #
+    # - if the base path exists, look for base.opensecret.io below, in and above the path
+    # - two or more different domains under the same base is fine however there is a catch
+    # - domain names cannot be duplicated (even if a different base path is given)
+    # - domain duplication is disallowed as domains are group keys in the config file
+    #
+    # <b>Error Flows</b>
+    #
+    # An error will be thrown
+    #
+    # - if ops can't create or extend the base directory
+    # - if the domain is already in the configuration file
+    # - if domain has non alphanums, excl hyphens, underscores, @ symbols, periods
+    # - if domain does not begin or end with alphanums.
+    # - if non alpha-nums (excl at signs) appear consecutively
+    # - if no alpha-nums appear in the string
+    # - if the domain string's length is less than 5
+    # - if "base.opensecret.io" appears twice (or more) in a directory tree
+    #
+    def execute
+
+      return unless ops_key_exists?
+
+      Mapper::Settings.stash @c[:global][:domain_now_id], @domain_name
+      Mapper::Settings.write @domain_name, @c[:global][:front_path_id], @base_path
+
+      instantiate_collateral
+      unless @master_p4ss
+        @master_p4ss = ToolBelt::Collect.secret_text(
+          @c[:global][:min_passwd_len],
+          true,
+          @c[:global][:prompt_1],
+          @c[:global][:prompt_2]
+        )
+      end
+
+      locking_key = create_crypt_store_locking_key
+
+      asymmetric_keys = OpenSSL::PKey::RSA.new @c[:global][:bit_key_size]
+      secured_keytext = asymmetric_keys.export @c[:global][:key_cipher], locking_key
+      @collateral.write_public_key asymmetric_keys.public_key.to_pem
+      @collateral.write_private_key secured_keytext
+
+      print_success_initializing
+
+    end
+
+
+    def pre_validation
+
+    end
+
+
+  end
+
+
+end

data/lib/interprete/key.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/ruby
+	
+module OpenSecret
+
+  # The <tt>key use case</tt> prints out an encrypted session key tied
+  # to the workstation and shell environment. It should be called like this
+  # and <tt>printenv</tt> can be used to verify that a shell-scoped
+  # environment variable tying OPS_KEY to an (approximately) 48 character
+  # session password, has been created.
+  #
+  #    export OPS_KEY=`ops key`
+  #    printenv
+  #
+  # Note the <b>back-ticks</b> surrounding the <tt>ops key</tt> call.
+  #
+  # == Algorithm or Creating the Key
+  #
+  # An (approximately) 48 character key is acquired and then the four
+  # data points below are used to symmetrically encrypt it.
+  #
+  # - <b>the parent shell's ID</b>
+  # - <em>the first MAC address</em>
+  # - <b>the machine's hostname</b>
+  # - <em>the current timestamp</em>
+  #
+  # The result is Base64 encoded in url safe mode and printed to standard
+  # out <b>without a trailing newline</b>.
+  #
+  # == Removing Equals from Key
+  #
+  # An environment variable holds the key's value and the <b>equals sign</b>
+  # is not allowed within environment variables (in some operating systems)
+  # mainly due to the fact that it is used as the key/value separator.
+  #
+  # The url safe base64 coding may produce one, two or three equal signs in
+  # a bid to pad the string into a multiple of 4 length.
+  #
+  # Thus, we replace the equals signs with the @ symbol when encoding and
+  # vice versa when decoding.
+  #
+  # For added security the key should auto time (or be zeroed) out.
+  class Key < Command
+
+
+    # The <tt>key use case</tt> prints out an encrypted session key tied
+    # to the workstation and shell environment. It should be called like this
+    # and <tt>printenv</tt> can be used to verify that a shell-scoped
+    # environment variable tying OPS_KEY to an (approximately) 48 character
+    # session password, has been created.
+    #
+    #    export OPS_KEY=`ops key`
+    #    printenv
+    #
+    # Note the <b>back-ticks</b> surrounding the <tt>ops key</tt> call.
+    #
+    # <b>The 3 Session Keys</b>
+    #
+    # Three keys are involved here.
+    #
+    # - the 48 character random session key
+    # - the encryption key which is an amalgam
+    # - the base64 encoded key cipher text
+    #
+    #
+    # == Removing Equals from Key
+    #
+    # An environment variable holds the key's value and the <b>equals sign</b>
+    # is not allowed within environment variables (in some operating systems)
+    # mainly due to the fact that it is used as the key/value separator.
+    #
+    # The url safe base64 coding may produce one, two or three equal signs in
+    # a bid to pad the string into a multiple of 4 length.
+    #
+    # Thus, we replace the equals signs with the @ symbol when encoding and
+    # vice versa when decoding.
+    #
+    # @example
+    #
+    #    Session Key => QE6tlTt1fgwvKCYj9aG1K3cwks0EBMy9RgPT1KLqbnDUVRCdlq1EMxirW3ixyaSA
+    #    Encrypt Key => 20cf3067dec35817data-crunch18083.0321.02.878296898
+    #    An Open Key => FvxETEpmoVUetyJ0jJk19aus1pQkzLZ8OVJccatYnC9GxDE4Iy3AyWNZ...
+    #
+    #    $ printenv
+    #    $ export OPS_KEY=`ops key`
+    #    $ printenv
+    #
+    #    The 2nd printenv should reveal a shell specific environment variable.
+    #
+    #    OPS_KEY=FvxETEpmoVUetyJ0jJk19aus1pQkzLZ8OVJccatYnC9GxDE4Iy3AyWNZ...
+    #
+    def execute
+
+      session_key = ToolBelt::Engineer.strong_key( 48 )
+      openkey_key = Base64.urlsafe_encode64(
+        ToolBelt::Blowfish.encryptor( session_key, session_key_password )
+      ).gsub("=","@")
+
+      print openkey_key
+
+    end
+
+
+    # Perform pre-conditional validations in preparation to executing the main flow
+    # of events for this use case. This method may throw the below exceptions.
+    #
+    # @raise [SafeDirNotConfigured] if the safe's url has not been configured
+    # @raise [EmailAddrNotConfigured] if the email address has not been configured
+    # @raise [StoreUrlNotConfigured] if the crypt store url is not configured
+    def pre_validation
+
+
+    end
+
+
+  end
+
+
+end
+