Ruby On Rails API: Authentication
This tutorial demonstrates how to add authorization to a Ruby on Rails API. We recommend that you log in to follow this quickstart with examples configured for your account.
I want to integrate with my app
15 minutesI want to explore a sample app
2 minutesGet a sample configured with your account settings or check it out on Github.
Configure Auth0 APIs
Create an API
In the APIs section of the Auth0 dashboard, click Create API. Provide a name and an identifier for your API, for example, https://quickstarts/api
. You will use the identifier as an audience
later, when you are configuring the Access Token verification. Leave the Signing Algorithm as RS256.
By default, your API uses RS256 as the algorithm for signing tokens. Since RS256 uses a private/public keypair, it verifies the tokens against the public key for your Auth0 account. The public key is in the JSON Web Key Set (JWKS) format, and can be accessed here.
Define permissions
Permissions let you define how resources can be accessed on behalf of the user with a given access token. For example, you might choose to grant read access to the messages
resource if users have the manager access level, and a write access to that resource if they have the administrator access level.
You can define allowed permissions in the Permissions tab of the Auth0 Dashboard's APIs section.
This example demonstrates:
-
How to check for a JSON Web Token (JWT) in the
Authorization
header of an incoming HTTP request. -
How to check if the token is valid, using the JSON Web Key Set (JWKS) for your Auth0 account. To learn more about validating Access Tokens, see Validate Access Tokens.
Validate Access Tokens
Install dependencies
This tutorial performs Access Token validation using the jwt Gem within a custom JsonWebToken
class. A Concern called Secured
is used to mark endpoints which require authentication through an incoming Access Token.
Install the jwt Gem.
gem 'jwt'
bundle install
Create a JsonWebToken class
Create a class called JsonWebToken
which decodes and verifies the incoming Access Token taken from the Authorization
header of the request. The public key for your Auth0 tenant can be fetched to verify the token.
# lib/json_web_token.rb
# frozen_string_literal: true
require 'net/http'
require 'uri'
class JsonWebToken
def self.verify(token)
JWT.decode(token, nil,
true, # Verify the signature of this token
algorithms: 'RS256',
iss: 'https://YOUR_DOMAIN/',
verify_iss: true,
aud: Rails.application.secrets.auth0_api_audience,
verify_aud: true) do |header|
jwks_hash[header['kid']]
end
end
def self.jwks_hash
jwks_raw = Net::HTTP.get URI("https://YOUR_DOMAIN/.well-known/jwks.json")
jwks_keys = Array(JSON.parse(jwks_raw)['keys'])
Hash[
jwks_keys
.map do |k|
[
k['kid'],
OpenSSL::X509::Certificate.new(
Base64.decode64(k['x5c'].first)
).public_key
]
end
]
end
end
Define a Secured concern
Create a Concern called Secured
which looks for the Access Token in the Authorization
header of an incoming request. If the token is present, it should be passed to JsonWebToken.verify
.
# app/controllers/concerns/secured.rb
# frozen_string_literal: true
module Secured
extend ActiveSupport::Concern
included do
before_action :authenticate_request!
end
private
def authenticate_request!
auth_token
rescue JWT::VerificationError, JWT::DecodeError
render json: { errors: ['Not Authenticated'] }, status: :unauthorized
end
def http_token
if request.headers['Authorization'].present?
request.headers['Authorization'].split(' ').last
end
end
def auth_token
JsonWebToken.verify(http_token)
end
end
Validate scopes
The JsonWebToken.verify
method above verifies that the Access Token included in the request is valid; however, it doesn't yet include any mechanism for checking that the token has the sufficient scope to access the requested resources.
To look for a particular scope
in an Access Token, provide an array of required scopes and check if they are present in the payload of the token.
In this example we define an SCOPES
array for all protected routes, specifying the required scopes for each one. For the /private-scoped
route, the scopes defined will be intersected with the scopes coming in the payload, to determine if it contains one or more items from the other array.
# app/controllers/concerns/secured.rb
SCOPES = {
'/private' => nil,
'/private-scoped' => ['read:messages']
}
private
def authenticate_request!
@auth_payload, @auth_header = auth_token
render json: { errors: ['Insufficient scope'] }, status: :unauthorized unless scope_included
rescue JWT::VerificationError, JWT::DecodeError
render json: { errors: ['Not Authenticated'] }, status: :unauthorized
end
def scope_included
if SCOPES[request.env['PATH_INFO']] == nil
true
else
# The intersection of the scopes included in the given JWT and the ones in the SCOPES hash needed to access
# the PATH_INFO, should contain at least one element
(String(@auth_payload['scope']).split(' ') & (SCOPES[request.env['PATH_INFO']])).any?
end
end
Protect API Endpoints
The routes shown below are available for the following requests:
GET /api/public
: available for non-authenticated requestsGET /api/private
: available for authenticated requests containing an Access Token with no additional scopesGET /api/private-scoped
: available for authenticated requests containing an Access Token with theread:messages
scope granted
The /public
endpoint does not require to use the Secured
concern.
# app/controllers/public_controller.rb
# frozen_string_literal: true
class PublicController < ActionController::API
# This route doesn't need authentication
def public
render json: { message: "Hello from a public endpoint! You don't need to be authenticated to see this." }
end
end
The protected endpoints need to include the Secured
concern. The scopes required for each one are defined in the code of the Secured
concern.
# app/controllers/private_controller.rb
# frozen_string_literal: true
class PrivateController < ActionController::API
include Secured
def private
render json: 'Hello from a private endpoint! You need to be authenticated to see this.'
end
def private_scoped
render json: { message: 'Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this.' }
end
end