ruby on rails साइन इन करने का प्रयास करते समय "BCrypt:: त्रुटियां:: अवैध हैश"




ruby-on-rails heroku (2)

मेरे पास पहले से ही लाइव उपयोगकर्ता थे, और इसी तरह डेटाबेस में अनएन्क्रिप्टेड पासवर्ड सहेजे गए हैं। एक बार जब मैंने bcrypt का उपयोग करना शुरू किया, तो यह एक एन्क्रिप्टेड पासवर्ड की उम्मीद कर रहा था, और जब इसे नहीं मिला, तो उसने यह त्रुटि उत्पन्न की।

इसलिए, मैंने त्रुटि को पकड़ने के लिए यह बचाव जोड़ा और विरासत उपयोगकर्ताओं को अपना पासवर्ड रीसेट करने के लिए प्रेरित किया:

begin
    # your code that attempts to login the user
rescue BCrypt::Errors::InvalidHash
  flash[:error] = 'We recently adjusted the way our passwords are stored. Please click the "forgot username or password?" link to re-establish your password. Thank you for your understanding!'
  redirect_to password_resets_url
end 

उम्मीद है की यह मदद करेगा।

मैं एक परियोजना खत्म करने की कोशिश कर रहा हूँ। मैं उपयोगकर्ता मॉडल के साथ काम कर रहा हूँ। जब मैं साइन अप करता हूं तो सबकुछ ठीक लगता है। लेकिन जब मैं एक ही सदस्य को साइन इन करने का प्रयास करता हूं तो मुझे यह त्रुटि मिलती है।

हमें खेद है, लेकिन कुछ गलत हो गया। heroku लॉग फ़ाइल त्रुटि के रूप में दिखाता है:

BCrypt::Errors::InvalidHash (invalid hash):
  app/controllers/sessions_controller.rb:8:in `create'

मेरा * session_controller * है:

class SessionsController < ApplicationController

  def new
  end

   def create
    user = User.find_by_email(params[:session][:email])
    if user && user.authenticate(params[:session][:password])
      sign_in user
      redirect_to user
    else
      flash.now[:error] = 'Invalid email/password combination'
      render 'new'
    end
  end


  def destroy
    sign_out
    redirect_to root_path
  end
end

और उपयोगकर्ता मॉडल है:

class User < ActiveRecord::Base
  attr_accessible :email, :name, :nickname,:password, :password_confirmation 
  has_secure_password


  before_save { |user| user.email = email.downcase }
  before_save { |user| user.nickname = nickname.downcase }
  before_save :create_remember_token
....validations......

    private

    def create_remember_token
      self.remember_token = SecureRandom.urlsafe_base64
    end
end 

यह मेरा सत्र है। हेल्पर

module SessionsHelper

  def sign_in(user)
    cookies.permanent[:remember_token] = user.remember_token
    self.current_user = user
  end
  def signed_in?
    !current_user.nil?
  end

  def current_user=(user)
    @current_user = user
  end

  def current_user
    @current_user ||= User.find_by_remember_token(cookies[:remember_token])
  end

  def sign_out
    self.current_user = nil
    cookies.delete(:remember_token)
  end
end

मैंने heroku रेक डीबी की कोशिश की: माइग्रेट, heroku पुनरारंभ .. कोई बदलाव नहीं है।


इसका मतलब है कि हैश पासवर्ड_डिजिस्ट में संग्रहीत है वैध बीसीआरप्ट हैश (जिसमें क्षेत्र खाली है) शामिल नहीं है।

टिप्पणियों के आधार पर, ऐसा लगता है कि आपने अभी उपयोगकर्ता को बनाया है, has_secure_password वहां नहीं था, इसलिए पासवर्ड पाचन कभी संग्रहित नहीं हुआ। डेटाबेस में देखें, आप शायद देखेंगे कि उस उपयोगकर्ता के लिए password_digest खाली है। उपयोगकर्ता को डेटाबेस से हटाएं और अपने नए कामकाजी कोड के साथ फिर से बनाएं और इसे काम करना चाहिए।

हालांकि टिप्पणियों में चर्चा करते हुए, मैंने एक गलत (गलत) अनुमान लगाया कि पासवर्ड गलत क्यों होंगे, और मैंने पहले ही स्पष्टीकरण लिखा है। तो यहां यह किसी भी भविष्य के आगंतुक के लिए है, जिसमें यह समस्या है, भले ही यह सीधे यहां लागू न हो:

यह आमतौर पर तब होता है जब आप बीएचआरपीटी में SHA1 या किसी अन्य एल्गोरिदम का उपयोग करने से स्विच करते हैं लेकिन बीसीआरपीटी में पासवर्ड को पुनः-हैश करने में विफल रहते हैं। चूंकि आपके पास मूल पासवर्ड तक पहुंच नहीं है (या कम से कम आपको नहीं चाहिए ...), यह स्विच करने के लिए थोड़ा बदसूरत है क्योंकि आपको बीसीआरपीटी और मूल प्रमाणीकरण योजना दोनों का उपयोग करना होगा। उदाहरण के लिए, यदि आप पहले बीएचआरपीटी का उपयोग करते हुए SHA1 का उपयोग कर रहे थे, तो आपको बीएचआरईपी इनपुट के लिए सादा टेक्स्ट पासवर्ड के रूप में SHA1 पासवर्ड हैश का इलाज करना होगा। उदाहरण के लिए, आप इस तरह एक बीसीक्रिप्ट पाचन बना सकते हैं:

sha1_password = Digest::SHA1.hexdigest("#{salt}#{real_password}")
self.password_digest = BCrypt::Password.create(sha1_password).to_s

फिर, आप sha1 पासवर्ड हैंश पर आधारित bcrypt password_digests बना सकते हैं जिनके पास आपके पास पहुंच है।

आप इस तरह प्रमाणित करेंगे:

sha1_password = Digest::SHA1.hexdigest("#{salt}#{attempted_password}")
BCrypt::Password.new(self.password_digest) == sha1_password

मैंने उपरोक्त उदाहरणों में SHA1 का उपयोग किया, लेकिन यह अन्य हैशिंग एल्गोरिदम के लिए भी काम करेगा।







bcrypt