Bagaimana cara mengubah Status Pengguna FORCE_CHANGE_PASSWORD?

Dengan menggunakan AWS Cognito, saya ingin membuat pengguna tiruan untuk tujuan pengujian.

Saya kemudian menggunakan AWS Console untuk membuat pengguna tersebut, tetapi pengguna memiliki nya statusnya ditetapkan untuk FORCE_CHANGE_PASSWORD. Dengan nilai tersebut, pengguna ini tidak dapat diautentikasi.

Apakah ada cara untuk mengubah status ini?

UPDATE Perilaku yang sama saat membuat pengguna dari CLI

Maaf Anda mengalami kesulitan. Kami tidak memiliki proses satu langkah di mana Anda hanya dapat membuat pengguna dan mengautentikasi mereka secara langsung. Kami mungkin mengubahnya di masa mendatang seperti mengizinkan administrator untuk mengatur kata sandi yang dapat digunakan secara langsung oleh pengguna. Untuk saat ini, saat Anda membuat pengguna baik menggunakan AdminCreateUseratau dengan mendaftarkan pengguna dengan aplikasi, langkah-langkah tambahan diperlukan, baik memaksa pengguna untuk mengubah kata sandi saat masuk atau meminta pengguna memverifikasi email atau nomor telepon untuk mengubah status pengguna CONFIRMED.

Saya tahu ini sudah lama tetapi saya pikir ini mungkin membantu orang lain yang menemukan posting ini.

Anda dapat menggunakan AWS CLI untuk mengubah kata sandi pengguna, bagaimanapun ini adalah proses multi langkah:

Langkah 1: Dapatkan token sesi untuk pengguna yang diinginkan:

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%

Jika ini mengembalikan kesalahan tentang Unable to verify secret hash for client, buat klien aplikasi lain tanpa rahasia dan gunakan ID klien tersebut.

Langkah 2: Jika langkah 1 berhasil, langkah itu akan merespons dengan tantangan NEW_PASSWORD_REQUIRED, parameter tantangan lain, dan kunci sesi pengguna. Kemudian, Anda dapat menjalankan perintah kedua untuk mengeluarkan respons tantangan:

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

Jika Anda mendapatkan pesan kesalahan tentang Invalid attributes given, XXX is missinglulus atribut yang hilang menggunakan formatuserAttributes.$FIELD_NAME=$VALUE

Perintah di atas harus mengembalikan Hasil Otentikasi yang valid dan Token yang sesuai.

Penting: Agar ini bekerja, Cognito User Pool HARUS memiliki klien Aplikasi yang dikonfigurasi dengan ADMIN_NO_SRP_AUTHfungsionalitas ( Langkah 5 dalam dokumen ini ).

Ini akhirnya ditambahkan ke AWSCLI: https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/admin-set-user-password.html

Anda dapat mengubah kata sandi pengguna dan memperbarui status menggunakan:

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

Sebelum menggunakan ini, Anda mungkin perlu memperbarui AWS CLI Anda menggunakan:

pip3 install awscli --upgrade

Cukup tambahkan kode ini setelah Anda onSuccess: function (result) { ... },dalam fungsi login Anda. Pengguna Anda kemudian akan memiliki status DIKONFIRMASI .

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

Anda dapat mengubah status pengguna tersebut FORCE_CHANGE_PASSWORDdengan memanggil respondToAuthChallenge()pengguna seperti ini:

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

Setelah ini, Anda akan melihat di konsol user3status tersebut CONFIRMED.

tidak yakin apakah Anda masih berjuang dengan ini tetapi untuk membuat sekelompok pengguna uji saja, saya menggunakan awscliseperti itu:

1. Gunakan subperintah daftar dari cognito-idp untuk membuat pengguna

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. Konfirmasikan pengguna menggunakan admin-confirm-sign-up

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

MEMPERBARUI:

Saya sekarang menggunakan ini, diterjemahkan untuk memperkuat, di dalam 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);
      });
  });
};

