Najlepszy sposób na stworzenie unikalnego tokena w Railsach?

Oto, czego używam. Token niekoniecznie musi zostać usłyszany, aby odgadnąć, bardziej przypomina krótki identyfikator adresu URL niż cokolwiek innego i chcę, aby był krótki. I już po kilka przykładów znalazłem w Internecie oraz w razie kolizji, myślę, że kod poniżej będzie odtworzyć token, ale nie jestem pewien rzeczywistym. Jestem jednak ciekawy, aby zobaczyć lepsze sugestie, ponieważ wydaje się to trochę szorstkie na krawędziach.

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

Moja kolumna bazy danych dla tokena to unikalny indeks i używam go również validates_uniqueness_of :tokenna modelu, ale ponieważ są one tworzone automatycznie partiami na podstawie działań użytkownika w aplikacji (zasadniczo składają zamówienie i kupują tokeny), nie jest możliwe, aby aplikacja zgłosiła błąd.

Mógłbym też, jak sądzę, zmniejszyć ryzyko kolizji, dołączyć na końcu kolejny ciąg, coś wygenerowanego na podstawie czasu lub coś w tym rodzaju, ale nie chcę, aby token był zbyt długi.

-- Aktualizacja --

Od 9 stycznia 2015r. Rozwiązanie jest teraz zaimplementowane w bezpiecznej implementacji tokena Rails 5 ActiveRecord .

- Szyny 4 i 3 -

Tylko dla przyszłego odniesienia, tworząc bezpieczny losowy token i zapewniając jego unikalność dla modelu (przy użyciu Ruby 1.9 i 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

Edytować:

@kain zasugerował, i zgodziłem się, aby wymienić begin...end..whilez loop do...break unless...endtą odpowiedzią, ponieważ poprzednia realizacja może zostaną usunięte w przyszłości.

Edycja 2:

W przypadku Rails 4 i obaw, polecałbym przenieść to na problem.

# 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 używa niezłego fragmentu kodu w swoim Railscast na zaproszeniach do bety . Daje to 40-znakowy ciąg alfanumeryczny.

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

Może to być późna odpowiedź, ale aby uniknąć używania pętli, możesz również wywołać metodę rekurencyjnie. Wygląda i wydaje mi się nieco czystszy.

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

W tym artykule przedstawiono kilka całkiem sprytnych sposobów:

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

Moja ulubiona lista to:

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

Jeśli chcesz czegoś, co będzie wyjątkowe, możesz użyć czegoś takiego:

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

jednakże spowoduje to wygenerowanie ciągu 32 znaków.

Jest jednak inny sposób:

require 'base64'

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

na przykład dla id, takiego jak 10000, wygenerowany token miałby postać „MTAwMDA =” (i można go łatwo zdekodować dla identyfikatora, wystarczy

Base64::decode64(string)

Może to być pomocne:

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

Jeśli chcesz usunąć dowolny znak specjalny niż umieszczony w pierwszym argumencie „+ / =”, a dowolny znak umieszczony w drugim argumencie „0aZ” i 15 to długość tutaj.

A jeśli chcesz usunąć dodatkowe spacje i znak nowego wiersza, dodaj następujące rzeczy:

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

Mam nadzieję, że to pomoże każdemu.

możesz user has_secure_token https://github.com/robertomiranda/has_secure_token

jest naprawdę prosty w użyciu

class User
  has_secure_token :token1, :token2
end

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

Spróbuj w ten sposób:

Od Ruby 1.9 generowanie uuid jest wbudowane. Użyj SecureRandom.uuidfunkcji.
Generowanie przewodników w Rubim

To było dla mnie pomocne

Aby utworzyć poprawny identyfikator GUID mysql, varchar 32

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

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

Myślę, że token powinien być traktowany tak jak hasło. Jako takie powinny być zaszyfrowane w DB.

Robię coś takiego, aby wygenerować unikalny nowy token dla modelu:

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