
Welcome to ASP.NET Core Identity Management and Security. In this introduction lecture, I explain to you that how the course structured and what you should expect.
Learn how to obtain an access token from Auth0 using Postman, configure OAuth2 client credentials, and verify JWTs with JWKS and the public key.
Implement PKCE-based authorization code flow with Auth0 by creating a new web application, obtaining client ID and domain, and exchanging code for access and ID tokens.
Modern web development is moving away from storing sensitive tokens in the browser. As security threats evolve, the Backend for Frontend (BFF) pattern has emerged as the industry standard for securing Single Page Applications (SPAs) and mobile clients. This lecture explores why traditional local storage is no longer sufficient and how the BFF pattern provides a robust architectural solution for modern identity management.
You will learn how the BFF acts as a dedicated security layer that handles the complexities of OAuth2 and OpenID Connect on behalf of the frontend. We will examine how this pattern mitigates Cross-Site Scripting (XSS) risks by keeping tokens out of reach from malicious scripts. By moving the heavy lifting of token exchange and session management to the server side, you can build leaner, more secure applications that align with current Best Current Practices (BCP).
The session covers practical implementation strategies, including how to handle cookies with the SameSite attribute and how to proxy requests to downstream microservices. We also discuss the trade-offs involved in adopting a Backend for Frontend approach, ensuring you have the architectural insight to decide when this pattern is the right fit for your software ecosystem.
Explains implementing the authorization code with PKCE in an ASP.NET Core app using a backend for frontend with Auth0, cookies, and offline access for refresh tokens.
Explore refresh tokens in OpenID Connect with PKCE and backend-for-frontend, including offline access, token rotation, enabling secure sessions and renewal in ASP.NET Core.
Implement workload identity by assigning your app an IAM role and policies, enabling temporary credentials via STS without long-lived keys, to securely access secrets and services.
Learn how on-behalf-of flow uses token exchange via the authorization server to let API A call API B securely on behalf of a user.
Explore RBC and policy-based authorization in ASP.NET Core, contrasting RBC limitations for workloads with policy-driven checks using external policies and context such as department, IP, and environment.
Explore the road ahead in zero trust and AI-driven security, focusing on model context protocol and agent-to-agent communications to secure modern ASP.NET Core applications.
Mastering modern application security is now essential for anyone building APIs, cloud services or AI driven applications. This course gives you a practical, hands on path to understanding authentication, authorisation and identity in ASP.NET Core.
You will learn how real world identity flows work, how to secure your APIs, how to handle users safely, and how to protect services talking to each other in distributed systems.
This course is designed for developers who want a strong, practical understanding of OAuth2, OpenID Connect, JWTs, PKCE, secrets management, delegated access and externalised policy-based authorisation.
What you will learn:
• The fundamentals of modern authentication and authorisation
• How identity actually flows through an application
• How JSON Web Tokens are structured, decoded and validated
• How to issue and inspect tokens using tools like Postman
• How to secure service to service communication with the Client Credentials Flow
• How to call protected APIs using C sharp and bearer tokens
• How to validate JWTs manually when you are not using ASP.NET Core middleware
• Why OpenID Connect is required for user authentication
• How ID tokens work and where they fit in the login process
• When to use OAuth and when to use OpenID Connect
• How the Authorisation Code Flow with PKCE protects mobile and browser based apps
• How to implement PKCE inside ASP.NET Core
• How to use refresh tokens safely
• How to call APIs on behalf of the signed in user
• Modern secrets management in the cloud
• How Managed Identity and Workload Identity remove the need for stored secrets
• How delegated authorisation works using the On Behalf Of Flow
• How to design upstream and downstream API security
• How to build policy based authorisation using PDP and PEP patterns
Throughout the corse you will work with Auth0 and Microsoft Entra ID to implement various authentication scenarios. We will also see how a modern Policy Decision Point pattern is implemented so easily using Amazon Verified Permissions.
Please bear in mind that in this third edition of the course, ASP.NET Identity Framework is not thaught, as the modern applications do not implement their own identity systems.
By the end of this course, you will understand modern identity flows with absolute clarity and have the confidence to design and secure applications using current industry standards.