Access tokens మరియు refresh tokens కలిసి ఎలా పని చేస్తాయి?

Question

IT Interview Practice · Accepted Answer

ఈ రెండు tokens ఒక సరళమైన జీవితచక్రాన్ని అనుసరిస్తాయి: ఒక **స్వల్పకాలిక access token** ప్రతి API కాల్‌ను అధికారం ఇస్తుంది, మరియు ఒక **దీర్ఘకాలిక refresh token** అవి గడువు ముగిసినప్పుడు నిశ్శబ్దంగా కొత్త access tokens‌ను తయారు చేస్తుంది — తద్వారా వినియోగదారు credentials‌ను మళ్లీ నమోదు చేయకుండా login‌లో ఉంటారు.

## ప్రవాహం

```
┌─────────┐  1. login (user + pass)   ┌────────────┐
│ Client  │ ────────────────────────▶ │ Auth server│
│         │ ◀──── access + refresh ─── │            │
└─────────┘                            └────────────┘
     │  2. API కాల్: Authorization: Bearer <access>
     ▼
┌────────────┐  signature + exp ధృవీకరించు (DB lookup లేదు)
│ Resource   │ ──── 200 OK ────▶ (access ఇంకా చెల్లుతుంది)
│ API        │ ──── 401 ───────▶ (access గడువు ముగిసింది)
└────────────┘
     │  3. 401 వద్ద: POST /token { refresh }
     ▼
┌────────────┐  ధృవీకరించు + రొటేట్ చేయి
│ Auth server│ ──── కొత్త access (+ కొత్త refresh) ────▶ కాల్‌ను మళ్లీ ప్రయత్నించు
└────────────┘
```

1. **Login** — వినియోగదారు ఒకసారి authenticate చేస్తారు; server ఒక **access token** (స్వల్ప TTL) మరియు ఒక **refresh token** (దీర్ఘ TTL) తిరిగి ఇస్తుంది.
2. **API‌లను యాక్సెస్ చేయి** — client ప్రతి request‌పై access token‌ను `Authorization: Bearer …`‌లో పంపుతుంది. API దాన్ని statelessly (signature + `exp`) ధృవీకరించి స్పందిస్తుంది — session store అవసరం లేదు.
3. **గడువు ముగిసినప్పుడు refresh** — API `401` తిరిగి ఇచ్చినప్పుడు (లేదా client `exp` దగ్గరగా ఉందని చూసినప్పుడు), client **refresh token**‌ను auth server యొక్క `/token` endpoint‌కు POST చేసి కొత్త access token పొందుతుంది, ఆపై అసలు request‌ను మళ్లీ ప్రయత్నిస్తుంది. వినియోగదారు ఏమీ గమనించరు.
4. **Logout / రద్దు** — server refresh token‌ను తొలగిస్తుంది లేదా denylist చేస్తుంది; తదుపరి refresh విఫలమవుతుంది మరియు session ముగుస్తుంది (ప్రస్తుత access token ఇంకా కొన్ని నిమిషాల్లో దానంతట అదే చనిపోతుంది).

```js
// Client interceptor: 401 వద్ద ఒకసారి refresh చేసి, ఆపై మళ్లీ ప్రయత్నించు.
async function apiFetch(url, opts = {}) {
  let res = await fetch(url, withAuth(opts, accessToken));
  if (res.status === 401) {
    accessToken = await refreshAccessToken(refreshToken); // POST /token
    res = await fetch(url, withAuth(opts, accessToken));   // మళ్లీ ప్రయత్నించు
  }
  return res;
}
```

## Refresh token rotation

ఉత్తమ పద్ధతి **rotation**: ప్రతి refresh కాల్ ఒక *కొత్త* refresh token‌ను తిరిగి ఇచ్చి పాతదాన్ని చెల్లనిదిగా చేస్తుంది. ఒక పాత (ఇప్పటికే ఉపయోగించిన) refresh token మళ్లీ సమర్పించబడితే, అది దొంగతనాన్ని సూచిస్తుంది — server మొత్తం token family‌ను రద్దు చేసి మళ్లీ login‌ను బలవంతం చేస్తుంది. ఇది దొంగిలించబడిన refresh token యొక్క నష్టాన్ని పరిమితం చేస్తుంది.

## నిల్వ

- **Refresh token** → `httpOnly`, `Secure`, `SameSite` cookie, తద్వారా JavaScript (మరియు తద్వారా XSS) దాన్ని చదవలేదు.
- **Access token** → client‌లో memory‌లో ఉంచబడుతుంది; స్వల్ప జీవితం బహిర్గతాన్ని పరిమితం చేస్తుంది.
- తప్పించుకోగలిగితే ఏదీ `localStorage`‌లో ఉంచవద్దు — ఇది ఇంజెక్ట్ చేయబడిన ఏ script‌కైనా చదవగలిగేది.

## ఇది ఎందుకు ముఖ్యం

ఈ ప్రవాహం ఆధునిక SPAs, mobile apps మరియు APIs‌లో session నిర్వహణకు వెన్నెముక, కాబట్టి interviewers మీరు దీన్ని మొదటి నుండి చివరి వరకు గుర్తించాలని ఆశిస్తారు: login‌లో రెండింటినీ జారీ చేయండి, access token‌తో అధికారం ఇవ్వండి, గడువు ముగిసినప్పుడు పారదర్శకంగా refresh చేయండి, మరియు భద్రత కోసం rotate + రద్దు చేయండి. వివరాలను సరిగ్గా పొందడం — stateless ధృవీకరణ, refresh token endpoint వద్ద మాత్రమే, పునర్వినియోగ గుర్తింపుతో rotation, మరియు `httpOnly` నిల్వ — అనేది సున్నితమైన, సురక్షితమైన session‌కు మరియు ఒక దొంగిలించబడిన token దీర్ఘకాలిక account స్వాధీనాన్ని సూచించే దానికి మధ్య వ్యత్యాసం.

ప్రవాహం

Refresh token rotation

నిల్వ

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు