Developer-authenticated Identitäten

Android

Zur Verwendung von entwicklerauthentifizierten Identitäten implementieren Sie eine eigene Identitätsanbieterklasse, die AWSAbstractCognitoIdentityProvider erweitert. Die Identitätsanbieterklasse sollte ein Antwortobjekt zurückgeben, das das Token als Attribut enthält.

Es folgt ein einfaches Beispiel für einen Identitätsanbieter.

public class DeveloperAuthenticationProvider extends AWSAbstractCognitoDeveloperIdentityProvider {

  private static final String developerProvider = "<Developer_provider_name>";

  public DeveloperAuthenticationProvider(String accountId, String identityPoolId, Regions region) {
    super(accountId, identityPoolId, region);
    // Initialize any other objects needed here.
  }

  // Return the developer provider name which you choose while setting up the
  // identity pool in the &COG; Console

  @Override
  public String getProviderName() {
    return developerProvider;
  }

  // Use the refresh method to communicate with your backend to get an
  // identityId and token.

  @Override
  public String refresh() {

    // Override the existing token
    setToken(null);

    // Get the identityId and token by making a call to your backend
    // (Call to your backend)

    // Call the update method with updated identityId and token to make sure
    // these are ready to be used from Credentials Provider.

    update(identityId, token);
    return token;

  }

  // If the app has a valid identityId return it, otherwise get a valid
  // identityId from your backend.

  @Override
  public String getIdentityId() {

    // Load the identityId from the cache
    identityId = cachedIdentityId;

    if (identityId == null) {
       // Call to your backend
    } else {
       return identityId;
    }

  }
}

Zur Verwendung dieses Anbieters müssen Sie ihn an übergeben CognitoCachingCredentialsProvider. Ein Beispiel:

DeveloperAuthenticationProvider developerProvider = new DeveloperAuthenticationProvider( null, "IDENTITYPOOLID", context, Regions.USEAST1);
CognitoCachingCredentialsProvider credentialsProvider = new CognitoCachingCredentialsProvider( context, developerProvider, Regions.USEAST1);

iOS – Objective-C

Zur Verwendung von entwicklerauthentifizierten Identitäten implementieren Sie eine eigene Identitätsanbieterklasse, die AWSCognitoCredentialsProviderHelper erweitert. Die Identitätsanbieterklasse sollte ein Antwortobjekt zurückgeben, das das Token als Attribut enthält.

@implementation DeveloperAuthenticatedIdentityProvider
/*
 * Use the token method to communicate with your backend to get an
 * identityId and token.
 */

- (AWSTask <NSString*> *) token {
    //Write code to call your backend:
    //Pass username/password to backend or some sort of token to authenticate user
    //If successful, from backend call getOpenIdTokenForDeveloperIdentity with logins map 
    //containing "your.provider.name":"enduser.username"
    //Return the identity id and token to client
    //You can use AWSTaskCompletionSource to do this asynchronously

    // Set the identity id and return the token
    self.identityId = response.identityId;
    return [AWSTask taskWithResult:response.token];
}

@end

Zur Verwendung dieses Identitätsanbieters müssen Sie ihn wie in folgendem Beispiel gezeigt an AWSCognitoCredentialsProvider übergeben:

DeveloperAuthenticatedIdentityProvider * devAuth = [[DeveloperAuthenticatedIdentityProvider alloc] initWithRegionType:AWSRegionYOUR_IDENTITY_POOL_REGION 
                                         identityPoolId:@"YOUR_IDENTITY_POOL_ID"
                                        useEnhancedFlow:YES
                                identityProviderManager:nil];
AWSCognitoCredentialsProvider *credentialsProvider = [[AWSCognitoCredentialsProvider alloc]
                                                          initWithRegionType:AWSRegionYOUR_IDENTITY_POOL_REGION
                                                          identityProvider:devAuth];

Wenn Sie sowohl nicht authentifizierte Identitäten als auch entwicklerauthentifizierte Identitäten unterstützen möchten, überschreiben Sie die Methode logins in der AWSCognitoCredentialsProviderHelper-Implementierung.

