authlogic 3.8.0 → 6.0.0

data/README.md

@@ -1,294 +0,0 @@
-# Authlogic
-
-**Authlogic supports rails 3, 4 and 5. For rails 2, see the [rails2 branch](https://github.com/binarylogic/authlogic/tree/rails2).**
-
-[![Gem Version](https://badge.fury.io/rb/authlogic.png)](http://badge.fury.io/rb/authlogic)
-[![Build Status](https://travis-ci.org/binarylogic/authlogic.png?branch=master)](https://travis-ci.org/binarylogic/authlogic)
-[![Code Climate](https://codeclimate.com/github/binarylogic/authlogic.png)](https://codeclimate.com/github/binarylogic/authlogic)
-
-Authlogic is a clean, simple, and unobtrusive ruby authentication solution.
-
-It introduces a new type of model. You can have as many as you want, and name them whatever you want, just like your other models. In this example, we want to authenticate with the User model, which is inferred by the name:
-
-```ruby
-class UserSession < Authlogic::Session::Base
-  # specify configuration here, such as:
-  # logout_on_timeout true
-  # ...many more options in the documentation
-end
-```
-
-In a `UserSessionsController`, login the user by using it just like your other models:
-
-```ruby
-UserSession.create(:login => "bjohnson", :password => "my password", :remember_me => true)
-
-session = UserSession.new(:login => "bjohnson", :password => "my password", :remember_me => true)
-session.save
-
-# requires the authlogic-oid "add on" gem
-UserSession.create(:openid_identifier => "identifier", :remember_me => true)
-
-# skip authentication and log the user in directly, the true means "remember me"
-UserSession.create(my_user_object, true)
-```
-
-The above handles the entire authentication process for you by:
-
-1. authenticating (i.e. **validating** the record)
-2. sets up the proper session values and cookies to persist the session (i.e. **saving** the record).
-
-You can also log out (i.e. **destroying** the session):
-
-``` ruby
-session.destroy
-```
-
-After a session has been created, you can persist it (i.e. **finding** the record) across requests. Thus keeping the user logged in:
-
-``` ruby
-session = UserSession.find
-```
-
-To get all of the nice authentication functionality in your model just do this:
-
-```ruby
-class User < ActiveRecord::Base
-  acts_as_authentic do |c|
-    c.my_config_option = my_value
-  end # the configuration block is optional
-end
-```
-
-This handles validations, etc. It is also "smart" in the sense that it if a login field is present it will use that to authenticate, if not it will look for an email field, etc. This is all configurable, but for 99% of cases that above is all you will need to do.
-
-You may specify how passwords are cryptographically hashed (or encrypted) by setting the Authlogic::CryptoProvider option:
-
-``` ruby
-c.crypto_provider = Authlogic::CryptoProviders::BCrypt
-```
-
-You may validate international email addresses by enabling the provided alternate regex:
-
-``` ruby
-c.validates_format_of_email_field_options = {:with => Authlogic::Regex.email_nonascii}
-```
-
-Also, sessions are automatically maintained. You can switch this on and off with configuration, but the following will automatically log a user in after a successful registration:
-
-``` ruby
-User.create(params[:user])
-```
-
-This also updates the session when the user changes his/her password.
-
-Authlogic is very flexible, it has a strong public API and a plethora of hooks to allow you to modify behavior and extend it. Check out the helpful links below to dig deeper.
-
-## Upgrading to Authlogic 3.4.0
-
-In version 3.4.0, the default crypto_provider was changed from *Sha512* to *SCrypt*.
-
-If you never set a crypto_provider and are upgrading, your passwords will break unless you set the original:
-
-``` ruby
-c.crypto_provider = Authlogic::CryptoProviders::Sha512
-```
-
-And if you want to automatically upgrade from *Sha512* to *SCrypt* as users login:
-
-```ruby
-c.transition_from_crypto_providers = [Authlogic::CryptoProviders::Sha512]
-c.crypto_provider = Authlogic::CryptoProviders::SCrypt
-```
-
-## Helpful links
-
-* <b>Documentation:</b> http://rdoc.info/projects/binarylogic/authlogic
-* <b>Repository:</b> http://github.com/binarylogic/authlogic/tree/master
-* <b>Railscasts Screencast:</b> http://railscasts.com/episodes/160-authlogic
-* <b>Example repository with tutorial in README:</b> http://github.com/binarylogic/authlogic_example/tree/master
-* <b>Tutorial: Reset passwords with Authlogic the RESTful way:</b> http://www.binarylogic.com/2008/11/16/tutorial-reset-passwords-with-authlogic
-* <b>Tutorial</b>: Rails Authentication with Authlogic http://www.sitepoint.com/rails-authentication-with-authlogic
-* <b>Issues:</b> http://github.com/binarylogic/authlogic/issues
-
-## Authlogic "add ons"
-
-* <b>Authlogic OpenID addon:</b> http://github.com/binarylogic/authlogic_openid
-* <b>Authlogic LDAP addon:</b> http://github.com/binarylogic/authlogic_ldap
-* <b>Authlogic Facebook Connect:</b> http://github.com/kalasjocke/authlogic_facebook_connect
-* <b>Authlogic Facebook Connect (New JS API):</b> http://github.com/studybyte/authlogic_facebook_connect
-* <b>Authlogic Facebook Shim</b> http://github.com/james2m/authlogic_facebook_shim
-* <b>Authlogic OAuth (Twitter):</b> http://github.com/jrallison/authlogic_oauth
-* <b>Authlogic Oauth and OpenID:</b> http://github.com/viatropos/authlogic-connect
-* <b>Authlogic PAM:</b> http://github.com/nbudin/authlogic_pam
-* <b>Authlogic x509:</b> http://github.com/auth-scc/authlogic_x509
-
-If you create one of your own, please let me know about it so I can add it to this list. Or just fork the project, add your link, and send me a pull request.
-
-## Documentation explanation
-
-You can find anything you want about Authlogic in the [documentation](http://rdoc.info/projects/binarylogic/authlogic), all that you need to do is understand the basic design behind it.
-
-That being said, there are 2 models involved during authentication. Your Authlogic model and your ActiveRecord model:
-
-1. <b>Authlogic::Session</b>, your session models that extend Authlogic::Session::Base.
-2. <b>Authlogic::ActsAsAuthentic</b>, which adds in functionality to your ActiveRecord model when you call acts_as_authentic.
-
-Each of the above has its various sub modules that contain common logic. The sub modules are responsible for including *everything* related to it: configuration, class methods, instance methods, etc.
-
-For example, if you want to timeout users after a certain period of inactivity, you would look in <b>Authlogic::Session::Timeout</b>. To help you out, I listed the following publicly relevant modules with short descriptions. For the sake of brevity, there are more modules than listed here, the ones not listed are more for internal use, but you can easily read up on them in the [documentation](http://rdoc.info/projects/binarylogic/authlogic).
-
-## Example migration
-
-If you want to enable all the features of Authlogic, a migration to create a
-+User+ model, for example, might look like this:
-
-``` ruby
-class CreateUser < ActiveRecord::Migration
-  def change
-    create_table :users do |t|
-      # Authlogic::ActsAsAuthentic::Email
-      t.string    :email
-
-      # Authlogic::ActsAsAuthentic::Password
-      t.string    :crypted_password
-      t.string    :password_salt
-
-      # Authlogic::ActsAsAuthentic::PersistenceToken
-      t.string    :persistence_token
-
-      # Authlogic::ActsAsAuthentic::SingleAccessToken
-      t.string    :single_access_token
-
-      # Authlogic::ActsAsAuthentic::PerishableToken
-      t.string    :perishable_token
-
-      # Authlogic::Session::MagicColumns
-      t.integer   :login_count, default: 0, null: false
-      t.integer   :failed_login_count, default: 0, null: false
-      t.datetime  :last_request_at
-      t.datetime  :current_login_at
-      t.datetime  :last_login_at
-      t.string    :current_login_ip
-      t.string    :last_login_ip
-
-      # Authlogic::Session::MagicStates
-      t.boolean   :active, default: false
-      t.boolean   :approved, default: false
-      t.boolean   :confirmed, default: false
-
-      t.timestamps
-    end
-  end
-end
-```
-
-## Quick Rails example
-
-What if creating sessions worked like an ORM library on the surface...
-
-``` ruby
-UserSession.create(params[:user_session])
-```
-
-What if your user sessions controller could look just like your other controllers...
-
-```ruby
-class UserSessionsController < ApplicationController
-  def new
-    @user_session = UserSession.new
-  end
-
-  def create
-    @user_session = UserSession.new(params[:user_session])
-    if @user_session.save
-      redirect_to account_url
-    else
-      render :action => :new
-    end
-  end
-
-  def destroy
-    current_user_session.destroy
-    redirect_to new_user_session_url
-  end
-end
-```
-
-As you can see, this fits nicely into the RESTful development pattern. What about the view...
-
-```erb
-<%= form_for @user_session do |f| %>
-  <% if @user_session.errors.any? %>
-  <div id="error_explanation">
-    <h2><%= pluralize(@user_session.errors.count, "error") %> prohibited:</h2>
-    <ul>
-      <% @user_session.errors.full_messages.each do |msg| %>
-        <li><%= msg %></li>
-      <% end %>
-    </ul>
-  </div>
-  <% end %>
-  <%= f.label :login %><br />
-  <%= f.text_field :login %><br />
-  <br />
-  <%= f.label :password %><br />
-  <%= f.password_field :password %><br />
-  <br />
-  <%= f.submit "Login" %>
-<% end %>
-```
-
-Or how about persisting the session...
-
-```ruby
-class ApplicationController
-  helper_method :current_user_session, :current_user
-
-  private
-    def current_user_session
-      return @current_user_session if defined?(@current_user_session)
-      @current_user_session = UserSession.find
-    end
-
-    def current_user
-      return @current_user if defined?(@current_user)
-      @current_user = current_user_session && current_user_session.user
-    end
-end
-```
-
-## CSRF Protection
-
-Because Authlogic introduces its own methods for storing user sessions, the CSRF (Cross Site Request Forgery) protection that is built into Rails will not work out of the box.
-
-No generally applicable mitigation by the authlogic library is possible, because the instance variable you use to store a reference to the user session in `def current_user_session` will not be known to authlogic.
-
-You will need to override `ActionController::Base#handle_unverified_request` to do something appropriate to how your app handles user sessions, e.g.:
-
-```ruby
-class ApplicationController < ActionController::Base
-  ...
-  protected
-
-  def handle_unverified_request
-    # raise an exception
-    fail ActionController::InvalidAuthenticityToken
-    # or destroy session, redirect
-    if current_user_session
-      current_user_session.destroy
-    end
-    redirect_to root_url
-  end
-end
-```
-
-## Testing
-
-See [Authlogic::TestCase](https://github.com/binarylogic/authlogic/blob/master/lib/authlogic/test_case.rb)
-
-## Tell me quickly how Authlogic works
-
-Interested in how all of this all works? Think about an ActiveRecord model. A database connection must be established before you can use it. In the case of Authlogic, a controller connection must be established before you can use it. It uses that controller connection to modify cookies, the current session, login with HTTP basic, etc. It connects to the controller through a before filter that is automatically set in your controller which lets Authlogic know about the current controller object. Then Authlogic leverages that to do everything, it's a pretty simple design. Nothing crazy going on, Authlogic is just leveraging the tools your framework provides in the controller object.
-
-Copyright (c) 2012 Ben Johnson of Binary Logic, released under the MIT license

data/Rakefile

@@ -1,21 +0,0 @@
-require 'rubygems'
-require 'bundler'
-
-Bundler.setup
-
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/*_test.rb'
-  test.verbose = false
-
-  # Set interpreter warning level to 1 (medium). Level 2 produces hundreds of warnings
-  # about uninitialized instance variables.
-  # TODO: Find a good way to deal with the level 2 warnings.
-  test.ruby_opts += ["-W1"]
-end
-
-require "rubocop/rake_task"
-RuboCop::RakeTask.new
-
-task :default => [:rubocop, :test]

data/authlogic.gemspec

@@ -1,27 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-
-Gem::Specification.new do |s|
-  s.name        = "authlogic"
-  s.version     = "3.8.0"
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Ben Johnson"]
-  s.email       = ["bjohnson@binarylogic.com"]
-  s.homepage    = "http://github.com/binarylogic/authlogic"
-  s.summary     = 'A clean, simple, and unobtrusive ruby authentication solution.'
-
-  s.license = 'MIT'
-
-  s.add_dependency 'activerecord', ['>= 3.2', '< 5.3']
-  s.add_dependency 'activesupport', ['>= 3.2', '< 5.3']
-  s.add_dependency 'request_store', '~> 1.0'
-  s.add_dependency 'scrypt', '>= 1.2', '< 4.0'
-  s.add_development_dependency 'bcrypt', '~> 3.1'
-  s.add_development_dependency 'timecop', '~> 0.7'
-  s.add_development_dependency 'rubocop', '~> 0.41.2'
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
-  s.require_paths = ["lib"]
-end

data/lib/authlogic/acts_as_authentic/restful_authentication.rb

@@ -1,70 +0,0 @@
-module Authlogic
-  module ActsAsAuthentic
-    # This module is responsible for transitioning existing applications from
-    # the restful_authentication plugin.
-    module RestfulAuthentication
-      def self.included(klass)
-        klass.class_eval do
-          extend Config
-          include InstanceMethods
-        end
-      end
-
-      module Config
-        # Switching an existing app to Authlogic from restful_authentication? No
-        # problem, just set this true and your users won't know anything
-        # changed. From your database perspective nothing will change at all.
-        # Authlogic will continue to encrypt passwords just like
-        # restful_authentication, so your app won't skip a beat. Although, might
-        # consider transitioning your users to a newer and stronger algorithm.
-        # Checkout the transition_from_restful_authentication option.
-        #
-        # * <tt>Default:</tt> false
-        # * <tt>Accepts:</tt> Boolean
-        def act_like_restful_authentication(value = nil)
-          r = rw_config(:act_like_restful_authentication, value, false)
-          set_restful_authentication_config if value
-          r
-        end
-        alias_method :act_like_restful_authentication=, :act_like_restful_authentication
-
-        # This works just like act_like_restful_authentication except that it
-        # will start transitioning your users to the algorithm you specify with
-        # the crypto provider option. The next time they log in it will resave
-        # their password with the new algorithm and any new record will use the
-        # new algorithm as well. Make sure to update your users table if you are
-        # using the default migration since it will set crypted_password and
-        # salt columns to a maximum width of 40 characters which is not enough.
-        def transition_from_restful_authentication(value = nil)
-          r = rw_config(:transition_from_restful_authentication, value, false)
-          set_restful_authentication_config if value
-          r
-        end
-        alias_method :transition_from_restful_authentication=, :transition_from_restful_authentication
-
-        private
-
-          def set_restful_authentication_config
-            crypto_provider_key = act_like_restful_authentication ? :crypto_provider : :transition_from_crypto_providers
-            self.send("#{crypto_provider_key}=", CryptoProviders::Sha1)
-            if !defined?(::REST_AUTH_SITE_KEY) || ::REST_AUTH_SITE_KEY.nil?
-              class_eval("::REST_AUTH_SITE_KEY = ''") if !defined?(::REST_AUTH_SITE_KEY)
-              CryptoProviders::Sha1.stretches = 1
-            end
-          end
-      end
-
-      module InstanceMethods
-        private
-
-          def act_like_restful_authentication?
-            self.class.act_like_restful_authentication == true
-          end
-
-          def transition_from_restful_authentication?
-            self.class.transition_from_restful_authentication == true
-          end
-      end
-    end
-  end
-end

data/lib/authlogic/acts_as_authentic/validations_scope.rb

@@ -1,32 +0,0 @@
-module Authlogic
-  module ActsAsAuthentic
-    # Allows you to scope everything to specific fields.
-    # See the Config submodule for more info.
-    # For information on how to scope off of a parent object see Authlogic::AuthenticatesMany
-    module ValidationsScope
-      def self.included(klass)
-        klass.class_eval do
-          extend Config
-        end
-      end
-
-      # All configuration for the scope feature.
-      module Config
-        # Allows you to scope everything to specific field(s). Works just like validates_uniqueness_of.
-        # For example, let's say a user belongs to a company, and you want to scope everything to the
-        # company:
-        #
-        #   acts_as_authentic do |c|
-        #     c.validations_scope = :company_id
-        #   end
-        #
-        # * <tt>Default:</tt> nil
-        # * <tt>Accepts:</tt> Symbol or Array of symbols
-        def validations_scope(value = nil)
-          rw_config(:validations_scope, value)
-        end
-        alias_method :validations_scope=, :validations_scope
-      end
-    end
-  end
-end

data/lib/authlogic/authenticates_many/association.rb

@@ -1,50 +0,0 @@
-module Authlogic
-  module AuthenticatesMany
-    # An object of this class is used as a proxy for the authenticates_many
-    # relationship. It basically allows you to "save" scope details and call
-    # them on an object, which allows you to do the following:
-    #
-    #   @account.user_sessions.new
-    #   @account.user_sessions.find
-    #   # ... etc
-    #
-    # You can call all of the class level methods off of an object with a saved
-    # scope, so that calling the above methods scopes the user sessions down to
-    # that specific account. To implement this via ActiveRecord do something
-    # like:
-    #
-    #   class User < ActiveRecord::Base
-    #     authenticates_many :user_sessions
-    #   end
-    class Association
-      attr_accessor :klass, :find_options, :id
-
-      # - id: Usually `nil`, but if the `scope_cookies` option is used, then
-      #   `id` is a string like "company_123". It may seem strange to refer
-      #   to such a string as an "id", but the naming is intentional, and
-      #   is derived from `Authlogic::Session::Id`.
-      def initialize(klass, find_options, id)
-        self.klass = klass
-        self.find_options = find_options
-        self.id = id
-      end
-
-      [:create, :create!, :find, :new].each do |method|
-        class_eval <<-"end_eval", __FILE__, __LINE__
-          def #{method}(*args)
-            klass.with_scope(scope_options) do
-              klass.#{method}(*args)
-            end
-          end
-        end_eval
-      end
-      alias_method :build, :new
-
-      private
-
-        def scope_options
-          { :find_options => find_options, :id => id }
-        end
-    end
-  end
-end

data/lib/authlogic/authenticates_many/base.rb

@@ -1,65 +0,0 @@
-module Authlogic
-  # This allows you to scope your authentication. For example, let's say all users belong
-  # to an account, you want to make sure only users that belong to that account can
-  # actually login into that account. Simple, just do:
-  #
-  #   class Account < ActiveRecord::Base
-  #     authenticates_many :user_sessions
-  #   end
-  #
-  # Now you can scope sessions just like everything else in ActiveRecord:
-  #
-  #   @account.user_sessions.new(*args)
-  #   @account.user_sessions.create(*args)
-  #   @account.user_sessions.find(*args)
-  #   # ... etc
-  #
-  # Checkout the authenticates_many method for a list of options.
-  # You may also want to checkout Authlogic::ActsAsAuthentic::Scope to scope your model.
-  module AuthenticatesMany
-    module Base
-      # Allows you set essentially set up a relationship with your sessions. See module
-      # definition above for more details.
-      #
-      # === Options
-      #
-      # * <tt>session_class:</tt> default: "#{name}Session",
-      #   This is the related session class.
-      #
-      # * <tt>relationship_name:</tt> default: options[:session_class].klass_name.underscore.pluralize,
-      #   This is the name of the relationship you want to use to scope everything. For
-      #   example an Account has many Users. There should be a relationship called :users
-      #   that you defined with a has_many. The reason we use the relationship is so you
-      #   don't have to repeat yourself. The relationship could have all kinds of custom
-      #   options. So instead of repeating yourself we essentially use the scope that the
-      #   relationship creates.
-      #
-      # * <tt>find_options:</tt> default: nil,
-      #   By default the find options are created from the relationship you specify with
-      #   :relationship_name. But if you want to override this and manually specify
-      #   find_options you can do it here. Specify options just as you would in
-      #   ActiveRecord::Base.find.
-      #
-      # * <tt>scope_cookies:</tt> default: false
-      #   By the nature of cookies they scope themselves if you are using subdomains to
-      #   access accounts. If you aren't using subdomains you need to have separate
-      #   cookies for each account, assuming a user is logging into more than one account.
-      #   Authlogic can take care of this for you by prefixing the name of the cookie and
-      #   session with the model id. Because it affects both cookies names and session keys,
-      #   the name `scope_cookies` is misleading. Perhaps simply `scope` or `scoped`
-      #   would have been better.
-      def authenticates_many(name, options = {})
-        options[:session_class] ||= name.to_s.classify.constantize
-        options[:relationship_name] ||= options[:session_class].klass_name.underscore.pluralize
-        class_eval <<-"end_eval", __FILE__, __LINE__
-          def #{name}
-            find_options = #{options[:find_options].inspect} || #{options[:relationship_name]}.where(nil)
-            @#{name} ||= Authlogic::AuthenticatesMany::Association.new(#{options[:session_class]}, find_options, #{options[:scope_cookies] ? "self.class.model_name.name.underscore + '_' + self.send(self.class.primary_key).to_s" : "nil"})
-          end
-        end_eval
-      end
-    end
-
-    ::ActiveRecord::Base.extend(Base) if defined?(::ActiveRecord)
-  end
-end

data/lib/authlogic/crypto_providers/aes256.rb

@@ -1,66 +0,0 @@
-require "openssl"
-
-module Authlogic
-  module CryptoProviders
-    # This encryption method is reversible if you have the supplied key. So in order to
-    # use this encryption method you must supply it with a key first. In an initializer,
-    # or before your application initializes, you should do the following:
-    #
-    #   Authlogic::CryptoProviders::AES256.key = "my really long and unique key, preferably a bunch of random characters"
-    #
-    # My final comment is that this is a strong encryption method, but its main weakness
-    # is that it's reversible. If you do not need to reverse the hash then you should
-    # consider Sha512 or BCrypt instead.
-    #
-    # Keep your key in a safe place, some even say the key should be stored on a separate
-    # server. This won't hurt performance because the only time it will try and access the
-    # key on the separate server is during initialization, which only happens once. The
-    # reasoning behind this is if someone does compromise your server they won't have the
-    # key also. Basically, you don't want to store the key with the lock.
-    class AES256
-      class << self
-        attr_writer :key
-
-        def encrypt(*tokens)
-          aes.encrypt
-          aes.key = @key
-          [aes.update(tokens.join) + aes.final].pack("m").chomp
-        end
-
-        def matches?(crypted, *tokens)
-          aes.decrypt
-          aes.key = @key
-          (aes.update(crypted.unpack("m").first) + aes.final) == tokens.join
-        rescue OpenSSL::CipherError
-          false
-        end
-
-        private
-
-          def aes
-            if @key.blank?
-              raise ArgumentError.new(
-                "You must provide a key like #{name}.key = my_key before using the #{name}"
-              )
-            end
-
-            @aes ||= openssl_cipher_class.new("AES-256-ECB")
-          end
-
-          # `::OpenSSL::Cipher::Cipher` has been deprecated since at least 2014,
-          # in favor of `::OpenSSL::Cipher`, but a deprecation warning was not
-          # printed until 2016
-          # (https://github.com/ruby/openssl/commit/5c20a4c014) when openssl
-          # became a gem. Its first release as a gem was 2.0.0, in ruby 2.4.
-          # (See https://github.com/ruby/ruby/blob/v2_4_0/NEWS)
-          def openssl_cipher_class
-            if ::Gem::Version.new(::OpenSSL::VERSION) < ::Gem::Version.new("2.0.0")
-              ::OpenSSL::Cipher::Cipher
-            else
-              ::OpenSSL::Cipher
-            end
-          end
-      end
-    end
-  end
-end

data/lib/authlogic/crypto_providers/wordpress.rb

@@ -1,43 +0,0 @@
-require 'digest/md5'
-module Authlogic
-  module CryptoProviders
-    class Wordpress
-      class << self
-        ITOA64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
-
-        def matches?(crypted, *tokens)
-          stretches = 1 << ITOA64.index(crypted[3, 1])
-          plain, salt = *tokens
-          hashed = Digest::MD5.digest(salt + plain)
-          stretches.times do |i|
-            hashed = Digest::MD5.digest(hashed + plain)
-          end
-          crypted[0, 12] + encode_64(hashed, 16) == crypted
-        end
-
-        def encode_64(input, length)
-          output = ""
-          i = 0
-          while i < length
-            value = input[i]
-            i += 1
-            break if value.nil?
-            output += ITOA64[value & 0x3f, 1]
-            value |= input[i] << 8 if i < length
-            output += ITOA64[(value >> 6) & 0x3f, 1]
-
-            i += 1
-            break if i >= length
-            value |= input[i] << 16 if i < length
-            output += ITOA64[(value >> 12) & 0x3f, 1]
-
-            i += 1
-            break if i >= length
-            output += ITOA64[(value >> 18) & 0x3f, 1]
-          end
-          output
-        end
-      end
-    end
-  end
-end