¿La mejor manera de crear tokens únicos en Rails?

Esto es lo que estoy usando. El token no necesariamente tiene que ser escuchado para adivinar, es más como un identificador de URL corto que cualquier otra cosa, y quiero que sea breve. He seguido algunos ejemplos que he encontrado en línea y, en caso de colisión, creo que el siguiente código recreará el token, pero no estoy muy seguro. Sin embargo, tengo curiosidad por ver mejores sugerencias, ya que esto se siente un poco áspero por los bordes.

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

La columna de mi base de datos para el token es un índice único y también lo estoy usando validates_uniqueness_of :tokenen el modelo, pero debido a que estos se crean en lotes automáticamente en función de las acciones del usuario en la aplicación (hacen un pedido y compran los tokens, esencialmente), es no es factible que la aplicación arroje un error.

Supongo que también podría reducir la posibilidad de colisiones, agregar otra cadena al final, algo generado en función del tiempo o algo así, pero no quiero que el token se alargue demasiado.

- Actualización -

A partir del 9 de enero de 2015. la solución ahora está implementada en la implementación segura de tokens de ActiveRecord de Rails 5 .

- Rieles 4 y 3 -

Solo para referencia futura, creando un token aleatorio seguro y asegurando que sea único para el modelo (cuando se usa Ruby 1.9 y 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

Editar:

@kain sugirió, y yo estaba de acuerdo, para reemplazar begin...end..whilecon loop do...break unless...enden esta respuesta porque la aplicación anterior podría obtener eliminado en el futuro.

Edición 2:

Con Rails 4 y preocupaciones, recomendaría mover esto a preocupación.

# 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 usa un poco de código en sus invitaciones de Railscast en beta . Esto produce una cadena alfanumérica de 40 caracteres.

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

Esto podría ser una respuesta tardía, pero para evitar el uso de un bucle, también puede llamar al método de forma recursiva. Se ve y se siente un poco más limpio para mí.

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

Hay algunas formas bastante ingeniosas de hacer esto demostradas en este artículo:

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

Mi lista favorita es esta:

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

Si quieres algo que sea único, puedes usar algo como esto:

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

sin embargo, esto generará una cadena de 32 caracteres.

Sin embargo, hay otra manera:

require 'base64'

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

por ejemplo, para id como 10000, el token generado sería como "MTAwMDA =" (y puedes decodificarlo fácilmente para id, solo crea

Base64::decode64(string)

Esto puede ser útil:

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

Si desea eliminar cualquier carácter especial que se ponga en el primer argumento '+ / =' y cualquier carácter puesto en el segundo argumento '0aZ' y 15 es la longitud aquí.

Y si desea eliminar los espacios adicionales y el nuevo carácter de línea, agregue cosas como:

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

Espero que esto ayude a cualquiera.

puedes usar has_secure_token https://github.com/robertomiranda/has_secure_token

es realmente simple de usar

class User
  has_secure_token :token1, :token2
end

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

Intenta de esta manera:

A partir de Ruby 1.9, la generación de uuid está integrada. Usa la SecureRandom.uuidfunción.
Generando Guías en Ruby

Esto fue útil para mi

Para crear un GUID apropiado, mysql, varchar 32

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

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

Creo que el token debe manejarse como una contraseña. Como tal, deben estar encriptados en DB.

Estoy haciendo algo como esto para generar un nuevo token único para un modelo:

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