- (AWSTask<NSDictionary<NSString *, NSString *> *> *)logins {
    if(/*logic to determine if user is unauthenticated*/) {
        return [AWSTask taskWithResult:nil];
    }else{
        return [super logins];
    }
}

Wenn Sie sowohl entwicklerauthentifizierte Identitäten als auch Social-Identity-Anbieter unterstützen möchten, müssen Sie den verwendeten aktuellen Anbieter in der logins-Implementierung von AWSCognitoCredentialsProviderHelper verwalten.

- (AWSTask<NSDictionary<NSString *, NSString *> *> *)logins {
    if(/*logic to determine if user is unauthenticated*/) {
        return [AWSTask taskWithResult:nil];
    }else if (/*logic to determine if user is Facebook*/){
        return [AWSTask taskWithResult: @{ AWSIdentityProviderFacebook : [FBSDKAccessToken currentAccessToken] }];
    }else {
        return [super logins];
    }
}

iOS – Swift

Zur Verwendung von entwicklerauthentifizierten Identitäten implementieren Sie eine eigene Identitätsanbieterklasse, die AWSCognitoCredentialsProviderHelper erweitert. Die Identitätsanbieterklasse sollte ein Antwortobjekt zurückgeben, das das Token als Attribut enthält.

import AWSCore
/*
 * Use the token method to communicate with your backend to get an
 * identityId and token.
 */
class DeveloperAuthenticatedIdentityProvider : AWSCognitoCredentialsProviderHelper {
    override func token() -> AWSTask<NSString> {
    //Write code to call your backend:
    //pass username/password to backend or some sort of token to authenticate user, if successful, 
    //from backend call getOpenIdTokenForDeveloperIdentity with logins map containing "your.provider.name":"enduser.username"
    //return the identity id and token to client
    //You can use AWSTaskCompletionSource to do this asynchronously

    // Set the identity id and return the token
    self.identityId = resultFromAbove.identityId
    return AWSTask(result: resultFromAbove.token)
}

Zur Verwendung dieses Identitätsanbieters müssen Sie ihn wie in folgendem Beispiel gezeigt an AWSCognitoCredentialsProvider übergeben:

let devAuth = DeveloperAuthenticatedIdentityProvider(regionType: .YOUR_IDENTITY_POOL_REGION, identityPoolId: "YOUR_IDENTITY_POOL_ID", useEnhancedFlow: true, identityProviderManager:nil)
let credentialsProvider = AWSCognitoCredentialsProvider(regionType: .YOUR_IDENTITY_POOL_REGION, identityProvider:devAuth)
let configuration = AWSServiceConfiguration(region: .YOUR_IDENTITY_POOL_REGION, credentialsProvider:credentialsProvider)
AWSServiceManager.default().defaultServiceConfiguration = configuration

Wenn Sie sowohl nicht authentifizierte Identitäten als auch entwicklerauthentifizierte Identitäten unterstützen möchten, überschreiben Sie die Methode logins in der AWSCognitoCredentialsProviderHelper-Implementierung.

override func logins () -> AWSTask<NSDictionary> {
    if(/*logic to determine if user is unauthenticated*/) {
        return AWSTask(result:nil)
    }else {
        return super.logins()
    }
}

Wenn Sie sowohl entwicklerauthentifizierte Identitäten als auch Social-Identity-Anbieter unterstützen möchten, müssen Sie den verwendeten aktuellen Anbieter in der logins-Implementierung von AWSCognitoCredentialsProviderHelper verwalten.

override func logins () -> AWSTask<NSDictionary> {
    if(/*logic to determine if user is unauthenticated*/) {
        return AWSTask(result:nil)
    }else if (/*logic to determine if user is Facebook*/){
        if let token = AccessToken.current?.authenticationToken {
            return AWSTask(result: [AWSIdentityProviderFacebook:token])
        }
        return AWSTask(error:NSError(domain: "Facebook Login", code: -1 , userInfo: ["Facebook" : "No current Facebook access token"]))
    }else {
        return super.logins()
    }
}

JavaScript

Nachdem Sie eine Identitäts-ID und ein Sitzungs-Token von Ihrem Backend erhalten haben, übergeben Sie diese an den AWS.CognitoIdentityCredentials-Anbieter. Der Anmeldeschlüssel muss dem Anspruch des Tokens entsprechen. iss Für Identitätspools in Regionen, die den globalen Aussteller verwenden, verwenden Sie. cognito-identity.amazonaws.com Für Identitätspools in anderen Regionen verwenden Siecognito-identity.region.amazonaws.com. Weitere Informationen finden Sie unter Format des regionalen Token-Ausstellers.

const token = 'TOKEN_RETURNED_FROM_YOUR_PROVIDER';

// Extract the issuer from the token
const payload = token.split('.')[1];
const claims = JSON.parse(Buffer.from(payload, 'base64url').toString());
const providerName = claims.iss;

AWS.config.credentials = new AWS.CognitoIdentityCredentials({
   IdentityPoolId: 'IDENTITY_POOL_ID',
   IdentityId: 'IDENTITY_ID_RETURNED_FROM_YOUR_PROVIDER',
   Logins: {
      [providerName]: token
   }
});

Unity

Zur Verwendung von entwicklerauthentifizierten Identitäten müssen Sie CognitoAWSCredentials erweitern und die Methode RefreshIdentity überschreiben, um die Benutzeridentitäts-ID und das Token vom Backend abzurufen und zurückzugeben. Nachstehend finden Sie ein einfaches Beispiel für einen Identitätsanbieter, der ein hypothetisches Backend unter „example.com“ kontaktiert:

using UnityEngine;
using System.Collections;
using Amazon.CognitoIdentity;
using System.Collections.Generic;
using ThirdParty.Json.LitJson;
using System;
using System.Threading;

public class DeveloperAuthenticatedCredentials : CognitoAWSCredentials
{
    const string PROVIDER_NAME = "example.com";
    const string IDENTITY_POOL = "IDENTITY_POOL_ID";
    static readonly RegionEndpoint REGION = RegionEndpoint.USEast1;

