Nie można zweryfikować tajnego skrótu klienta w puli użytkowników Amazon Cognito

131

Utknąłem w procesie „Pule użytkowników Amazon Cognito Identity”.

Wypróbowałem wszystkie możliwe kody do uwierzytelniania użytkownika w puli użytkowników cognito. Ale zawsze pojawia się komunikat o błędzie: „Błąd: nie można zweryfikować tajnego skrótu klienta 4b ******* fd”.

Oto kod:

AWS.config.region = 'us-east-1'; // Region
AWS.config.credentials = new AWS.CognitoIdentityCredentials({
    IdentityPoolId: 'us-east-1:b64bb629-ec73-4569-91eb-0d950f854f4f'
});

AWSCognito.config.region = 'us-east-1';
AWSCognito.config.credentials = new AWS.CognitoIdentityCredentials({
    IdentityPoolId: 'us-east-1:b6b629-er73-9969-91eb-0dfffff445d'
});

AWSCognito.config.update({accessKeyId: 'AKIAJNYLRONAKTKBXGMWA', secretAccessKey: 'PITHVAS5/UBADLU/dHITesd7ilsBCm'})

var poolData = { 
    UserPoolId : 'us-east-1_l2arPB10',
    ClientId : '4bmsrr65ah3oas5d4sd54st11k'
};
var userPool = new AWSCognito.CognitoIdentityServiceProvider.CognitoUserPool(poolData);

var userData = {
     Username : '[email protected]',
     Pool : userPool
};

var cognitoUser = new AWSCognito.CognitoIdentityServiceProvider.CognitoUser(userData);

cognitoUser.confirmRegistration('123456', true,function(err, result) {
if (err) {
    alert(err);
    return;
}
console.log('call result: ' + result);
});
Ronak Patel
źródło
9
Zaakceptowana odpowiedź NIE jest już ważna. Instrukcje dotyczące generowania tajnego skrótu są tutaj docs.aws.amazon.com/cognito/latest/developerguide/ ...
jasiustasiu
Tak i spójrz na odpowiedź @Simon Buchan poniżej, aby zobaczyć implementację JavaScript. Działa doskonale.
guzmonne

Odpowiedzi:

182

Wygląda na to, że obecnie AWS Cognito nie radzi sobie doskonale z tajemnicą klienta. Będzie działać w najbliższej przyszłości, ale na razie jest to nadal wersja beta.

Dla mnie działa dobrze w przypadku aplikacji bez klucza klienta, ale nie działa w przypadku aplikacji z kluczem klienta.

Dlatego w puli użytkowników spróbuj utworzyć nową aplikację bez generowania klucza tajnego klienta. Następnie użyj tej aplikacji, aby zarejestrować nowego użytkownika lub potwierdzić rejestrację.

thomas.g
źródło
14
FYI: To właśnie mi się przydarzyło, właśnie teraz. To nadal działa w ten sposób, styczeń 2017. Kiedy tworzyłem aplikację bez client_secret, mogłem używać JS SDK. Kiedy tworzyłem aplikację z client_secret, otrzymałem te same błędy, co w pierwotnym pytaniu.
Cheeso
5
Od 21 kwietnia 2017 nadal nie działa przy użyciu interfejsu wiersza polecenia AWS, gdy tajny klucz został włączony dla klienta aplikacji. aws cognito-idp admin-inicjate-auth \ --region ap-north-1 \ --user-pool-id ID_MY_POOL \ --client-id ID_MY_CLIENT \ --auth-flow ADMIN_NO_SRP_AUTH \ --auth-parameters NAZWA_UŻYTKOWNIKA = nazwa użytkownika @ gmail.com, PASSWORD = som3PassW0rd
Stanley Yong
26
Od stycznia 2018 r. Nadal nie jest to obsługiwane. Wspomina o tym dokumentacja repozytorium Github github.com/aws/amazon-cognito-identity-js :"When creating the App, the generate client secret box must be unchecked because the JavaScript SDK doesn't support apps that have a client secret."
kakoma
5
19 maja 2018, ten sam błąd, który musimy utworzyć przy tworzeniu aplikacji bez klucza klienta.
Dileep
4
12 września 2018 r. - ten sam numer. Nawet jeśli nie używam klienta, który generuje hasło, otrzymuję 400 niezależnie od tego, czy użytkownik jest uwierzytelniony, czy nie. Mimo to aplikacja działa zgodnie z oczekiwaniami.
foxtrotuniform6969
37

