Jak zmienić status użytkownika FORCE_CHANGE_PASSWORD?

Korzystając z AWS Cognito, chcę stworzyć fałszywych użytkowników do celów testowych.

Następnie używam konsoli AWS do tworzenia takiego użytkownika, ale ten użytkownik ma ustawiony statusFORCE_CHANGE_PASSWORD . Przy tej wartości ten użytkownik nie może zostać uwierzytelniony.

Czy istnieje sposób na zmianę tego statusu?

UPDATE To samo zachowanie podczas tworzenia użytkownika z CLI

Przepraszamy, masz trudności. Nie mamy jednoetapowego procesu, w którym można po prostu tworzyć użytkowników i bezpośrednio ich uwierzytelniać. W przyszłości możemy to zmienić, na przykład zezwalając administratorom na ustawianie haseł, których użytkownicy mogą bezpośrednio używać. Na razie, gdy tworzysz użytkowników za pomocą aplikacji AdminCreateUserlub rejestrując użytkowników w aplikacji, wymagane są dodatkowe kroki, zmuszające użytkowników do zmiany hasła po zalogowaniu lub wymagające weryfikacji adresu e-mail lub numeru telefonu w celu zmiany statusu użytkownika na CONFIRMED.

Wiem, że minęło trochę czasu, ale pomyślałem, że może to pomóc innym osobom, które natknęły się na ten post.

Możesz użyć interfejsu AWS CLI, aby zmienić hasło użytkownika, jednak jest to proces wieloetapowy:

Krok 1: Uzyskaj token sesji dla wybranego użytkownika:

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%

Jeśli to zwróci błąd dotyczący Unable to verify secret hash for client, utwórz innego klienta aplikacji bez wpisu tajnego i użyj tego identyfikatora klienta.

Krok 2: Jeśli krok 1 zakończy się powodzeniem, odpowie wyzwaniem NEW_PASSWORD_REQUIRED, innymi parametrami wyzwania i kluczem sesji użytkownika. Następnie możesz uruchomić drugie polecenie, aby wydać odpowiedź na wyzwanie:

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

Jeśli pojawi się błąd dotyczący Invalid attributes given, XXX is missingprzekazania brakujących atrybutów przy użyciu formatuuserAttributes.$FIELD_NAME=$VALUE

Powyższe polecenie powinno zwrócić prawidłowy wynik uwierzytelnienia i odpowiednie tokeny.

Ważne: aby to zadziałało, pula użytkowników Cognito MUSI mieć skonfigurowanego klienta aplikacji z ADMIN_NO_SRP_AUTHfunkcjonalnością ( krok 5 w tym dokumencie ).

To zostało ostatecznie dodane do AWSCLI: https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/admin-set-user-password.html

Możesz zmienić hasło użytkownika i zaktualizować stan za pomocą:

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

Przed użyciem tego może być konieczne zaktualizowanie interfejsu wiersza polecenia AWS za pomocą:

pip3 install awscli --upgrade

Po prostu dodaj ten kod po swojej onSuccess: function (result) { ... },funkcji logowania. Twój użytkownik będzie miał wtedy status POTWIERDZONY .

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

Możesz zmienić ten status użytkownika FORCE_CHANGE_PASSWORD, dzwoniąc respondToAuthChallenge()do użytkownika w ten sposób:

var params = {
  ChallengeName: 'NEW_PASSWORD_REQUIRED', 
  ClientId: 'your_own3j6...0obh',
  ChallengeResponses: {
    USERNAME: 'user3',
    NEW_PASSWORD: 'changed12345'
  },
  Session: 'xxxxxxxxxxZDMcRu-5u...sCvrmZb6tHY'
};

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

Następnie zobaczysz w konsoli, że user3status to CONFIRMED.

nie jestem pewien, czy nadal z tym walczysz, ale do tworzenia tylko grupy użytkowników testowych, użyłem awsclijako takiego:

