Klocksynkronisering i applikationer — essens, protokoll och implementering

Vad är klocksynkronisering?

Klocksynkronisering (Clock Sync) — är mekanismen för att justera enhetens interna klocka till referenstiden UTC (Universal Coordinated Time). Utan synkronisering driver kvartsoscillatorn i en mobil enhet gradvis — driften är 1–10 sekunder per dag beroende på temperatur och komponentkvalitet. Synkronisering kompenserar denna drift genom att få exakt tid från externa källor: NTP-servrar på internet, GPS-satelliter eller mobila basstationer. Idealisk bör enheten synkroniseras var 4–6:e timme för att bibehålla noggrannhet inom 1 sekund.

Hårdvaru- och mjukvaruklocka

I en mobil enhet finns två typer av klockor: hårdvaruklocka (RTC, Real-Time Clock) med separat batterimatning — fungerar även när enheten är avstängd, och mjukvaruklocka (systemtid) som hanteras av operativsystemet. Vid start av enheten initieras systemtiden från RTC och upprätthålls sedan via avbrott från klocksignalgeneratorn. NTP-synkronisering korrigerar systemtiden och i vissa fall skrivs korrigeringen även till RTC. I Android är åtkomst till hårdvaru-RTC begränsad — applikationer kan inte ändra den utan root-rättigheter.

Varför behövs tidssynkronisering i mobila applikationer

Många aspekter av en mobil applikations funktion är kritiskt beroende av exakt systemtid. SSL-certifikat har en giltighetstid: om tiden på enheten är inställd före certifikatets utfärdandedatum eller efter dess utgångsdatum blockeras HTTPS-anslutningen. OAuth-tokens och JWT-autentisering använder tidsstämplar för att kontrollera giltighet — desynkronisering leder till falska avslagsbeslut. Push-notiser schemaläggs baserat på tid, och om klockan driver får användaren notiser vid fel tidpunkt eller inte alls.

Konsekvenser av desynkronisering

Säkerheten för applikationer lider också av felaktig tid: tidsbaserad kryptering (time-based OTP), händelseloggar med felaktiga tidsstämplar, felaktig funktion av rate-limiting på serversidan (servern blockerar ”framtida” förfrågningar). Enligt OWASP Mobile Top 10 (2024) faller misstro mot systemtiden under kategorin otillräcklig plattformssäkerhet. Utvecklare rekommenderas att alltid kontrollera tiden på servern, inte enbart lita på klientklockan. Om skillnaden överstiger tröskeln (rekommenderat 5 sekunder) bör applikationen blockera kritiska operationer tills synkronisering.

Synkroniseringsprotokoll: NTP och SNTP

Huvudprotokollen för klocksynkronisering — NTP och dess förenklade version SNTP. NTP (RFC 5905) — fullt protokoll med serverfiltrering, driftanalys och PLL-korrigering. Används på servrar och nätverksutrustning. SNTP (RFC 4330) — lättviktsversion för klientenheter som inte kräver kontinuerlig synkronisering. SNTP-klienten skickar en förfrågan, får ett svar och ställer in tiden utan historikanalys. På mobila enheter används just SNTP — den inbyggda Android Google Time Service (GTS) synkroniseras via SNTP med servrarna time.google.com.

Ytterligare synkroniseringsmetoder

Förutom NTP/SNTP är tidssynkronisering på mobila enheter möjlig via GPS-mottagare (noggrannhet upp till 10 ns under idealiska förhållanden) och mobilt nätverk (via NITZ — Network Identity and Time Zone). GPS ger maximal noggrannhet men fungerar bara utomhus och förbrukar mycket energi. NITZ tillhandahålls automatiskt av mobiloperatören vid registrering i nätverket, men inte alla operatörer stöder det. Android använder en kombination av alla metoder: GTS (SNTP) som prioritet, NITZ som reserv och GPS för applikationer som kräver hög noggrannhet.

Synkroniseringsproblem i distribuerade system

I distribuerade system — när server och klient finns på olika enheter — stöter klocksynkronisering på grundläggande begränsningar. Nätverksfördröjning (latens) gör det omöjligt att entydigt bestämma exakt tid på klienten: om ett paket tog 200 ms är tiden på servern vid sändning av förfrågan och mottagning av svar redan annorlunda. NTP löser detta problem genom RTT-mätning och statistisk bearbetning, men för distribuerade transaktioner (t.ex. banköverföringar) är detta inte tillräckligt — logiska klockor (Lamport-tidsstämplar) eller vektorklockor används.

