Xamarin.Essentials: Webové Authenticator

ASP.NET back-end základního serveru

Rozhraní API je možné používat s WebAuthenticator jakoukoli webovou back-end službou. Pokud ji chcete použít ASP.NET základní aplikací, musíte nejprve nakonfigurovat webovou aplikaci pomocí následujících kroků:

1. Nastavte požadované externí zprostředkovatele sociálního ověřování ve webové ASP.NET Core aplikaci.
2. Ve volání nastavte Výchozí CookieAuthenticationDefaults.AuthenticationScheme schéma .AddAuthentication() ověřování na .
3. Použijte .AddCookie() ve volání Startup.cs. .AddAuthentication()
4. Všichni zprostředkovatelé musí být nakonfigurovaní pomocí .SaveTokens = true; .

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

Přidání vlastního kontroleru mobilního ověřování

U toku mobilního ověřování je obvykle žádoucí iniciovat tok přímo poskytovateli, který uživatel zvolil (například kliknutím na tlačítko Microsoft na přihlašovací obrazovce aplikace). Je také důležité mít možnost vrátit do aplikace relevantní informace s konkrétním identifikátorem URI zpětného volání za účelem ukončení toku ověřování.

K tomu použijte vlastní kontroler rozhraní API:

[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
    }
}

Účelem tohoto kontroleru je odvodit schéma (poskytovatele), které aplikace požaduje, a iniciovat tok ověřování se zprostředkovatelem sociální sítě. Když zprostředkovatel volá zpět do webového back-endu, kontroler parsuje výsledek a přesměruje ho na identifikátor URI zpětného volání aplikace pomocí parametrů.

Někdy můžete chtít vrátit data, jako je například poskytovatel, zpět do aplikace, což můžete provést prostřednictvím parametrů dotazu access_token identifikátoru URI zpětného volání. Nebo můžete chtít místo toho na serveru vytvořit vlastní identitu a předat aplikaci vlastní token. Co a jak tuto část udělat je na vás!

Podívejte se na úplnou ukázku kontroleru v úložišti Essentials.

rozhraní API

• /WebAuthenticator" data-linktype="external">zdrojový kód WebAuthenticator
• Dokumentace k rozhraní WebAuthenticator API
• ASP.NET Core server

Třída WebAuthenticator umožňuje iniciovat toky založené na prohlížeči, které naslouchají zpětnému volání na konkrétní adresu URL zaregistrovanou v aplikaci.

Přehled

Mnoho aplikací vyžaduje přidání ověřování uživatelů, což často znamená, že uživatelům umožníte přihlásit se ke svým stávajícím účtům Microsoft, Facebook, Google a nyní k Apple Sign In.

Microsoft Authentication Library (MSAL) poskytuje vynikající řešení na klíč pro přidání ověřování do vaší aplikace. Ve svých klientských aplikacích je dokonce k dispozici podpora pro NuGet xamarin.

Pokud vás zajímá použití vlastní webové služby k ověřování, můžete k implementaci funkcí na straně klienta použít WebAuthenticator.

Proč používat back-end serveru?

Řada zprostředkovatelů ověřování se přesunula na nabídku explicitních nebo dvounohých toků ověřování, aby se zajistilo lepší zabezpečení. To znamená, že k dokončení toku ověřování budete od poskytovatele potřebovat tajný klíč klienta. Mobilní aplikace bohužel nejsou skvělým místem pro ukládání tajných kódů a cokoli jiného uloženého v kódu, binárních souborech mobilní aplikace nebo jinak se obecně považuje za nezabezpečené.

Osvědčeným postupem je použít webový back-end jako střední vrstvu mezi mobilní aplikací a poskytovatelem ověřování.

Začínáme

Pokud chcete začít používat toto rozhraní API, přečtěte si příručku Začínáme pro a ujistěte se, že je knihovna správně nainstalovaná a nastavená ve vašich projektech.

Pro přístup k funkcím WebAuthenticator se vyžaduje následující nastavení specifické pro platformu.

const string CALLBACK_SCHEME = "myapp";

[Activity(NoHistory = true, LaunchMode = LaunchMode.SingleTop)]
[IntentFilter(new[] { Android.Content.Intent.ActionView },
    Categories = new[] { Android.Content.Intent.CategoryDefault, Android.Content.Intent.CategoryBrowsable },
    DataScheme = CALLBACK_SCHEME)]
public class WebAuthenticationCallbackActivity : Xamarin.Essentials.WebAuthenticatorCallbackActivity
{
}

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

<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleURLName</key>
        <string>xamarinessentials</string>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>xamarinessentials</string>
        </array>
        <key>CFBundleTypeRole</key>
        <string>Editor</string>
    </dict>
</array>

public override bool OpenUrl(UIApplication app, NSUrl url, NSDictionary options)
{
    if (Xamarin.Essentials.Platform.OpenUrl(app, url, options))
        return true;

    return base.OpenUrl(app, url, options);
}

public override bool ContinueUserActivity(UIApplication application, NSUserActivity userActivity, UIApplicationRestorationHandler completionHandler)
{
    if (Xamarin.Essentials.Platform.ContinueUserActivity(application, userActivity, completionHandler))
        return true;
    return base.ContinueUserActivity(application, userActivity, completionHandler);
}

<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>

Použití WebAuthenticatoru

Do třídy Xamarin.Essentials přidejte odkaz na :

using Xamarin.Essentials;

Rozhraní API se skládá hlavně z jedné metody, která přebírá dva parametry: adresu URL, která se má použít ke spuštění toku webového prohlížeče, a identifikátor URI, na který očekáváte, že tok nakonec zavolá zpět a na kterou je vaše aplikace zaregistrovaná, aby mohla AuthenticateAsync zpracovat.

Výsledkem je , WebAuthenticatorResult který zahrnuje všechny parametry dotazu parsované z identifikátoru URI zpětného volání:

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

var accessToken = authResult?.AccessToken;

Rozhraní WebAuthenticator API se postará o spuštění adresy URL v prohlížeči a čekání na přijetí zpětného volání:

Pokud uživatel tok kdykoli zruší, vyvolá TaskCanceledException se .

Relace privátního ověřování

V iOSu 13 bylo zavedeno dočasné rozhraní API webového prohlížeče, které vývojářům umožňuje spustit ověřovací relaci jako soukromou. To umožňuje vývojářům žádat, aby mezi relacemi ověřování nebyly dostupné žádné sdílené soubory cookie nebo údaje o procházení, a pokaždé se jedná o novou relaci přihlášení. Tato funkce je dostupná prostřednictvím WebAuthenticatorOptions nového, který byl představen ve Xamarin.Essentials windows 1.7 pro iOS.

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

Rozdíly mezi platformami

Apple Sign In

Pokud vaše aplikace používá kověření nějakou službu sociálních přihlášení, musí podle pokynů apple pro revize nabízet také možnost Přihlášení Apple.

Pokud chcete do svých aplikací přidat Apple Sign In, musíte nejprve nakonfigurovat aplikaci tak, aby k používání aplikace Apple Sign In (Přihlášení Apple).

Pro iOS 13 a vyšší budete chtít volat AppleSignInAuthenticator.AuthenticateAsync() metodu . Tím se pod pokličkou použije nativní rozhraní API pro přihlašování Apple, aby uživatelé na těchto zařízeních našli nejlepší možné prostředí. Sdílený kód můžete napsat tak, aby za běhu mohl používat správné rozhraní API, například:

var scheme = "..."; // Apple, Microsoft, Google, Facebook, etc.
WebAuthenticatorResult r = null;

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

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

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

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