Skip to main content

Insecurely generated token


Secure token generation


  • Usage of Ruby for building dynamic and object-oriented applications
  • Usage of digest for generating and verifying message digests


Non compliant code

require 'digest'

def generate_token(user)
Digest::MD5.hexdigest( +

The above code is an example of an insecurely generated token. Here, we are creating a token for a user using the built-in Digest::MD5 module from Ruby, which is a hashing function. The token is generated by concatenating the user's ID and the current timestamp, and then creating an MD5 hash of this string.

This is insecure because MD5 is a weak hashing algorithm that is vulnerable to collision attacks, where two different inputs produce the same hash. Additionally, the inputs to the hash function (user ID and timestamp) are predictable and could be easily guessed by an attacker.

Furthermore, the code does not incorporate any kind of salt or random value in the token generation process, which would make it much harder for an attacker to guess the token. Because of these issues, an attacker could potentially crack the token's hash and obtain the information it is masking.


  • Use a secure cryptographic algorithm to generate the token.
  • Include a random and unique salt in the token generation process.
  • Use a strong hashing algorithm to hash the token.
  • Consider using a library or framework-provided method for token generation and hashing.
  • Ensure that the token generation process is not predictable or easily guessable.
  • Regularly review and update the token generation mechanism to stay up-to-date with best practices.

Compliant code

require 'securerandom'
require 'digest'

def generate_token(user)
salt = SecureRandom.hex(10)
time_stamp =
Digest::SHA256.hexdigest( + time_stamp + salt)

The updated code uses the SecureRandom library to generate a random salt. This salt is then appended to the user's ID and the current timestamp to create a unique string. This string is then hashed using the SHA256 algorithm, which is a secure cryptographic hash function.

The use of a random salt ensures that even if two users have the same ID and generate a token at the exact same time, their tokens will still be different. This makes it much more difficult for an attacker to guess or predict the token.

The use of SHA256 instead of MD5 for hashing significantly increases the security of the token. MD5 is considered to be a weak hash function due to its vulnerability to collision attacks, where two different inputs produce the same hash. SHA256, on the other hand, is currently considered to be secure against such attacks.

By using a secure random salt and a strong hash function, the token generation process is now much more secure. However, it is still important to regularly review and update this process to ensure that it remains secure as new vulnerabilities and attacks are discovered.