Fysiska vs. logiska klockor

Fysiska klockor (väggklocka) — verklig UTC-tid, synkroniserad via NTP. Logiska klockor — ordningsnummer för händelser i systemet, inte kopplade till fysisk tid. I distribuerade system används ofta vektorklockor för att ordna händelser: varje nod lagrar en vektor av räknare för alla noder i klustret. För mobila applikationer räcker fysisk synkronisering med noggrannhet på 1–5 sekunder — det säkerställer korrekt funktion av OAuth, SSL och push-notiser. Om strikt ordning av händelser krävs (t.ex. i realtidschattar) läggs logisk synkronisering till på servernivå.

Implementering av klocksynkronisering i Android

Att implementera klocksynkronisering i en Android-applikation kan göras på flera sätt. Det enklaste — få servertid via REST API: servern returnerar Unix-tidsstämpel i svarstexten eller i HTTP-huvudet Date. Denna metod kräver inga extra bibliotek och garanterar att tiden överensstämmer med servern. Det andra sättet — använda en SNTP-klient för direkt fråga till en NTP-server. Det tredje — lita på Android Google Time Service, som automatiskt synkroniserar systemtiden om enheten är ansluten till internet.

Jämförelse av metoder för Android

I Android-applikationer med autentisering och finansiella transaktioner rekommenderas en kombinerad metod: vid varje API-förfrågan sparas skillnaden mellan servertid och System.currentTimeMillis(). Denna skillnad tillämpas på alla tidsberäkningar på klienten, oavsett om systemklockan är synkroniserad eller inte. Denna metod kallas clock skew correction och implementeras via en klass som lagrar den senast kända skillnaden med servern. Dessutom kan bakgrunds-NTP-synkronisering köras var 4–6:e timme via WorkManager.

// Korrigering av klockdrift
class ClockSyncManager {
    private var serverTimeDiff: Long = 0 // serverTime - deviceTime (ms)

    fun updateServerTime(serverTimestampMs: Long) {
        serverTimeDiff = serverTimestampMs - System.currentTimeMillis()
    }

    fun getCorrectedTime(): Long {
        return System.currentTimeMillis() + serverTimeDiff
    }

    fun isSyncValid(maxDiffMs: Long = 5000): Boolean {
        return Math.abs(serverTimeDiff) < maxDiffMs
    }
}

Bakgrundssynkronisering via WorkManager

För periodisk bakgrundssynkronisering av tid på Android, använd WorkManager med PeriodicWorkRequest. Synkroniseringsuppgiften utför en SNTP-fråga eller ett REST API-anrop, får servertiden och uppdaterar ClockSyncManager. Minimintervall för PeriodicWorkRequest är 15 minuter, men för tidssynkronisering räcker 4–6 timmar. Vid synkronisering, beakta nätverksstatus — använd NetworkType.CONNECTED för att förhindra onödiga förfrågningar vid roaming. Om synkronisering misslyckas, behåll föregående korrigering — den förblir giltig med gradvis minskande noggrannhet.

Automatisk tidssynkronisering på enheter

Moderna mobila enheter synkroniserar tid automatiskt via inbyggda tjänster. På Android — Google Time Service (GTS), en del av Google Play Services. På iOS — NTP-klient inbyggd i operativsystemet. Dessa tjänster fungerar oberoende av applikationer och kräver ingen extra konfiguration. Användaren kan stänga av automatisk synkronisering i inställningarna, vilket skapar en risk för applikationer — i detta fall måste utvecklaren implementera egen synkronisering. Det rekommenderas att kontrollera status för autosynkronisering via Settings.Global.getInt(AUTO_TIME) och varna användaren när den är avstängd.

Rekommendationer för utvecklare

Att enbart lita på automatisk synkronisering är riskabelt — användaren kan stänga av den eller befinna sig i en zon utan internet. Bästa praxis — hämta tid från servern vid varje API-förfrågan och lagra desynkroniseringen i SharedPreferences eller DataStore. För kritiska operationer (betalningar, autentisering, dokumentsignering) kontrollera alltid isSyncValid() före utförande. Om desynkroniseringen överstiger tröskeln — visa användaren en skärm med förslag att aktivera autosynkronisering eller vänta på synkronisering. För spel och underhållningsapplikationer räcker det att hämta tid från servern vid start och uppdatera varje timme.