How to Implement OAuth 2.0 in ASP.NET Core?

OAuth 2.0 is an industry-standard authorization framework that enables secure delegated access to protected resources without exposing user credentials. In ASP.NET Core applications, OAuth 2.0 is commonly used for social login (Google, Microsoft, Facebook), third-party API integration, and securing enterprise-grade Web APIs. Implementing OAuth 2.0 correctly ensures scalable, secure authentication and authorization in distributed systems and cloud-native architectures.

This article explains how to implement OAuth 2.0 in ASP.NET Core, configure external login providers, secure APIs using access tokens, and apply production-ready security practices.

Understanding OAuth 2.0 Flow in ASP.NET Core

OAuth 2.0 involves the following components:

Resource Owner (User)
Client Application (ASP.NET Core app)
Authorization Server (OAuth provider such as Google or Microsoft)
Resource Server (Protected API)

The most common flow used in web applications is the Authorization Code Flow. The client application redirects the user to the OAuth provider for authentication. After successful login, the provider sends an authorization code, which is exchanged for an access token.

Step 1: Register Application with OAuth Provider

Before implementation, register your ASP.NET Core application with the OAuth provider (for example, Google Cloud Console or Microsoft Entra ID). After registration, you receive:

Client ID
Client Secret
Redirect URI

These credentials are required to configure OAuth in ASP.NET Core.

Step 2: Install Required Packages

Install authentication packages via NuGet:

Microsoft.AspNetCore.Authentication.Google
Microsoft.AspNetCore.Authentication.JwtBearer (for API protection)

Step 3: Configure OAuth Authentication in Program.cs

Example using Google OAuth:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddAuthentication(options =>
{
    options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = GoogleDefaults.AuthenticationScheme;
})
.AddCookie()
.AddGoogle(options =>
{
    options.ClientId = builder.Configuration["Authentication:Google:ClientId"];
    options.ClientSecret = builder.Configuration["Authentication:Google:ClientSecret"];
});

builder.Services.AddAuthorization();

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

app.MapControllers();

app.Run();

Step 4: Add Configuration in appsettings.json

"Authentication": {
  "Google": {
    "ClientId": "your-client-id",
    "ClientSecret": "your-client-secret"
  }
}

Store secrets securely using environment variables or secret managers in production environments.

Step 5: Protect Controllers with Authorize Attribute

[Authorize]
[HttpGet("profile")]
public IActionResult GetProfile()
{
    return Ok(User.Identity.Name);
}

When accessing this endpoint, unauthenticated users are redirected to the OAuth provider.

Securing APIs with OAuth 2.0 Access Tokens

For securing ASP.NET Core Web APIs, configure JWT Bearer authentication:

builder.Services.AddAuthentication("Bearer")
    .AddJwtBearer("Bearer", options =>
    {
        options.Authority = "https://your-auth-server";
        options.Audience = "your-api";
    });

This setup validates access tokens issued by the OAuth authorization server.

Authorization Code Flow vs Client Credentials Flow

Feature	Authorization Code Flow	Client Credentials Flow
User involved	Yes	No
Used for	Web apps, user login	Machine-to-machine APIs
Returns	Access token + refresh token	Access token
Best for	Frontend applications	Backend services

Choose the appropriate flow depending on whether user interaction is required.

Implement Role-Based Authorization with OAuth Claims

OAuth providers return claims inside tokens. You can enforce role-based access control:

[Authorize(Roles = "Admin")]

Ensure roles are mapped correctly from token claims.

Security Best Practices

Use HTTPS for all OAuth communication
Store client secrets securely
Implement refresh tokens for long sessions
Validate token issuer and audience
Avoid exposing access tokens in URLs
Enable logging for authentication failures

Proper OAuth configuration enhances security posture and ensures compliance with modern authentication standards.

Common Implementation Mistakes

Hardcoding client secrets
Incorrect redirect URI configuration
Missing UseAuthentication middleware
Not validating access tokens properly
Using implicit flow instead of authorization code flow

Careful implementation prevents security vulnerabilities and authentication failures.

Summary

Implementing OAuth 2.0 in ASP.NET Core involves registering the application with an authorization provider, configuring authentication middleware, enabling external login using authorization code flow, and validating access tokens for API protection. By selecting the correct OAuth flow, securely storing client credentials, validating token claims, and enforcing role-based authorization, developers can build secure, scalable, and production-ready ASP.NET Core applications that integrate seamlessly with modern identity providers and cloud-based authentication systems.