1. Użyj komendy rejestracji z cognito-idp, aby utworzyć użytkownika

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%

2. Potwierdź użytkownika za pomocą polecenia admin-confirm-sign-up

aws cognito-idp admin-confirm-sign-up \
--user-pool-id %aws_user_pools_web_client_id% \
--username %email_address%

Jeśli próbujesz zmienić status jako administrator z konsoli. Następnie wykonaj poniższe czynności po utworzeniu użytkownika.

1. W Cognito goto -> "zarządzaj pulą użytkowników" ->
2. Przejdź do „Ustawienia klienta aplikacji” w sekcji Integracja aplikacji.
3. Sprawdź poniższe elementy i) Pula użytkowników Cognito ii) Nadanie kodu autoryzacji iii) Udzielenie niejawne iv) telefon v) e-mail vi) openid vii) aws.cognito.signin.user.admin viii) profil
4. Wprowadź adres zwrotny swojej aplikacji. Jeśli nie masz pewności, wpisz na przykład: https://google.com i później możesz zmienić go na rzeczywisty adres zwrotny
5. kliknij Zapisz zmiany.
6. Po zapisaniu zmian kliknij link „Uruchom hostowany interfejs użytkownika”
7. Wprowadź poświadczenia nowo utworzonego użytkownika
8. Zresetuj hasło, używając nowych poświadczeń i udostępnij je użytkownikowi

krok 2

krok 3 4 5 6

krok 7

krok 8

AKTUALIZACJA:

Pojawiły się pewne aktualizacje i klient Amplify nie jest już potrzebny. Po adminCreateUser () możesz teraz po prostu użyć

cisp.adminSetUserPassword({
  UserPoolId: pool_id,
  Username: login,
  Password: password,
  Permanent: true
}) 

[https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminSetUserPassword.html]

spowoduje to ustawienie użytkownika na „potwierdzone”.

AKTUALIZACJA:

Teraz używam tego, przetłumaczonego na wzmocnienie, wewnątrz NodeJS Lambda:

// enable node-fetch polyfill for Node.js
global.fetch = require("node-fetch").default;
global.navigator = {};

const AWS = require("aws-sdk");
const cisp = new AWS.CognitoIdentityServiceProvider();

const Amplify = require("@aws-amplify/core").default;
const Auth = require("@aws-amplify/auth").default;

...


/*
  this_user: {
    given_name: string,
    password: string,
    email: string,
    cell: string
  }
*/
const create_cognito = (this_user) => {
  let this_defaults = {
    password_temp: Math.random().toString(36).slice(-8),
    password: this_user.password,
    region: global._env === "prod" ? production_region : development_region,
    UserPoolId:
      global._env === "prod"
        ? production_user_pool
        : development_user_pool,
    ClientId:
      global._env === "prod"
        ? production_client_id
        : development_client_id,
    given_name: this_user.given_name,
    email: this_user.email,
    cell: this_user.cell,
  };

  // configure Amplify
  Amplify.configure({
    Auth: {
      region: this_defaults.region,
      userPoolId: this_defaults.UserPoolId,
      userPoolWebClientId: this_defaults.ClientId,
    },
  });
  if (!Auth.configure())
    return Promise.reject("could not configure amplify");

  return new Promise((resolve, reject) => {
    let _result = {};

    let this_account = undefined;
    let this_account_details = undefined;

    // create cognito account
    cisp
      .adminCreateUser({
        UserPoolId: this_defaults.UserPoolId,
        Username: this_defaults.given_name,
        DesiredDeliveryMediums: ["EMAIL"],
        ForceAliasCreation: false,
        MessageAction: "SUPPRESS",
        TemporaryPassword: this_defaults.password_temp,
        UserAttributes: [
          { Name: "given_name", Value: this_defaults.given_name },
          { Name: "email", Value: this_defaults.email },
          { Name: "phone_number", Value: this_defaults.cell },
          { Name: "email_verified", Value: "true" },
        ],
      })
      .promise()
      .then((user) => {
        console.warn(".. create_cognito: create..");
        _result.username = user.User.Username;
        _result.temporaryPassword = this_defaults.password_temp;
        _result.password = this_defaults.password;

        // sign into cognito account
        return Auth.signIn(_result.username, _result.temporaryPassword);
      })
      .then((user) => {
        console.warn(".. create_cognito: signin..");

        // complete challenge
        return Auth.completeNewPassword(user, _result.password, {
          email: this_defaults.email,
          phone_number: this_defaults.cell,
        });
      })
      .then((user) => {
        console.warn(".. create_cognito: confirmed..");
        this_account = user;
        // get details
        return Auth.currentAuthenticatedUser();
      })
      .then((this_details) => {
        if (!(this_details && this_details.attributes))
          throw "account creation failes";

        this_account_details = Object.assign({}, this_details.attributes);

        // signout
        return this_account.signOut();
      })
      .then(() => {
        console.warn(".. create_cognito: complete");
        resolve(this_account_details);
      })
      .catch((err) => {
        console.error(".. create_cognito: error");
        console.error(err);
        reject(err);
      });
  });
};

