NTP — wat is het, tijdsprotocol en synchronisatie in applicaties
NTP (Network Time Protocol) — een netwerkprotocol voor kloksynchronisatie dat tijdsnauwkeurigheid tot milliseconden in lokale netwerken en tot tientallen milliseconden in het wereldwijde netwerk garandeert. Het protocol, ontwikkeld door David Mills in 1985, wordt gebruikt in alle moderne besturingssystemen, mobiele apparaten en netwerkapparatuur om interne klokken af te stemmen op de referentietijd UTC. Volgens NTP Pool Project (2026) voeren meer dan 4 miljard apparaten dagelijks NTP-verzoeken uit voor synchronisatie.
Belangrijkste punten
- NTP — tijdsynchronisatieprotocol via netwerk, nauwkeurigheid van 1 ms (LAN) tot 50 ms (WAN)
- Stratumhiërarchie — systeem van niveaus (stratum 0–16), waarbij stratum 0 de referentie-atoomklokken zijn
- Driftcorrectie — NTP stelt niet alleen de tijd in, maar past de klokfrequentie aan voor constante nauwkeurigheid
- SNTP — vereenvoudigde versie van NTP voor apparaten met beperkte middelen, gebruikt in IoT en Android
- Beveiliging — NTPv4 ondersteunt authenticatie via symmetrische sleutels en NTS (Network Time Security)
Wat is NTP?
NTP (Network Time Protocol) — is een netwerkprotocol ontworpen voor nauwkeurige synchronisatie van de interne klok van een computer met een referentietijdbron via een pakketgeschakeld netwerk. Het protocol, beschreven in RFC 5905 (NTPv4), gebruikt een hiërarchisch systeem van servers, waarbij elk niveau een stratum wordt genoemd. De NTP-client stuurt verzoeken naar de server, meet de round-trip tijd (RTT) van het pakket en berekent de offset van de eigen klok ten opzichte van de referentietijd. Het correctie-algoritme houdt niet alleen rekening met eenmalige offset, maar ook met drift van de klokgenerator, waardoor de nauwkeurigheid gedurende lange tijd zonder herhaalde verzoeken behouden blijft.
Geschiedenis van NTP-ontwikkeling
Het protocol is ontwikkeld door David Mills in 1985 voor het ARPANET-netwerk. De eerste specificatie (RFC 958) beschreef een eenvoudig synchronisatie-algoritme met een nauwkeurigheid tot 100 ms. NTPv3 (RFC 1305, 1992) voegde een filteralgoritme en verbeterde verwerking van vertragingen toe. NTPv4 (RFC 5905, 2010) — de huidige versie — omvat ondersteuning voor IPv6, automatische configuratie van servers en bescherming tegen aanvallen via Network Time Security (NTS). In 40 jaar is het protocol van een wetenschappelijk project uitgegroeid tot een infrastructuurstandaard, zonder welke financiële transacties, telecommunicatie en mobiele netwerken niet mogelijk zijn.
Hoe NTP werkt
Het werkingsprincipe van NTP is gebaseerd op het meten van de reistijd van een pakket in het netwerk. De client stuurt een verzoek met tijdstempel T1 (lokale verzendtijd). De server ontvangt het verzoek op tijdstip T2 (servertijd), maakt een antwoord met tijdstempel T3 en stuurt het terug. De client ontvangt het antwoord op tijdstip T4. Met alle vier de tijdstempels berekent de client de offset = ((T2 - T1) + (T3 - T4)) / 2 en de vertraging delay = (T4 - T1) - (T3 - T2). Als de vertraging groter is dan 1 seconde, wordt het resultaat als onbetrouwbaar beschouwd — dit is bescherming tegen overbelaste of instabiele kanalen.
Correctie van klokdrift
Het simpelweg instellen van de juiste tijd is niet voldoende — de kristaloscillator op het apparaat driftt constant (loopt vooruit of achteruit) door temperatuur, veroudering en spanning. NTP lost dit probleem op met het PLL (Phase-Locked Loop)-algoritme: het stelt de tijd niet geforceerd in, maar past de snelheid van de klok aan. Als het apparaat 0,1 seconde per uur voorloopt, vertraagt NTP de systeemklok totdat de drift is gecompenseerd. Deze aanpak maakt synchronisatie eens per paar uur in stabiele netwerken mogelijk, in plaats van elke 30 seconden.
cpp
// Vereenvoudigd schema van NTP-algoritme
struct NTPPacket {
uint8_t flags; // LI, VN, Modus
uint8_t stratum; // server stratumniveau
uint32_t refTimestamp; // referentie tijdstempel
uint32_t originTimestamp; // T1
uint32_t recvTimestamp; // T2
uint32_t xmitTimestamp; // T3
};
// Bereken offset en vertraging
double offset = ((t2 - t1) + (t3 - t4)) / 2.0;
double delay = (t4 - t1) - (t3 - t2);Stratum — hiërarchie van NTP
Het hele NTP-systeem is georganiseerd in een hiërarchie, waarbij elk niveau een stratum wordt genoemd. Stratum 0 — referentieklokken: atoomklokken, GPS-ontvangers of WWVB-radiosignalen. Deze apparaten zijn niet rechtstreeks op het netwerk aangesloten. Stratum 1 — servers die rechtstreeks zijn aangesloten op referentieklokken. Stratum 2 ontvangen tijd van stratum 1, stratum 3 van stratum 2, enzovoort tot stratum 15. Hoe hoger het stratumnummer, hoe lager de potentiële nauwkeurigheid — elk niveau voegt een kleine vertraging en fout toe. Stratum 16 betekent dat de tijd niet beschikbaar is (niet gesynchroniseerd).
| Stratum | Beschrijving | Nauwkeurigheid |
|---|---|---|
| Stratum 0 | Atoomklokken, GPS, radiosignalen | Nanoseconden |
| Stratum 1 | Servers aangesloten op referentie | Microseconden |
| Stratum 2 | Openbare NTP-servers | 1–10 ms |
| Stratum 3 | Lokale servers van organisaties | 10–50 ms |
| Stratum 4+ | Clientapparaten | tot 100 ms |
Serverkeuze op basis van stratum
Voor mobiele apparaten zijn stratum 2-servers optimaal — er zijn er voldoende en ze bieden een goede balans tussen nauwkeurigheid en beschikbaarheid. Bijvoorbeeld pool.ntp.org — een pool van duizenden servers wereldwijd die automatisch de belasting verdeelt. Voor Android-applicaties wordt direct gebruik van stratum 1 afgeraden: ten eerste creëert het overmatige belasting op primaire servers, en ten tweede heeft een mobiel apparaat voldoende aan de nauwkeurigheid van 10–50 ms die stratum 2 biedt. In bedrijfsnetwerken wordt een lokale stratum 3-4-server geïnstalleerd die synchroniseert met een externe stratum 2.
SNTP — vereenvoudigde versie van NTP
SNTP (Simple Network Time Protocol, RFC 4330) — een vereenvoudigde implementatie van NTP voor apparaten met beperkte middelen: microcontrollers, IoT-sensoren en mobiele applicaties die geen hoge nauwkeurigheid vereisen. In tegenstelling tot volledige NTP voert SNTP geen filtering van meerdere servers uit, analyseert het geen klokdrift en gebruikt het geen complexe PLL-algoritmen. De SNTP-client stuurt een verzoek, ontvangt een antwoord en stelt eenmalig de tijd in. De nauwkeurigheid van SNTP is 10–100 ms afhankelijk van het netwerk — dit is voldoende voor de overgrote meerderheid van mobiele scenario's, behalve financiële transacties.
Wanneer SNTP gebruiken in plaats van NTP
SNTP is geschikt voor Android-applicaties die eenvoudig de huidige tijd van de server willen krijgen zonder constante synchronisatie te onderhouden. Bijvoorbeeld, de applicatie toont de tijd van de server bij het inloggen of synchroniseert eenmaal per dag. Volledige NTP is nodig voor serversystemen, telecommunicatieapparatuur, financiële platforms en gedistribueerde databases, waar constante nauwkeurigheid en driftmonitoring kritisch zijn. Voor mobiele ontwikkeling is SNTP voldoende — de ingebouwde Android-tijddienst gebruikt het voor periodieke synchronisatie met Google-servers.
Implementatie van NTP in Android
In Android-applicaties is het verkrijgen van de exacte tijd via NTP nodig wanneer de systeemtijd door de gebruiker kan worden gewijzigd of afwijkt van de werkelijke tijd door gebrek aan netwerk. Android heeft geen ingebouwde openbare NTP-client — ontwikkelaars gebruiken de Apache Commons Net SntpClient-bibliotheek of externe oplossingen. In 2022 voegde Google de interne klasse SntpClient toe aan de Android API (via Google Play Services), maar deze vereist configuratie en is niet gedocumenteerd voor algemeen gebruik. Een alternatieve benadering — tijdsverzoek via REST API, die de servertimestamp in de antwoordbody retourneert.
Voorbeeldimplementatie van SNTP-client
De basisimplementatie van SNTP op Android bestaat uit het verzenden van een UDP-pakket naar een NTP-server (bijv. pool.ntp.org), het parsen van het antwoord en het extraheren van de verzendtijd (T3 — Transmit Timestamp). Code moet netwerk-timeouts en parseerfouten afhandelen — in een echte applicatie wordt deze bewerking op de achtergrond uitgevoerd en wordt het resultaat in de cache opgeslagen tot de volgende synchronisatie. De Apache Commons Net-bibliotheek biedt de kant-en-klasse klasse NTPUDPClient, die met minimale aanpassingen in Android kan worden gebruikt door een afhankelijkheid aan build.gradle toe te voegen.
kotlin
// NTP-tijd ophalen via Apache Commons Net
fun getNtpTime(server: String = "pool.ntp.org"): Date? {
return try {
val client = NTPUDPClient()
client.setDefaultTimeout(5000)
val info = client.getTime(InetAddress.getByName(server))
client.close()
Date(info.getMessage().getTransmitTimeStamp().getTime())
} catch (e: Exception) {
null
}
}Nauwkeurigheid van NTP en beïnvloedende factoren
De nauwkeurigheid van NTP hangt af van verschillende factoren: netwerkvertraging (RTT), kanaalstabiliteit, serverbelasting en kwaliteit van de lokale klokgenerator. In een lokaal netwerk met een vertraging van minder dan 1 ms bereikt NTP een nauwkeurigheid van 0.1–1 ms. Via internet bij een vertraging van 10–50 ms daalt de nauwkeurigheid naar 10–50 ms. Belangrijker dan eenmalige nauwkeurigheid is stabiliteit: als de vertraging varieert (jitter), heeft NTP meer tijd nodig om een betrouwbare offset te berekenen. Voor mobiele apparaten is de belangrijkste instabiliteitsfactor het schakelen tussen Wi-Fi en mobiel netwerk, waarbij de vertraging met een orde van grootte kan veranderen.
Aanbevelingen voor mobiele ontwikkeling
Voor Android-applicaties die gevoelig zijn voor nauwkeurige tijd wordt aanbevolen: gebruik meerdere NTP-servers en kies de minimale vertraging; synchroniseer niet op momenten van netwerkschakeling; cache de laatst ontvangen tijd en corrigeer deze via System.currentTimeMillis. Voor games en real-time applicaties (NTP is niet geschikt vanwege netwerkvertraging) — gebruik de servertijd die in elk verzoek wordt meegegeven. Controleer in applicaties voor financiële transacties altijd de afwijking met de server — als het verschil groter is dan 5 seconden, blokkeer de operatie als potentieel onveilig.
Veelgestelde vragen
Wat is NTP en waarvoor dient het?
NTP (Network Time Protocol) — een kloksynchronisatieprotocol via internet. Het is nodig om de tijd op apparaten af te stemmen op referentie-UTC. Zonder NTP lopen computerklokken seconden per dag af door drift van de kristaloscillator, wat kritisch is voor financiële transacties, logging en beveiliging.
Hoe is de NTP-hiërarchie georganiseerd?
Het NTP-systeem gebruikt niveaus — strata: stratum 0 (atoomklokken en GPS), stratum 1 (servers aangesloten op referentie), stratum 2 (openbare NTP-servers), stratum 3–4 (lokale servers), stratum 5–15 (cliënten). Hoe hoger het stratum, hoe groter de potentiële fout. Stratum 16 betekent dat de tijd niet is gesynchroniseerd.
Wat is het verschil tussen NTP en SNTP?
SNTP — vereenvoudigde versie van NTP voor apparaten met beperkte middelen. Het filtert geen servers, analyseert geen klokdrift en gebruikt geen PLL. SNTP is geschikt voor mobiele applicaties waar een nauwkeurigheid van 10–100 ms voldoende is. Volledige NTP is nodig voor servers, telecommunicatieapparatuur en fintech-systemen.
Hoe krijg ik de juiste tijd via NTP in Android?
Gebruik de bibliotheek Apache Commons Net met de klasse NTPUDPClient. Stuur een verzoek naar pool.ntp.org, ontvang het antwoord en extraheer de Transmit Timestamp. Gebruik anders de REST API van uw server, die de servertijd retourneert in de Date-header of in de antwoordbody in Unix Timestamp-formaat.
Waarom is tijdsynchronisatie op mobiele apparaten belangrijk?
Zonder NTP-synchronisatie kan de systeemtijd op het apparaat minuten en uren afwijken. Dit verstoort pushmeldingen, SSL-certificaten (validiteitscontrole), logs, taakplanners en cryptografische protocollen. In applicaties met financiële transacties wordt desynchronisatie van meer dan 5 seconden als een beveiligingsrisico beschouwd.
Samenvatting
- NTP — netwerkprotocol voor tijdsynchronisatie met een nauwkeurigheid van 1 ms (LAN) tot 50 ms (WAN) via de stratumhiërarchie stratum 0–16
- Driftcorrectie — NTP stelt niet alleen de tijd in, maar past de klokfrequentie aan via PLL, waardoor nauwkeurigheid urenlang tussen synchronisaties behouden blijft
- Stratumhiërarchie — elk niveau (stratum) voegt potentiële fout toe; voor mobiele apparaten zijn stratum 2-servers zoals pool.ntp.org optimaal
- SNTP — vereenvoudigde versie van NTP voor IoT en Android, zonder filtering en PLL; nauwkeurigheid van 10–100 ms is voldoende voor de meeste scenario's
- Implementatie in Android — via Apache Commons Net (NTPUDPClient) of REST API met servertimestamp; het platform heeft geen ingebouwde openbare NTP-client
- Beveiliging — NTPv4 ondersteunt Network Time Security (NTS) voor bescherming tegen antwoordvervalsing; cruciaal voor financiële en bedrijfstoepassingen
- Nauwkeurigheidsfactoren — RTT, jitter, netwerkschakeling; mobiele applicaties hebben een nauwkeurigheid van 10–50 ms nodig, maar kritische operaties vereisen controle van de afwijking met de server
We ontwikkelen een mobiele applicatie turnkey
IT Sectr creëert sinds 2017 iOS- en Android-applicaties voor startups en bedrijven. We adviseren u en stellen de beste oplossing voor.
Lees ook