    private string login = null;

    public DeveloperAuthenticatedCredentials(string loginAlias)
        : base(IDENTITY_POOL, REGION)
    {
        login = loginAlias;
    }

    protected override IdentityState RefreshIdentity()
    {
        IdentityState state = null;
        ManualResetEvent waitLock = new ManualResetEvent(false);
        MainThreadDispatcher.ExecuteCoroutineOnMainThread(ContactProvider((s) =>
        {
            state = s;
            waitLock.Set();
        }));
        waitLock.WaitOne();
        return state;
    }

    IEnumerator ContactProvider(Action<IdentityState> callback)
    {
        WWW www = new WWW("http://example.com/?username="+login);
        yield return www;
        string response = www.text;

        JsonData json = JsonMapper.ToObject(response);

        //The backend has to send us back an Identity and a OpenID token
        string identityId = json["IdentityId"].ToString();
        string token = json["Token"].ToString();

        IdentityState state = new IdentityState(identityId, PROVIDER_NAME, token, false);
        callback(state);
    }
}

Der obige Code verwendet ein Thread-Dispatcher-Objekt zum Aufrufen einer Coroutine. Wenn Sie in Ihrem Projekt nicht die Möglichkeit dazu haben, können Sie das folgende Skript in Ihren Szenen verwenden:

using System;
using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class MainThreadDispatcher : MonoBehaviour
{
    static Queue<IEnumerator> _coroutineQueue = new Queue<IEnumerator>();
    static object _lock = new object();

    public void Update()
    {
        while (_coroutineQueue.Count > 0)
        {
            StartCoroutine(_coroutineQueue.Dequeue());
        }
    }

    public static void ExecuteCoroutineOnMainThread(IEnumerator coroutine)
    {
        lock (_lock) {
            _coroutineQueue.Enqueue(coroutine);
        }
    }
}

Xamarin

Zur Verwendung von entwicklerauthentifizierten Identitäten müssen Sie CognitoAWSCredentials erweitern und die Methode RefreshIdentity überschreiben, um die Benutzeridentitäts-ID und das Token vom Backend abzurufen und zurückzugeben. Nachstehend finden Sie ein einfaches Beispiel für einen Identitätsanbieter, der ein hypothetisches Backend unter „example.com“ kontaktiert:

public class DeveloperAuthenticatedCredentials : CognitoAWSCredentials
{
    const string PROVIDER_NAME = "example.com";
    const string IDENTITY_POOL = "IDENTITY_POOL_ID";
    static readonly RegionEndpoint REGION = RegionEndpoint.USEast1;
    private string login = null;

