Autenticação e Autorização: JWT, OAuth2 e OpenID Connect

1

xxxxx.yyyyy.zzzzz

1
2
3
4
5

{
  "alg": "RS256",
  "typ": "JWT",
  "kid": "abc123"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

{
  "iss": "https://login.microsoftonline.com/{tenant-id}/v2.0",
  "sub": "user-object-id",
  "aud": "api://minha-api-client-id",
  "exp": 1739750400,
  "iat": 1739746800,
  "name": "Lincoln Zocateli",
  "preferred_username": "[email protected]",
  "roles": ["Admin", "Reader"],
  "scp": "User.Read Profile.Read"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

┌──────────┐                              ┌───────────────────┐
│  Client   │──(1) Auth Request + PKCE ──►│ Authorization     │
│  (App)    │                              │ Server            │
│           │◄─(4) Authorization Code ─────│ (Azure Entra ID)  │
│           │──(5) Code + Verifier ───────►│                   │
│           │◄─(6) Access Token ──────────│                   │
│           │                              └───────────────────┘
│           │──(7) API Request + Token ──►┌───────────────────┐
│           │◄─(8) Protected Resource ────│ Resource Server   │
└──────────┘                              │ (Sua API)         │
                                          └───────────────────┘

1
2
3
4
5
6
7
8
9

# Registrar uma aplicação SPA no Azure Entra ID
az ad app create \
  --display-name "Minha SPA Angular" \
  --sign-in-audience "AzureADMyOrg" \
  --enable-id-token-issuance true \
  --enable-access-token-issuance false \
  --web-redirect-uris "" \
  --public-client-redirect-uris "http://localhost:4200" \
  --is-fallback-public-client true

1

npm install @azure/msal-browser @azure/msal-angular

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

// src/app/auth-config.ts — Configuração do MSAL para Angular 16+
import { MsalGuardConfiguration, MsalInterceptorConfiguration } from "@azure/msal-angular";
import {
  BrowserCacheLocation,
  InteractionType,
  IPublicClientApplication,
  LogLevel,
  PublicClientApplication,
} from "@azure/msal-browser";

// Configuração do MSAL — NÃO inclui client secret (app pública)
export function MSALInstanceFactory(): IPublicClientApplication {
  return new PublicClientApplication({
    auth: {
      clientId: "seu-client-id-aqui",             // Application (client) ID
      authority: "https://login.microsoftonline.com/seu-tenant-id",
      redirectUri: "http://localhost:4200",         // Redirect URI configurada no portal
      postLogoutRedirectUri: "http://localhost:4200",
    },
    cache: {
      cacheLocation: BrowserCacheLocation.SessionStorage, // sessionStorage para SPAs
      storeAuthStateInCookie: false,
    },
    system: {
      loggerOptions: {
        logLevel: LogLevel.Info,
        loggerCallback: (level, message) => console.log(message),
      },
    },
  });
}

// Configuração do MsalGuard — protege rotas que exigem autenticação
export function MSALGuardConfigFactory(): MsalGuardConfiguration {
  return {
    interactionType: InteractionType.Redirect, // Redirect ou Popup
    authRequest: {
      scopes: ["openid", "profile", "email"],
    },
  };
}

// Configuração do MsalInterceptor — injeta access token automaticamente nas requisições HTTP
export function MSALInterceptorConfigFactory(): MsalInterceptorConfiguration {
  const protectedResources = new Map<string, Array<string>>();
  // Toda requisição para sua API receberá o token automaticamente
  protectedResources.set("https://api.seudominio.com/*", ["api://minha-api/User.Read"]);
  // Microsoft Graph (opcional)
  protectedResources.set("https://graph.microsoft.com/v1.0/*", ["User.Read"]);

  return {
    interactionType: InteractionType.Redirect,
    protectedResourceMap: protectedResources,
  };
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// src/app/app.config.ts — Configuração standalone do Angular 16+
import { ApplicationConfig, importProvidersFrom } from "@angular/core";
import { provideRouter } from "@angular/router";
import { provideHttpClient, withInterceptorsFromDi, HTTP_INTERCEPTORS } from "@angular/common/http";
import {
  MsalModule,
  MsalService,
  MsalGuard,
  MsalInterceptor,
  MsalBroadcastService,
  MSAL_INSTANCE,
  MSAL_GUARD_CONFIG,
  MSAL_INTERCEPTOR_CONFIG,
} from "@azure/msal-angular";
import {
  MSALInstanceFactory,
  MSALGuardConfigFactory,
  MSALInterceptorConfigFactory,
} from "./auth-config";
import { routes } from "./app.routes";

export const appConfig: ApplicationConfig = {
  providers: [
    provideRouter(routes),
    provideHttpClient(withInterceptorsFromDi()),
    importProvidersFrom(MsalModule),
    {
      provide: HTTP_INTERCEPTORS,
      useClass: MsalInterceptor, // Interceptor injeta token nas requisições automaticamente
      multi: true,
    },
    {
      provide: MSAL_INSTANCE,
      useFactory: MSALInstanceFactory,
    },
    {
      provide: MSAL_GUARD_CONFIG,
      useFactory: MSALGuardConfigFactory,
    },
    {
      provide: MSAL_INTERCEPTOR_CONFIG,
      useFactory: MSALInterceptorConfigFactory,
    },
    MsalService,
    MsalGuard,             // Guard para proteger rotas
    MsalBroadcastService,  // Service para observar eventos de autenticação
  ],
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// src/app/app.routes.ts — Rotas com MsalGuard para proteger acesso
import { Routes } from "@angular/router";
import { MsalGuard } from "@azure/msal-angular";
import { HomeComponent } from "./home/home.component";
import { DashboardComponent } from "./dashboard/dashboard.component";

export const routes: Routes = [
  { path: "", component: HomeComponent },
  {
    path: "dashboard",
    component: DashboardComponent,
    canActivate: [MsalGuard], // Rota protegida — requer autenticação
  },
];

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

// src/app/home/home.component.ts — Componente com login e consumo de API
import { Component, OnInit, OnDestroy, inject } from "@angular/core";
import { CommonModule } from "@angular/common";
import { HttpClient } from "@angular/common/http";
import { MsalService, MsalBroadcastService } from "@azure/msal-angular";
import { InteractionStatus } from "@azure/msal-browser";
import { Subject, filter, takeUntil } from "rxjs";

@Component({
  selector: "app-home",
  standalone: true,
  imports: [CommonModule],
  template: `
    <div *ngIf="!isAutenticado">
      <h2>Bem-vindo</h2>
      <button (click)="login()">Login com Azure Entra ID</button>
    </div>
    <div *ngIf="isAutenticado">
      <h2>Olá, {{ nomeUsuario }}!</h2>
      <button (click)="chamarApi()">Chamar API Protegida</button>
      <button (click)="logout()">Logout</button>
      <pre *ngIf="dadosApi">{{ dadosApi | json }}</pre>
    </div>
  `,
})
export class HomeComponent implements OnInit, OnDestroy {
  private msalService = inject(MsalService);
  private broadcastService = inject(MsalBroadcastService);
  private http = inject(HttpClient);
  private destroy$ = new Subject<void>();

  isAutenticado = false;
  nomeUsuario = "";
  dadosApi: any = null;

  ngOnInit(): void {
    // Observar mudanças no estado de autenticação
    this.broadcastService.inProgress$
      .pipe(
        filter((status) => status === InteractionStatus.None),
        takeUntil(this.destroy$)
      )
      .subscribe(() => {
        const accounts = this.msalService.instance.getAllAccounts();
        this.isAutenticado = accounts.length > 0;
        if (this.isAutenticado) {
          this.nomeUsuario = accounts[0].name ?? accounts[0].username;
        }
      });
  }

  login(): void {
    // Inicia o fluxo de login via redirect (Authorization Code + PKCE)
    this.msalService.loginRedirect({
      scopes: ["openid", "profile", "email", "api://minha-api/User.Read"],
    });
  }

  logout(): void {
    this.msalService.logoutRedirect({
      postLogoutRedirectUri: "http://localhost:4200",
    });
  }

  chamarApi(): void {
    // O MsalInterceptor injeta o access token automaticamente
    this.http.get("https://api.seudominio.com/api/dados").subscribe({
      next: (data) => (this.dadosApi = data),
      error: (err) => console.error("Erro ao chamar API:", err),
    });
  }

  ngOnDestroy(): void {
    this.destroy$.next();
    this.destroy$.complete();
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Registrar uma aplicação web confidencial
az ad app create \
  --display-name "Minha Web App" \
  --sign-in-audience "AzureADMyOrg" \
  --web-redirect-uris "https://app.seudominio.com/auth/callback" \
  --enable-id-token-issuance true

# Criar um Client Secret (válido por 2 anos)
az ad app credential reset \
  --id "seu-app-object-id" \
  --display-name "Prod Secret" \
  --years 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

# app.py — Aplicação Flask com autenticação via Azure Entra ID
import os
from flask import Flask, redirect, url_for, session, request
import msal

app = Flask(__name__)
app.secret_key = os.environ.get("FLASK_SECRET_KEY", "dev-secret-key")

# Configuração — Client Secret armazenado em variável de ambiente
CLIENT_ID = os.environ["AZURE_CLIENT_ID"]
CLIENT_SECRET = os.environ["AZURE_CLIENT_SECRET"]  # Seguro no servidor
AUTHORITY = f"https://login.microsoftonline.com/{os.environ['AZURE_TENANT_ID']}"
REDIRECT_URI = "https://app.seudominio.com/auth/callback"
SCOPE = ["User.Read"]  # Escopos do Microsoft Graph

# Criar instância confidencial do MSAL
def criar_msal_app():
    return msal.ConfidentialClientApplication(
        CLIENT_ID,
        authority=AUTHORITY,
        client_credential=CLIENT_SECRET,  # Secret usado aqui (servidor seguro)
    )

@app.route("/login")
def login():
    """Inicia o fluxo de autenticação OAuth 2.0 Authorization Code."""
    msal_app = criar_msal_app()
    # Gerar URL de autorização
    auth_url = msal_app.get_authorization_request_url(
        scopes=SCOPE,
        redirect_uri=REDIRECT_URI,
    )
    return redirect(auth_url)

@app.route("/auth/callback")
def callback():
    """Callback do Azure Entra ID após autenticação."""
    msal_app = criar_msal_app()
    code = request.args.get("code")

    # Trocar authorization code por tokens
    result = msal_app.acquire_token_by_authorization_code(
        code,
        scopes=SCOPE,
        redirect_uri=REDIRECT_URI,
    )

    if "access_token" in result:
        session["user"] = result.get("id_token_claims")
        session["access_token"] = result["access_token"]
        return redirect(url_for("index"))
    else:
        return f"Erro na autenticação: {result.get('error_description')}", 401

@app.route("/")
def index():
    """Página principal — requer autenticação."""
    user = session.get("user")
    if not user:
        return redirect(url_for("login"))
    return f"Olá, {user.get('name')}! Você está autenticado."

if __name__ == "__main__":
    app.run(debug=True, port=5000)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

# daemon_service.py — Serviço M2M com Client Credentials
import os
import msal
import requests

# Configuração do daemon/serviço
CLIENT_ID = os.environ["AZURE_CLIENT_ID"]
CLIENT_SECRET = os.environ["AZURE_CLIENT_SECRET"]
TENANT_ID = os.environ["AZURE_TENANT_ID"]
AUTHORITY = f"https://login.microsoftonline.com/{TENANT_ID}"

# Escopo da API alvo — formato: api://<client-id>/.default
API_SCOPE = ["api://api-destino-client-id/.default"]
API_BASE_URL = "https://api.seudominio.com"

def obter_token_m2m():
    """Obtém access token usando Client Credentials (sem usuário)."""
    app = msal.ConfidentialClientApplication(
        CLIENT_ID,
        authority=AUTHORITY,
        client_credential=CLIENT_SECRET,
    )

    # Tenta usar token em cache antes de solicitar novo
    result = app.acquire_token_silent(API_SCOPE, account=None)
    if not result:
        # Solicita novo token via Client Credentials
        result = app.acquire_token_for_client(scopes=API_SCOPE)

    if "access_token" in result:
        return result["access_token"]
    else:
        raise Exception(f"Falha ao obter token: {result.get('error_description')}")

def chamar_api_protegida():
    """Chama a API protegida usando o access token M2M."""
    token = obter_token_m2m()

    # Incluir o token no header Authorization
    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
    }

    response = requests.get(f"{API_BASE_URL}/api/dados", headers=headers)
    response.raise_for_status()
    return response.json()

if __name__ == "__main__":
    dados = chamar_api_protegida()
    print(f"Dados recebidos da API: {dados}")

1
2
3
4
5
6
7

# Criar projeto Web API
dotnet new webapi -n MinhaApiProtegida --framework net8.0
cd MinhaApiProtegida

# Instalar pacotes de autenticação Microsoft Identity
dotnet add package Microsoft.Identity.Web
dotnet add package Microsoft.Identity.Web.MicrosoftGraph  # Opcional: se precisar chamar Graph

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

{
  "AzureAd": {
    "Instance": "https://login.microsoftonline.com/",
    "TenantId": "seu-tenant-id",
    "ClientId": "api://seu-client-id-da-api",
    "Audience": "api://seu-client-id-da-api",
    "Scopes": "User.Read Admin.Full"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information"
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

// Program.cs — API REST protegida com Azure Entra ID (ASP.NET Core 8)
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.Identity.Web;

var builder = WebApplication.CreateBuilder(args);

// Configura autenticação JWT Bearer com Azure Entra ID
// O Microsoft.Identity.Web cuida automaticamente de:
// - Buscar chaves públicas (JWKS) do Azure Entra ID
// - Validar issuer, audience, assinatura e expiração do token
// - Validar escopos e roles
builder.Services
    .AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApi(builder.Configuration.GetSection("AzureAd"));

// Configurar políticas de autorização baseadas em roles e escopos
builder.Services.AddAuthorizationBuilder()
    .AddPolicy("LeituraPermitida", policy =>
        policy.RequireScope("User.Read"))       // Exige escopo User.Read
    .AddPolicy("AdminOnly", policy =>
        policy.RequireRole("Admin"));            // Exige role Admin

builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Configurar CORS para permitir requisições da SPA Angular
builder.Services.AddCors(options =>
{
    options.AddPolicy("PermitirSPA", corsBuilder =>
    {
        corsBuilder
            .WithOrigins("http://localhost:4200", "https://app.seudominio.com")
            .AllowAnyHeader()
            .AllowAnyMethod();
    });
});

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();
app.UseCors("PermitirSPA");
app.UseAuthentication();  // Middleware de autenticação (valida o JWT)
app.UseAuthorization();   // Middleware de autorização (verifica policies)
app.MapControllers();

app.Run();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

// Controllers/DadosController.cs — Endpoints protegidos com autorização granular
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Identity.Web;
using Microsoft.Identity.Web.Resource;

namespace MinhaApiProtegida.Controllers;

[ApiController]
[Route("api/[controller]")]
[Authorize]  // Todos os endpoints exigem autenticação por padrão
public class DadosController : ControllerBase
{
    /// <summary>
    /// Endpoint protegido — requer access token válido com escopo User.Read.
    /// Pode ser chamado por SPAs (delegated) ou daemons (application).
    /// </summary>
    [HttpGet]
    [RequiredScope(RequiredScopesConfigurationKey = "AzureAd:Scopes")] // Valida escopo
    public IActionResult ObterDados()
    {
        // Extrair informações do token JWT validado
        var usuario = User.GetDisplayName()
                     ?? User.FindFirst("preferred_username")?.Value
                     ?? "Desconhecido";

        var objectId = User.GetObjectId();             // OID do Azure Entra
        var tenantId = User.GetTenantId();             // Tenant ID
        var scopes = User.FindFirst("scp")?.Value;     // Escopos delegados

        return Ok(new
        {
            Mensagem = "Acesso autorizado!",
            Usuario = usuario,
            ObjectId = objectId,
            TenantId = tenantId,
            Scopes = scopes,
            Timestamp = DateTime.UtcNow
        });
    }

    /// <summary>
    /// Endpoint admin — requer role 'Admin' atribuída no Azure Entra ID.
    /// </summary>
    [HttpGet("admin")]
    [Authorize(Policy = "AdminOnly")] // Exige role Admin
    public IActionResult ObterDadosAdmin()
    {
        var roles = User.Claims
            .Where(c => c.Type == "roles" || c.Type == System.Security.Claims.ClaimTypes.Role)
            .Select(c => c.Value)
            .ToList();

        return Ok(new
        {
            Mensagem = "Bem-vindo, administrador!",
            Roles = roles,
            Usuario = User.GetDisplayName()
        });
    }

    /// <summary>
    /// Endpoint que diferencia chamadas delegadas (usuário) de chamadas M2M (daemon).
    /// Útil quando a mesma API é consumida por SPAs e por serviços backend.
    /// </summary>
    [HttpGet("info")]
    public IActionResult InformacoesToken()
    {
        var scopeClaim = User.FindFirst("scp");        // Presente em tokens delegados
        var rolesClaim = User.FindFirst("roles");      // Presente em tokens de aplicação

        var tipoFluxo = scopeClaim != null
            ? "Delegado (usuário via SPA/Web App)"
            : "Aplicação (M2M via Client Credentials)";

        return Ok(new
        {
            TipoFluxo = tipoFluxo,
            Issuer = User.FindFirst("iss")?.Value,
            Audience = User.FindFirst("aud")?.Value,
            Expiracao = User.FindFirst("exp")?.Value,
            Scopes = scopeClaim?.Value,
            Roles = rolesClaim?.Value
        });
    }
}