Mit JavaScript richtig zu Zeichen einer Zeichenfolge mit HmacSHA256

In der Houndify API Docs für die Authentifizierung müssen Sie den folgenden block von Inhalten:

Ein Beispiel für eine Anfrage zu Authentifizieren

Nehmen wir an, wir haben folgende Informationen:

UserID: ae06fcd3-6447-4356-afaa-813aa4f2ba41
    RequestID: 70aa7c25-c74f-48be-8ca8-cbf73627c05f
    Timestamp: 1418068667   
    ClientID: KFvH6Rpy3tUimL-pCUFpPg==
    ClientKey: KgMLuq-k1oCUv5bzTlKAJf_mGo0T07jTogbi6apcqLa114CCPH3rlK4c0RktY30xLEQ49MZ-C2bMyFOVQO4PyA==

Verketten die UserID, string -, Anforderungs-id string-und TimeStamp-string im folgenden format: {user_id};{request_id}{timestamp}
Mit den Werten aus dem Beispiel die erwartete Ausgabe wäre in diesem Fall: ae06fcd3-6447-4356-afaa-813aa4f2ba41;70aa7c25-c74f-48be-8ca8-cbf73627c05f1418068667
Signieren der Nachricht mit dem decodierten ClientKey. Das Ergebnis ist ein 32-byte-Binär-string (die wir hier nicht darstellen, visuell). Nach base-64-Kodierung, aber die Signatur ist: myWdEfHJ7AV8OP23v8pCH1PILL_gxH4uDOAXMi06akk=
Den client generiert dann zwei Authentisierungs-Header Hound-Anfrage-Authentifizierung und Hound-Client-Authentifizierung.
Den Hund-Request-header Authentifizierung besteht in der Verknüpfung der Benutzer-id und das Anforderungs-id im folgenden format ein: {user-id};{request-id}. Um das obige Beispiel fortzuführen, wird der Wert für diesen header wäre:
Hound-Anfrage-Authentifizierung: ae06fcd3-6447-4356-afaa-813aa4f2ba41;70aa7c25-c74f-48be-8ca8-cbf73627c05f
Den Hund-Client-Authentication-header besteht aus concatening der ClientID, die TimeStamp-string und die Signatur in das folgende format: {client-id};{timestamp};{signature}. Um das obige Beispiel fortzuführen, wird der Wert für diesen header wäre: Hound-Client-Authentication: KFvH6Rpy3tUimL-pCUFpPg==;1418068667;myWdEfHJ7AV8OP23v8pCH1PILL_gxH4uDOAXMi06akk=

Für Nummer 3, es heißt "Zeichen der Nachricht mit den dekodierten ClientKey". Die "Nachricht" und "ClientKey" sind zwei unterschiedliche Zeichenfolgen.

Meine Frage(N): Wie meldet man eine Zeichenkette mit einer anderen Zeichenkette, d.h. was genau bedeutet das? Und wie würde man das in JavaScript?

var message = 'my_message';
var key = 'signing_key';

//??what next??

Ich versuche, um Abbildung es heraus, so kann ich erstellen Sie eine pre-request-script in Postman, um eine ordnungsgemäße HmacSHA256 hash.

Offenbar muß man sich anmelden, um anzeigen der api-docs Houndify.
Sorry, wusste nicht, dass. Ich werde nach den entsprechenden block, anstatt den link

InformationsquelleAutor Obinwanne Hill | 2016-02-05

Gemäß der Dokumentation, wenn Sie mit einem Ihrer SDKs, wird es automatisch authentifizieren Ihre Anforderungen:

SDKs bereits handhaben Authentifizierung für Sie. Sie müssen nur liefern
die SDK mit der Client-ID und Client-Schlüssel generiert wurde, für Ihre
client, wenn es erstellt wurde. Wenn Sie nicht mit einem SDK code verwenden
Beispiel auf der rechten Seite zu generieren, die Ihre eigenen HTTP-Header zu authentifizieren
Ihre Anfrage.

Jedoch, wenn Sie wollen, um es manuell tun, ich glaube, Sie brauchen, um zu berechnen, HMAC Wert der Zeichenfolge, die Sie beschreiben, in der link in deiner Frage und dann schicken Sie es base64-codiert als Teil der Hound-Client-Authentication - header in Ihre Anfragen. Sie bieten eine Beispiel für node.js:

var uuid = require('node-uuid');
var crypto = require('crypto');

