Kullanıcı Durumu FORCE_CHANGE_PASSWORD nasıl değiştirilir?

AWS Cognito'yu kullanarak test amacıyla sahte kullanıcılar oluşturmak istiyorum.

Daha sonra böyle bir kullanıcı oluşturmak için AWS Konsolu'nu kullanıyorum , ancak kullanıcının durumu olarak ayarlanmış FORCE_CHANGE_PASSWORD. Bu değerle, bu kullanıcının kimliği doğrulanamaz.

Bu durumu değiştirmenin bir yolu var mı?

GÜNCELLEME CLI'den kullanıcı oluştururken aynı davranış

Üzgünüm zorluklar yaşıyorsun. Doğrudan kullanıcılar oluşturup kimliklerini doğrulayabileceğiniz tek adımlı bir sürece sahip değiliz. Bunu gelecekte, yöneticilerin doğrudan kullanıcılar tarafından kullanılabilen şifreler belirlemesine izin verecek şekilde değiştirebiliriz. Şimdilik, AdminCreateUserkullanıcıları uygulamayı kullanarak veya uygulamayla kaydolarak oluşturduğunuzda, kullanıcıları oturum açarken parolayı değiştirmeye zorlamak ya da kullanıcının durumunu değiştirmek için e-posta veya telefon numarasını doğrulatmak gibi ekstra adımlar gereklidir CONFIRMED.

Bir süredir biliyorum ama bunun, bu gönderiyle karşılaşan diğer insanlara yardımcı olabileceğini düşündüm.

Kullanıcı parolasını değiştirmek için AWS CLI'yi kullanabilirsiniz, ancak bu çok adımlı bir süreçtir:

1. Adım: İstenen kullanıcı için bir oturum jetonu alın:

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%

Bu, hakkında bir hata döndürürse Unable to verify secret hash for client, gizli olmayan başka bir uygulama istemcisi oluşturun ve bu istemci kimliğini kullanın.

Adım 2: Adım 1 başarılı olursa, sorgulama NEW_PASSWORD_REQUIRED, diğer sorgulama parametreleri ve kullanıcı oturum anahtarı ile yanıt verecektir . Ardından, sorgulama yanıtını vermek için ikinci komutu çalıştırabilirsiniz:

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

Invalid attributes given, XXX is missingBiçimi kullanarak eksik öznitelikleri geçirme konusunda bir hata alırsanızuserAttributes.$FIELD_NAME=$VALUE

Yukarıdaki komut, geçerli bir Kimlik Doğrulama Sonucu ve uygun Belirteçler döndürmelidir.

Önemli: Bunun çalışması için, Cognito Kullanıcı Havuzu'nun işlevsellikle yapılandırılmış bir Uygulama istemcisi OLMALIDIR ADMIN_NO_SRP_AUTH( bu belgedeki Adım 5 ).

Bu nihayet AWSCLI'ye eklendi: https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/admin-set-user-password.html

Şunları kullanarak bir kullanıcının şifresini değiştirebilir ve durumunu güncelleyebilirsiniz:

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

Bunu kullanmadan önce, AWS CLI'nizi aşağıdakileri kullanarak güncellemeniz gerekebilir:

pip3 install awscli --upgrade

Bu kodu onSuccess: function (result) { ... },giriş fonksiyonunuzdan sonra eklemeniz yeterlidir. Kullanıcınız ONAYLANDI durumuna sahip olacaktır .

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

Kullanıcıyı şu şekilde FORCE_CHANGE_PASSWORDarayarak bu kullanıcı durumunu değiştirebilirsiniz respondToAuthChallenge():

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

Bundan sonra, konsolda user3durumun olduğunu göreceksiniz CONFIRMED.

Hala bununla mücadele edip etmediğinizden emin değilim, ancak yalnızca bir grup test kullanıcısı oluşturmak için, şu şekilde kullandım awscli:

1. Kullanıcıyı oluşturmak için cognito-idp'deki kayıt alt komutunu kullanın

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. Yönetici-onayla-kaydolma özelliğini kullanarak kullanıcıyı onaylayın

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

GÜNCELLEME:

Şimdi bunu bir NodeJS Lambda içinde yükseltmek için çevrilmiş olarak kullanıyorum:

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

