గుర్తింపు ధ్రువీకరణ

ధ్రువీకరణ ఎందుకు#

డిఫాల్ట్‌గా SDK అనామకంగా పనిచేస్తుంది: అది స్థిరమైన visitor_idని తయారుచేసి ప్లాట్‌ఫామ్ కీస్టోర్‌లో ఉంచుతుంది. ఒక పరికరంలో ఒక సంభాషణకు అది సరిపోతుంది. అయితే నిర్దిష్ట వినియోగదారుని గుర్తించాలంటే, మళ్లీ లాగిన్ అయినప్పుడో వేరే పరికరంలోనో చరిత్రను తిరిగి తేవాలంటే, సంభాషణను కాంటాక్ట్ ప్రొఫైల్‌తో నమ్మకంగా ముడిపెట్టాలంటే — క్లయింట్ తాను చెప్పుకుంటున్న వ్యక్తే అనడానికి బ్యాకెండ్‌కు రుజువు కావాలి. SDK కేవలం "నేను user 42" అని పంపితే, ఎవరైనా వేరే idని నటించి ఇతరుల చాట్‌ను చదవగలరు — అందుకే మీ బ్యాకెండ్ మాత్రమే తయారుచేయగల క్రిప్టోగ్రాఫిక్ సంతకాన్ని, అంటే userHashను, Respondo తప్పనిసరి చేస్తుంది.

identity secret ఎలా పొందాలి#

identity_secret అనేది మీ ఏజెంట్‌కు (మీ విడ్జెట్ ఛానెల్ అనుసంధానమై ఉన్న AI కార్మికుడికి) ముడిపడిన రహస్య స్ట్రింగ్. దాన్ని డ్యాష్‌బోర్డ్‌లో Channels → Widget → Identity verification కింద తయారుచేసుకోండి. సీక్రెట్ ఏజెంట్‌పైనే ఉంటుంది కాబట్టి, ఆ ఏజెంట్ నడిపే ప్రతి ఛానెల్ — వెబ్ విడ్జెట్ అయినా, మొబైల్ SDK అయినా — అదే సీక్రెట్‌ను పంచుకుంటుంది. గుర్తింపులపై సంతకం చేసే హక్కును అది ఇస్తుంది కాబట్టి, అది మీ బ్యాకెండ్‌లో మాత్రమే ఉండాలి, యాప్‌తో పాటు ఎప్పుడూ పంపకూడదు.

userHash సూత్రం#

userHash అంటే సంతకం చేసిన ఒకే ఒక గుర్తింపు స్ట్రింగ్‌పై HMAC-SHA256, చిన్న అక్షరాల hex రూపంలో:

userHash = HMAC_SHA256( identity_secret, payload )

payload = userId          // userId ఇచ్చినట్లయితే
        = email           // లేదంటే, email ఇచ్చినట్లయితే
        = (invalid)       // రెండూ ఖాళీ అయితే సంతకం చేయడానికి ఏమీ లేదు

• సీక్రెట్ అనేది HMAC కీ; గుర్తింపు స్ట్రింగ్ అనేది మెసేజ్ — తారుమారు కాదు.
• సరిగ్గా ఒకే ఒక స్ట్రింగ్‌పై సంతకం చేయండి — ముడి userId (లేదా ఈమెయిల్), ఎలాంటి సాల్ట్ కానీ JSON ర్యాపర్ కానీ లేకుండా.
• userIdనూ ఈమెయిల్‌నూ రెండింటినీ పంపితే, userIdపై సంతకం చేయండి (దానికే ప్రాధాన్యం).
• ఫలితం hex రూపంలో ఉంటుంది (SHA-256కు 64 అక్షరాలు), base64 కాదు.

బ్యాకెండ్ ఉదాహరణలు#

సంతకాన్ని మీ బ్యాకెండ్‌లో లెక్కించి, సిద్ధమైన userHashను యాప్‌కు అందించండి.

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

// HMAC_SHA256(identity_secret, userId) — చిన్న అక్షరాల hex రూపంలో.
func ComputeUserHash(identitySecret, userID string) string {
    mac := hmac.New(sha256.New, []byte(identitySecret))
    mac.Write([]byte(userID))
    return hex.EncodeToString(mac.Sum(nil))
}

const crypto = require("crypto");

// మొబైల్ క్లయింట్‌లో Respondo.identifyకు పంపాల్సిన userHashను తిరిగి ఇస్తుంది.
function computeUserHash(identitySecret, userId) {
  return crypto
    .createHmac("sha256", identitySecret)
    .update(userId, "utf8")
    .digest("hex");
}

import hmac
import hashlib

# మొబైల్ క్లయింట్‌లో Respondo.identifyకు పంపాల్సిన userHashను తిరిగి ఇస్తుంది.
def compute_user_hash(identity_secret: str, user_id: str) -> str:
    return hmac.new(
        identity_secret.encode(),
        user_id.encode(),
        hashlib.sha256,
    ).hexdigest()

<?php
// మొబైల్ క్లయింట్‌లో Respondo.identifyకు పంపాల్సిన userHashను తిరిగి ఇస్తుంది.
function computeUserHash(string $identitySecret, string $userId): string {
    return hash_hmac('sha256', $userId, $identitySecret);
}

