Strategie uwierzytelniania i autoryzacji
Zabezpieczy Pan/Pani punkty końcowe API za pomocą popularnych metod uwierzytelniania, takich jak JWT, oraz zaimplementuje reguły autoryzacji.
Strategie uwierzytelniania i autoryzacji to bezpłatna lekcja Elixir & Phoenix: Scalable Backend Development na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Elixir & Phoenix: Scalable Backend Development, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Elixir & Phoenix: Scalable Backend Development zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
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!
Często zadawane pytania
Czy lekcja „Strategie uwierzytelniania i autoryzacji” jest bezpłatna?
Tak — pełny tekst „Strategie uwierzytelniania i autoryzacji” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Elixir & Phoenix: Scalable Backend Development, przejdź na CoddyKit PRO. Kurs Elixir & Phoenix: Scalable Backend Development zawiera 4 lekcji w sumie.
Co nauczysz się w „Strategie uwierzytelniania i autoryzacji”?
Zabezpieczy Pan/Pani punkty końcowe API za pomocą popularnych metod uwierzytelniania, takich jak JWT, oraz zaimplementuje reguły autoryzacji. Ćwiczysz Elixir & Phoenix: Scalable Backend Development z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Elixir & Phoenix: Scalable Backend Development?
Nie wymagamy żadnego doświadczenia. Elixir & Phoenix: Scalable Backend Development w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.
Ile czasu zajmuje lekcja „Strategie uwierzytelniania i autoryzacji”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Elixir & Phoenix: Scalable Backend Development?
Tak. Każda lekcja Elixir & Phoenix: Scalable Backend Development zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Zasady projektowania API i najlepsze praktyki
- Implementowanie punktów końcowych API i serializacja
- Strategie uwierzytelniania i autoryzacji
- Paginacja, filtrowanie i wersjonowanie API