Authentication and Authorization Strategies
Secure your API endpoints using common authentication methods like JWT and implement authorization rules.
Authentication and Authorization Strategies is a free Elixir & Phoenix: Scalable Backend Development lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Elixir & Phoenix: Scalable Backend Development learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Securing Your API Endpoints
When building APIs with Phoenix, securing your endpoints is paramount. This ensures only authorized users can access specific resources and perform actions.
We'll explore two key aspects: Authentication (proving who you are) and Authorization (determining what you can do).
What is Authentication?
Authentication is the process of verifying a user's identity. It's how your API confirms that the person or application making a request is who they claim to be.
- Common methods include username/password, API keys, or tokens.
- Once authenticated, the user's identity is known to the system.
Token-Based Authentication
For APIs, sending username/password with every request is inefficient and insecure. Token-based authentication is a popular solution.
After initial login, the server issues a unique token. The client then sends this token with subsequent requests to prove its identity, without re-sending credentials.
JSON Web Tokens (JWT)
JSON Web Tokens (JWTs) are a common type of token. They are compact, URL-safe means of representing claims to be transferred between two parties.
A JWT is essentially a string with three parts, separated by dots:
- Header: Describes the token type and signing algorithm.
- Payload: Contains the 'claims' (user data, roles, expiration).
- Signature: Verifies the token's integrity and authenticity.
JWT Header and Payload
Both the Header and Payload are JSON objects, Base64Url-encoded. This encoding makes them safe for URL transmission, but it's not encryption – anyone can read them.
Let's see how to encode a simple Header and Payload in Elixir:
alias Jason
alias Base
defmodule JWTExample do
def encode_part(data) do
data
|> Jason.encode!()
|> Base.url_encode64(padding: false)
end
def main do
header = %{"alg" => "HS256", "typ" => "JWT"}
payload = %{"user_id" => 123, "role" => "admin"}
encoded_header = encode_part(header)
encoded_payload = encode_part(payload)
IO.puts "Encoded Header: " <> encoded_header
IO.puts "Encoded Payload: " <> encoded_payload
end
end
JWTExample.main()JWT Signature Explained
The Signature is crucial for security. It's created by taking the encoded Header, the encoded Payload, a secret key, and the algorithm specified in the header, then cryptographically signing them.
This signature ensures the token hasn't been tampered with. If someone changes the header or payload, the signature verification will fail.
Creating & Verifying a JWT
Here's a full Elixir example demonstrating how to combine the parts to create a simple JWT and then verify its integrity. We'll use a secret key for signing.
Notice how `Base.url_decode64` and `:crypto.mac` are used to simulate JWT logic.
alias Jason
alias Base
defmodule JWTService do
@secret_key "my_super_secret_key_123"
def create_token(payload) do
header = %{"alg" => "HS256", "typ" => "JWT"}
encoded_header = encode_part(header)
encoded_payload = encode_part(payload)
signature = sign(encoded_header, encoded_payload)
"#{encoded_header}.#{encoded_payload}.#{signature}"
end
def verify_token(token) do
[encoded_header, encoded_payload, signature] = String.split(token, ".")
expected_signature = sign(encoded_header, encoded_payload)
if signature == expected_signature do
decoded_payload = encoded_payload |> Base.url_decode64!() |> Jason.decode!()
{:ok, decoded_payload}
else
{:error, "Invalid signature"}
end
end
defp encode_part(data) do
data
|> Jason.encode!()
|> Base.url_encode64(padding: false)
end
defp sign(encoded_header, encoded_payload) do
data_to_sign = "#{encoded_header}.#{encoded_payload}"
:crypto.mac(:hmac, :sha256, @secret_key, data_to_sign)
|> Base.url_encode64(padding: false)
end
def main do
payload = %{"user_id" => 456, "role" => "editor", "exp" => 1678886400}
token = create_token(payload)
IO.puts "Generated Token: " <> token
case verify_token(token) do
{:ok, data} -> IO.puts "Verified! Payload: " <> inspect(data)
{:error, reason} -> IO.puts "Verification Failed: " <> reason
end
# Simulate tampering
tampered_payload = %{"user_id" => 456, "role" => "admin", "exp" => 1678886400}
tampered_token = create_token(tampered_payload)
[h, _p, s] = String.split(tampered_token, ".")
# Replace the payload but keep original signature
tampered_token_str = "#{h}." <> (payload |> Jason.encode!() |> Base.url_encode64(padding: false)) <> ".#{s}"
IO.puts "\nTampered Token: " <> tampered_token_str
case verify_token(tampered_token_str) do
{:ok, data} -> IO.puts "Verified (unexpectedly)! Payload: " <> inspect(data)
{:error, reason} -> IO.puts "Tampering Detected: " <> reason
end
end
end
JWTService.main()What is Authorization?
Once a user is authenticated (we know who they are), Authorization determines what actions they are allowed to perform and what resources they can access.
It's about permissions. For example, an 'admin' user might be able to delete posts, while a 'guest' user can only view them.
Role-Based Access Control (RBAC)
A common authorization strategy is Role-Based Access Control (RBAC).
- Users are assigned one or more roles (e.g., 'admin', 'editor', 'viewer').
- Each role has a predefined set of permissions (e.g., 'create_post', 'edit_own_post', 'delete_any_post').
- When a request comes in, the system checks if the authenticated user's role has the necessary permission for the requested action.
Authorization with Phoenix Plugs
In Phoenix, Plugs are an excellent way to implement authorization logic. A Plug is a modular function that processes requests.
You can create a Plug that checks the user's role (often extracted from a JWT payload) before allowing access to a controller action or an entire scope of routes.
For example, a `RequireAdminPlug` would halt the request if the user's role isn't 'admin'.
JWT & Authz Check
Which of the following statements about JWTs and API security are TRUE?
Summary: Secure Your APIs
You've learned the fundamentals of securing API endpoints!
- Authentication confirms identity, often using tokens like JWTs.
- JWTs consist of an encoded Header, Payload, and a cryptographic Signature for integrity.
- Authorization defines what an authenticated user can do, commonly managed with Role-Based Access Control (RBAC).
- Phoenix Plugs are ideal for implementing authorization checks in your API routes.
Keep exploring security best practices to build robust and safe applications!
Frequently asked questions
Is the “Authentication and Authorization Strategies” lesson free?
Yes — the full text of “Authentication and Authorization Strategies” is free to read here on the web, and the Elixir & Phoenix: Scalable Backend Development course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Elixir & Phoenix: Scalable Backend Development course, upgrade to CoddyKit PRO.
What will I learn in “Authentication and Authorization Strategies”?
Secure your API endpoints using common authentication methods like JWT and implement authorization rules. You practise Elixir & Phoenix: Scalable Backend Development with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start Elixir & Phoenix: Scalable Backend Development?
No prior experience is required. Elixir & Phoenix: Scalable Backend Development on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Authentication and Authorization Strategies” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this Elixir & Phoenix: Scalable Backend Development lesson?
Yes. Every Elixir & Phoenix: Scalable Backend Development lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- API Design Principles and Best Practices
- Implementing API Endpoints and Serialization
- Authentication and Authorization Strategies
- Pagination, Filtering & API Versioning