it-swarm.com.de

Wie kann ich den Anwenderstatus FORCE_CHANGE_PASSWORD ändern?

Mit AWS Cognito möchte ich Dummy-Benutzer zu Testzwecken erstellen.

Ich verwende dann die AWS Console , um einen solchen Benutzer zu erstellen, aber der Benutzer hat seinen status auf FORCE_CHANGE_PASSWORD gesetzt. Mit diesem Wert kann dieser Benutzer nicht authentifiziert werden.

Gibt es eine Möglichkeit, diesen Status zu ändern?

UPDATE Gleiches Verhalten beim Erstellen eines Benutzers über die CLI

45
Dominique Vial

Entschuldigung, Sie haben Schwierigkeiten. Wir haben keinen Ein-Schritt-Prozess, bei dem Sie einfach Benutzer erstellen und direkt authentifizieren können. Wir könnten dies in Zukunft ändern, indem Administratoren Kennwörter festlegen können, die direkt von Benutzern verwendet werden können. Wenn Sie jetzt Benutzer entweder mit AdminCreateUser erstellen oder indem Sie Benutzer mit der App anmelden, sind zusätzliche Schritte erforderlich, indem Sie die Benutzer dazu zwingen, das Kennwort bei der Anmeldung zu ändern, oder die Benutzer die E-Mail- oder Telefonnummer bestätigen lassen, um den Status des Benutzers zu ändern CONFIRMED.

11
Ionut Trestian

Ich weiß, es ist schon eine Weile her, aber ich dachte, das könnte anderen Leuten helfen, die auf diesen Beitrag stoßen.

Sie können die AWS-CLI verwenden, um das Benutzerkennwort zu ändern. Dies ist jedoch ein mehrstufiger Prozess:
Schritt 1 ist das Abrufen eines Sitzungstokens für den gewünschten Benutzer:
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%

dies wird mit der Abfrage "NEW_PASSWORD_REQUIRED", anderen Abfrageparametern und dem Sitzungsschlüssel des Benutzers antworten. Dann können Sie den zweiten Befehl ausführen, um die Challenge-Antwort auszugeben:
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 ""%

dies sollte ein gültiges Authentifizierungsergebnis und entsprechende Token zurückgeben.

Damit dies funktioniert, MUSS der Cognito User Pool über einen App-Client verfügen, der mit der Funktionalität ADMIN_NO_SRP_AUTH konfiguriert ist. (Hinweis Schritt 5 http://docs.aws.Amazon.com/cognito/latest/developerguide/user-pool-settings-client-apps.html )

91
Neutral Penguin

Sie können diesen Benutzerstatus FORCE_CHANGE_PASSWORD ändern, indem Sie replyToAuthChallenge () für den Benutzer folgendermaßen aufrufen:

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

Danach sehen Sie in der Konsole, dass der Status von user3 BESTÄTIGT ist

15
Ariel Araza

Fügen Sie diesen Code einfach nach Ihrer onSuccess: function (result) { ... }, in Ihre Login-Funktion ein. Ihr Benutzer hat dann den StatusBESTÄTIGT.

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

Dies wurde schließlich zu AWSCLI hinzugefügt: https://docs.aws.Amazon.com/cli/latest/reference/cognito-idp/admin-set-user-password.html

Sie können das Kennwort und den Aktualisierungsstatus eines Benutzers wie folgt ändern:

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

Bevor Sie dies verwenden können, müssen Sie möglicherweise Ihre AWS-CLI aktualisieren, indem Sie Folgendes verwenden:

pip3 install awscli --upgrade

4
joe

Sie können dieses Problem mit dem Amazon-cognito-identity-js-SDK lösen, indem Sie sich nach der Kontoerstellung mit cognitoidentityserviceprovider.adminCreateUser() mit dem temporären Kennwort authentifizieren und cognitoUser.completeNewPasswordChallenge() innerhalb von cognitoUser.authenticateUser( ,{newPasswordRequired}) ausführen - alles innerhalb der Funktion, die Ihren Benutzer erstellt.

Ich verwende den folgenden Code in AWS-Lambda, um aktivierte Cognito-Benutzerkonten zu erstellen. Ich bin sicher, dass es optimiert werden kann, habe Geduld mit mir. Dies ist mein erster Beitrag und ich bin noch relativ neu in 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

Für das Java SDK können Sie davon ausgehen, dass Ihr Cognito-Client eingerichtet ist und sich Ihr Benutzer im Status FORCE_CHANGE_PASSWORD befindet. Sie können Folgendes tun, um Ihren Benutzer zu BESTÄTIGEN ... und dann wie gewohnt zu authentifizieren.

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

Hoffe, es hilft bei diesen Integrationstests (Sorry über die Formatierung)

3
HKalsi

OK. Ich habe endlich Code, wo ein Administrator einen neuen Benutzer anlegen kann. Der Prozess läuft so ab:

  1. Admin erstellt den Benutzer 
  2. Der Benutzer erhält eine E-Mail mit seinem temporären Passwort 
  3. Der Benutzer meldet sich an und wird aufgefordert, sein Passwort zu ändern

Schritt 1 ist der schwierige Teil. Hier ist mein Code zum Erstellen eines Benutzers in Node JS:

let params = {
  UserPoolId: "@[email protected]",
  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: "@[email protected]",
      Username: username
    }, function(err) {
      if (err) {
        console.log(err, err.stack);
      } else {
        console.log("Success!");
        resolve(data);
      }
    });
  }
});

Grundsätzlich müssen Sie einen zweiten Befehl senden, damit die E-Mail als verifiziert gilt. Der Benutzer muss immer noch zu seiner E-Mail gehen, um das temporäre Kennwort zu erhalten (das auch die E-Mail überprüft). Aber ohne diesen zweiten Anruf, bei dem die E-Mail als bestätigt eingestuft wird, erhalten Sie nicht den richtigen Rückruf, um das Kennwort zurückzusetzen.

1

Ich weiß, es ist die gleiche Antwort, dachte aber, es könnte der Go Entwicklergemeinschaft helfen. Im Grunde geht es darum, eine Authentifizierungsanfrage zu starten, die Sitzung abzurufen und auf die Herausforderung zu antworten. 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 
}

Hier ist ein Unit-Test:

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

Im Grunde ist dies die gleiche Antwort, aber für .Net C # SDK:

Im Folgenden wird eine vollständige Admin-Benutzererstellung mit dem gewünschten Benutzernamen und Kennwort erstellt.

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

Sie können einen Benutzer erstellen und mit folgenden Funktionen verwenden:

   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

ich bin mir nicht sicher, ob Sie immer noch damit kämpfen, aber um nur einige Testbenutzer zu erstellen, habe ich die awscli als solche verwendet:

  1. Verwenden Sie den Unterbefehl zur Anmeldung von cognito-idp, um den Benutzer zu erstellen
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. Bestätigen Sie den Benutzer mit admin-confirm-sign
aws cognito-idp admin-confirm-sign-up \
--user-pool-id %aws_user_pools_web_client_id% \
--username %email_address%
0
Björn W