opensecret 0.0.913 → 0.0.941

data/lib/crypto/verify.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/ruby
+
+module OpenSecret
+
+  # This class verifies domain names, email addresses and othe external
+  # reference data.
+  class Verify
+
+    # Register two fundamental opensecret crypt pointers 
+    #
+    # - an opensecret domain like » **lecturers@harvard**
+    # - the url to a backend store like Git, S3 or an SSH accessible drive.
+    #
+    # The domain will be extended to cover verified internet domains.
+    # They will also latch onto LDAP domains so when admins add, revoke
+    # or remove users, their opensecret access is adjusted accordingly.
+    #
+    # @param domain [String] the DOMAIN eg lecturers@harvard for your family or work group.
+    # @param store_url [String] the STORE_URL for connecting to the backend storage service
+    #
+    def self.vreify_domain domain, store_url
+
+      # -> read config file map
+      # -> create new domain in map
+      # -> add type and store url to map
+      # -> backup configuration
+      # -> overwrite the ini config file
+
+    end
+
+  end
+
+end

data/lib/extension/array.rb

@@ -0,0 +1,133 @@
+#!/usr/bin/ruby
+
+#
+# Reopen the core ruby Array class and add the below methods to it.
+#
+# Case Sensitivity rules for [ALL] the below methods that are
+# added to the core Ruby string class.
+#
+# For case insensitive behaviour make sure you downcase both the
+# string object and the parameter strings (or strings within
+# other parameter objects, like arrays and hashes).
+class Array
+
+
+  # Log the array using our logging mixin by printing every array
+  # item into its own log line. In most cases we (the array) are
+  # a list of strings, however if not, each item's to_string method
+  # is invoked and the result printed using one log line.
+  #
+  # The INFO log level is used to log the lines - if this is not
+  #   appropriate create a (level) parameterized log lines method.
+  def log_lines
+
+    self.each do |line|
+      clean_line = line.to_s.chomp.gsub("\\n","")
+      log.info(x) { line } if clean_line.length > 0
+    end
+
+  end
+
+
+  # Get the text [in between] this and that delimeter [exclusively].
+  # Exclusively means the returned text [does not] include either of
+  # the matched delimeters (although an unmatched instance of [this]
+  # delimeter may appear in the in-between text).
+  #
+  # --------------------
+  # Multiple Delimiters
+  # --------------------
+  #
+  # When multiple delimiters exist, the text returned is in between the
+  #
+  #  [a] - first occurrence of [this] delimeter AND the
+  #  [b] - 1st occurrence of [that] delimeter [AFTER] the 1st delimiter
+  #
+  # Instances of [that] delimiter occurring before [this] are ignored.
+  # The text could contain [this] delimeter instances but is guaranteed
+  # not to contain a [that] delimeter.
+  #
+  # -----------
+  # Parameters
+  # -----------
+  #
+  #   this_delimiter : begin delimeter (not included in returned string)
+  #   that_delimiter : end delimeter (not included in returned string)
+  #
+  # -----------
+  # Exceptions
+  # -----------
+  #
+  # An exception (error) will be thrown if
+  #
+  #   => any nil (or empties) exist in the input parameters
+  #   => [this] delimeter does not appear in the in_string
+  #   => [that] delimeter does not appear after [this] one
+  #
+  def before_and_after begin_delimeter, end_delimeter
+
+    Throw.if_nil_or_empty_strings [ self, begin_delimeter, end_delimeter ]
+
+    before_after_lines = []
+    in_middle_bit = false
+
+    self.each do |candidate_line|
+
+      is_middle_boundary = !in_middle_bit && candidate_line.downcase.include?(begin_delimeter.downcase)
+      if is_middle_boundary
+        in_middle_bit = true
+        next
+      end
+
+      unless in_middle_bit
+        before_after_lines.push candidate_line
+        next
+      end
+
+      #--
+      #-- Now we are definitely in the middle bit.
+      #-- Let's check for the middle end delimeter
+      #--
+      if candidate_line.downcase.include? end_delimeter.downcase
+        in_middle_bit = false
+      end
+
+    end
+
+    return before_after_lines
+
+  end
+
+
+  def middlle_bit begin_delimeter, end_delimeter
+
+    Throw.if_nil_or_empty_strings [ self, begin_delimeter, end_delimeter ]
+
+    middle_lines = []
+    in_middle_bit = false
+
+    self.each do |candidate_line|
+
+      is_middle_boundary = !in_middle_bit && candidate_line.downcase.include?(begin_delimeter.downcase)
+      if is_middle_boundary
+        in_middle_bit = true
+        next
+      end
+
+      end_of_middle = in_middle_bit && candidate_line.downcase.include?(end_delimeter.downcase)
+      return middle_lines if end_of_middle
+      
+      #--
+      #-- We are definitely in the middle bit.
+      #--
+      middle_lines.push(candidate_line) if in_middle_bit
+
+    end
+
+    unreachable_str = "This point should be unreachable unless facts are ended."
+    raise RuntimeError.new unreachable_str
+
+  end
+
+
+end