Ustawiam hasło tymczasowe, a następnie resetuję je do hasła żądanego przez użytkownika.

STARY POST:

Możesz rozwiązać ten problem za pomocą zestawu SDK amazon-cognito-identity-js, uwierzytelniając się tymczasowym hasłem po utworzeniu konta cognitoidentityserviceprovider.adminCreateUser()i uruchamiając cognitoUser.completeNewPasswordChallenge()wcognitoUser.authenticateUser( ,{newPasswordRequired}) ramach funkcji, która tworzy użytkownika.

Używam poniższego kodu wewnątrz lambdy AWS, aby utworzyć włączone konta użytkowników Cognito. Jestem pewien, że można to zoptymalizować, bądź do mnie cierpliwa. To jest mój pierwszy post, a ja wciąż jestem całkiem nowy w 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 });
    });

W przypadku Java SDK, zakładając, że klient Cognito jest skonfigurowany, a użytkownik jest w stanie FORCE_CHANGE_PASSWORD, można wykonać następujące czynności, aby uzyskać POTWIERDZENIE użytkownika ... a następnie normalnie uwierzytelnić.

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

Mam nadzieję, że pomoże to w tych testach integracji (przepraszam za formatowanie)

Zasadniczo jest to ta sama odpowiedź, ale w przypadku zestawu SDK .Net C #:

Poniższe czynności spowodują utworzenie pełnego administratora z żądaną nazwą użytkownika i hasłem. Posiadanie następującego modelu użytkownika:

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

Możesz utworzyć użytkownika i przygotować go do użycia za pomocą:

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

Wiem, że to ta sama odpowiedź, ale pomyślałem, że może pomóc Gospołeczności programistów. w zasadzie jest to zainicjowanie żądania autoryzacji, uzyskanie sesji i odpowiedź na wyzwanieNEW_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 
}

Oto test jednostkowy:

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)

        })

    })
}

DOBRZE. W końcu mam kod, w którym administrator może utworzyć nowego użytkownika. Proces przebiega następująco:

1. Administrator tworzy użytkownika
2. Użytkownik otrzyma wiadomość e-mail z tymczasowym hasłem
3. Użytkownik loguje się i jest proszony o zmianę hasła

Krok 1 to najtrudniejsza część. Oto mój kod do tworzenia użytkownika w 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);
      }
    });
  }
});

Zasadniczo musisz wysłać drugie polecenie, aby wymusić uznanie wiadomości e-mail za zweryfikowaną. Użytkownik nadal musi przejść do swojego adresu e-mail, aby uzyskać tymczasowe hasło (które również weryfikuje e-mail). Ale bez tego drugiego połączenia, które ustawia adres e-mail na zweryfikowany, nie otrzymasz odpowiedniego połączenia zwrotnego, aby zresetować hasło.