उपयोगकर्ता स्थिति FORCE_CHANGE_PASSWORD कैसे बदलें?

Question 1

AWS Cognito का उपयोग करके, मैं परीक्षण उद्देश्यों के लिए डमी उपयोगकर्ता बनाना चाहता हूं।

मैं तो ऐसे उपयोगकर्ता को बनाने के लिए AWS कंसोल का उपयोग करता हूं , लेकिन उपयोगकर्ता के पास इसकी स्थिति निर्धारित है FORCE_CHANGE_PASSWORD। उस मान के साथ, इस उपयोगकर्ता को प्रमाणित नहीं किया जा सकता है।

क्या इस स्थिति को बदलने का कोई तरीका है?

उपयोगकर्ता को CLI से बनाते समय समान व्यवहार

Question 2

क्षमा करें आपको कठिनाइयाँ हो रही हैं। हमारे पास एक चरण की प्रक्रिया नहीं है जहां आप केवल उपयोगकर्ता बना सकते हैं और उन्हें सीधे प्रमाणित कर सकते हैं। हम भविष्य में इसे बदल सकते हैं जैसे कि प्रशासकों को उपयोगकर्ताओं द्वारा सीधे प्रयोग करने योग्य पासवर्ड सेट करने की अनुमति देना। अभी के लिए, जब आप उपयोगकर्ताओं का उपयोग करते हैं AdminCreateUserया ऐप के साथ उपयोगकर्ताओं को साइन अप करते हैं, तो अतिरिक्त चरणों की आवश्यकता होती है, या तो उपयोगकर्ताओं को लॉगिन पर पासवर्ड बदलने के लिए मजबूर करना या उपयोगकर्ताओं को उपयोगकर्ता की स्थिति बदलने के लिए ईमेल या फोन नंबर सत्यापित करना CONFIRMED।

Question 3

मुझे पता है कि यह एक समय हो गया है, लेकिन यह इस पोस्ट में आने वाले अन्य लोगों की मदद कर सकता है।

उपयोगकर्ताओं के पासवर्ड को बदलने के लिए आप AWS CLI का उपयोग कर सकते हैं, हालाँकि यह एक बहु कदम प्रक्रिया है:

चरण 1: वांछित उपयोगकर्ता के लिए एक सत्र टोकन प्राप्त करें:

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%

यदि यह एक त्रुटि देता है Unable to verify secret hash for client, तो गुप्त के बिना एक और ऐप क्लाइंट बनाएं और उस क्लाइंट आईडी का उपयोग करें।

चरण 2: यदि चरण 1 सफल होता है, तो यह चुनौती NEW_PASSWORD_REQUIRED, अन्य चुनौती मापदंडों और उपयोगकर्ताओं के सत्र कुंजी के साथ जवाब देगा । फिर, आप चुनौती प्रतिक्रिया जारी करने के लिए दूसरी कमांड चला सकते हैं:

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 missingप्रारूप का उपयोग करके लापता विशेषताओं को पारित करने में त्रुटि मिलती हैuserAttributes.$FIELD_NAME=$VALUE

उपरोक्त कमांड को एक वैध प्रमाणीकरण परिणाम और उचित टोकन वापस करना चाहिए।

महत्वपूर्ण: काम करने के लिए, कॉग्निटो यूजर पूल MUST में एक ऐप क्लाइंट है जिसे ADMIN_NO_SRP_AUTHकार्यक्षमता के साथ कॉन्फ़िगर किया गया है ( चरण 5 इस डॉक्टर में )।

Question 4

इसे अंततः AWSCLI: https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/admin-set-user-password.html में जोड़ा गया है

आप एक उपयोगकर्ता का पासवर्ड और अपडेट स्थिति का उपयोग करके बदल सकते हैं:

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

इसका उपयोग करने से पहले, आपको अपने AWS CLI को अपडेट करने की आवश्यकता हो सकती है:

pip3 install awscli --upgrade

Question 5

बस onSuccess: function (result) { ... },अपने लॉगिन फ़ंक्शन के भीतर इस कोड को जोड़ें । आपके उपयोगकर्ता के पास तब स्थिति की पुष्टि होगी ।

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

Question 6

आप उपयोगकर्ता की स्थिति FORCE_CHANGE_PASSWORDको 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
});

इसके बाद, आप कंसोल में देखेंगे कि user3स्थिति क्या है CONFIRMED।

Question 7

यकीन नहीं है कि आप अभी भी इस के साथ लड़ रहे हैं लेकिन केवल परीक्षण उपयोगकर्ताओं का एक समूह बनाने के लिए, मैंने awscliइस तरह का उपयोग किया :

उपयोगकर्ता बनाने के लिए cognito-idp से साइन-अप उपकमांड का उपयोग करें

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%

व्यवस्थापक-पुष्टि-साइन-अप का उपयोग करके उपयोगकर्ता की पुष्टि करें

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

Question 8

यदि आप कंसोल से एक व्यवस्थापक के रूप में स्थिति बदलने की कोशिश कर रहे हैं। फिर उपयोगकर्ता बनाने के बाद नीचे दिए गए चरणों का पालन करें।

