Der beste Weg, um ein einzigartiges Token in Rails zu erstellen?

Hier ist was ich benutze. Das Token muss nicht unbedingt gehört werden, um es zu erraten. Es ist eher eine kurze URL-Kennung als alles andere, und ich möchte es kurz halten. Ich habe einige Beispiele befolgt, die ich online gefunden habe, und im Falle einer Kollision denke ich, dass der folgende Code das Token neu erstellt, bin mir aber nicht sicher. Ich bin jedoch gespannt auf bessere Vorschläge, da sich dies an den Rändern etwas rau anfühlt.

def self.create_token
    random_number = SecureRandom.hex(3)
    "1X#{random_number}"

    while Tracker.find_by_token("1X#{random_number}") != nil
      random_number = SecureRandom.hex(3)
      "1X#{random_number}"
    end
    "1X#{random_number}"
  end

Meine Datenbankspalte für das Token ist ein eindeutiger Index, den ich auch validates_uniqueness_of :tokenfür das Modell verwende. Da diese jedoch in Stapeln automatisch basierend auf den Aktionen eines Benutzers in der App erstellt werden (sie geben eine Bestellung auf und kaufen die Token im Wesentlichen), ist dies der Fall Es ist nicht möglich, dass die App einen Fehler auslöst.

Ich könnte auch die Wahrscheinlichkeit von Kollisionen verringern, am Ende eine weitere Zeichenfolge anhängen, etwas, das basierend auf der Zeit oder ähnlichem generiert wird, aber ich möchte nicht, dass das Token zu lang wird.

- Update -

Ab dem 9. Januar 2015. Die Lösung ist jetzt in der sicheren Token-Implementierung von Rails 5 ActiveRecord implementiert .

- Schienen 4 & 3 -

Nur zum späteren Nachschlagen, Erstellen eines sicheren zufälligen Tokens und Sicherstellen, dass es für das Modell eindeutig ist (bei Verwendung von Ruby 1.9 und ActiveRecord):

class ModelName < ActiveRecord::Base

  before_create :generate_token

  protected

  def generate_token
    self.token = loop do
      random_token = SecureRandom.urlsafe_base64(nil, false)
      break random_token unless ModelName.exists?(token: random_token)
    end
  end

end

Bearbeiten:

@kain vorgeschlagen, und ich stimmte zu ersetzen , begin...end..whilemit loop do...break unless...endin dieser Antwort , weil frühere Umsetzung könnte in der Zukunft entfernt bekommen.

Bearbeiten 2:

Bei Rails 4 und Bedenken würde ich empfehlen, dies auf Bedenken zu verschieben.

# app/models/model_name.rb
class ModelName < ActiveRecord::Base
  include Tokenable
end

# app/models/concerns/tokenable.rb
module Tokenable
  extend ActiveSupport::Concern

  included do
    before_create :generate_token
  end

  protected

  def generate_token
    self.token = loop do
      random_token = SecureRandom.urlsafe_base64(nil, false)
      break random_token unless self.class.exists?(token: random_token)
    end
  end
end

Ryan Bates verwendet in seinem Railscast auf Beta-Einladungen ein schönes Stück Code . Dies erzeugt eine alphanumerische Zeichenfolge mit 40 Zeichen.

Digest::SHA1.hexdigest([Time.now, rand].join)

Dies kann eine späte Antwort sein, aber um die Verwendung einer Schleife zu vermeiden, können Sie die Methode auch rekursiv aufrufen. Es sieht und fühlt sich für mich etwas sauberer an.

class ModelName < ActiveRecord::Base

  before_create :generate_token

  protected

  def generate_token
    self.token = SecureRandom.urlsafe_base64
    generate_token if ModelName.exists?(token: self.token)
  end

end

In diesem Artikel werden einige ziemlich raffinierte Methoden gezeigt:

https://web.archive.org/web/20121026000606/http://blog.logeek.fr/2009/7/2/creating-small-unique-tokens-in-ruby

Mein Favorit ist folgender:

rand(36**8).to_s(36)
=> "uur0cj2h"

Wenn Sie etwas Einzigartiges wollen, können Sie Folgendes verwenden:

string = (Digest::MD5.hexdigest "#{ActiveSupport::SecureRandom.hex(10)}-#{DateTime.now.to_s}")

Dadurch wird jedoch eine Zeichenfolge mit 32 Zeichen generiert.

Es gibt jedoch einen anderen Weg:

require 'base64'

def after_create
update_attributes!(:token => Base64::encode64(id.to_s))
end

Beispiel: Für eine ID wie 10000 wäre das generierte Token "MTAwMDA =" (und Sie können es einfach für eine ID dekodieren, machen Sie es einfach

Base64::decode64(string)

Dies kann hilfreich sein:

SecureRandom.base64(15).tr('+/=', '0aZ')

Wenn Sie ein Sonderzeichen entfernen möchten, als das erste Argument '+ / =' und jedes Zeichen, das in das zweite Argument '0aZ' und 15 eingegeben wurde, ist die Länge hier.

Und wenn Sie die zusätzlichen Leerzeichen und das neue Linienzeichen entfernen möchten, fügen Sie Folgendes hinzu:

SecureRandom.base64(15).tr('+/=', '0aZ').strip.delete("\n")

Hoffe das wird jedem helfen.

Sie können has_secure_token https://github.com/robertomiranda/has_secure_token verwenden

ist wirklich einfach zu bedienen

class User
  has_secure_token :token1, :token2
end

user = User.create
user.token1 => "44539a6a59835a4ee9d7b112b48cd76e"
user.token2 => "226dd46af6be78953bde1641622497a8"

Versuchen Sie Folgendes:

Ab Ruby 1.9 ist die UUID-Generierung integriert. Verwenden Sie die SecureRandom.uuidFunktion.
Generieren von Guids in Ruby

Das war hilfreich für mich

Um eine richtige, mysql, varchar 32 GUID zu erstellen

SecureRandom.uuid.gsub('-','').upcase

def generate_token
    self.token = Digest::SHA1.hexdigest("--#{ BCrypt::Engine.generate_salt }--")
end

Ich denke, Token sollte genauso behandelt werden wie ein Passwort. Als solche sollten sie in DB verschlüsselt werden.

Ich mache so etwas, um ein einzigartiges neues Token für ein Modell zu generieren:

key = ActiveSupport::KeyGenerator
                .new(Devise.secret_key)
                .generate_key("put some random or the name of the key")

loop do
  raw = SecureRandom.urlsafe_base64(nil, false)
  enc = OpenSSL::HMAC.hexdigest('SHA256', key, raw)

  break [raw, enc] unless Model.exist?(token: enc)
end