web-dev-qa-db-fra.com

Comment changer le statut d'utilisateur FORCE_CHANGE_PASSWORD?

Avec AWS Cognito, je souhaite créer des utilisateurs factices à des fins de test.

J'utilise ensuite la console AWS pour créer cet utilisateur, mais son utilisateur status est défini sur FORCE_CHANGE_PASSWORD. Avec cette valeur, cet utilisateur ne peut pas être authentifié.

Y a-t-il un moyen de changer ce statut?

UPDATE Même comportement lors de la création d'un utilisateur à partir de la CLI

amazon-web-servicesaws-cliamazon-cognito
45
Dominique Vial

Désolé, vous rencontrez des difficultés. Nous n'avons pas de processus en une étape où vous pouvez simplement créer des utilisateurs et les authentifier directement. Nous pourrions changer cela à l'avenir, de manière à permettre aux administrateurs de définir des mots de passe directement utilisables par les utilisateurs. Pour l'instant, lorsque vous créez des utilisateurs à l'aide de AdminCreateUser ou en vous inscrivant à l'application, des étapes supplémentaires sont nécessaires: obliger les utilisateurs à modifier le mot de passe lors de la connexion ou demander aux utilisateurs de vérifier l'adresse e-mail ou le numéro de téléphone afin de modifier le statut de l'utilisateur. CONFIRMED.

11
Ionut Trestian

Je sais que cela fait longtemps, mais j'ai pensé que cela pourrait aider les autres personnes qui trouveraient ce message.

Vous pouvez utiliser l'AWS CLI pour modifier le mot de passe des utilisateurs, mais il s'agit d'un processus en plusieurs étapes:
La première étape consiste à obtenir un jeton de session pour l'utilisateur souhaité:
aws cognito-idp admin-initiate-auth --user-pool-id %USER POOL ID% --client-id %APP CLIENT ID% --auth-flow ADMIN_NO_SRP_AUTH --auth-parameters USERNAME=%USERS USERNAME%,PASSWORD=%USERS CURRENT PASSWORD%

cela répondra avec le défi "NEW_PASSWORD_REQUIRED", d'autres paramètres de défi et la clé de session des utilisateurs. Ensuite, vous pouvez exécuter la deuxième commande pour émettre la réponse au défi:
aws cognito-idp admin-respond-to-auth-challenge --user-pool-id %USER POOL ID% --client-id %CLIENT ID% --challenge-name NEW_PASSWORD_REQUIRED --challenge-responses NEW_PASSWORD=%DESIRED PASSWORD%,USERNAME=%USERS USERNAME% --session %SESSION KEY FROM PREVIOUS COMMAND with ""%

cela devrait renvoyer un résultat d'authentification valide et des jetons appropriés.

