Opdater tokenrotation: Bedste praksis for udviklere
Vil du gøre din app mere sikker og samtidig holde brugerne glade? Opdater token-rotation kan hjælpe. Det er en metode, hvor opdateringstokens udskiftes efter hver brug, hvilket sikrer, at de kun er gyldige til engangsbrug. Dette forbedrer sikkerheden, blokerer gentagelsesangreb og forenkler sessionsstyring – alt sammen uden at afbryde brugeroplevelsen.
Hvorfor bruge Refresh Token Rotation?
- Stærkere sikkerhed: Begrænser tokenmisbrug og giver klare aktivitetslogfiler.
- Bedre kontrol: Administrer sessioner præcist og tilbagekald adgang øjeblikkeligt, hvis det er nødvendigt.
- Glat brugeroplevelse: Lange sessioner uden hyppige logins.
Sådan fungerer det:
- Når et adgangstoken udløber, bruges opdateringstokenet til at anmode om et nyt.
- Serveren udsteder nye adgangs- og opdateringstokens, mens den ugyldiggør det gamle opdateringstoken.
- Dette skaber en sikker kæde af tokens, hvilket reducerer risici som token-tyveri.
Nøgletrin til implementering:
- Indstil kort levetid for adgangstokener (15-30 minutter).
- Brug engangsopdateringstokens (gyldig i 7-14 dage).
- Gem tokens sikkert (f.eks. kun HTTP-cookies eller sikker lagring på serversiden).
- Overvåg for mistænkelig aktivitet som tokengenbrug eller usædvanlige loginmønstre.
Ved at bruge opdateringstokenrotation styrker du din apps sikkerhed, samtidig med at godkendelsen forbliver problemfri for brugerne. Klar til at lære mere? Lad os dykke ned!
Registrering af sessionskapring ved hjælp af roterende opdateringstokens
Sådan fungerer Refresh Tokens
Dette afsnit forklarer OAuth 2.0-tokenprocessen, og hvordan rotation af opdateringstoken forbedrer sikkerheden.
OAuth 2.0-tokenflow
OAuth 2.0 administrerer opdateringstokens gennem en defineret sekvens af trin. Når en bruger logger på, leverer autorisationsserveren to tokens: et kortvarigt adgangstoken (gyldigt i 15-60 minutter) og et længerevarende opdateringstoken (der varer 7-14 dage).
Sådan fungerer processen:
1. Indledende godkendelse
Efter et vellykket login udløser systemet:
- Et kortsigtet adgangstoken til API-kald.
- Et længerevarende opdateringstoken for at anmode om nye adgangstokens.
2. Brug af adgangstoken
Klienten inkluderer adgangstokenet i autorisationsoverskriften for hver API-anmodning, sådan her:
Autorisation: Ihændehaver eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9... 3. Opdater token
Når adgangstokenet udløber, bruger klienten opdateringstokenet til at anmode om et nyt uden at kræve, at brugeren logger på igen.
Lad os derefter se på, hvordan token-rotation forbedrer denne proces.
Token-rotationsproces
Tokenrotation styrker sikkerheden ved at udskifte tokens efter hver opdatering, hvilket sikrer, at opdateringstokens kun er gyldige til en enkelt brug. Sådan fungerer det:
- Klienten bemærker, at adgangstokenet er udløbet.
- Den sender det aktuelle opdateringstoken til tokenslutpunktet.
- Serveren validerer opdateringstokenet og udsteder nye adgangs- og opdateringstokens.
- Det gamle opdateringstoken er ugyldigt.
- Serveren sender de nye tokens tilbage til klienten.
- Klienten opdaterer sine gemte tokens.
Denne tilgang til "engangsbrug" skaber en sikker kæde af tokens, hvilket reducerer risikoen for misbrug.
For at gennemtvinge engangsopdateringstokens skal du overveje disse kontroller:
| Check | Formål | Implementering |
|---|---|---|
| Detektion af tokengenbrug | Forhindr replay-angreb | Spor brugte opdateringstokens på en sortliste |
| Afdragsfri periode | Håndtag race forhold | Tillad et 30-sekunders vindue for samtidige anmodninger |
| Token familie validering | Vedligehold token-afstamning | Inkluder overordnede token-referencer i nye tokens |
Tokenrotation fungerer problemfrit i baggrunden, hvilket øger sikkerheden, samtidig med at brugeroplevelsen holdes jævn. Ved at bruge denne metode sikrer du sikre, automatiske legitimationsopdateringer uden hyppige brugerlogins.
Opsætning af token-rotation
Grundlæggende konfigurationstrin
For at konfigurere tokenrotation skal du konfigurere din autorisationsserver med følgende parametre:
- Indstil adgangstokens levetid til 15-30 minutter.
- Begræns gyldigheden af opdateringstoken til maksimalt 7-14 dage.
- Aktiver token-valideringstjek for at sikre sikkerheden.
- Anvend hastighedsbegrænsning på token-endepunkter for at forhindre misbrug.
Din server bør vedligeholde et token-register med disse vigtige felter:
| Felt | Formål | Eksempel værdi |
|---|---|---|
| Token-id | Unik identifikator | uuid-v4 |
| Udgivelsestid | Tidsstempel for token-oprettelse | 18/03/2025, 14:30 EST |
| Familie ID | Grupperelaterede tokens | familie-uuid-v4 |
| Forrige token | Sporer overordnet token | prev-token-hash |
| Tilbagekaldelsesstatus | Indikerer token-status | aktiv/tilbagekaldt |
Når den er konfigureret, skal du gå videre til implementering af token-rotation i din kode.
Programmeringseksempler
Her er et eksempel på token-rotation ved hjælp af Node.js:
const jwt = require('jsonwebtoken'); const crypto = require('crypto'); async function rotateTokens(refreshToken) { const decodedToken = jwt.verify(refreshToken, process.env.SECRET_KEY); // Generer nyt token-par 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' } ); * ... // Ugyldiggør gammel opdateringstoken await invalidateToken(refreshToken); return { accessToken: newAccessToken, refreshToken: newRefreshToken }; } Token-opbevaring bedste praksis
Efter implementering af tokenrotation skal du sikre dig, at tokens opbevares sikkert ved at følge disse fremgangsmåder:
- Opbevaring på serversiden
Brug en sikker, hurtig database som Redis til at gemme token-metadata. Redis' indbyggede udløbssupport er særlig nyttig:await redis.setex(`token:${tokenId}`, 604800, // 7 dage i sekunder JSON.stringify(tokenMetadata)); - Opbevaring på klientsiden
For webapplikationer skal du opbevare opdateringstokens i kun HTTP-cookies med korrekte sikkerhedsflag:res.cookie('refreshToken', token, { httpOnly: true, secure: true, sameSite: 'strict', maxAge: 604800000 // 7 dage i millisekunder }); - Mobilapplikationer
Brug platformspecifikke sikker opbevaringsmuligheder:- iOS: Nøgleringtjenester
- Android: EncryptedSharedPreferences
- React Native: Krypteret AsyncStorage
Undgå disse fejl, når du opbevarer tokens:
- Gem aldrig tokens i
lokalopbevaring, da det er sårbart over for XSS-angreb. - Undgå at indlejre følsomme data i JWT-nyttelasten.
- Sørg for, at alle lagrede data er krypteret.
- Hold adgang og opdater tokens på separate lagersteder for at reducere risici.
sbb-itb-59e1987
Sikkerhedsforanstaltninger
Forhindrer genbrug af tokens
For at stoppe genafspilningsangreb skal du overvåge tokenbrug med et centraliseret system, der sporer tokentilstandsændringer:
const tokenRegistry = { async markTokenUsed(tokenId, timestamp) { const token = await db.tokens.findOne({ id: tokenId }); if (token.used || token.revoked) { throw new SecurityError('Genbrug af token registreret'); } await db.tokens.update({ id: tokenId, used: true, lastUsedAt: timestamp }); } }; Tag: } * ... Hvis der registreres genbrug af tokener, skal du handle med det samme:
- Tilbagekald tokenet for at forhindre yderligere misbrug.
- Log hændelsen til revisionsformål.
- Tving gengodkendelse for den berørte session.
- Underret administratorer at undersøge bruddet.
Disse trin supplerer token-tilbagekaldelsesmetoderne beskrevet nedenfor.
Trin til tilbagekaldelse af token
Token tilbagekaldelse kan anvendes på forskellige niveauer afhængigt af situationen:
| Tilbagekaldelsestype | Hvornår skal bruges | Indvirkning |
|---|---|---|
| Enkelt token | Mistænkelig aktivitet på én enhed | Kun det specifikke token er påvirket |
| Familie tilbagekaldelse | Brud, der involverer flere enheder | Alle relaterede tokens er ugyldige |
| Global tilbagekaldelse | Større sikkerhedshændelse | Alle aktive tokens tilbagekaldes i hele systemet |
Her er et eksempel på tilbagekaldelse af familietoken:
async function revokeTokenFamily(familyId) { await db.tokens.updateMany({ familyId: familyId }, { revoked: true, revokedAt: new Date(), reason: 'security_breach' } ); // Giv klienter besked await notifyClients(familyId); // Log sikkerhedshændelse await logSecurityEvent({ type: 'family_revocation', familyId: familyId, timestamp: new Date() }); } * ... Brugsgrænser og sporing
Overvågning af tokenanmodninger er afgørende for at opdage usædvanlig aktivitet. Brug hastighedsgrænser og spor brugsmønstre for at identificere potentielle trusler:
const rateLimits = { tokenRequests: { window: '15m', maxAttempts: 100, blockDuration: '1t' }, refreshAttempts: { window: '24t', maxAttempts: 1000, blockDuration: '24t' } }; Bemærk: Denne kode er i hovedtræk afhængig af formålet. Kommentarer er i hovedtræk afhængigt af, om de er konfigurerbare, men de kan muligvis ikke oversættes korrekt. Nøglemålinger til at overvåge inkluderer:
- Hyppighed af token-opdateringer pr. bruger
- Mislykkede token-opdateringsforsøg
- Geografisk oprindelse af anmodninger
- Tidsbaserede brugstendenser
- Antal samtidige aktive sessioner
Konfigurer advarsler for mistænkelig adfærd, såsom:
- Flere opdateringsforsøg fra forskellige IP'er
- Hurtige token-rotationer
- Adgang på usædvanlige tidspunkter
- Anmodninger fra uventede steder
Gem tokenbrugsdata i en tidsseriedatabase for bedre analyse og trusselsdetektion:
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 await for the userAgent. UserAgent will ... Når der opdages uregelmæssigheder, skal du øge sikkerheden ved at:
- Øge overvågningsintervaller
- Forkortelse af tokens udløbstider
- Tilføjelse af ekstra verifikationstrin
- Igangsættelse af manuelle anmeldelser for dybere undersøgelser
Test og vedligeholdelse
Testprocedurer
Automatiserede test er afgørende for at sikre, at token-rotationsprocessen fungerer efter hensigten. Her er et eksempel på, hvordan du tester denne funktionalitet:
describe('Token Rotation Tests', () => { test('skal rotere og validere tokens', async () => { // Test grundlæggende rotation const initialToken = await generateRefreshToken(); const rotatedToken = await rotateToken(initialToken); expect(rotatedToken).not.toEqual(initialToken); expect(await validateToken(rotatedToken)).toBeTruthy(); // Test fuld godkendelsesflow const authResponse = await authenticate(credentials); await simulateTokenExpiry(authResponse.accessToken); const newTokens = await performTokenRotation(authResponse.refreshToken); await verifyTokenLineage(authResponse.refreshToken, newTokens.refreshToken); }); }); Når du har bekræftet, at token-rotation fungerer som forventet, skal du holde øje med systemets ydeevne for at identificere og løse problemer tidligt.
Systemovervågning
Spor ydeevnen af token-rotation ved hjælp af nøglemetrics for at bevare pålideligheden:
| Metrisk | Beskrivelse | Advarselstærskel |
|---|---|---|
| Rotationsforsinkelse | Tid til at fuldføre rotationen | > 500 ms |
| Succesrate | Vellykkede rotationer | < 99,9% |
| Token kædelængde | Rotationer i rækkefølge | > 50 omdrejninger |
| Fejlfrekvens | Mislykkede forsøg i timen | > 10 fejl |
Log desuden alle tokens livscyklushændelser for bedre sporbarhed:
const rotationLogger = { async logRotationEvent(event) { await logger.info('token_rotation', { timestamp: new Date().toISOString(), tokenId: event.tokenId, rotationDuration: event.duration, status: event.status, errorCode: event.error || null }); } }; Bemærk: Denne kode er i hovedtræk "RotationEvent" som den første, der bruger EventLogger, errorCode: event.error || null. Bemærk: } }; ... }; Bemærk: } } }; Bemærk: } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } Fejlhåndtering
Selv med grundig test og overvågning kan der stadig opstå fejl. Brug dedikerede gendannelsesmekanismer til at håndtere dem effektivt:
const errorHandler = { async handleRotationError(fejl, kontekst) { // Primær fejlhåndtering med integreret afbryder 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(kontekst); break; default: await this.notifyAdministrator(fejl); } await metrics.recordError(fejl); }, async retryWithBackoff(kontekst, forsøg = 0) { if (forsøg > 3) return; await new Promise(resolve => setTimeout(resolve, Math.pow(2, forsøg) * 1000)); return this.handleRotationError(kontekst, forsøg + 1); } }; ... Denne tilgang sikrer, at fejl håndteres effektivt, hvilket minimerer forstyrrelser i systemet.
Konklusion
Nøgle takeaways
Refresh token rotation sikrer en balance mellem sikkerhed, præstation, og brugeroplevelse. Her er de grundlæggende praksisser, du skal huske på:
- Optimer systemets ydeevne gennem løbende overvågning.
- Implementer modstandsdygtig fejlhåndtering for at muliggøre problemfri genopretning fra problemer.
- Udfør strenge tests at validere og finjustere rotationsmekanismen.
Trin-for-trin guide til implementering
Hvis du er klar til at implementere token-rotation, er her en oversigt over processen:
- Indledende opsætning
Start med at bygge sikker token-lagring ved hjælp af industristandardkrypteringsmetoder. Inkorporer hastighedsbegrænsning og sørg for, at din godkendelsesserver kan skaleres for at imødekomme efterspørgslen. - Sikkerhedskonfiguration
Definer kritiske parametre som tokens levetid, rotationsvinduer og grænser. For eksempel, her er en simpel konfiguration:const securityConfig = { tokenLifetime: 3600, // Tokens gyldige i 1 times rotationVindue: 86400, // Opdater tokens gyldige i 24 timer maxRotations: 30, // Maksimalt antal tokenrotationer jwtAlgorithm: 'RS256', // Asymmetrisk krypteringsalgoritme tokenLength: 256 // Tokenstørrelse i bits }; - Opsætning af overvågning
Etabler tærskler for systemets ydeevne og opsæt advarsler for uregelmæssigheder. Vær forberedt på at skalere din infrastruktur, når målinger viser øget efterspørgsel. - Produktionsimplementering
Rul systemet gradvist ud, og hold øje med kritiske målinger. Vedligehold detaljerede logfiler over rotationshændelser til revision og fejlfinding. For en skalerbar og pålidelig infrastruktur bør du overveje hostingløsninger som f.eks Serverion (https://serverion.com), som understøtter højtydende miljøer.