Cognito goto में -> "उपयोगकर्ता पूल प्रबंधित करें" ->
ऐप एकीकरण अनुभाग के तहत गोटो "ऐप क्लाइंट सेटिंग्स"।
नीचे दी गई वस्तुओं पर जाँच करें i) Cognito उपयोगकर्ता पूल ii) प्राधिकरण कोड अनुदान iii) लागू अनुदान iv) फोन v) ईमेल vi) ओपनिड vii) aws.cognito.signin.user.admin viii - प्रोफ़ाइल
अपने एप्लिकेशन का कॉलबैक url दर्ज करें। यदि आप उदाहरण के लिए सुनिश्चित नहीं हैं: https://google.com और बाद में आप इसे अपने वास्तविक कॉलबैक url में बदल सकते हैं
परिवर्तन सहेजें पर क्लिक करें।
एक बार परिवर्तन सहेजे जाने के बाद "लॉन्च होस्टेड UI" लिंक पर क्लिक करें
नए बनाए गए उपयोगकर्ता के क्रेडेंशियल दर्ज करें
पासवर्ड को नए क्रेडेंशियल्स के साथ रीसेट करें और उपयोगकर्ता के लिए समान साझा करें

Question 9

अपडेट करें:

कुछ अपडेट किए गए हैं, और Amplify क्लाइंट की अब आवश्यकता नहीं है। AdminCreateUser () के बाद, आप अभी उपयोग कर सकते हैं

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]

यह उपयोगकर्ता को "पुष्टि" करने के लिए सेट करेगा।

अपडेट करें:

मैं अब इसका उपयोग कर रहा हूं, जिसका अनुवाद एनोडजेएस लैंबडा के अंदर प्रवर्धन के लिए किया गया है:

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

मैं एक अस्थायी पासवर्ड सेट कर रहा हूं और फिर बाद में इसे उपयोगकर्ता के अनुरोधित पासवर्ड पर रीसेट कर रहा हूं।

पुराने पोस्ट:

आप अमेज़न-cognito-पहचान-js साथ खाता निर्माण के अस्थायी पासवर्ड के साथ के सत्यापन से SDK का उपयोग इस हल कर सकते हैं cognitoidentityserviceprovider.adminCreateUser(), और चल cognitoUser.completeNewPasswordChallenge()भीतर cognitoUser.authenticateUser( ,{newPasswordRequired})समारोह है कि अपने उपयोगकर्ता बनाता है अंदर सभी -।

मैं सक्षम Cognito उपयोगकर्ता खाते बनाने के लिए AWS लैम्ब्डा के अंदर नीचे दिए गए कोड का उपयोग कर रहा हूं। मुझे यकीन है कि इसे अनुकूलित किया जा सकता है, मेरे साथ धैर्य रखें। यह मेरी पहली पोस्ट है, और मैं अभी भी जावास्क्रिप्ट के लिए बहुत नया हूं।

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

Question 10

जावा एसडीके के लिए, आपका कॉग्निटो क्लाइंट संभालने के लिए सेटअप है और आपके पास FORCE_CHANGE_PASSWORD स्थिति में आपका उपयोगकर्ता है जो आप अपने उपयोगकर्ता को प्राप्त करने के लिए निम्न कार्य कर सकते हैं ... और फिर सामान्य रूप से अधिकृत करेंगे।

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

आशा है कि यह उन एकीकरण परीक्षणों में मदद करता है (प्रारूपण के बारे में क्षमा करें)

Question 11

मूल रूप से यह एक ही उत्तर है लेकिन .Net C # SDK के लिए:

निम्नलिखित वांछित उपयोगकर्ता नाम और पासवर्ड के साथ एक पूर्ण व्यवस्थापक उपयोगकर्ता निर्माण करेगा। निम्नलिखित उपयोगकर्ता मॉडल होने:

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

आप एक उपयोगकर्ता बना सकते हैं और इसका उपयोग करने के लिए तैयार कर सकते हैं:

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

Question 12

मुझे पता है कि यह एक ही उत्तर है, लेकिन यह Goडेवलपर समुदाय की मदद कर सकता है। मूल रूप से यह नीतिगत अनुरोध शुरू कर रहा है, सत्र प्राप्त करें और चुनौती का जवाब दें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 
}

यहाँ एक इकाई परीक्षण है:

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)

        })

    })
}

Question 13

ठीक। मेरे पास अंत में कोड है जहां एक व्यवस्थापक एक नया उपयोगकर्ता बना सकता है। प्रक्रिया इस प्रकार है:

व्यवस्थापक उपयोगकर्ता बनाता है
उपयोगकर्ता अपने अस्थायी पासवर्ड के साथ एक ईमेल प्राप्त करता है
उपयोगकर्ता लॉग इन करता है और अपना पासवर्ड बदलने के लिए कहा जाता है

चरण 1 कठिन हिस्सा है। यहाँ नोड जेएस में एक उपयोगकर्ता बनाने के लिए मेरा कोड है:

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

मूल रूप से, आपको ईमेल को सत्यापित करने के लिए बाध्य करने के लिए दूसरी कमांड भेजने की आवश्यकता है। अस्थायी पासवर्ड प्राप्त करने के लिए उपयोगकर्ता को अभी भी अपने ईमेल पर जाने की आवश्यकता है (जो ईमेल की पुष्टि भी करता है)। लेकिन उस दूसरी कॉल के बिना जो ईमेल को सत्यापित करने के लिए सेट करता है, आपको उनका पासवर्ड रीसेट करने के लिए सही कॉल बैक नहीं मिलेगा।