access tokens आणि refresh tokens एकत्र कसे काम करतात?

Question

IT Interview Practice · Accepted Answer

दोन tokens एक साधे lifecycle पाळतात: **अल्पकालीन access token** प्रत्येक API call ला authorize करतो, आणि **दीर्घकालीन refresh token** ते expire झाल्यावर मूकपणे नवीन access tokens तयार करतो — त्यामुळे user credentials पुन्हा न टाकता logged in राहतो.

## प्रवाह

```
┌─────────┐  1. login (user + pass)   ┌────────────┐
│ Client  │ ────────────────────────▶ │ Auth server│
│         │ ◀──── access + refresh ─── │            │
└─────────┘                            └────────────┘
     │  2. API call: Authorization: Bearer <access>
     ▼
┌────────────┐  signature + exp तपासा   (DB lookup नाही)
│ Resource   │ ──── 200 OK ────▶ (access अजून वैध)
│ API        │ ──── 401 ───────▶ (access expired)
└────────────┘
     │  3. 401 वर: POST /token { refresh }
     ▼
┌────────────┐  तपासा + rotate करा
│ Auth server│ ──── नवीन access (+ नवीन refresh) ────▶ call पुन्हा करा
└────────────┘
```

1. **Login** — user एकदाच authenticate करतो; server एक **access token** (short TTL) आणि एक **refresh token** (long TTL) परत करतो.
2. **API access** — client प्रत्येक request वर `Authorization: Bearer …` मध्ये access token पाठवतो. API तो statelessly (signature + `exp`) verify करून प्रतिसाद देतो — session store ची गरज नाही.
3. **Expiry वर refresh** — जेव्हा API `401` परत करते (किंवा client ला `exp` जवळ आल्याचे दिसते), तेव्हा client **refresh token** auth server च्या `/token` endpoint ला POST करतो आणि नवीन access token मिळवतो, मग मूळ request पुन्हा करतो. User ला काहीच जाणवत नाही.
4. **Logout / revoke** — server refresh token delete करतो किंवा 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 call एक *नवीन* refresh token परत करते आणि जुना invalidate करते. जर एक जुना (आधीच वापरलेला) refresh token पुन्हा सादर केला, तर ते चोरीचे संकेत आहे — server संपूर्ण token family revoke करतो आणि re-login भाग पाडतो. यामुळे चोरलेल्या refresh token चे नुकसान मर्यादित होते.

## साठवण

- **Refresh token** → `httpOnly`, `Secure`, `SameSite` cookie जेणेकरून JavaScript (आणि म्हणून XSS) तो वाचू शकत नाही.
- **Access token** → client वर memory मध्ये ठेवला; short life exposure मर्यादित करते.
- शक्य असल्यास दोन्हीपैकी कोणताही `localStorage` मध्ये कधीही ठेवू नका — तो कोणत्याही injected script द्वारे वाचता येतो.

## हे का महत्त्वाचे आहे

हा प्रवाह आधुनिक SPAs, mobile apps आणि APIs मधील session management चा कणा आहे, म्हणून मुलाखत घेणारे अपेक्षा करतात की तुम्ही तो सुरुवातीपासून शेवटपर्यंत मागोवा घ्याल: login ला दोन्ही issue करा, access token ने authorize करा, expiry वर पारदर्शकपणे refresh करा, आणि सुरक्षिततेसाठी rotate + revoke करा. तपशील बरोबर मिळवणे — stateless verification, फक्त token endpoint वर refresh, reuse detection सह rotation, आणि `httpOnly` storage — हा एका गुळगुळीत, सुरक्षित session आणि जिथे एक चोरलेला token म्हणजे दीर्घकालीन account takeover यामधील फरक आहे.

प्रवाह

Refresh token rotation

साठवण

हे का महत्त्वाचे आहे

संबंधित प्रश्न