function generateAuthHeaders (clientId, clientKey, userId, requestId) {

    if (!clientId || !clientKey) {
        throw new Error('Must provide a Client ID and a Client Key');
    }

    //Generate a unique UserId and RequestId.
    userId      = userId || uuid.v1();

    //keep track of this requestId, you will need it for the RequestInfo Object
    requestId   = requestId || uuid.v1();

    var requestData = userId + ';' + requestId;

    //keep track of this timestamp, you will need it for the RequestInfo Object
    var timestamp   = Math.floor(Date.now() / 1000),  

        unescapeBase64Url = function (key) {
            return key.replace(/-/g, '+').replace(/_/g, '/');
        },

        escapeBase64Url = function (key) {
            return key.replace(/\+/g, '-').replace(/\//g, '_');
        },

        signKey = function (clientKey, message) {
            var key = new Buffer(unescapeBase64Url(clientKey), 'base64');
            var hash = crypto.createHmac('sha256', key).update(message).digest('base64');
            return escapeBase64Url(hash);

        },

        encodedData = signKey(clientKey, requestData + timestamp),
        headers = {
            'Hound-Request-Authentication': requestData,
            'Hound-Client-Authentication': clientId + ';' + timestamp + ';' + encodedData
        };

    return headers;
};

Vielen Dank. Ich versuche zu schaffen, Briefträger pre-request-Skript im Grunde tun, was Sie gebucht haben. Ich brauchte nur meinen Kopf um die Konzepte. Dies wird Ihnen helfen.

InformationsquelleAutor Sam

Also im Grunde, Unterzeichnung [in diesem Fall] bedeutet einfach, erstellen einen hash des Strings über einen hash-Algorithmus zusätzlich zu einem Schlüssel, im Gegensatz zu einem keyless hash [wie MD5]. Zum Beispiel:

var message = 'my_message';
var key = 'signing_key';
var hashed_message = hash_func(message, key);

wo hash_func ist ein hashing-Algorithmus, wie HmacSHA256 (den Hash-Algorithmus in Frage).

Der Grund, ich habe versucht, dieses heraus zu testen, wurde die Authentifizierung für die Houndify API mit Postboten. Zum Glück, der Postbote hat ein nettes feature namens pre-request scripts [komplett mit hashing-algorithmen], die hilft, wenn Sie brauchen, um pre-Werte generieren, die versendet werden müssen, zusammen mit Ihrer Anfrage.

Nach viel hantieren, konnte ich erstellen Sie eine pre-request-Skript korrekt authentifiziert zu dieser API (siehe code unten).

var unescapeBase64Url = function (key) {
            return key.replace(/-/g, '+').replace(/_/g, '/');
        },

        escapeBase64Url = function (key) {
            return key.replace(/\+/g, '-').replace(/\//g, '_');
        },
        guid = function() {
    function s4() {
        return Math.floor((1 + Math.random()) * 0x10000)
        .toString(16)
        .substring(1);
    }
    return s4() + s4() + '-' + s4() + '-' + s4() + '-' +
        s4() + '-' + s4() + s4() + s4();
    };

var client_id_str = environment["client-id"];
var client_key_str = environment["client-key"];
var user_id_str = environment["user-id"];
var request_id_str = guid();
var timestamp_str = Math.floor(Date.now() / 1000);

var client_key_dec_str = CryptoJS.enc.Base64.parse(unescapeBase64Url(client_key_str));

var message_str = user_id_str+";"+request_id_str+timestamp_str;
var signature_hash_obj = CryptoJS.HmacSHA256(message_str, client_key_dec_str);
var signature_str = signature_hash_obj.toString(CryptoJS.enc.Base64);

var hound_request_str = user_id_str+";"+request_id_str;
var hound_client_str = client_id_str+";"+timestamp_str+";"+escapeBase64Url(signature_str);

postman.setEnvironmentVariable("hound-request-authentication", hound_request_str);
postman.setEnvironmentVariable("hound-client-authentication", hound_client_str);

Beachten Sie, dass Sie gehen zu müssen, um das erstellen von environment-Variablen in Briefträger für client-id, client-key, und Benutzer-id, sowie für die header-Variablen hound-Anfrage-Authentifizierung und hound-client-Authentifizierung halten der letzten Werte verwiesen werden, die bei der Definition von Kopfzeilen.

Hoffe, es hilft.

InformationsquelleAutor Obinwanne Hill

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.