Może to nastąpić kilka lat później, ale po prostu odznacz opcję „Generuj klucz klienta” i będzie działać dla Twoich klientów internetowych.

Generuj opcję klienta aplikacji

Tiisetso Tjabane
źródło
8
Pamiętaj, że nie możesz go edytować po utworzeniu klienta, więc w razie potrzeby utwórz nowy.
URL87
Jeśli tworzysz nowego klienta aplikacji i masz pulę tożsamości (na „Tożsamości federacyjne”), która używa dostawcy uwierzytelniania Cognito, pamiętaj, aby zaktualizować pole identyfikatora klienta aplikacji o identyfikator nowego klienta aplikacji.
AMS777
21

Ponieważ wszyscy inni opublikowali swój język, oto węzeł (i działa w przeglądarce z browserify-crypto, automatycznie używany, jeśli używasz pakietu webpacka lub browserify):

const crypto = require('crypto');

...

crypto.createHmac('SHA256', clientSecret)
  .update(username + clientId)
  .digest('base64')
Simon Buchan
źródło
4
to jest proste i najlepsze wbudowane rozwiązanie Node.js, dzięki @simon
Engineer
19

Miałem ten sam problem w .net SDK.

Oto, jak sobie poradziłem, na wypadek, gdyby ktoś tego potrzebował:

public static class CognitoHashCalculator
{
    public static string GetSecretHash(string username, string appClientId, string appSecretKey)
    {
        var dataString = username + appClientId;

        var data = Encoding.UTF8.GetBytes(dataString);
        var key = Encoding.UTF8.GetBytes(appSecretKey);

        return Convert.ToBase64String(HmacSHA256(data, key));
    }

    public static byte[] HmacSHA256(byte[] data, byte[] key)
    {
        using (var shaAlgorithm = new System.Security.Cryptography.HMACSHA256(key))
        {
            var result = shaAlgorithm.ComputeHash(data);
            return result;
        }
    }
}

Rejestracja wygląda wtedy następująco:

public class CognitoSignUpController
{
    private readonly IAmazonCognitoIdentityProvider _amazonCognitoIdentityProvider;

    public CognitoSignUpController(IAmazonCognitoIdentityProvider amazonCognitoIdentityProvider)
    {
        _amazonCognitoIdentityProvider = amazonCognitoIdentityProvider;
    }

    public async Task<bool> SignUpAsync(string userName, string password, string email)
    {
        try
        {
            var request = CreateSignUpRequest(userName, password, email);
            var authResp = await _amazonCognitoIdentityProvider.SignUpAsync(request);

            return true;
        }
        catch
        {
            return false;
        }
    }

    private static SignUpRequest CreateSignUpRequest(string userName, string password, string email)
    {
        var clientId = ConfigurationManager.AppSettings["ClientId"];
        var clientSecretId = ConfigurationManager.AppSettings["ClientSecretId"];

        var request = new SignUpRequest
        {
            ClientId = clientId,
            SecretHash = CognitoHashCalculator.GetSecretHash(userName, clientId, clientSecretId),
            Username = userName,
            Password = password,
        };

        request.UserAttributes.Add("email", email);
        return request;
    }
}
Ron Sijm
źródło
Potwierdzenie, że jest to nadal potrzebne i nadal działa w zestawie SDK .NET w wersji 3.5 AWS (wersja zapoznawcza).
pieSquared
13

Dla każdego, kto jest zainteresowany wykorzystaniem AWS Lambda do rejestracji użytkownika przy użyciu AWS JS SDK, oto kroki, które wykonałem:

Utwórz kolejną funkcję lambda w Pythonie, aby wygenerować klucz:

import hashlib
import hmac
import base64

secretKey = "key"
clientId = "clientid"
digest = hmac.new(secretKey,
                  msg=username + clientId,
                  digestmod=hashlib.sha256
                 ).digest()
signature = base64.b64encode(digest).decode()

Wywołaj funkcję za pomocą funkcji nodeJS w AWS. Podpis działał jako tajny skrót dla Cognito

