Webautentikator

Bläddra i exemplet

Den här artikeln beskriver hur du kan använda gränssnittet .NET Multi-platform App UI (.NET MAUI).IWebAuthenticator Med det här gränssnittet kan du starta webbläsarbaserade autentiseringsflöden som lyssnar efter ett återanrop till en specifik URL som är registrerad i appen.

Standardimplementeringen av IWebAuthenticator-gränssnittet är tillgänglig via egenskapen WebAuthenticator.Default. Både IWebAuthenticator-gränssnittet och WebAuthenticator-klassen finns i namnområdet Microsoft.Maui.Authentication.

Översikt

Många appar kräver att du lägger till användarautentisering, och det innebär ofta att användarna kan logga in på sitt befintliga Microsoft-, Facebook-, Google- eller Apple-inloggningskonto.

Om du är intresserad av att använda din egen webbtjänst för autentisering är det möjligt att använda WebAuthenticator för att implementera funktionerna på klientsidan.

Varför använda en serverserverdel

Många autentiseringsleverantörer har övergått till att endast erbjuda explicita eller tvåbenta autentiseringsflöden för att säkerställa bättre säkerhet. Det innebär att du behöver en klienthemlighet från providern för att slutföra autentiseringsflödet. Mobilappar är tyvärr inte ett bra ställe att lagra hemligheter på och allt som lagras i en mobilapps kod, binärfiler eller på annat sätt anses vara osäkert.

Bästa praxis här är att använda en webbserverdel som ett mellanlager mellan din mobilapp och autentiseringsprovidern.

Get started

För att få åtkomst till WebAuthenticator funktionerna krävs följande plattformsspecifika installation.

using Android.App;
using Android.Content.PM;

namespace YourNameSpace;

[Activity(NoHistory = true, LaunchMode = LaunchMode.SingleTop, Exported = true)]
[IntentFilter(new[] { Android.Content.Intent.ActionView },
              Categories = new[] { Android.Content.Intent.CategoryDefault, Android.Content.Intent.CategoryBrowsable },
              DataScheme = CALLBACK_SCHEME)]
public class WebAuthenticationCallbackActivity : Microsoft.Maui.Authentication.WebAuthenticatorCallbackActivity
{
    const string CALLBACK_SCHEME = "myapp";

}

<queries>
  <intent>
    <action android:name="android.support.customtabs.action.CustomTabsService" />
  </intent>
</queries>

<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleURLName</key>
        <string>My App</string>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>myapp</string>
        </array>
        <key>CFBundleTypeRole</key>
        <string>Editor</string>
    </dict>
</array>

<Applications>
    <Application Id="App" Executable="$targetnametoken$.exe" EntryPoint="MyApp.App">
        <Extensions>
            <uap:Extension Category="windows.protocol">
            <uap:Protocol Name="myapp">
                <uap:DisplayName>My App</uap:DisplayName>
            </uap:Protocol>
            </uap:Extension>
        </Extensions>
    </Application>
</Applications>

Att använda WebAuthenticator

API:et består huvudsakligen av en enda metod, AuthenticateAsync, som tar två parametrar:

1. Url:en som används för att starta webbläsarflödet.
2. Den URI som flödet förväntas anropa tillbaka till och som är registrerad för din app.

Resultatet är "WebAuthenticatorResult, som innehåller alla frågeparametrar som parsas från återanrops-URI:n:

try
{
    WebAuthenticatorResult authResult = await WebAuthenticator.Default.AuthenticateAsync(
        new Uri("https://mysite.com/mobileauth/Microsoft"),
        new Uri("myapp://"));

    string accessToken = authResult?.AccessToken;

    // Do something with the token
}
catch (TaskCanceledException e)
{
    // Use stopped auth
}

API:et WebAuthenticator tar hand om att starta URL:en i webbläsaren och väntar tills återanropet tas emot:

Om användaren avbryter flödet när som helst utlöses en TaskCanceledException .

Privat autentiseringssession

iOS 13 introducerade ett tillfälliga webbläsar-API för utvecklare för att starta autentiseringssessionen som privat. Detta gör det möjligt för utvecklare att begära att inga delade cookies eller webbdata är tillgängliga mellan autentiseringssessioner och kommer att vara en ny inloggningssession varje gång. Detta är tillgängligt genom parametern WebAuthenticatorOptions som skickas till metoden AuthenticateAsync.

try
{
    WebAuthenticatorResult authResult = await WebAuthenticator.Default.AuthenticateAsync(
        new WebAuthenticatorOptions()
        {
            Url = new Uri("https://mysite.com/mobileauth/Microsoft"),
            CallbackUrl = new Uri("myapp://"),
            PrefersEphemeralWebBrowserSession = true
        });

    string accessToken = authResult?.AccessToken;

    // Do something with the token
}
catch (TaskCanceledException e)
{
    // Use stopped auth
}

Plattformsskillnader

I det här avsnittet beskrivs de plattformsspecifika skillnaderna med API:et för webbautentisering.

Apple-inloggning

Enligt Apples riktlinjer för granskning, om din Apple-app använder någon social inloggningstjänst för att autentisera, måste den också erbjuda Apple-inloggning som ett alternativ. Om du vill lägga till Apple-inloggning i dina appar måste du lägga till inloggningen med Apple-berättigande till din app. Den här rättigheten com.apple.developer.applesignin definieras med hjälp av nyckeln, av Arraytypen String :

<key>com.apple.developer.applesignin</key>
<array>
  <string>Default</string>
</array>

Mer information finns i Logga in med Apple-berättigande på developer.apple.com.

Anropa AppleSignInAuthenticator.AuthenticateAsync metoden för iOS 13 och senare. Detta använder inbyggda Api:er för Apple-inloggning så att användarna får bästa möjliga upplevelse på dessa enheter. Du kan till exempel skriva din delade kod för att använda rätt API under körning.

var scheme = "..."; // Apple, Microsoft, Google, Facebook, etc.
var authUrlRoot = "https://mysite.com/mobileauth/";
WebAuthenticatorResult result = null;

if (scheme.Equals("Apple")
    && DeviceInfo.Platform == DevicePlatform.iOS
    && DeviceInfo.Version.Major >= 13)
{
    // Use Native Apple Sign In API's
    result = await AppleSignInAuthenticator.AuthenticateAsync();
}
else
{
    // Web Authentication flow
    var authUrl = new Uri($"{authUrlRoot}{scheme}");
    var callbackUrl = new Uri("myapp://");

    result = await WebAuthenticator.Default.AuthenticateAsync(authUrl, callbackUrl);
}

var authToken = string.Empty;

if (result.Properties.TryGetValue("name", out string name) && !string.IsNullOrEmpty(name))
    authToken += $"Name: {name}{Environment.NewLine}";

if (result.Properties.TryGetValue("email", out string email) && !string.IsNullOrEmpty(email))
    authToken += $"Email: {email}{Environment.NewLine}";

// Note that Apple Sign In has an IdToken and not an AccessToken
authToken += result?.AccessToken ?? result?.IdToken;

ASP.NET serverdel för kärnserver

Det är möjligt att använda API:et WebAuthenticator med valfri webbserverdelstjänst. Om du vill använda den med en ASP.NET kärnapp konfigurerar du webbappen med följande steg:

1. Konfigurera dina externa leverantörer för social autentisering i en ASP.NET Core-webbapp.
2. Ange standardautentiseringsschemat till CookieAuthenticationDefaults.AuthenticationScheme i .AddAuthentication() anropet.
3. Använd .AddCookie() i ditt Startup.cs-samtal.AddAuthentication() .
4. Alla leverantörer måste konfigureras med .SaveTokens = true;.

services.AddAuthentication(o =>
    {
        o.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    })
    .AddCookie()
    .AddFacebook(fb =>
    {
        fb.AppId = Configuration["FacebookAppId"];
        fb.AppSecret = Configuration["FacebookAppSecret"];
        fb.SaveTokens = true;
    });

Lägga till en anpassad mobil autentiseringskontrollant

Med ett flöde för mobil autentisering startar du vanligtvis flödet direkt till en provider som användaren har valt. Du kan till exempel klicka på knappen "Microsoft" på inloggningsskärmen i appen. Det är också viktigt att returnera relevant information till din app vid en specifik återanrops-URI för att avsluta autentiseringsflödet.

För att uppnå detta använder du en anpassad API-kontrollant:

[Route("mobileauth")]
[ApiController]
public class AuthController : ControllerBase
{
    const string callbackScheme = "myapp";

    [HttpGet("{scheme}")] // eg: Microsoft, Facebook, Apple, etc
    public async Task Get([FromRoute]string scheme)
    {
        // 1. Initiate authentication flow with the scheme (provider)
        // 2. When the provider calls back to this URL
        //    a. Parse out the result
        //    b. Build the app callback URL
        //    c. Redirect back to the app
    }
}

Syftet med den här kontrollanten är att härleda schemat (providern) som appen begär och starta autentiseringsflödet med den sociala providern. När providern anropar tillbaka till webbserverdelen parsar kontrollanten ut resultatet och omdirigerar till appens återanrops-URI med parametrar.

Ibland kanske du vill returnera data som providerns access_token tillbaka till appen, vilket du kan göra via återanrops-URI:ns frågeparametrar. Eller så kanske du i stället vill skapa en egen identitet på servern och skicka tillbaka din egen token till appen. Vad och hur du gör den här delen är upp till dig!

Kolla in det fullständiga kontrollantexemplet.