హాష్ Respondoకు ఎలా చేరుతుంది#

రెండు దశలు — వాటిలో మొదటిది మాత్రమే మీరు కట్టాల్సింది:

1. మీ బ్యాకెండ్ → మీ యాప్. హాష్‌ను మీకు నచ్చిన విధంగా చేరవేయండి. అన్నింటికన్నా చౌకైన మార్గం — మీరు ఇప్పటికే తిరిగి ఇచ్చే login/bootstrap స్పందనలో ఒక అదనపు ఫీల్డ్ జోడించడం; అదనపు రౌండ్ ట్రిప్ అక్కర్లేదు. మీ సొంత బ్యాకెండ్‌లో ప్రత్యేక ఎండ్‌పాయింట్ (ఉదాహరణకు POST /myapp/identity — { userId, userHash } తిరిగి ఇస్తుంది) కూడా అంతే బాగా పనిచేస్తుంది. ఆ ఎండ్‌పాయింట్‌ను Respondo హోస్ట్ చేయదు — దాన్ని మీరే అమలు చేయాలి.
2. మీ యాప్ → Respondo. ఇది మీ కోసం చేసిపెట్టబడింది. మీరు identifyని ఒకసారి కాల్ చేస్తే చాలు — SDK సంబంధిత ప్రతి అభ్యర్థనకూ హాష్‌ను జతచేస్తుంది, బ్యాకెండ్ ప్రతిసారీ దాన్ని మళ్లీ ధ్రువీకరిస్తుంది.

POST /api/v1/chat                      body   identity.userHash
GET  /api/v1/chat/resume               query  user_hash
GET  /api/v1/chat/history              query  user_hash
GET  /api/v1/chat/ws                   frames    user_hash (subscribe/identify JSON frames after connect — not in the handshake URL)
GET  /api/v1/widget/tours              query  user_hash
GET  /api/v1/widget/checklists         query  user_hash
POST /api/v1/widget/push/register      body   user_hash

హాష్‌ను ప్రతి అభ్యర్థనకూ మళ్లీ తనిఖీ చేస్తారు; ఒకసారి ఇచ్చి సెషన్‌గా మార్చుకోవడం కాదు — అందుకే దొంగిలించిన userId ఒక్కటే ఎందుకూ పనికిరాదు.

SDKకు గుర్తింపును అందించడం#

సంతకం చేసిన గుర్తింపును మీ బ్యాకెండ్ నుంచి తెచ్చుకుని, ఏ ప్లాట్‌ఫామ్‌లోనైనా userHashను identifyకు పంపండి:

Respondo.identify(
    RespondoIdentity(userId = "42", email = "user@example.com", userHash = hash),
)

Respondo.identify(
    RespondoIdentity(userId: "42", email: "user@example.com", userHash: hash)
)

Respondo.identify(RespondoIdentity(
  userId: '42', email: 'user@example.com', userHash: hash,
));

చెల్లని userHash ఉన్నప్పుడు ప్రవర్తన#

ఏజెంట్‌పై ధ్రువీకరణ ఆన్‌లో ఉండి సంతకం లేకపోయినా, తప్పుగా ఉన్నా — బ్యాకెండ్ నిశ్శబ్దంగా అనామక స్థాయికి దించేస్తుంది: చాట్ పనిచేస్తూనే ఉంటుంది, visitor_id అలాగే ఉంటుంది, సంభాషణ అనామక కాంటాక్ట్‌తో ముడిపడుతుంది — కానీ ప్రొఫైల్‌తో లింక్ ఉండదు, పరికరాల మధ్య చరిత్రా ఉండదు. వినియోగదారుని "గుర్తించడం లేదు" అంటే దాదాపు ఎప్పుడూ కారణం సంతకమే: మీరు userIdపైనే సంతకం చేశారా (ఈమెయిల్ లేదా JSONపై కాదు), సరైన identity_secret వాడారా, ఫలితం చిన్న అక్షరాల hexలో వచ్చిందా — ఇవి సరిచూసుకోండి. ఏజెంట్‌కు identity_secret ఖాళీగా ఉంటే ధ్రువీకరణ ఆఫ్‌లో ఉంటుంది, userId / ఈమెయిల్ ఉన్నదున్నట్టుగానే ఆమోదించబడతాయి.

identity_secretను మార్చడం ఆచరణలో పూర్తి కటోవర్ లాంటిది: పాత సీక్రెట్‌తో తయారైన ప్రతి హాషూ వెంటనే ధ్రువీకరణ కావడం ఆగిపోతుంది; అందువల్ల ఇప్పటికే సైన్ ఇన్ అయిన వినియోగదారులు — మీ బ్యాకెండ్ కొత్త సీక్రెట్‌తో వారి userHashను మళ్లీ లెక్కించి అందించే వరకు — నిశ్శబ్దంగా అనామక స్థాయికి దిగిపోతారు. సంతకం చేసే వైపును అదే సమయంలో అప్‌డేట్ చేయగలిగినప్పుడు మాత్రమే సీక్రెట్‌ను మార్చండి.