Uwaga: odpowiedź w dużej mierze opiera się na odpowiedzi George'a Campbella w poniższym linku: Obliczanie skrótu SHA za pomocą ciągu znaków + tajnego klucza w Pythonie

Molezz
źródło
12

Rozwiązanie dla golang. Wydaje się, że należy to dodać do SDK.

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
)

func SecretHash(username, clientID, clientSecret string) string {
    mac := hmac.New(sha256.New, []byte(clientSecret))
    mac.Write([]byte(username + ClientID))
    return base64.StdEncoding.EncodeToString(mac.Sum(nil))
}
syvex
źródło
8

Rozwiązanie dla NodeJS z SecretHash

Wydaje się głupie, że AWS usunęło tajny klucz z SDK, ponieważ nie zostanie on ujawniony w NodeJS.

Mam to działające w NodeJS przechwytując pobieranie i dodając zaszyfrowany klucz za pomocą odpowiedzi @Simon Buchan .

cognito.js

import { CognitoUserPool, CognitoUserAttribute, CognitoUser } from 'amazon-cognito-identity-js'
import crypto from 'crypto'
import * as fetchIntercept from './fetch-intercept'

const COGNITO_SECRET_HASH_API = [
  'AWSCognitoIdentityProviderService.ConfirmForgotPassword',
  'AWSCognitoIdentityProviderService.ConfirmSignUp',
  'AWSCognitoIdentityProviderService.ForgotPassword',
  'AWSCognitoIdentityProviderService.ResendConfirmationCode',
  'AWSCognitoIdentityProviderService.SignUp',
]

const CLIENT_ID = 'xxx'
const CLIENT_SECRET = 'xxx'
const USER_POOL_ID = 'xxx'

const hashSecret = (clientSecret, username, clientId) => crypto.createHmac('SHA256', clientSecret)
  .update(username + clientId)
  .digest('base64')

fetchIntercept.register({
  request(url, config) {
    const { headers } = config
    if (headers && COGNITO_SECRET_HASH_API.includes(headers['X-Amz-Target'])) {
      const body = JSON.parse(config.body)
      const { ClientId: clientId, Username: username } = body
      // eslint-disable-next-line no-param-reassign
      config.body = JSON.stringify({
        ...body,
        SecretHash: hashSecret(CLIENT_SECRET, username, clientId),
      })
    }
    return [url, config]
  },
})

const userPool = new CognitoUserPool({
  UserPoolId: USER_POOL_ID,
  ClientId: CLIENT_ID,
})

const register = ({ email, password, mobileNumber }) => {
  const dataEmail = { Name: 'email', Value: email }
  const dataPhoneNumber = { Name: 'phone_number', Value: mobileNumber }

  const attributeList = [
    new CognitoUserAttribute(dataEmail),
    new CognitoUserAttribute(dataPhoneNumber),
  ]

  return userPool.signUp(email, password, attributeList, null, (err, result) => {
    if (err) {
      console.log((err.message || JSON.stringify(err)))
      return
    }
    const cognitoUser = result.user
    console.log(`user name is ${cognitoUser.getUsername()}`)
  })
}

export {
  register,
}