Pour que cela fonctionne, le groupe d'utilisateurs Cognito DOIT avoir un client d'application configuré avec la fonctionnalité ADMIN_NO_SRP_AUTH. (notez l'étape 5 http://docs.aws.Amazon.com/cognito/latest/developerguide/user-pool-settings-client-apps.html )

91
Neutral Penguin

Vous pouvez modifier le statut de l'utilisateur FORCE_CHANGE_PASSWORD en appelant respondToAuthChallenge () de la manière suivante:

var params = {
  ChallengeName: 'NEW_PASSWORD_REQUIRED', 
  ClientId: 'your_own3j63rs8j16bxxxsto25db00obh',
  ChallengeResponses: {
    USERNAME: 'user3',
    NEW_PASSWORD: 'changed12345'
  },
  Session: 'xxxxxxxxxxZDMcRu-5u019i_gAcX5lw1biFnKLtfPrO2eZ-nenOLrr5xaHv-ul_-nGsOulyNG12H85GJ2UGiCGtfe-BdwTmQ-BMUnd2Twr9El45xgpGKWDrYcp11J4J9kZN71ZczynizRJ7oa5a_j2AiBYukzhd_YzPWGscrFu98qqn_JoiLsJ7w9v_C_Zpw6-ixCs09suYQKZ3YlWNFmMpC2nSiKrXUA8ybQkdj6vIO68d-vtYq0mVHt410v2TBtK4czOAh5MieO55kgvGHCxvEusQOTeFYh4Mjh1bwcHWRvSV6mVIrVSm4FnRs0u26vUDq79CgkuycRl2iOoqxc1abcaANKmEB45r2oPnmPZIhVqNO5eHe6fpac7s3pHwLKvNOv7EaQkjyY9Vb5gINmSjXBjBl3O3aqQ7KXyueuHHSLrfchP64SwuNQZSfL1Vis0ap5JtSat3udslzUBiU8FEhmJNwPX08QyIm4DqviTLp6lDqH5pH6BuvO9OUHPrEcDzufOx1a76pld-9f-NGfactCUZC0elQcAiGSqbwfiRYHn7TDHuX1WKf9L9E6GvhJhB154SxxhXsLm3Yv9DhWhOlVbhdbzR2Bq4dqJRDOPY2wengFX6v36TLlYZTHbGEc_PbSlx8Ru80avxehAmUNtNqDYjGbXq0vBWaEiJmkr1isF7XsCvrmZb6tHY'
};

cognitoidentityserviceprovider.respondToAuthChallenge(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Après cela, vous verrez dans la console que le statut de l'utilisateur 3 est CONFIRMÉ.

15
Ariel Araza

Ajoutez simplement ce code après votre onSuccess: function (result) { ... }, dans votre fonction de connexion. Votre utilisateur aura alors le statutCONFIRMÉ.

newPasswordRequired: function(userAttributes, requiredAttributes) {
    // User was signed up by an admin and must provide new
    // password and required attributes, if any, to complete
    // authentication.

    // the api doesn't accept this field back
    delete userAttributes.email_verified;

    // unsure about this field, but I don't send this back
    delete userAttributes.phone_number_verified;

    // Get these details and call
    cognitoUser.completeNewPasswordChallenge(newPassword, userAttributes, this);
}
13
Baked Inhalf

Ceci a finalement été ajouté à AWSCLI: https://docs.aws.Amazon.com/cli/latest/reference/cognito-idp/admin-set-user-password.html

Vous pouvez changer le mot de passe d'un utilisateur et son statut de mise à jour en utilisant:

aws cognito-idp admin-set-user-password --user-pool-id <your user pool id> --username user1 --password password --permanent

Avant de l'utiliser, vous devrez peut-être mettre à jour votre AWS CLI en utilisant:

pip3 install awscli --upgrade

4
joe

Vous pouvez résoudre ce problème à l'aide du SDK Amazon-cognito-identity-js en vous authentifiant avec le mot de passe temporaire après la création du compte avec cognitoidentityserviceprovider.adminCreateUser() et en exécutant cognitoUser.completeNewPasswordChallenge() dans cognitoUser.authenticateUser( ,{newPasswordRequired}), le tout dans la fonction qui crée votre utilisateur.

J'utilise le code ci-dessous dans AWS lambda pour créer des comptes d'utilisateur Cognito activés. Je suis sûr que cela peut être optimisé, soyez patient avec moi. Ceci est mon premier article et je suis encore assez nouveau en JavaScript.

var AWS = require("aws-sdk");
var AWSCognito = require("Amazon-cognito-identity-js");

var params = {
    UserPoolId: your_poolId,
    Username: your_username,
    DesiredDeliveryMediums: ["EMAIL"],
    ForceAliasCreation: false,
    MessageAction: "SUPPRESS",
    TemporaryPassword: your_temporaryPassword,
    UserAttributes: [
        { Name: "given_name", Value: your_given_name },
        { Name: "email", Value: your_email },
        { Name: "phone_number", Value: your_phone_number },
        { Name: "email_verified", Value: "true" }
    ]
};

var cognitoidentityserviceprovider = new AWS.CognitoIdentityServiceProvider();
let promise = new Promise((resolve, reject) => {
    cognitoidentityserviceprovider.adminCreateUser(params, function(err, data) {
        if (err) {
            reject(err);
        } else {
            resolve(data);
        }
    });
});

promise
    .then(data => {
        // login as new user and completeNewPasswordChallenge
        var anotherPromise = new Promise((resolve, reject) => {
            var authenticationDetails = new AWSCognito.AuthenticationDetails({
                Username: your_username,
                Password: your_temporaryPassword
            });
            var poolData = {
                UserPoolId: your_poolId,
                ClientId: your_clientId
            };
            var userPool = new AWSCognito.CognitoUserPool(poolData);
            var userData = {
                Username: your_username,
                Pool: userPool
            };

            var cognitoUser = new AWSCognito.CognitoUser(userData);
            let finalPromise = new Promise((resolve, reject) => {
                cognitoUser.authenticateUser(authenticationDetails, {
                    onSuccess: function(authResult) {
                        cognitoUser.getSession(function(err) {
                            if (err) {
                            } else {
                                cognitoUser.getUserAttributes(function(
                                    err,
                                    attResult
                                ) {
                                    if (err) {
                                    } else {
                                        resolve(authResult);
                                    }
                                });
                            }
                        });
                    },
                    onFailure: function(err) {
                        reject(err);
                    },
                    newPasswordRequired(userAttributes, []) {
                        delete userAttributes.email_verified;
                        cognitoUser.completeNewPasswordChallenge(
                            your_newPoassword,
                            userAttributes,
                            this
                        );
                    }
                });
            });

            finalPromise
                .then(finalResult => {
                    // signout
                    cognitoUser.signOut();
                    // further action, e.g. email to new user
                    resolve(finalResult);
                })
                .catch(err => {
                    reject(err);
                });
        });
        return anotherPromise;
    })
    .then(() => {
        resolve(finalResult);
    })
    .catch(err => {
        reject({ statusCode: 406, error: err });
    });
3
qqan.ny

Pour le SDK Java, en supposant que votre client Cognito soit configuré et que votre utilisateur soit dans l'état FORCE_CHANGE_PASSWORD, vous pouvez procéder comme suit pour obtenir votre utilisateur CONFIRMED ..., puis autorisé comme d'habitude.

AdminCreateUserResult createUserResult = COGNITO_CLIENT.adminCreateUser(createUserRequest());

AdminInitiateAuthResult authResult = COGNITO_CLIENT.adminInitiateAuth(authUserRequest());


Map<String,String> challengeResponses = new HashMap<>();
challengeResponses.put("USERNAME", USERNAME);
challengeResponses.put("NEW_PASSWORD", PASSWORD);
RespondToAuthChallengeRequest respondToAuthChallengeRequest = new RespondToAuthChallengeRequest()
      .withChallengeName("NEW_PASSWORD_REQUIRED")
      .withClientId(CLIENT_ID)
      .withChallengeResponses(challengeResponses)
      .withSession(authResult.getSession());

COGNITO_CLIENT.respondToAuthChallenge(respondToAuthChallengeRequest);

J'espère que cela aidera avec ces tests d'intégration (Désolé pour le formatage)

3
HKalsi

D'ACCORD. J'ai enfin le code où un administrateur peut créer un nouvel utilisateur. Le processus se déroule comme suit:

  1. Admin crée l'utilisateur 
  2. L'utilisateur reçoit un email avec son mot de passe temporaire 
  3. L'utilisateur se connecte et est invité à changer son mot de passe

L'étape 1 est la partie difficile. Voici mon code pour créer un utilisateur dans Node JS:

let params = {
  UserPoolId: "@cognito_pool_id@",
  Username: username,
  DesiredDeliveryMediums: ["EMAIL"],
  ForceAliasCreation: false,
  UserAttributes: [
    { Name: "given_name", Value: firstName },
    { Name: "family_name", Value: lastName},
    { Name: "name", Value: firstName + " " + lastName},
    { Name: "email", Value: email},
    { Name: "custom:title", Value: title},
    { Name: "custom:company", Value: company + ""}
  ],
};
let cognitoIdentityServiceProvider = new AWS.CognitoIdentityServiceProvider();
cognitoIdentityServiceProvider.adminCreateUser(params, function(error, data) {
  if (error) {
    console.log("Error adding user to cognito: " + error, error.stack);
    reject(error);
  } else {
    // Uncomment for interesting but verbose logging...
    //console.log("Received back from cognito: " + CommonUtils.stringify(data));
    cognitoIdentityServiceProvider.adminUpdateUserAttributes({
      UserAttributes: [{
        Name: "email_verified",
        Value: "true"
      }],
      UserPoolId: "@cognito_pool_id@",
      Username: username
    }, function(err) {
      if (err) {
        console.log(err, err.stack);
      } else {
        console.log("Success!");
        resolve(data);
      }
    });
  }
});

Fondamentalement, vous devez envoyer une deuxième commande pour forcer le courrier électronique à être considéré comme vérifié. L'utilisateur doit toujours accéder à son courrier électronique pour obtenir le mot de passe temporaire (qui vérifie également le courrier électronique). Mais sans ce deuxième appel qui définit le courrier électronique sur vérifié, vous ne recevrez pas le bon rappel pour réinitialiser leur mot de passe.

1
Ryan Shillington

Je sais que c'est la même réponse, mais je pensais que cela pourrait aider la communauté de développeurs Go. fondamentalement, il lance une demande d'authentification, récupère la session et répond au défi NEW_PASSWORD_REQUIRED

func sessionWithDefaultRegion(region string) *session.Session {
    sess := Session.Copy()
    if v := aws.StringValue(sess.Config.Region); len(v) == 0 {
        sess.Config.Region = aws.String(region)
    }

    return sess
}



func (c *CognitoAppClient) ChangePassword(userName, currentPassword, newPassword string)   error {

    sess := sessionWithDefaultRegion(c.Region)
    svc := cognitoidentityprovider.New(sess)

    auth, err := svc.AdminInitiateAuth(&cognitoidentityprovider.AdminInitiateAuthInput{
        UserPoolId:aws.String(c.UserPoolID),
        ClientId:aws.String(c.ClientID),
        AuthFlow:aws.String("ADMIN_NO_SRP_AUTH"),
        AuthParameters: map[string]*string{
            "USERNAME": aws.String(userName),
            "PASSWORD": aws.String(currentPassword),
        },

    })



    if err != nil {
        return err
    }

    request := &cognitoidentityprovider.AdminRespondToAuthChallengeInput{
        ChallengeName: aws.String("NEW_PASSWORD_REQUIRED"),
        ClientId:aws.String(c.ClientID),
        UserPoolId: aws.String(c.UserPoolID),
        ChallengeResponses:map[string]*string{
            "USERNAME":aws.String(userName),
            "NEW_PASSWORD": aws.String(newPassword),
        },
        Session:auth.Session,
    }


    _, err = svc.AdminRespondToAuthChallenge(request)

    return err 
}

Voici un test unitaire:

import (
    "fmt"
    "github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
    . "github.com/smartystreets/goconvey/convey"
    "testing"
)


func TestCognitoAppClient_ChangePassword(t *testing.T) {


    Convey("Testing ChangePassword!", t, func() {
        err := client.ChangePassword("user_name_here", "current_pass", "new_pass")



        Convey("Testing ChangePassword Results!", func() {
            So(err, ShouldBeNil)

        })

    })
}
1
msoliman

En gros, la réponse est la même, mais pour le SDK .Net C #:

Ce qui suit va créer une création d'administrateur complet avec le nom d'utilisateur et le mot de passe souhaités . Avoir le modèle d'utilisateur suivant:

public class User
{
    public string Username { get; set; }
    public string Password { get; set; }
}

Vous pouvez créer un utilisateur et le rendre prêt à l'emploi en utilisant:

   public void AddUser(User user)
    {
        var tempPassword = "ANY";
        var request = new AdminCreateUserRequest()
        {
            Username = user.Username,
            UserPoolId = "MyuserPoolId",
            TemporaryPassword = tempPassword
        };
        var result = _cognitoClient.AdminCreateUserAsync(request).Result;
        var authResponse = _cognitoClient.AdminInitiateAuthAsync(new AdminInitiateAuthRequest()
        {
            UserPoolId = "MyuserPoolId",
            ClientId = "MyClientId",
            AuthFlow = AuthFlowType.ADMIN_NO_SRP_AUTH,
            AuthParameters = new Dictionary<string, string>()
            {
                {"USERNAME",user.Username },
                {"PASSWORD", tempPassword}
            }
        }).Result;
        _cognitoClient.RespondToAuthChallengeAsync(new RespondToAuthChallengeRequest()
        {
         ClientId = "MyClientId",
            ChallengeName = ChallengeNameType.NEW_PASSWORD_REQUIRED,
            ChallengeResponses = new Dictionary<string, string>()
            {
                {"USERNAME",user.Username },
                {"NEW_PASSWORD",user.Password }
            },
            Session = authResponse.Session
        });
    }
0
Yahya Hussein

je ne sais pas si vous vous battez toujours avec cela, mais pour créer un groupe d'utilisateurs test uniquement, j'ai utilisé la variable awscli en tant que telle:

  1. Utilisez la sous-commande d'abonnement de cognito-idp pour créer l'utilisateur.
aws cognito-idp sign-up \
   --region %aws_project_region% \
   --client-id %aws_user_pools_web_client_id% \
   --username %email_address% \
   --password %password% \
   --user-attributes Name=email,Value=%email_address%
  1. Confirmez l'utilisateur avec admin-confirmation-sign-up
aws cognito-idp admin-confirm-sign-up \
--user-pool-id %aws_user_pools_web_client_id% \
--username %email_address%
0
Björn W