data/lib/extension/file.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/ruby
+
+# Reopen the core ruby File class and add the below methods to it.
+class File
+
+  # This method adds (logging its own contents) behaviour to
+  # the standard library {File} class. If this File points to
+  # a directory - that folder's single level content files are
+  # listed inside the logs.
+  #
+  # The <tt>DEBUG</tt> log level is used for logging. To change this
+  # create a new parameterized method.
+  #
+  # @param file_context [String] context denotes the whys and wherefores of this file.
+  def log_contents file_context
+
+    ## This will fail - add physical raise statement.
+    Throw.if_not_exists self
+
+    log.debug(x) { "# -- ------------------------------------------------------------------------ #" }
+    log.debug(x) { "# -- ------------------------------------------------------------------------ #" }
+    log.debug(x) { "# -- The File Path to Log => #{self}" }
+
+    hr_file_size = PrettyPrint.byte_size( File.size(self) )
+    dotless_extension = File.extname( self )[1..-1]
+    parent_dir_name = File.basename( File.dirname( self ) )
+    file_name = File.basename self
+    is_zip = dotless_extension.eql? "zip"
+
+    log.debug(x) { "# -- ------------------------------------------------------------------------ #" }
+    log.debug(x) { "# -- File Name => #{file_name}" }
+    log.debug(x) { "# -- File Size => #{hr_file_size}" }
+    log.debug(x) { "# -- File Type => #{file_context}" }
+    log.debug(x) { "# -- In Folder => #{parent_dir_name}" }
+    log.debug(x) { "# -- ------------------------------------------------------------------------ #" }
+
+    log.debug(x) { "File #{file_name} is a zip (binary) file." } if is_zip
+    return if is_zip
+
+    File.open( self, "r") do | file_obj |
+      line_no = 1
+      file_obj.each_line do | file_line |
+        line_num = sprintf '%03d', line_no
+        clean_line = file_line.chomp.strip
+        log.debug(x) { "# -- [#{line_num}] - #{clean_line}" }
+        line_no += 1
+      end
+    end
+
+    log.debug(x) { "# -- ------------------------------------------------------------------------ #" }
+    log.debug(x) { "# -- [#{file_context}] End of File [ #{File.basename(self)} ]" }
+    log.debug(x) { "# -- ------------------------------------------------------------------------ #" }
+
+  end
+
+end

data/lib/extension/hash.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/ruby
+
+# Reopen the core ruby Hash class and add the below methods to it.
+class Hash
+
+  # This method adds (logging its own contents) behaviour to
+  # the standard library {Hash} class.
+  #
+  # @note This behaviour does not consider that SECRETS may be inside
+  #    the key value maps - it logs itself without a care in the world.
+  #    This functionality must be included if this behaviourr is used by
+  #    any cryptography classes.
+  #
+  # The <tt>DEBUG</tt> log level is used for logging. To change this
+  # create a new parameterized method.
+  def log_contents
+
+    log.debug(x) { "# --- ----------------------------------------------" }
+    log.debug(x) { "# --- Map has [#{self.length}] key/value pairs." }
+    log.debug(x) { "# --- ----------------------------------------------" }
+
+    self.each do |the_key, the_value|
+
+      padded_key = sprintf '%-33s', the_key
+      log.debug(x) { "# --- #{padded_key} => #{the_value}" }
+
+    end
+
+    log.debug(x) { "# --- ----------------------------------------------" }
+
+  end
+
+end