    public DeveloperAuthenticatedCredentials(string loginAlias)
        : base(IDENTITY_POOL, REGION)
    {
        login = loginAlias;
    }

    protected override async Task<IdentityState> RefreshIdentityAsync()
    {
        IdentityState state = null;
        //get your identity and set the state
        return state;
    }
}

Android

Nach erfolgreicher Authentifizierung des Benutzers mit Ihrem Authentifizierungssystem aktualisieren Sie die Anmeldezuweisung mit dem Entwickleranbieter-Namen und einer Entwicklerbenutzer-ID. Dies ist eine alphanumerische Zeichenfolge, die einen Benutzer in Ihrem Authentifizierungssystem eindeutig identifiziert. Stellen Sie sicher, dass nach der Aktualisierung der Anmeldezuweisung die Methode refresh da die identityId sich möglicherweise geändert hat:

HashMap<String, String> loginsMap = new HashMap<String, String>();
loginsMap.put(developerAuthenticationProvider.getProviderName(), developerUserIdentifier);

credentialsProvider.setLogins(loginsMap);
credentialsProvider.refresh();

iOS – Objective-C

Das iOS-SDK ruft die Methode logins nur auf, um die aktuelle Anmeldezuweisung abzurufen, wenn keine Anmeldeinformationen vorliegen oder diese abgelaufen sind. Wenn Sie das Abrufen neuer Anmeldeinformationen im SDK erzwingen möchten (weil beispielsweise ein nicht authentifizierter Endbenutzer jetzt authentifiziert ist und Sie Anmeldeinformationen für den authentifizierten Benutzer benötigen), rufen Sie clearCredentials in credentialsProvider auf.

[credentialsProvider clearCredentials];

iOS – Swift

Das iOS-SDK ruft die Methode logins nur auf, um die aktuelle Anmeldezuweisung abzurufen, wenn keine Anmeldeinformationen vorliegen oder diese abgelaufen sind. Wenn Sie das Abrufen neuer Anmeldeinformationen im SDK erzwingen möchten (weil beispielsweise ein nicht authentifizierter Endbenutzer jetzt authentifiziert ist und Sie Anmeldeinformationen für den authentifizierten Benutzer benötigen), rufen Sie clearCredentials in credentialsProvider auf.

credentialsProvider.clearCredentials()

Android

Ihre Anwendung erfordert möglicherweise die Unterstützung sowohl von nicht authentifizierten Identitäten oder authentifizierten Identitäten unter Verwendung öffentlicher Anbieter (Anmeldung mit Amazon, Apple, Facebook oder Google) als auch von entwicklerauthentifizierten Identitäten. Der wesentliche Unterschied zwischen entwicklerauthentifizierten Identitäten und anderen Identitäten (nicht authentifizierten Identitäten und authentifizierten Identitäten unter Verwendung von öffentlichen Anbietern) ist die Art, in der die Identitäts-ID und das Token abgerufen werden. Für andere Identitäten interagiert die mobile Anwendung direkt mit Amazon Cognito, anstatt Ihr Authentifizierungssystem zu kontaktieren. Die mobile Anwendung muss daher in Abhängigkeit von der Auswahl durch den App-Benutzer zwei verschiedene Abläufe unterstützen können. Hierzu müssen Sie einige Änderungen am benutzerdefinierten Identitätsanbieter vornehmen.

Die refresh-Methode überprüft die Anmeldezuordnung. Ist diese nicht leer, sondern enthält einen Schlüssel mit dem Entwickleranbieter-Namen, müssen Sie Ihr Backend aufrufen. Rufen Sie andernfalls die IdentityId Get-Methode auf und geben Sie Null zurück.

public String refresh() {

   setToken(null);

   // If the logins map is not empty make a call to your backend
   // to get the token and identityId
   if (getProviderName() != null &&
      !this.loginsMap.isEmpty() &&
      this.loginsMap.containsKey(getProviderName())) {

      /**
       * This is where you would call your backend
       **/

      // now set the returned identity id and token in the provider
      update(identityId, token);
      return token;

   } else {
      // Call getIdentityId method and return null
      this.getIdentityId();
      return null;
   }
}

Entsprechend weist die Methode getIdentityId zwei Abläufe auf, die vom Inhalt der Anmeldezuweisung abhängen:

public String getIdentityId() {

   // Load the identityId from the cache
   identityId = cachedIdentityId;

   if (identityId == null) {

      // If the logins map is not empty make a call to your backend
      // to get the token and identityId

      if (getProviderName() != null && !this.loginsMap.isEmpty()
         && this.loginsMap.containsKey(getProviderName())) {

         /**
           * This is where you would call your backend
          **/

         // now set the returned identity id and token in the provider
         update(identityId, token);
         return token;

      } else {
         // Otherwise call &COG; using getIdentityId of super class
         return super.getIdentityId();
      }

   } else {
      return identityId;
   }

}

iOS – Objective-C

Ihre Anwendung erfordert möglicherweise die Unterstützung sowohl von nicht authentifizierten Identitäten oder authentifizierten Identitäten unter Verwendung öffentlicher Anbieter (Anmeldung mit Amazon, Apple, Facebook oder Google) als auch von entwicklerauthentifizierten Identitäten. Überschreiben Sie dazu die AWSCognitoCredentialsProviderHelper logins Methode, um die korrekte Login-Map auf der Grundlage des aktuellen Identitätsanbieters zurückgeben zu können. Das folgende Beispiel zeigt, wie Sie zwischen einer authentifizierten Identität, Facebook und einer entwicklerauthentifizierten Identität wechseln können.

- (AWSTask<NSDictionary<NSString *, NSString *> *> *)logins {
    if(/*logic to determine if user is unauthenticated*/) {
        return [AWSTask taskWithResult:nil];
    }else if (/*logic to determine if user is Facebook*/){
        return [AWSTask taskWithResult: @{ AWSIdentityProviderFacebook : [FBSDKAccessToken currentAccessToken] }];
    }else {
        return [super logins];
    }
}

Beim Wechsel von einem nicht authentifizierten zu einem authentifizierten Anbieter müssen Sie [credentialsProvider clearCredentials]; aufrufen und so erzwingen, dass das SDK die neuen authentifizierten Anmeldeinformationen abruft. Wenn Sie zwischen zwei authentifizierten Anbietern wechseln und nicht versuchen, die beiden Anbieter zu verknüpfen (d. h. Sie stellen im Anmeldeverzeichnis keine Token für mehrere Anbieter bereit), müssen Sie [credentialsProvider clearKeychain]; aufrufen. Dadurch werden sowohl die Anmeldeinformationen als auch die Identität gelöscht und das SDK ruft neue Informationen ab.

iOS – Swift

Ihre Anwendung erfordert möglicherweise die Unterstützung sowohl von nicht authentifizierten Identitäten oder authentifizierten Identitäten unter Verwendung öffentlicher Anbieter (Anmeldung mit Amazon, Apple, Facebook oder Google) als auch von entwicklerauthentifizierten Identitäten. Überschreiben Sie dazu die AWSCognitoCredentialsProviderHelper logins Methode, um die korrekte Login-Map auf der Grundlage des aktuellen Identitätsanbieters zurückgeben zu können. Das folgende Beispiel zeigt, wie Sie zwischen einer authentifizierten Identität, Facebook und einer entwicklerauthentifizierten Identität wechseln können.

override func logins () -> AWSTask<NSDictionary> {
    if(/*logic to determine if user is unauthenticated*/) {
        return AWSTask(result:nil)
    }else if (/*logic to determine if user is Facebook*/){
        if let token = AccessToken.current?.authenticationToken {
            return AWSTask(result: [AWSIdentityProviderFacebook:token])
        }
        return AWSTask(error:NSError(domain: "Facebook Login", code: -1 , userInfo: ["Facebook" : "No current Facebook access token"]))
    }else {
        return super.logins()
    }
}

Beim Wechsel von einem nicht authentifizierten zu einem authentifizierten Anbieter müssen Sie credentialsProvider.clearCredentials() aufrufen und so erzwingen, dass das SDK die neuen authentifizierten Anmeldeinformationen abruft. Wenn Sie zwischen zwei authentifizierten Anbietern wechseln und nicht versuchen, die beiden Anbieter zu verknüpfen (d. h. Sie stellen im Anmeldeverzeichnis keine Token für mehrere Anbieter bereit), müssen Sie aufrufen credentialsProvider.clearKeychain(). Dadurch werden sowohl die Anmeldeinformationen als auch die Identität gelöscht und das SDK ruft neue Informationen ab.

Unity

Ihre Anwendung erfordert möglicherweise die Unterstützung sowohl von nicht authentifizierten Identitäten oder authentifizierten Identitäten unter Verwendung öffentlicher Anbieter (Anmeldung mit Amazon, Apple, Facebook oder Google) als auch von entwicklerauthentifizierten Identitäten. Der wesentliche Unterschied zwischen entwicklerauthentifizierten Identitäten und anderen Identitäten (nicht authentifizierten Identitäten und authentifizierten Identitäten unter Verwendung von öffentlichen Anbietern) ist die Art, in der die Identitäts-ID und das Token abgerufen werden. Für andere Identitäten interagiert die mobile Anwendung direkt mit Amazon Cognito, anstatt Ihr Authentifizierungssystem zu kontaktieren. Die mobile Anwendung muss daher je nach Auswahl durch den App-Benutzer zwei verschiedene Abläufe unterstützen können. Hierzu müssen Sie einige Änderungen am benutzerdefinierten Identitätsanbieter vornehmen.

Die empfohlene Methode, dies in Unity zu tun, besteht darin AbstractCognitoIdentityProvider, Ihren Identitätsanbieter von AmazonCognitoEnhancedIdentityProvide instead of zu erweitern und die übergeordnete RefreshAsync Methode anstelle Ihrer eigenen aufzurufen, falls der Benutzer nicht mit Ihrem eigenen Backend authentifiziert ist. Wenn der Benutzer authentifiziert wurde, können Sie den gleichen Ablauf verwenden, der oben bereits erläutert wurde.

Xamarin

Ihre Anwendung erfordert möglicherweise die Unterstützung sowohl von nicht authentifizierten Identitäten oder authentifizierten Identitäten unter Verwendung öffentlicher Anbieter (Anmeldung mit Amazon, Apple, Facebook oder Google) als auch von entwicklerauthentifizierten Identitäten. Der wesentliche Unterschied zwischen entwicklerauthentifizierten Identitäten und anderen Identitäten (nicht authentifizierten Identitäten und authentifizierten Identitäten unter Verwendung von öffentlichen Anbietern) ist die Art, in der die Identitäts-ID und das Token abgerufen werden. Für andere Identitäten interagiert die mobile Anwendung direkt mit Amazon Cognito, anstatt Ihr Authentifizierungssystem zu kontaktieren. Die mobile Anwendung muss daher je nach Auswahl durch den App-Benutzer zwei verschiedene Abläufe unterstützen können. Hierzu müssen Sie einige Änderungen am benutzerdefinierten Identitätsanbieter vornehmen.