fetch-inceptor.js ( rozwidlone i edytowane dla NodeJS z Fork z https://github.com/werk85/fetch-intercept/blob/develop/src/index.js )

let interceptors = []

if (!global.fetch) {
  try {
    // eslint-disable-next-line global-require
    global.fetch = require('node-fetch')
  } catch (err) {
    throw Error('No fetch available. Unable to register fetch-intercept')
  }
}
global.fetch = (function (fetch) {
  return (...args) => interceptor(fetch, ...args)
}(global.fetch))

const interceptor = (fetch, ...args) => {
  const reversedInterceptors = interceptors.reduce((array, _interceptor) => [_interceptor].concat(array), [])
  let promise = Promise.resolve(args)

  // Register request interceptors
  reversedInterceptors.forEach(({ request, requestError }) => {
    if (request || requestError) {
      promise = promise.then(_args => request(..._args), requestError)
    }
  })

  // Register fetch call
  promise = promise.then(_args => fetch(..._args))

  // Register response interceptors
  reversedInterceptors.forEach(({ response, responseError }) => {
    if (response || responseError) {
      promise = promise.then(response, responseError)
    }
  })

  return promise
}

const register = (_interceptor) => {
  interceptors.push(_interceptor)
  return () => {
    const index = interceptors.indexOf(_interceptor)
    if (index >= 0) {
      interceptors.splice(index, 1)
    }
  }
}

const clear = () => {
  interceptors = []
}

export {
  register,
  clear,
}
ptimson
źródło
Udało mi się zarejestrować zgodnie z twoją procedurą, ale nie mogę zalogować się przy użyciu tego proc. Czy trzeba wprowadzić jakieś zmiany, aby się zalogować? Byłoby bardzo pomocne, gdybyś mógł go tutaj dodać. Z góry dziękuję.
Vinay Wadagavi
7

W Javie możesz użyć tego kodu:

private String getSecretHash(String email, String appClientId, String appSecretKey) throws Exception {
    byte[] data = (email + appClientId).getBytes("UTF-8");
    byte[] key = appSecretKey.getBytes("UTF-8");

    return Base64.encodeAsString(HmacSHA256(data, key));
}

static byte[] HmacSHA256(byte[] data, byte[] key) throws Exception {
    String algorithm = "HmacSHA256";
    Mac mac = Mac.getInstance(algorithm);
    mac.init(new SecretKeySpec(key, algorithm));
    return mac.doFinal(data);
}
gandrademello
źródło
Gdzie używasz tego tajnego skrótu w SDK oprócz wyprowadzania go na ekran?
Aaron
1
Czy ktoś może wskazać jakiekolwiek dokumenty AWS online, w których wyjaśniono uwierzytelnianie za pomocą tajemnicy klienta? Kodowanie sygnatur base64 / sha256 to atrakcyjne rozwiązania - ale bezwartościowe, chyba że są wyraźnie zgodne z dokumentami AWS opisującymi, jak uwierzytelniać się w tajemnicy klienta.
Kode Charlie
7

Amazon wspomina o tym, jak Computing SecretHash Values for Amazon Cognito w swojej dokumentacji z kodem aplikacji Java. Tutaj ten kod działa z zestawem Boto 3 Python SDK .

szczegóły klienta aplikacji

Możesz znaleźć swoje App clientsw menu po lewej stronie pod General settings. Zdobądź je App client idi App client secrettwórz SECRET_HASH. Dla lepszego zrozumienia wykomentowałem wszystkie wyniki każdego wiersza.

import hashlib
import hmac
import base64

app_client_secret = 'u8f323eb3itbr3731014d25spqtv5r6pu01olpp5tm8ebicb8qa'
app_client_id = '396u9ekukfo77nhcfbmqnrec8p'
username = 'wasdkiller'

# convert str to bytes
key = bytes(app_client_secret, 'latin-1')  # b'u8f323eb3itbr3731014d25spqtv5r6pu01olpp5tm8ebicb8qa'
msg = bytes(username + app_client_id, 'latin-1')  # b'wasdkiller396u9ekukfo77nhcfbmqnrec8p'

new_digest = hmac.new(key, msg, hashlib.sha256).digest()  # b'P$#\xd6\xc1\xc0U\xce\xc1$\x17\xa1=\x18L\xc5\x1b\xa4\xc8\xea,\x92\xf5\xb9\xcdM\xe4\x084\xf5\x03~'
SECRET_HASH = base64.b64encode(new_digest).decode()  # UCQj1sHAVc7BJBehPRhMxRukyOoskvW5zU3kCDT1A34=

W dokumentacji boto 3 widzimy dużo czasu, o który pytamy SECRET_HASH. Zatem powyższe linie kodu pomogą ci to stworzyć SECRET_HASH.

Jeśli nie chcesz używać, SECRET_HASHusuń zaznaczenie Generate client secretpodczas tworzenia aplikacji.

Utwórz nową aplikację

Kushan Gunasekera
źródło
1
U mnie zadziałało to tylko wtedy, gdy przełączyłem msg = bytes (app_client_id + username, 'latin-1') na msg = bytes (nazwa użytkownika + app_client_id, 'latin-1'). Żeby było jasne, zmieniłem kolejność clientId i nazwy użytkownika tak, że nazwa użytkownika pojawia się jako pierwsza.
Josh Wolff
1
Wielkie dzięki @JoshWolff, omyłkowo zamieniam app_client_idi username. Ale wyświetlam poprawne wyjście jako komentarz, który jest wyświetlany zgodnie z username+ app_client_id. Wielkie dzięki.
Kushan Gunasekera
1
Żaden problem! @Kushan Gunasekera
Josh Wolff
6

to jest przykładowy kod php, którego używam do generowania tajnego skrótu

<?php
    $userId = "aaa";
    $clientId = "bbb";
    $clientSecret = "ccc";
    $s = hash_hmac('sha256', $userId.$clientId, $clientSecret, true);
    echo base64_encode($s);
?>

w tym przypadku wynikiem jest:

DdSuILDJ2V84zfOChcn6TfgmlfnHsUYq0J6c01QV43I=
Titi Wangsa bin Damhore
źródło
5

dla JAVA i .NET musisz podać sekret w parametrach auth z nazwą SECRET_HASH.

AdminInitiateAuthRequest request = new AdminInitiateAuthRequest
{
  ClientId = this.authorizationSettings.AppClientId,
  AuthFlow = AuthFlowType.ADMIN_NO_SRP_AUTH,
  AuthParameters = new Dictionary<string, string>
  {
    {"USERNAME", username},
    {"PASSWORD", password},
    {
      "SECRET_HASH", EncryptionHelper.GetSecretHash(username, AppClientId, AppClientSecret)
    }
  },
  UserPoolId = this.authorizationSettings.UserPoolId
};

I powinno działać.

Shanmukhi Goli
źródło
3

C ++ z Qt Framework

QByteArray MyObject::secretHash(
     const QByteArray& email,
     const QByteArray& appClientId, 
     const QByteArray& appSecretKey)
{
            QMessageAuthenticationCode code(QCryptographicHash::Sha256);
            code.setKey(appSecretKey);
            code.addData(email);
            code.addData(appClientId);
            return code.result().toBase64();
};
vpicaver
źródło
1

Może istnieć bardziej kompaktowa wersja, ale działa to dla Rubiego, szczególnie w Ruby on Rails, bez konieczności niczego:

key = ENV['COGNITO_SECRET_HASH']
data = username + ENV['COGNITO_CLIENT_ID']
digest = OpenSSL::Digest.new('sha256')

hmac = Base64.strict_encode64(OpenSSL::HMAC.digest(digest, key, data))
Nikolay D.
źródło
0

Uwierzytelnianie Cognito

Błąd: klient aplikacji nie jest skonfigurowany pod kątem hasła tajnego, ale odebrano tajny skrót

Podanie klucza SecretKey jako nil działało dla mnie. Podane poświadczenia obejmują: -

  • CognitoIdentityUserPoolRegion (region)
  • CognitoIdentityUserPoolId (userPoolId)
  • CognitoIdentityUserPoolAppClientId (ClientId)
  • AWSCognitoUserPoolsSignInProviderKey (AccessKeyId)

    // setup service configuration
    let serviceConfiguration = AWSServiceConfiguration(region: CognitoIdentityUserPoolRegion, credentialsProvider: nil)
    
    // create pool configuration
    let poolConfiguration = AWSCognitoIdentityUserPoolConfiguration(clientId: CognitoIdentityUserPoolAppClientId,
                                                                    clientSecret: nil,
                                                                    poolId: CognitoIdentityUserPoolId)
    
    // initialize user pool client
    AWSCognitoIdentityUserPool.register(with: serviceConfiguration, userPoolConfiguration: poolConfiguration, forKey: AWSCognitoUserPoolsSignInProviderKey)
    

Wszystkie powyższe rzeczy działają z poniższym połączonym przykładem kodu.

Przykładowy kod AWS: https://github.com/awslabs/aws-sdk-ios-samples/tree/master/CognitoYourUserPools-Sample/Swift

Daj mi znać, jeśli to nie zadziała.

Siddharth Kavthekar
źródło
to jest martwy link
Jpnh
0

Oto moje 1 polecenie i działa (potwierdzone :))

EMAIL="[email protected]" \
CLIENT_ID="[CLIENT_ID]" \
CLIENT_SECRET="[CLIENT_ID]" \
&& SECRET_HASH=$(echo -n "${EMAIL}${CLIENT_ID}" | openssl dgst -sha256 -hmac "${CLIENT_SECRET}" | xxd -r -p | openssl base64) \
&& aws cognito-idp ...  --secret-hash "${SECRET_HASH}"
Tuong Le
źródło