Grundlagen von OAuth2 und JWT

When building applications, especially those with REST APIs, security is paramount. You're exposing data and functionality that needs protection.

Without proper security, your API could be vulnerable to unauthorized access, data breaches, or malicious attacks. This lesson lays the groundwork for understanding how to secure your services.

Before diving in, let's clarify two critical terms:

• Authentication (AuthN): Verifying who a user or client is. Think of it as showing your ID to prove your identity.
• Authorization (AuthZ): Determining what an authenticated user or client is allowed to do. This is like a bouncer checking your ticket to see if you can enter a specific area.

OAuth2 primarily focuses on authorization.

OAuth2 (Open Authorization 2.0) is an industry-standard protocol for authorization. It allows a third-party application (the 'client') to obtain limited access to an HTTP service (the 'resource server') on behalf of a user (the 'resource owner').

Crucially, OAuth2 enables this access without the user having to share their credentials (username and password) directly with the client application.

OAuth2 defines four main roles that interact in the authorization process:

• Resource Owner: The user who owns the protected resources.
• Client: The application requesting access to the resource owner's protected resources.
• Authorization Server: The server that authenticates the resource owner and issues access tokens to the client.
• Resource Server: The server hosting the protected resources, capable of accepting and responding to protected resource requests using access tokens.

OAuth2 uses different 'grant types' (also known as flows) to issue an access token. An access token is a credential that grants the client access to specific resources on the resource server.

The choice of grant type depends on the client's type (e.g., web application, mobile app, server-side application) and its security requirements. The Authorization Code Flow is widely used for traditional web applications.

A JSON Web Token (JWT), pronounced 'jot', is a compact, URL-safe means of representing claims to be transferred between two parties. These claims are pieces of information about an entity (typically, the user) and additional metadata.

JWTs are often used as the format for access tokens in OAuth2, providing a self-contained way to securely transmit information about the user and their permissions.

A JWT consists of three parts, separated by dots (.):

• Header: Contains metadata about the token itself, like the type of token (JWT) and the signing algorithm used (e.g., HMAC SHA256 or RSA).
• Payload: Contains the 'claims' – statements about an entity (like a user) and additional data. Claims can be registered (standardized), public, or private.
• Signature: Used to verify that the sender of the JWT is who it says it is and that the message hasn't been tampered with. It's created using the header, the payload, and a secret key.

Here's what a typical JWT might look like. Each part is Base64Url encoded:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
.
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ
.
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

• The first part is the Header.
• The second part is the Payload.
• The third part is the Signature.

These parts are encoded separately and joined by dots.

The header and payload of a JWT are simply Base64Url encoded JSON. This means anyone can easily decode them to read their contents. The security comes from the signature, which verifies the token's integrity and authenticity.

Try decoding a sample Base64Url string in Java:

JWTs offer several advantages, especially in distributed systems like microservices:

• Statelessness: The server doesn't need to store session information. Each JWT contains all necessary user data.
• Scalability: Since tokens are self-contained, any service can validate them without a central session store, simplifying scaling.
• Compact & URL-Safe: They are small and can be easily transmitted in URL parameters, POST requests, or HTTP headers.
• Self-Contained: They contain all the information about the user, reducing the need for database lookups on every request.

In this lesson, you've gained a foundational understanding of API security principles. We distinguished between Authentication (who you are) and Authorization (what you can do).

You learned about OAuth2 as a standard for secure authorization, allowing controlled access to resources. We also explored JSON Web Tokens (JWTs), understanding their structure and benefits as a compact, self-contained way to transmit information, often used as access tokens within OAuth2.