Delve into using Single Sign-On (SSO) to secure ASP.NET Core applications, including MVC, web API, and more. Discover protocols, configuration, and securing pages and endpoints.

Single Sign-on Authentication and authorization in ASP.NET Core.png

sso.tar.gz

Stand Alone Auth Provider

Client App Only

Full Authentication Flow

Full Authentication Flow With Secondary App

Blazor WebAssembly OIDC

Client and back-end

Securing web applications is extremely important, as you do not want unauthorized people to gain access to your data. The most convenient way of securing an application is to use single sign-on (SSO) because it allows users to authenticate once and gain access to all apps within the same system.

In this course, you’ll cover the process of using SSO in ASP.NET Core apps. You’ll also cover its usage inside all application types supported by ASP.NET Core, including MVC, web API, gRPC services, Blazor, and SignalR.

By the end of this course, you will have learned what SSO consists of, what protocols it uses, and how it’s configured inside an ASP.NET Core middleware. You will also have learned how to secure any endpoints, pages, and views supported by ASP.NET Core.

Using Single Sign-On for Securing Applications in ASP.NET Core

It provides documentation that can be followed while manually adding all the code gRPC services.

It provides the communication interface between the client and the server.

It automatically creates code stubs in C#.

It automatically creates complete gRPC service implementations.

**(Select all that apply.)** What is the role of a protobuf file in a C# gRPC project? 

(Select all that apply.) What is the role of a protobuf file in a C# gRPC project?

By passing the bearer token in the HTTP header

By triggering the client to initiate the OIDC authentication flow

By passing the bearer token in the authorization metadata

Any access token obtained by the client will be automatically included in a gRPC call.

**(Select all that apply.)** How can gRPC endpoints be secured? 

(Select all that apply.) How can gRPC endpoints be secured?

By invoking the following method on the `MapGrpcService()` in the application middleware:

```
RequireAzuthorization("adminOnly");
```


By adding the following attribute above the class signature:

```
[Authorize("adminOnly")]
```

By adding the following attribute above the class signature:

```
[Authorize(Roles="adminOnly")]
```

We cannot apply a specific authorization policy to a gRPC service. We can only do it on individual gRPC endpoints

**(Select all that apply.)** Assume you have an authorization policy called `"adminOnly"`. How can this policy be enforced on a specific gRPC service? 

(Select all that apply.) Assume you have an authorization policy called <code>&quot;adminOnly&quot;</code>. How can this policy be enforced on a specific gRPC service?

The protobuf file should be located in the root folder of the project and not in the `Protos` folder.

There's no `Protobuf` element in the project file.

The C# namespace is not defined in the protobuf file.

The `GrpcServices` attribute has the value of the `Client` rather than the `Server`.

**(Select all that apply.)** Assume you have a protobuf file called `userService.proto` inside the `Protos` folder of your .NET project representing a gRPC server. You have already implemented a service based on this file and know that the file is correctly formatted and there are no syntax errors in it. You also have the `Grpc.AspNetCore` NuGet package referenced. What could be the reasons if the application does not compile?

(Select all that apply.) Assume you have a protobuf file called <code>userService.proto</code> inside the <code>Protos</code> folder of your .NET project representing a gRPC server. You have already implemented a service based on this file and know that the file is correctly formatted and there are no syntax errors in it. You also have the <code>Grpc.AspNetCore</code> NuGet package referenced. What could be the reasons if the application does not compile?

Test your knowledge of securing gRPC endpoints in ASP.NET Core.

Introduction to Single Sign-On (SSO)

JWT and Authorization Middleware

Enabling SSO in MVC Apps

Enabling SSO in Razor Pages

Enabling SSO in Web API

Enabling SSO in Blazor

Enabling SSO in gRPC

Enabling SSO in SignalR

Wrapping Up

Appendix

Quiz Yourself on SSO in gRPC