Geçici bir parola ayarlıyorum ve daha sonra bunu kullanıcının istediği parolaya sıfırlıyorum.

ESKİ YAYIN:

Sen amazon-Cognito-kimlik-js ile hesap oluşturulduktan sonra geçici şifre ile doğrulayarak SDK kullanarak bu çözebilir cognitoidentityserviceprovider.adminCreateUser()ve çalışan cognitoUser.completeNewPasswordChallenge()içinde cognitoUser.authenticateUser( ,{newPasswordRequired})senin kullanıcı oluşturur fonksiyonu içindeki tüm -.

Etkin Cognito kullanıcı hesapları oluşturmak için aşağıdaki kodu AWS lambda içinde kullanıyorum. Optimize edilebileceğine eminim, bana karşı sabırlı olun. Bu benim ilk yazım ve hala JavaScript konusunda oldukça yeniyim.

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

Java SDK için, Cognito istemcinizin kurulu olduğunu ve kullanıcınızın FORCE_CHANGE_PASSWORD durumunda olduğunu varsayarsak, kullanıcınızı ONAYLI hale getirmek için aşağıdakileri yapabilirsiniz ... ve ardından normal şekilde yetkilendirilir.

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

Umarım bu entegrasyon testlerine yardımcı olur (Biçimlendirme için üzgünüz)

Temelde bu aynı cevaptır ancak .Net C # SDK için:

Aşağıdakiler, istenen kullanıcı adı ve şifre ile tam bir yönetici kullanıcı oluşturacaktır. Aşağıdaki Kullanıcı modeline sahip olmak:

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

Aşağıdakileri kullanarak bir kullanıcı oluşturabilir ve onu kullanıma hazır hale getirebilirsiniz:

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

Konsoldan yönetici olarak durumu değiştirmeye çalışıyorsanız. Ardından kullanıcıyı oluşturduktan sonra aşağıdaki adımları izleyin.

1. Cognito'da -> "kullanıcı havuzunu yönet" ->
2. Uygulama entegrasyonu bölümünün altında "Uygulama istemcisi ayarları" na gidin.
3. Aşağıdaki öğeleri kontrol edin i) Cognito Kullanıcı Havuzu ii) Yetkilendirme kodu verme iii) Örtülü hibe iv) telefon v) e-posta vi) openid vii) aws.cognito.signin.user.admin viii) profil
4. Uygulamanızın geri arama url'sini girin. Örneğin, https://google.com ve daha sonra girdiğinizden emin değilseniz, bunu gerçek geri arama url'nizle değiştirebilirsiniz.
5. değişiklikleri kaydet seçeneğine tıklayın.
6. Değişiklikler kaydedildikten sonra "Barındırılan Kullanıcı Arayüzünü Başlat" bağlantısını tıklayın
7. Yeni oluşturulan kullanıcının kimlik bilgilerini girin
8. Şifreyi yeni kimlik bilgileriyle sıfırlayın ve aynısını kullanıcıyla paylaşın

Adım 2

Adım 3 4 5 6

7. Adım

8. adım

Bunun aynı cevap olduğunu biliyorum, ancak Gogeliştirici topluluğuna yardımcı olabileceğini düşündüm . temelde kimlik doğrulama isteği başlatmak, oturumu almak ve sorgulamaya yanıt vermekNEW_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 
}

İşte bir birim testi:

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)

        })

    })
}

TAMAM. Sonunda bir yöneticinin yeni bir kullanıcı oluşturabileceği bir koda sahibim. Süreç şu şekildedir:

1. Yönetici kullanıcıyı oluşturur
2. Kullanıcı, geçici şifresini içeren bir e-posta alır
3. Kullanıcı oturum açar ve şifresini değiştirmesi istenir

Adım 1 zor kısımdır. Node JS'de bir kullanıcı oluşturmak için kodum:

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

Temel olarak, e-postanın doğrulanmış olarak kabul edilmesini sağlamak için ikinci bir komut göndermeniz gerekir. Kullanıcının yine de geçici parolayı almak için e-postasına gitmesi gerekir (bu da e-postayı doğrular). Ancak, e-postayı doğrulanacak şekilde ayarlayan bu ikinci çağrı olmadan, şifrelerini sıfırlamak için doğru aramayı geri alamazsınız.