Uppdatera tokenrotation: bästa praxis för utvecklare
Vill du göra din app säkrare samtidigt som användarna är nöjda? Uppdatera tokenrotation kan hjälpa. Det är en metod där uppdateringstokens ersätts efter varje användning, vilket säkerställer att de endast är giltiga för engångsbruk. Detta förbättrar säkerheten, blockerar replay-attacker och förenklar sessionshanteringen – allt utan att avbryta användarupplevelsen.
Varför använda Refresh Token Rotation?
- Starkare säkerhet: Begränsar missbruk av token och ger tydliga aktivitetsloggar.
- Bättre kontroll: Hantera sessioner exakt och återkalla åtkomst direkt om det behövs.
- Smidig användarupplevelse: Långa sessioner utan frekventa inloggningar.
Hur det fungerar:
- När en åtkomsttoken löper ut, används uppdateringstoken för att begära en ny.
- Servern utfärdar nya åtkomst- och uppdateringstoken samtidigt som den gamla uppdateringstoken ogiltigförklaras.
- Detta skapar en säker kedja av tokens, vilket minskar risker som tokenstöld.
Viktiga steg att implementera:
- Ställ in kort livslängd för åtkomsttoken (15–30 minuter).
- Använd engångsuppdateringstokens (giltigt i 7–14 dagar).
- Lagra tokens säkert (t.ex. HTTP-endast cookies eller säker lagring på serversidan).
- Övervaka efter misstänkt aktivitet som återanvändning av token eller ovanliga inloggningsmönster.
Genom att använda uppdateringstokenrotation stärker du din apps säkerhet samtidigt som autentiseringen förblir smidig för användarna. Är du redo att lära dig mer? Låt oss dyka in!
Upptäcker kapning av sessioner med hjälp av roterande uppdateringstoken
Hur Refresh Tokens fungerar
Det här avsnittet förklarar OAuth 2.0-tokenprocessen och hur rotation av uppdateringstoken förbättrar säkerheten.
OAuth 2.0-tokenflöde
OAuth 2.0 hanterar uppdateringstoken genom en definierad sekvens av steg. När en användare loggar in tillhandahåller auktoriseringsservern två tokens: en kortlivad åtkomsttoken (giltig i 15–60 minuter) och en längre livslängd uppdateringstoken (varar i 7–14 dagar).
Så här fungerar processen:
1. Initial autentisering
Efter en lyckad inloggning utfärdar systemet:
- En kortsiktig åtkomsttoken för API-anrop.
- En längre uppdateringstoken för att begära nya åtkomsttoken.
2. Använda åtkomsttoken
Klienten inkluderar åtkomsttoken i auktoriseringshuvudet för varje API-begäran, så här:
Auktorisation: Bärare eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9... 3. Uppdaterar token
När åtkomsttoken löper ut använder klienten uppdateringstoken för att begära en ny utan att användaren behöver logga in igen.
Låt oss sedan titta på hur tokenrotation förbättrar denna process.
Token Rotation Process
Tokenrotation stärker säkerheten genom att byta ut tokens efter varje uppdatering, vilket säkerställer att uppdateringstoken endast är giltiga för en enda användning. Så här fungerar det:
- Klienten märker att åtkomsttoken har gått ut.
- Den skickar den aktuella uppdateringstoken till tokenslutpunkten.
- Servern validerar uppdateringstoken och utfärdar nya åtkomst- och uppdateringstoken.
- Den gamla uppdateringstoken är ogiltig.
- Servern skickar de nya tokens tillbaka till klienten.
- Klienten uppdaterar sina lagrade tokens.
Denna metod för "engångsanvändning" skapar en säker kedja av tokens, vilket minskar risken för missbruk.
För att upprätthålla uppdateringstoken för engångsbruk bör du överväga dessa kontroller:
| Kontrollera | Syfte | Genomförande |
|---|---|---|
| Detektering av tokenåteranvändning | Förhindra reprisattacker | Spåra använda uppdateringstoken i en svartlista |
| Nådperiod | Hantera tävlingsförhållanden | Tillåt ett 30-sekunders fönster för samtidiga förfrågningar |
| Token familjevalidering | Behåll token härstamning | Inkludera referenser för överordnade token i nya tokens |
Tokenrotation fungerar sömlöst i bakgrunden, vilket förbättrar säkerheten samtidigt som användarupplevelsen blir smidig. Genom att använda den här metoden säkerställer du säkra, automatiska autentiseringsuppdateringar utan frekventa användarinloggningar.
Ställa in tokenrotation
Grundläggande konfigurationssteg
För att ställa in tokenrotation, konfigurera din auktoriseringsserver med följande parametrar:
- Ställ in åtkomsttokens livslängd till 15–30 minuter.
- Begränsa uppdateringstokens giltighet till maximalt 7–14 dagar.
- Aktivera tokenvalideringskontroller för att säkerställa säkerheten.
- Tillämpa hastighetsbegränsning på token-slutpunkter för att förhindra missbruk.
Din server bör ha ett tokenregister med dessa viktiga fält:
| Fält | Syfte | Exempelvärde |
|---|---|---|
| Token-ID | Unik identifierare | uuid-v4 |
| Utgivningstid | Tidsstämpel för tokenskapande | 18/03/2025, 14:30 EST |
| Familje-ID | Grupprelaterade tokens | family-uuid-v4 |
| Föregående token | Spårar överordnad token | prev-token-hash |
| Återkallelsestatus | Indikerar tokenstatus | aktiv/återkallad |
När du har konfigurerat, gå vidare till att implementera tokenrotation i din kod.
Programmeringsexempel
Här är ett exempel på tokenrotation med Node.js:
const jwt = require('jsonwebtoken'); const crypto = require('crypto'); async function rotateTokens(refreshToken) { const decodedToken = jwt.verify(refreshToken, process.env.SECRET_KEY); // Generera nytt tokenpar const newAccessToken = jwt.sign({ userId: decodedToken.userId }, process.env.SECRET_KEY, { expiresIn: '30m' } ); const newRefreshToken = jwt.sign({ userId: decodedToken.userId, familyId: decodedToken.familyId, previousToken: crypto.createHash('sha256') .update(refreshToken).digest('hex') }, process.env.SECRET_KEY, { expiresIn: '7d' } ); Behöver du detta villkor? Behöver du detta fel? // Ogiltigförklara gammal uppdateringstoken await invalidateToken(refreshToken); return { accessToken: newAccessToken, refreshToken: newRefreshToken }; } Bästa praxis för tokenlagring
Efter att ha implementerat tokenrotation, se till att tokens lagras säkert genom att följa dessa metoder:
- Lagring på serversidan
Använd en säker, snabb databas som Redis för att lagra tokenmetadata. Redis inbyggda utgångsstöd är särskilt användbart:await redis.setex(`token:${tokenId}`, 604800, // 7 dagar i sekunder JSON.stringify(tokenMetadata)); - Lagring på klientsidan
För webbapplikationer, lagra uppdateringstoken i endast HTTP-cookies med korrekta säkerhetsflaggor:res.cookie('refreshToken', token, { httpOnly: true, secure: true, sameSite: 'strict', maxAge: 604800000 // 7 dagar i millisekunder }); - Mobila applikationer
Använd plattformsspecifika säkra lagringsalternativ:- iOS: Nyckelringtjänster
- Android: EncryptedSharedPreferences
- React Native: Krypterad AsyncStorage
Undvik dessa misstag när du lagrar tokens:
- Förvara aldrig tokens i
localStorage, eftersom det är sårbart för XSS-attacker. - Undvik att bädda in känslig data i JWT-nyttolasten.
- Se till att all lagrad data är krypterad.
- Håll åtkomst och uppdatera tokens på separata lagringsplatser för att minska riskerna.
sbb-itb-59e1987
Säkerhetsåtgärder
Förhindrar återanvändning av token
För att stoppa omspelsattacker, övervaka tokenanvändning med ett centraliserat system som spårar tokentillståndsändringar:
const tokenRegistry = { async markTokenUsed(tokenId, timestamp) { const token = await db.tokens.findOne({ id: tokenId }); if (token.used || token.revoked) { throw new SecurityError('Återanvändning av token upptäckt'); } await db.tokens.update({ id: tokenId, used: true, lastUsedAt: timestamp }); } }; Behöver du mer information om återanvändning av token? Om tokenåteranvändning upptäcks, vidta omedelbara åtgärder:
- Återkalla token för att förhindra ytterligare missbruk.
- Logga händelsen för revisionsändamål.
- Framtvinga ny autentisering för den berörda sessionen.
- Meddela administratörer för att utreda intrånget.
Dessa steg kompletterar metoderna för återkallande av token som beskrivs nedan.
Steg för återkallande av token
Tokenåterkallelse kan tillämpas på olika nivåer beroende på situationen:
| Återkallelsetyp | När du ska använda | Inverkan |
|---|---|---|
| Single Token | Misstänkt aktivitet på en enhet | Endast den specifika token påverkas |
| Familjeåterkallelse | Intrång som involverar flera enheter | Alla relaterade tokens är ogiltiga |
| Global återkallelse | Stor säkerhetsincident | Alla aktiva tokens återkallas i hela systemet |
Här är ett exempel på återkallande av familjetoken:
async function revokeTokenFamily(familyId) { await db.tokens.updateMany({ familyId: familyId }, { revoked: true, revokedAt: new Date(), reason: 'security_breach' } ); // Meddela klienter await notifyClients(familyId); // Logga säkerhetshändelse await logSecurityEvent({ type: 'family_revocation', familyId: familyId, timestamp: new Date() }); } ... Användningsgränser och spårning
Att övervaka tokenförfrågningar är avgörande för att upptäcka ovanlig aktivitet. Använd hastighetsgränser och spåra användningsmönster för att identifiera potentiella hot:
const rateLimits = { tokenRequests: { window: '15m', maxAttempts: 100, blockDuration: '1h' }, refreshAttempts: { window: '24h', maxAttempts: 1000, blockDuration: '24h' } }; Viktiga mätvärden att övervaka inkluderar:
- Frekvens för tokenuppdateringar per användare
- Misslyckade tokenuppdateringsförsök
- Geografiskt ursprung för förfrågningar
- Tidsbaserade användningstrender
- Antal samtidiga aktiva sessioner
Ställ in varningar för misstänkt beteende, som:
- Flera uppdateringsförsök från olika IP-adresser
- Snabba tokenrotationer
- Tillträde under ovanliga tider
- Förfrågningar från oväntade platser
Lagra tokenanvändningsdata i en tidsseriedatabas för bättre analys och hotdetektering:
const metrics = { async recordTokenUsage(tokenId, context) { await timeseriesDB.insert({ timestamp: new Date(), tokenId: tokenId, userId: context.userId, ipAddress: context.ip, userAgent: context.userAgent, geoLocation: await geolocate(context.ip) }); } }; Please be aware that the context may be aware that the context has been provided text and the functions. Attribute specificerar att dela innehållet med andra källor. Insert the context is objectionable. UserAgent Name ... När oegentligheter upptäcks, höj säkerheten genom att:
- Ökade övervakningsintervaller
- Förkorta tokens utgångstider
- Lägger till extra verifieringssteg
- Initiera manuella granskningar för djupare utredning
Testning och underhåll
Testprocedurer
Automatiserade tester är viktiga för att säkerställa att tokenrotationsprocessen fungerar som avsett. Här är ett exempel på hur du testar den här funktionen:
describe('Token Rotation Tests', () => { test('ska rotera och validera tokens', async () => { // Testa grundläggande rotation const initialToken = await generateRefreshToken(); const rotatedToken = await rotateToken(initialToken); expect(rotatedToken).not.toEqual(initialToken); expect(await validateToken(rotatedToken)).toBeTruthy(); // Testa fullständigt autentiseringsflöde const authResponse = await authentic(credentials); await simulateTokenExpiry(authResponse.accessToken); const newTokens = await performTokenRotation(authResponse.refreshToken); await verifyTokenLineage(authResponse.refreshToken, newTokens.refreshToken); }); }); När du har bekräftat att tokenrotation fungerar som förväntat, håll ett öga på systemets prestanda för att identifiera och lösa problem tidigt.
Systemövervakning
Spåra prestanda för tokenrotation med hjälp av nyckelmått för att bibehålla tillförlitligheten:
| Metrisk | Beskrivning | Varningströskel |
|---|---|---|
| Rotationslatens | Dags att slutföra rotationen | > 500 ms |
| Framgångsfrekvens | Framgångsrika rotationer | < 99.9% |
| Token Kedjelängd | Rotationer i följd | > 50 varv |
| Felfrekvens | Misslyckade försök per timme | > 10 fel |
Logga dessutom alla tokens livscykelhändelser för bättre spårbarhet:
const rotationLogger = { async logRotationEvent(händelse) { await logger.info('token_rotation', { timestamp: new Date().toISOString(), tokenId: händelse.tokenId, rotationDuration: händelse.duration, status: händelse.status, errorCode: händelse.error || null }); } }; Felhantering
Även med noggrann testning och övervakning kan fel fortfarande uppstå. Använd dedikerade återställningsmekanismer för att hantera dem effektivt:
const errorHandler = { async handleRotationError(error, context) { // Primär felhantering med integrerad brytare if (this.failureCount >= 5) { await this.activateFailover(); return; } switch(error.code) { case 'TOKEN_EXPIRED': await forceReauthentication(context.userId); break; case 'DATABASE_ERROR': await this.retryWithBackoff(context); break; default: await this.notifyAdministrator(error); } await metrics.recordError(error); }, async retryWithBackoff(context, attempts = 0) { if (attempts > 3) return; await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempts) * 1000)); return this.handleRotationError(context, attempts + 1); } }; ... Detta tillvägagångssätt säkerställer att fel hanteras effektivt, vilket minimerar störningar i systemet.
Slutsats
Viktiga takeaways
Refresh token rotation säkerställer en balans mellan säkerhet, prestanda, och användarupplevelse. Här är de grundläggande metoderna att tänka på:
- Optimera systemets prestanda genom kontinuerlig övervakning.
- Implementera motståndskraftig felhantering för att möjliggöra smidig återhämtning från problem.
- Genomför rigorösa tester för att validera och finjustera rotationsmekanismen.
Steg-för-steg-guide för implementering
Om du är redo att implementera tokenrotation, här är en uppdelning av processen:
- Initial installation
Börja med att bygga säker tokenlagring med branschstandardkrypteringsmetoder. Inkludera hastighetsbegränsning och se till att din autentiseringsserver kan skalas för att möta efterfrågan. - Säkerhetskonfiguration
Definiera kritiska parametrar som tokens livslängder, rotationsfönster och gränser. Till exempel, här är en enkel konfiguration:const securityConfig = { tokenLifetime: 3600, // Tokens giltiga i 1 timmes rotationWindow: 86400, // Uppdatera tokens giltiga i 24 timmar maxRotations: 30, // Maximalt antal tokenrotationer jwtAlgorithm: 'RS256', // Asymmetrisk krypteringsalgoritm tokenLength: 256 // Tokenstorlek i bitar }; - Övervakningsinställningar
Upprätta trösklar för systemets prestanda och ställ in varningar för avvikelser. Var beredd att skala din infrastruktur när statistik visar ökad efterfrågan. - Produktionsinstallation
Rulla ut systemet gradvis och håll ett öga på kritiska mätvärden. Upprätthåll detaljerade loggar över rotationshändelser för granskning och felsökning. För en skalbar och pålitlig infrastruktur, överväg värdlösningar som t.ex Serverion (https://serverion.com), som stöder högpresterande miljöer.
