Developer-authenticated identidades

Android

Para usar las identidades autenticadas por el desarrollador, implemente su propia clase de proveedor de identidad que amplía AWSAbstractCognitoIdentityProvider. La clase de proveedor de identidad debe devolver un objeto de respuesta que contenga el token como un atributo.

El siguiente es un ejemplo básico de un proveedor de identidades.

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

  }
}

Para utilizar este proveedor de identidad, tiene que pasarlo en CognitoCachingCredentialsProvider. A continuación se muestra un ejemplo:

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

iOS - Objective-C

Para usar las identidades autenticadas por el desarrollador, implemente su propia clase de proveedor de identidad que amplía AWSCognitoCredentialsProviderHelper. La clase de proveedor de identidad debe devolver un objeto de respuesta que contenga el token como un atributo.

@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

Para utilizar este proveedor de identidad, tiene que pasarlo en AWSCognitoCredentialsProvider, como se muestra en el ejemplo siguiente:

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

Si quiere dar soporte a las identidades sin autenticar y a las identidades autenticadas por el desarrollador, anule el método logins en la implementación de AWSCognitoCredentialsProviderHelper.

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

Si quiere dar soporte a las identidades autenticadas por el desarrollador y a los proveedores sociales, debe administrar quién es el proveedor actual en la implementación logins de AWSCognitoCredentialsProviderHelper.

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

Para usar las identidades autenticadas por el desarrollador, implemente su propia clase de proveedor de identidad que amplía AWSCognitoCredentialsProviderHelper. La clase de proveedor de identidad debe devolver un objeto de respuesta que contenga el token como un atributo.

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

Para utilizar este proveedor de identidad, tiene que pasarlo en AWSCognitoCredentialsProvider, como se muestra en el ejemplo siguiente:

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

Si quiere dar soporte a las identidades sin autenticar y a las identidades autenticadas por el desarrollador, anule el método logins en la implementación de AWSCognitoCredentialsProviderHelper.

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

Si quiere dar soporte a las identidades autenticadas por el desarrollador y a los proveedores sociales, debe administrar quién es el proveedor actual en la implementación logins de AWSCognitoCredentialsProviderHelper.

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

Una vez que obtengas un identificador de identidad y un token de sesión de tu servidor, los pasarás al fromCognitoIdentity proveedor desde allí. @aws-sdk/credential-providers La clave de inicio de sesión debe coincidir con la iss afirmación del token. Para los grupos de identidades en las regiones que utilizan el emisor global, utilice. cognito-identity.amazonaws.com Para grupos de identidades en otras regiones, utilicecognito-identity.region.amazonaws.com. Para obtener más información, consulte Formato de emisor de fichas regional.

import { fromCognitoIdentity } from "@aws-sdk/credential-providers";

const token = 'TOKEN_RETURNED_FROM_YOUR_PROVIDER';
const region = 'IDENTITY_POOL_REGION';

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

// Your backend already established the identity, so use fromCognitoIdentity
// (which calls GetCredentialsForIdentity directly for the identity ID you pass)
// rather than fromCognitoIdentityPool (which would call GetId and resolve a new identity).
const credentials = fromCognitoIdentity({
   identityId: 'IDENTITY_ID_RETURNED_FROM_YOUR_PROVIDER',
   logins: {
      [providerName]: token
   },
   clientConfig: { region }
});

// Attach the provider to each service client that needs credentials.
const client = new SomeServiceClient({ region, credentials });

Android

Después de autenticar correctamente al usuario con su propio sistema de autenticación, actualice la asignación de inicios de sesión con el nombre del proveedor de desarrollador y un identificador de usuario de desarrollador. Se trata de una cadena alfanumérica que identifica de forma exclusiva a un usuario en el sistema de autenticación. Asegúrese de llamar al método refresh después de actualizar la asignación de inicios de sesión, ya que identityId podría haber cambiado:

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

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

iOS - Objective-C

El SDK para iOS solo llama al método logins para obtener la última asignación de inicios de sesión si no hay credenciales o estas han caducado. Si quiere obligar al SDK a obtener nuevas credenciales (por ejemplo, el usuario final ha pasado de no estar autenticado a estar autenticado y usted quiere credenciales sobre el usuario autenticado), llame a clearCredentials en su credentialsProvider.

[credentialsProvider clearCredentials];

iOS - Swift

El SDK para iOS solo llama al método logins para obtener la última asignación de inicios de sesión si no hay credenciales o estas han caducado. Si quiere obligar al SDK a obtener nuevas credenciales (por ejemplo, el usuario final ha pasado de no estar autenticado a estar autenticado y usted quiere credenciales sobre el usuario autenticado), llame a clearCredentials en su credentialsProvider.

