Tidak dapat memverifikasi hash rahasia untuk klien di Amazon Cognito Userpools

Saya terjebak dalam proses "kumpulan pengguna Amazon Cognito Identity".

Saya mencoba semua kode yang mungkin untuk mengautentikasi pengguna di cognito userpools. Tetapi saya selalu mendapatkan kesalahan yang mengatakan "Kesalahan: Tidak dapat memverifikasi hash rahasia untuk klien 4b ******* fd".

Ini kodenya:

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

Sepertinya saat ini AWS Cognito tidak menangani rahasia klien dengan sempurna. Ini akan berfungsi dalam waktu dekat tetapi untuk saat ini masih versi beta.

Bagi saya ini berfungsi dengan baik untuk aplikasi tanpa rahasia klien tetapi gagal untuk aplikasi dengan rahasia klien.

Jadi di kumpulan pengguna Anda, cobalah membuat aplikasi baru tanpa membuat rahasia klien. Kemudian gunakan aplikasi itu untuk mendaftarkan pengguna baru atau untuk mengonfirmasi pendaftaran.

Menurut Dokumen: http://docs.aws.amazon.com/cognito/latest/developerguide/setting-up-the-javascript-sdk.html

Javascript SDK tidak mendukung Aplikasi dengan Rahasia Klien.

Instruksi sekarang menyatakan bahwa Anda perlu menghapus centang pada "Hasilkan Rahasia Klien" saat membuat aplikasi untuk User Pool.

Ini mungkin terlambat beberapa tahun tetapi hapus centang pada opsi "Buat rahasia klien" dan ini akan berfungsi untuk klien web Anda.

Karena semua orang telah memposting bahasa mereka, inilah node (dan berfungsi di browser dengan browserify-crypto, secara otomatis digunakan jika Anda menggunakan webpack atau browserify):

const crypto = require('crypto');

...

crypto.createHmac('SHA256', clientSecret)
  .update(username + clientId)
  .digest('base64')

Saya memiliki masalah yang sama di .net SDK.

Inilah cara saya menyelesaikannya, jika ada orang lain yang membutuhkannya:

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

Mendaftar kemudian terlihat seperti ini:

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

Bagi siapa pun yang tertarik menggunakan AWS Lambda untuk mendaftarkan pengguna menggunakan AWS JS SDK, berikut adalah langkah-langkah yang saya lakukan:

Buat fungsi lambda lain di python untuk menghasilkan kunci:

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

Panggil fungsi tersebut melalui fungsi nodeJS di AWS. Tanda tangan tersebut bertindak sebagai hash rahasia untuk Cognito

Catatan: Jawabannya sangat didasarkan pada jawaban George Campbell di tautan berikut: Menghitung hash SHA dengan string + kunci rahasia di python

Solusi untuk golang. Sepertinya ini harus ditambahkan ke 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))
}

Solusi untuk NodeJS dengan SecretHash

Tampaknya konyol bahwa AWS menghapus kunci rahasia dari SDK karena tidak akan terekspos di NodeJS.

Saya membuatnya berfungsi di NodeJS dengan mencegat pengambilan dan menambahkan kunci hash menggunakan jawaban @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 ( Bercabang dan diedit untuk NodeJS dari Fork dari 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,
}

Amazon menyebutkan bagaimana Menghitung Nilai SecretHash untuk Amazon Cognito dalam dokumentasinya dengan kode aplikasi Java. Di sini kode ini bekerja dengan boto 3 Python SDK .

Anda dapat menemukan Anda App clientsdi menu sisi kiri di bawah General settings. Dapatkan itu App client iddan App client secretbuat SECRET_HASH. Agar Anda lebih mengerti, saya mengomentari semua output dari setiap baris.

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=

Dalam dokumentasi boto 3 , kita bisa melihat banyak waktu bertanya SECRET_HASH. Jadi baris kode di atas membantu Anda membuat ini SECRET_HASH.

Jika Anda tidak ingin menggunakan, SECRET_HASHhapus centang Generate client secretsaat membuat aplikasi.

Di Java, Anda dapat menggunakan kode ini:

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

ini adalah contoh kode php yang saya gunakan untuk menghasilkan hash rahasia

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

dalam hal ini hasilnya adalah:

DdSuILDJ2V84zfOChcn6TfgmlfnHsUYq0J6c01QV43I=

untuk JAVA dan .NET Anda harus meneruskan rahasia yang ada di parameter auth dengan nama 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
};

Dan itu harus berhasil.

C ++ dengan 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();
};

Mungkin ada versi yang lebih ringkas, tetapi ini berfungsi untuk Ruby, khususnya di Ruby on Rails tanpa harus memerlukan apa pun:

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

Otentikasi Penyamaran

Kesalahan: Klien aplikasi tidak dikonfigurasi untuk rahasia tetapi hash rahasia telah diterima

Memberikan secretKey sebagai nol berhasil untuk saya. Kredensial yang diberikan meliputi: -

• CognitoIdentityUserPoolRegion (wilayah)
• 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)
  

Semua hal di atas bekerja dengan contoh kode tertaut di bawah ini.

Kode Sampel AWS: https://github.com/awslabs/aws-sdk-ios-samples/tree/master/CognitoYourUserPools-Sample/Swift

Beri tahu saya jika itu tidak berhasil untuk Anda.

Ini adalah 1 perintah saya, dan berfungsi (Dikonfirmasi :))

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