data/lib/extension/string.rb

@@ -0,0 +1,349 @@
+#!/usr/bin/ruby
+
+
+# Reopen the core ruby String class and add the below methods to it.
+#
+# Case Sensitivity rules for [ALL] the below methods that are
+# added to the core Ruby string class.
+#
+# For case insensitive behaviour make sure you downcase both the
+# string object and the parameter strings (or strings within
+# other parameter objects, like arrays and hashes).
+class String
+
+
+  # Get the text [in between] this and that delimeter [exclusively].
+  # Exclusively means the returned text [does not] include either of
+  # the matched delimeters (although an unmatched instance of [this]
+  # delimeter may appear in the in-between text).
+  #
+  # ### Multiple Delimiters
+  #
+  # When multiple delimiters exist, the text returned is in between the
+  #
+  # - first occurrence of [this] delimeter AND the
+  # - 1st occurrence of [that] delimeter [AFTER] the 1st delimiter
+  #
+  # Instances of [that] delimiter occurring before [this] are ignored.
+  # The text could contain [this] delimeter instances but is guaranteed
+  # not to contain a [that] delimeter.
+  #
+  # @throw an exception (error) will be thrown if
+  #
+  # - any nil (or empties) exist in the input parameters
+  # - **this** delimeter does not appear in the in_string
+  # - **that** delimeter does not appear after [this] one
+  #
+  # @param this_delimeter [String] begin delimeter (not included in returned string)
+  # @param that_delimeter [String] end delimeter (not included in returned string)
+  #
+  # @return [String] the text in between (excluding) the two parameter delimiters
+  def in_between this_delimeter, that_delimeter
+
+    raise ArgumentError, "This string is NIL or empty." if self.nil? || self.empty?
+    raise ArgumentError, "Begin delimiter is NIL or empty." if this_delimiter.nil? || this_delimiter.empty?
+    raise ArgumentError, "End delimiter is NIL or empty." if that_delimiter.nil? || that_delimiter.empty?
+    
+    scanner_1 = StringScanner.new self
+    scanner_1.scan_until /#{this_delimeter}/
+    scanner_2 = StringScanner.new scanner_1.post_match
+    scanner_2.scan_until /#{that_delimeter}/
+
+    in_between_text = scanner_2.pre_match.strip
+    log.info(ere){ in_between_text }
+
+    return in_between_text
+
+  end
+
+
+  # Flatten (lower) a camel cased string and add periods to
+  # denote separation where the capital letters used to be.
+  #
+  # Example behaviour is illustrated
+  #
+  # - in  => ObjectOriented
+  # - out => object.oriented
+  #
+  # Even when a capital letter does not lead lowercase characters
+  # the behaviour should resemble this.
+  #
+  # - in  => SuperX
+  # - out => super.x
+  #
+  #
+  # And if every letter is uppercase, each one represents its
+  # own section like this.
+  #
+  # - in  => BEAST
+  # - out => b.e.a.s.t
+  #
+  # @return [String] a flatten (period separated) version of this camel cased string
+  def do_flatten
+
+    snapped_str = ""
+    self.each_char do |this_char|
+      is_lower = "#{this_char}".is_all_lowercase?
+      snapped_str += "." unless is_lower || snapped_str.empty?
+      snapped_str += this_char.downcase
+    end
+
+    return snapped_str
+
+  end
+
+
+
+  # Return true if every character in this string is lowercase.
+  # Note that if this string is empty this method returns true.
+  #
+  # @return true if every alpha character in this string is lowercase
+  def is_all_lowercase?
+    return self.downcase.eql? self
+  end
+
+
+
+  # Flatten (lower) a camel cased string and add periods to
+  # denote separation where the capital letters used to be.
+  # The inverse operation to [ do_flatten ] which  resurrects
+  # this (expected) period separated string changing it back
+  # to a camel (mountain) cased string.
+  #
+  # Example behaviour is illustrated
+  #
+  # - in  => object.oriented
+  # - out => ObjectOriented
+  #
+  # Even when a single character exists to the right of the period
+  # the behaviour should resemble this.
+  #
+  # - in  => super.x
+  # - out => SuperX
+  #
+  #
+  # And if every letter is period separated
+  #
+  # - in  => b.e.a.s.t
+  # - out => BEAST
+  #
+  # @return [String] camel cased version of this flattened (period separated) string
+  def un_flatten
+
+    segment_array = self.strip.split "."
+    resurrected_arr = Array.new
+
+    segment_array.each do |seg_word|
+      resurrected_arr.push seg_word.capitalize
+    end
+
+    undone_str = resurrected_arr.join
+    log.info(x){ "unflattening => [#{self}] and resurrecting to => [#{undone_str}]" }
+
+    return undone_str
+
+  end
+
+
+
+  # --
+  # Return true if the [little string] within this
+  # string object is both
+  # --
+  #  a] topped by the parameter prefix AND
+  #  b] tailed by the parameter postfix
+  # --
+  # -----------------------------------------
+  # In the below example [true] is returned
+  # -----------------------------------------
+  # --
+  #   This [String] => "Hey [<-secrets->] are juicy."
+  #   little string => "secrets"
+  #   topped string => "[<-"
+  #   tailed string => "->]"
+  # --
+  # Why true? Because the little string "secret" is
+  # (wrapped) topped by "[<-" and tailed by "->]"
+  # --
+  # -----------------------------------------
+  # Assumptions | Constraints | Boundaries
+  # -----------------------------------------
+  # --
+  #   - all matches are [case sensitive]
+  #   - this string must contain little_str
+  #   - one strike and its true
+  #       (if little string appears more than once)
+  #       so => "all secrets, most [<-secrets->] r juicy"
+  #          => true as long as (at least) one is wrapped
+  # --
+  # --
+  def has_wrapped? little_str, prefix, postfix
+
+    return self.include?( prefix + little_str + postfix )
+
+  end
+
+  
+  # Sandwich the first occurrence of a substring in
+  # this string with the specified pre and postfix.
+  #
+  # This string contains the little string and an
+  # IN-PLACE change is performed with the first
+  # occurrence of the little string being prefixed
+  # and postfixed with the 2 parameter strings.
+  #
+  # Example of sandwiching [wrapping]
+  #
+  # -  [String]  => "Hey secrets are juicy."
+  # -  [To_Wrap] => "secrets"
+  # -  [Prefix]  => "[<-"
+  # -  [Postfix] => "->]"
+  #
+  #   [String]  => "Hey [<-secrets->] are juicy."
+  #
+  # This string IS changed in place.
+  def sandwich_substr to_wrap_str, prefix, postfix
+
+    occurs_index = self.downcase.index to_wrap_str.downcase
+    self.insert occurs_index, prefix
+    shifted_index = occurs_index + prefix.length + to_wrap_str.length
+    self.insert shifted_index, postfix
+
+  end
+
+  
+  # The parameter is a list of character sequences and TRUE is returned
+  # if EVERY ONE of the character sequences is always found nestled somewhere
+  # within this string. The matching is case-sensitive.
+  #
+  # The parameter array can be [empty] but not nil. And the harboured
+  # character sequences can neither be nil nor empty.
+  #
+  # @param word_array [Array] array of string words for the inclusivity test
+  #
+  # @return [Boolean] true if EVERY ONE of the char sequences appear somewhere in this string
+  def includes_all? word_array
+
+    raise ArgumentError, "This string is NIL" if self.nil?
+    raise ArgumentError, "The parameter word array is NIL" if word_array.nil?
+
+    word_array.each do |word|
+
+      raise ArgumentError, "The word array #{word_array} contains a nil value." if word.nil?
+      return false unless self.include? word
+
+    end
+
+    return true
+
+  end
+
+
+  # The parameter is a list of character sequences and TRUE is returned
+  # if any one of the character sequences can be found nestled somewhere
+  # within this string. The matching is case-sensitive.
+  #
+  # The parameter array can be [empty] but not nil. And the harboured
+  # character sequences can neither be nil nor empty.
+  #
+  # @param word_array [Array] array of string words for the inclusivity test
+  #
+  # @return [Boolean] true if string includes ANY one of the character sequences in array
+  def includes_any? word_array
+
+    raise ArgumentError, "This string is NIL" if self.nil?
+    raise ArgumentError, "The parameter word array is NIL" if word_array.nil?
+
+    word_array.each do |word|
+
+      raise ArgumentError, "The word array #{word_array} contains a nil value." if word.nil?
+      return true if self.include? word
+
+    end
+
+    return false
+
+  end
+
+
+  # --
+  # Encrypt this string with the parameter encryption/decryption key
+  # and return the encrypted text as a new string.
+  # --
+  #  decrypt_key  => the key that will decrypt the output string
+  # --
+  # --
+  def encrypt decrypt_key
+
+## ----> Write a RE-CRYPT method that goes through a folder - decrypting and recrypting
+## ----> Write a RE-CRYPT method that goes through a folder - decrypting and recrypting
+## ----> Write a RE-CRYPT method that goes through a folder - decrypting and recrypting
+## ----> Write a RE-CRYPT method that goes through a folder - decrypting and recrypting
+
+###### ON Linux improve by changing to OpenSSL::Cipher.new('DES-EDE3-CBC').encrypt
+###### ON Linux improve by changing to Digest::SHA2.hexdigest decrypt_key
+###### ON Linux improve by changing to OpenSSL::Cipher.new('DES-EDE3-CBC').encrypt
+###### ON Linux improve by changing to Digest::SHA2.hexdigest decrypt_key
+###### ON Linux improve by changing to OpenSSL::Cipher.new('DES-EDE3-CBC').encrypt
+###### ON Linux improve by changing to Digest::SHA2.hexdigest decrypt_key
+###### ON Linux improve by changing to OpenSSL::Cipher.new('DES-EDE3-CBC').encrypt
+###### ON Linux improve by changing to Digest::SHA2.hexdigest decrypt_key
+
+    cipher = OpenSSL::Cipher::Cipher.new('DES-EDE3-CBC').encrypt
+    cipher.key = Digest::SHA1.hexdigest decrypt_key
+    crypted = cipher.update(self) + cipher.final
+    encrypted_text = crypted.unpack('H*')[0].upcase
+
+    return encrypted_text
+
+  end
+
+
+  # --
+  # Decrypt this string with the parameter encryption/decryption key
+  # and return the decrypted text as a new string.
+  # --
+  #  encrypt_key  => the key the input string was encrypted with
+  # --
+  # --
+  def decrypt encrypt_key
+
+## ----> Write a RE-CRYPT method that goes through a folder - decrypting and recrypting
+## ----> Write a RE-CRYPT method that goes through a folder - decrypting and recrypting
+## ----> Write a RE-CRYPT method that goes through a folder - decrypting and recrypting
+## ----> Write a RE-CRYPT method that goes through a folder - decrypting and recrypting
+
+###### ON Linux improve by changing to OpenSSL::Cipher.new('DES-EDE3-CBC').encrypt
+###### ON Linux improve by changing to Digest::SHA2.hexdigest decrypt_key
+###### ON Linux improve by changing to OpenSSL::Cipher.new('DES-EDE3-CBC').encrypt
+###### ON Linux improve by changing to Digest::SHA2.hexdigest decrypt_key
+###### ON Linux improve by changing to OpenSSL::Cipher.new('DES-EDE3-CBC').encrypt
+###### ON Linux improve by changing to Digest::SHA2.hexdigest decrypt_key
+
+    cipher = OpenSSL::Cipher::Cipher.new('DES-EDE3-CBC').decrypt
+    cipher.key = Digest::SHA1.hexdigest encrypt_key
+    uncrypted = [self].pack("H*").unpack("C*").pack("c*")
+    decrypted_text = cipher.update(uncrypted) + cipher.final
+
+    return decrypted_text
+
+  end
+
+
+  # Log the string which is expected to be delineated.
+  #   If the string originated from a file it will be logged
+  #   line by line. If no line delineation the string will be
+  #   dumped just as a blob.
+  #
+  # The INFO log level is used to log the lines - if this is not
+  #   appropriate create a (level) parameterized log lines method.
+  def log_lines
+
+    self.each_line do |line|
+      clean_line = line.chomp.gsub("\\n","")
+      log.info(x) { line } if clean_line.length > 0
+    end
+
+  end
+
+end