credentialsProvider.clearCredentials()

Android

Es posible que la aplicación requiera admitir identidades sin autenticar o autenticadas mediante proveedores públicos (Login with Amazon, Sign in with Apple, Facebook o Google) junto con identidades autenticadas por el desarrollador. La diferencia fundamental entre las identidades autenticadas por el desarrollador y otras identidades (identidades sin autenticar e identidades autenticadas mediante un proveedor público) radica en la forma de obtener identityId y el token. En el caso de otras identidades, la aplicación móvil interactúa directamente con Amazon Cognito en lugar de ponerse en contacto con el sistema de autenticación. Por lo tanto, la aplicación móvil debería poder admitir dos flujos diferentes en función de la elección realizada por el usuario de la aplicación. Para esto, tendrá que realizar algunos cambios en el proveedor de identidades personalizado.

El método refresh comprueba el mapa de inicios de sesión. Si el mapa no está vacío y tiene una clave con el nombre del proveedor desarrollador, póngase en contacto con su equipo de administración. De lo contrario, llama al IdentityId método get y devuelve null.

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

Del mismo modo, el getIdentityId método tiene dos flujos en función del contenido del mapa de inicios de sesión:

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

Es posible que la aplicación requiera admitir identidades sin autenticar o autenticadas mediante proveedores públicos (Login with Amazon, Sign in with Apple, Facebook o Google) junto con identidades autenticadas por el desarrollador. Para ello, anule el AWSCognitoCredentialsProviderHelperloginsmétodo para poder devolver el mapa de inicios de sesión correcto en función del proveedor de identidad actual. En este ejemplo se muestra cómo puede moverse entre identidades sin autenticar e identidades autenticadas mediante Facebook o por el desarrollador.

- (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];
    }
}

Cuando pase de identidades sin autenticar a identidades autenticadas, llame a [credentialsProvider clearCredentials]; para obligar al SDK a obtener credenciales autenticadas nuevas. Cuando cambie entre dos proveedores autenticados y no esté intentando vincularlos (por ejemplo, no proporciona tokens para varios proveedores en el diccionario de inicios de sesión), llame a [credentialsProvider clearKeychain];. Esto borra tanto las credenciales como la identidad y obliga al SDK a obtener otras nuevas.

iOS - Swift

Es posible que la aplicación requiera admitir identidades sin autenticar o autenticadas mediante proveedores públicos (Login with Amazon, Sign in with Apple, Facebook o Google) junto con identidades autenticadas por el desarrollador. Para ello, anule el AWSCognitoCredentialsProviderHelperloginsmétodo para poder devolver el mapa de inicios de sesión correcto en función del proveedor de identidad actual. En este ejemplo se muestra cómo puede moverse entre identidades sin autenticar e identidades autenticadas mediante Facebook o por el desarrollador.

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()
    }
}

Cuando pase de identidades sin autenticar a identidades autenticadas, llame a credentialsProvider.clearCredentials() para obligar al SDK a obtener credenciales autenticadas nuevas. Cuando cambie entre dos proveedores autenticados y no esté intentando vincularlos (por ejemplo, no proporciona tokens para varios proveedores en el diccionario de inicios de sesión), llame a credentialsProvider.clearKeychain(). Esto borra tanto las credenciales como la identidad y obliga al SDK a obtener otras nuevas.

Unity

Es posible que la aplicación requiera admitir identidades sin autenticar o autenticadas mediante proveedores públicos (Login with Amazon, Sign in with Apple, Facebook o Google) junto con identidades autenticadas por el desarrollador. La diferencia fundamental entre las identidades autenticadas por el desarrollador y otras identidades (identidades sin autenticar e identidades autenticadas mediante un proveedor público) radica en la forma de obtener identityId y el token. En el caso de otras identidades, la aplicación móvil interactúa directamente con Amazon Cognito en lugar de ponerse en contacto con el sistema de autenticación. La aplicación móvil debería poder admitir dos flujos diferentes en función de la elección realizada por el usuario de la aplicación. Para ello, tendrá que realizar algunos cambios en el proveedor de identidad personalizado.

La forma recomendada de hacerlo en Unity consiste en ampliar el proveedor de identidad desde AmazonCognitoEnhancedIdentityProvide y llamar al RefreshAsync método principal en lugar del propio AbstractCognitoIdentityProvider, en caso de que el usuario no esté autenticado con su propio servidor. Si el usuario está autenticado, puede utilizar el mismo flujo explicado anteriormente.