opensecret 0.0.9925 → 0.0.9949

data/lib/modules/cryptology/open.bcrypt.rb

@@ -1,170 +0,0 @@
-#!/usr/bin/ruby
-# coding: utf-8
-
-
-=begin
-
-Using BCrypt for password hashing has several advantages over the builtin Digest classes. First of all it has a decent interface:
-
-gem "bcrypt-ruby"
-require "bcrypt"
-hashed_password = BCrypt::Password.create "my password"
-hashed_password is now an instance of BCrypt::Password. You can check the password now with ==:
-
-hashed_password == "my password" # => true
-The second nice point is the built-in security. Passwords are automatically salted. Furthermore, BCrypt has a parameter cost which exponentially scales the computation time.
-
-hashed_password1 = BCrypt::Password.create( "my password", cost: 1 )
-hashed_password10 = BCrypt::Password.create( "my password", cost: 10 )
-Computing hashedpassword10 is 2^9 times as expessive as computing hashedpassword1. This way you can adjust the hashing algorithm to your available resources and always use the most-expensive-to-crack hashing you can afford.
-
-Last but definitly not least storing and restoring BCrypt::Passwords is simple as hell:
-
-storable_string = hashed_password.to_s
-restored_hash = BCrypt::Password.new storable_string
-NICE!
-
-
-
-
-
-
-
-bcrypt-ruby
-An easy way to keep your users' passwords secure.
-
-http://github.com/codahale/bcrypt-ruby/tree/master
-Build Status
-
-Why you should use bcrypt()
-If you store user passwords in the clear, then an attacker who steals a copy of your database has a giant list of emails and passwords. Some of your users will only have one password -- for their email account, for their banking account, for your application. A simple hack could escalate into massive identity theft.
-
-It's your responsibility as a web developer to make your web application secure -- blaming your users for not being security experts is not a professional response to risk.
-
-bcrypt() allows you to easily harden your application against these kinds of attacks.
-
-Note: JRuby versions of the bcrypt gem <= 2.1.3 had a security vulnerability that was fixed in >= 2.1.4. If you used a vulnerable version to hash passwords with international characters in them, you will need to re-hash those passwords. This vulnerability only affected the JRuby gem.
-
-How to install bcrypt
-gem install bcrypt
-The bcrypt gem is available on the following ruby platforms:
-
-JRuby
-RubyInstaller 1.8, 1.9, 2.0, 2.1, and 2.2 builds on win32
-Any 1.8, 1.9, 2.0, 2.1, 2.2, or 2.3 Ruby on a BSD/OS X/Linux system with a compiler
-How to use bcrypt() in your Rails application
-Note: Rails versions >= 3 ship with ActiveModel::SecurePassword which uses bcrypt-ruby. has_secure_password docs implements a similar authentication strategy to the code below.
-
-The User model
-require 'bcrypt'
-
-class User < ActiveRecord::Base
-  # users.password_hash in the database is a :string
-  include BCrypt
-
-  def password
-    @password ||= Password.new(password_hash)
-  end
-
-  def password=(new_password)
-    @password = Password.create(new_password)
-    self.password_hash = @password
-  end
-end
-Creating an account
-def create
-  @user = User.new(params[:user])
-  @user.password = params[:password]
-  @user.save!
-end
-Authenticating a user
-def login
-  @user = User.find_by_email(params[:email])
-  if @user.password == params[:password]
-    give_token
-  else
-    redirect_to home_url
-  end
-end
-How to use bcrypt-ruby in general
-require 'bcrypt'
-
-my_password = BCrypt::Password.create("my password")
-#=> "$2a$10$vI8aWBnW3fID.ZQ4/zo1G.q1lRps.9cGLcZEiGDMVr5yUP1KUOYTa"
-
-my_password.version              #=> "2a"
-my_password.cost                 #=> 10
-my_password == "my password"     #=> true
-my_password == "not my password" #=> false
-
-my_password = BCrypt::Password.new("$2a$10$vI8aWBnW3fID.ZQ4/zo1G.q1lRps.9cGLcZEiGDMVr5yUP1KUOYTa")
-my_password == "my password"     #=> true
-my_password == "not my password" #=> false
-Check the rdocs for more details -- BCrypt, BCrypt::Password.
-
-How bcrypt() works
-bcrypt() is a hashing algorithm designed by Niels Provos and David Mazières of the OpenBSD Project.
-
-Background
-Hash algorithms take a chunk of data (e.g., your user's password) and create a "digital fingerprint," or hash, of it. Because this process is not reversible, there's no way to go from the hash back to the password.
-
-In other words:
-
-hash(p) #=> <unique gibberish>
-You can store the hash and check it against a hash made of a potentially valid password:
-
-<unique gibberish> =? hash(just_entered_password)
-Rainbow Tables
-But even this has weaknesses -- attackers can just run lists of possible passwords through the same algorithm, store the results in a big database, and then look up the passwords by their hash:
-
-PrecomputedPassword.find_by_hash(<unique gibberish>).password #=> "secret1"
-Salts
-The solution to this is to add a small chunk of random data -- called a salt -- to the password before it's hashed:
-
-hash(salt + p) #=> <really unique gibberish>
-The salt is then stored along with the hash in the database, and used to check potentially valid passwords:
-
-<really unique gibberish> =? hash(salt + just_entered_password)
-bcrypt-ruby automatically handles the storage and generation of these salts for you.
-
-Adding a salt means that an attacker has to have a gigantic database for each unique salt -- for a salt made of 4 letters, that's 456,976 different databases. Pretty much no one has that much storage space, so attackers try a different, slower method -- throw a list of potential passwords at each individual password:
-
-hash(salt + "aadvark") =? <really unique gibberish>
-hash(salt + "abacus")  =? <really unique gibberish>
-etc.
-This is much slower than the big database approach, but most hash algorithms are pretty quick -- and therein lies the problem. Hash algorithms aren't usually designed to be slow, they're designed to turn gigabytes of data into secure fingerprints as quickly as possible. bcrypt(), though, is designed to be computationally expensive:
-
-Ten thousand iterations:
-             user     system      total        real
-md5      0.070000   0.000000   0.070000 (  0.070415)
-bcrypt  22.230000   0.080000  22.310000 ( 22.493822)
-If an attacker was using Ruby to check each password, they could check ~140,000 passwords a second with MD5 but only ~450 passwords a second with bcrypt().
-
-Cost Factors
-In addition, bcrypt() allows you to increase the amount of work required to hash a password as computers get faster. Old passwords will still work fine, but new passwords can keep up with the times.
-
-The default cost factor used by bcrypt-ruby is 10, which is fine for session-based authentication. If you are using a stateless authentication architecture (e.g., HTTP Basic Auth), you will want to lower the cost factor to reduce your server load and keep your request times down. This will lower the security provided you, but there are few alternatives.
-
-To change the default cost factor used by bcrypt-ruby, use BCrypt::Engine.cost = new_value:
-
-BCrypt::Password.create('secret').cost
-  #=> 10, the default provided by bcrypt-ruby
-
-# set a new default cost
-BCrypt::Engine.cost = 8
-BCrypt::Password.create('secret').cost
-  #=> 8
-The default cost can be overridden as needed by passing an options hash with a different cost:
-
-BCrypt::Password.create('secret', :cost => 6).cost  #=> 6
-More Information
-bcrypt() is currently used as the default password storage hash in OpenBSD, widely regarded as the most secure operating system available.
-
-For a more technical explanation of the algorithm and its design criteria, please read Niels Provos and David Mazières' Usenix99 paper: http://www.usenix.org/events/usenix99/provos.html
-
-If you'd like more down-to-earth advice regarding cryptography, I suggest reading Practical Cryptography by Niels Ferguson and Bruce Schneier: http://www.schneier.com/book-practical.html
-
-Etc
-
-=end
-

data/lib/usecase/read.rb

@@ -1,89 +0,0 @@
-#!/usr/bin/ruby
-	
-module OpenSecret
-
-
-  class Read < Command
-
-
-    def execute
-
-      return unless ops_key_exists?
-      appdb_content = OpenKey::KeyApi.read_app_content()
-
-## @todo - rename appdb_content as master_db
-## @todo - rename appdb_content as master_db
-## @todo - rename appdb_content as master_db
-## @todo - rename appdb_content as master_db
-## @todo - rename appdb_content as master_db
-## @todo - rename appdb_content as master_db
-## @todo - rename appdb_content as master_db
-## @todo - rename appdb_content as master_db
-## @todo - rename appdb_content as master_db
-## @todo - rename appdb_content as master_db
-## @todo - rename appdb_content as master_db
-## @todo - rename appdb_content as master_db
-## @todo - rename appdb_content as master_db
-## @todo - rename appdb_content as master_db
-## @todo - rename appdb_content as master_db
-
-      return if unopened_envelope?( appdb_content )
-
-      envelope_id = ENVELOPE_KEY_PREFIX + appdb_content[ ENV_PATH ]
-      has_content = OpenKey::KeyApi.content_exists?( appdb_content[ envelope_id ] )
-
-      # --
-      # -- To get hold of the content we must either
-      # --
-      # --   a) unlock it using the breadcrumbs or
-      # --   b) start afresh with a new content db
-      # --
-      content_box = OpenKey::KeyApi.content_unlock( appdb_content[ envelope_id ] ) if has_content
-      content_box = content_box.fast_forward( appdb_content[ KEY_PATH ] )
-      content_box = OpenKey::KeyDb.new() unless has_content
-
-      puts ""
-      puts "--- ----------------------------------\n"
-      puts "--- envelope => #{appdb_content[ ENV_PATH ]}\n"
-      puts "--- key path => #{appdb_content[ KEY_PATH ]}\n"
-      puts "--- ----------------------------------\n"
-      puts JSON.pretty_generate( content_box )
-      puts "--- ----------------------------------\n"
-      puts ""
-
-      return
-
-    end
-
-
-    private
-
-
-    def print_put_success
-
-      puts ""
-      puts "Success putting a key/value pair into the open envelope."
-      puts "You can put more in and then close the envelope."
-      puts ""
-      puts "    ops close"
-      puts ""
-
-    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

data/lib/usecase/safe.rb

@@ -1,92 +0,0 @@
-#!/usr/bin/ruby
-	
-module OpenSecret
-
-  # This is the [On] usecase that is triggered when a user would like
-  # to start a locking (encryption) session.
-  #
-  # Pre-Conditions
-  #
-  # - [session.config.file] exists with domain,user,email,store_id => store_url
-  #
-  # Main Flow of Events
-  #
-  # Stash the path into the host machine's configuration file and proceed
-  # to create the path directory chain if it does not already exist.
-  #
-  class Safe < Command
-
-    attr_writer :safe_path
-    @@context_name = "opensecret"
-    @@prime_name = "opensecret.safe"
-
-    # The safe use case simply validates the presented path and when the
-    # execute method is called it stashes the path within the host machine's
-    # configuration file and proceeds to create the path directory chain
-    # if it does not already exist.
-    def execute
-      
-      OpenSession::Attributes.stash @@context_name, @@context_name, "safe", @safe_path
-      FileUtils.mkdir_p @safe_path unless File.exists? @safe_path
-
-    end
-
-
-    def pre_validation
-
-      needs_chopping = @safe_path.end_with?("/") || @safe_path.end_with?("\\")
-      @safe_path = @safe_path.chop if needs_chopping
-
-      index_1st = @safe_path.index @@prime_name
-      index_2nd = @safe_path.rindex @@prime_name
-
-      xtra_msg = "Text [ #{@@prime_name} ] can only appear once in [ #{@safe_path} ]."
-      raise SafePrimeNameRepeated.new xtra_msg, @safe_path unless index_1st == index_2nd
-
-      unless @safe_path.end_with? @@prime_name
-
-        if @safe_path.include? @@prime_name
-          prime_name_end_index = @safe_path.index(@@prime_name) + @@prime_name.length
-          @safe_path = @safe_path[0..prime_name_end_index]
-        else
-          @safe_path = File.join @safe_path, @@prime_name
-        end
-
-        ends_with_prime = @safe_path.end_with? @@prime_name          
-        not_at_end_msg = "Text [#{@@prime_name} ] is not at end of [ #{@safe_path} ]."
-        raise SafePrimeNameNotAtEnd.new not_at_end_msg, @safe_path unless ends_with_prime
-
-      end
-
-      if( File.exists?( @safe_path ) && !(File.directory? @safe_path) )
-        raise SafeDirectoryIsFile.new "the [safe] directory path points to a file", @safe_path
-      end
-
-    end
-
-
-    # The safe_path instance attribute must be configured within
-    # the context configuration file using a keyname of "safe".
-    #
-    # @raise ArgumentError for any one of a long list of reasons that
-    #     cause the key value to not be retrieved. This can range from
-    #     non-existent directories and files, non readable files, incorrect
-    #     configurations right down to missing keys or even missing values.
-    def post_validation
-
-      configured_path = OpenSession::Attributes.instance.get_value @@context_name, @@context_name, "safe"
-      path_string_1 = "  path 1 => #{configured_path}"
-      path_string_2 = "  path 2 => #{@safe_path}"
-      mismatch_path = "Path mismatch to opensecret [safe] detected."
-      err_msg = "\n" + mismatch_path + "\n" + path_string_1 + "\n" + path_string_2 + "\n"
-
-      raise RuntimeError, err_msg unless @safe_path.eql? configured_path
-
-
-    end
-
-
-  end
-
-
-end