Saya menyetel kata sandi sementara dan kemudian menyetel ulang ke kata sandi yang diminta pengguna.

POSTING LAMA:

Anda dapat menyelesaikan ini menggunakan amazon-cognito-identity-js SDK dengan mengautentikasi dengan kata sandi sementara setelah pembuatan akun dengan cognitoidentityserviceprovider.adminCreateUser(), dan berjalan di cognitoUser.completeNewPasswordChallenge()dalam cognitoUser.authenticateUser( ,{newPasswordRequired})- semua di dalam fungsi yang membuat pengguna Anda.

Saya menggunakan kode di bawah ini di dalam AWS lambda untuk membuat akun pengguna Cognito yang diaktifkan. Saya yakin bisa dioptimalkan, bersabarlah dengan saya. Ini adalah posting pertama saya, dan saya masih cukup baru mengenal 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 });
    });

Untuk Java SDK, anggap klien Cognito Anda sudah disiapkan dan Anda memiliki pengguna dalam status FORCE_CHANGE_PASSWORD, Anda dapat melakukan hal berikut untuk membuat pengguna DIKONFIRMASI ... dan kemudian diautentikasi seperti biasa.

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

Semoga membantu dengan tes integrasi tersebut (Maaf tentang pemformatannya)

Pada dasarnya ini adalah jawaban yang sama tetapi untuk .Net C # SDK:

Berikut ini akan membuat pembuatan pengguna admin penuh dengan nama pengguna dan kata sandi yang diinginkan. Memiliki model Pengguna berikut:

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

Anda dapat membuat pengguna dan membuatnya siap untuk digunakan menggunakan:

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

Jika Anda mencoba mengubah status sebagai admin dari konsol. Kemudian ikuti langkah-langkah di bawah ini setelah membuat pengguna.

1. Dalam Cognito goto -> "kelola kumpulan pengguna" ->
2. Buka "Pengaturan klien aplikasi" di bawah bagian Integrasi aplikasi.
3. Periksa item di bawah ini i) Kumpulan Pengguna Cognito ii) Pemberian kode otorisasi iii) Pemberian implisit iv) telepon v) email vi) openid vii) aws.cognito.signin.user.admin viii) profil
4. Masukkan url panggilan balik dari aplikasi Anda. Jika Anda tidak yakin masukkan misalnya: https://google.com dan nanti Anda dapat mengubahnya ke url panggilan balik Anda yang sebenarnya
5. klik simpan perubahan.
6. Setelah perubahan disimpan, klik link "Luncurkan UI yang Dihosting"
7. Masukkan kredensial pengguna baru yang dibuat
8. Setel ulang sandi dengan kredensial baru dan bagikan hal yang sama kepada pengguna

Langkah 2

langkah 3 4 5 6

langkah 7

langkah 8

Saya tahu Itu adalah jawaban yang sama, tetapi saya pikir itu mungkin membantu Gokomunitas pengembang. pada dasarnya ini adalah memulai permintaan autentikasi, mendapatkan sesi, dan menanggapi tantanganNEW_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 
}

Berikut tes unitnya:

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)

        })

    })
}

BAIK. Saya akhirnya memiliki kode di mana administrator dapat membuat pengguna baru. Prosesnya berjalan seperti ini:

1. Admin membuat pengguna
2. Pengguna menerima email dengan kata sandi sementara mereka
3. Pengguna masuk dan diminta untuk mengubah kata sandi mereka

Langkah 1 adalah bagian yang sulit. Inilah kode saya untuk membuat pengguna di 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);
      }
    });
  }
});

Pada dasarnya, Anda perlu mengirim perintah kedua untuk memaksa email dianggap diverifikasi. Pengguna masih perlu membuka emailnya untuk mendapatkan sandi sementara (yang juga memverifikasi email tersebut). Tetapi tanpa panggilan kedua yang mengatur email untuk diverifikasi, Anda tidak akan mendapatkan panggilan yang benar kembali untuk mengatur ulang kata sandinya.