Finestra TOTP: secondi rimanenti e indice
All’istante Unix 1700000000 con un periodo di 30 secondi si trova nella finestra 56666666 e mancano 10 secondi prima che il contatore avanzi. Inserisca periodo e timestamp per analizzare codici che sembrano scadere prima, senza alcun segreto. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Periodo
- 30
- Ora attuale
- 1.700.000.000
- Secondi rimanenti
- 10
- Indice della finestra
- 56.666.666
Questo calcolatore di finestre temporali TOTP trasforma la durata di un periodo e un timestamp Unix in due valori pratici: l’indice della finestra attiva e il numero di secondi interi che mancano all’inizio della successiva. È utile per sviluppare, collaudare o diagnosticare sistemi di password monouso basate sul tempo, soprattutto quando un codice sembra scadere prima del previsto. Il calcolo è deterministico, non usa chiavi segrete, non genera password e non legge mai l’orologio del dispositivo; pertanto, lo stesso input produce sempre lo stesso risultato.
Comprenda che cosa rappresenta una finestra temporale TOTP
Un sistema TOTP divide il tempo Unix in finestre consecutive di uguale durata. Trenta secondi è un periodo comune, ma il calcolo funziona con qualsiasi numero intero positivo di secondi. L’indice della finestra si ottiene dividendo il timestamp Unix per il periodo e arrotondando per difetto.
Tutti i timestamp che producono lo stesso quoziente appartengono alla stessa finestra; in questo modo, un autenticatore e un server possono selezionare autonomamente il medesimo contatore mobile. Il calcolatore mostra direttamente tale contatore senza richiedere un segreto condiviso né generare un codice di autenticazione. Indica inoltre quanti secondi interi restano prima dell’avanzamento del contatore.
Nel primo secondo esatto di una finestra rimane l’intero periodo, mentre nell’ultimo rimane un secondo. Questa convenzione sui limiti rende utili i conti alla rovescia ed evita di mostrare zero quando la finestra corrente è ancora attiva.
Scelga gli input e interpreti il risultato
Imposti period sulla durata configurata di un passo TOTP, espressa come numero intero positivo di secondi. L’indice parte da zero all’epoca Unix e, per i timestamp odierni, è normalmente un intero elevato. Non è un codice e non deve essere confrontato con le cifre mostrate da un autenticatore.
Confronti invece gli indici delle finestre per verificare se due componenti concordano sull’orario, oppure usi il valore restante per decidere quando un test deve attendere il limite successivo. La funzione non applica tolleranza allo scarto dell’orologio, accettazione delle finestre adiacenti, correzioni dei secondi intercalari o ritardi di rete. Queste sono scelte proprie dei criteri del verificatore.
Il risultato descrive soltanto la finestra matematicamente attiva per il timestamp e il periodo forniti, mantenendo prevedibili i test automatici e rendendo più semplice isolare le divergenze.
Usi il calcolatore in sicurezza nei test e nelle operazioni
Usi questa capacità quando Le servono informazioni temporali senza esporre un seed TOTP. Nei test di integrazione, timestamp fissi consentono di verificare il comportamento subito prima, in corrispondenza e dopo un limite senza simulare un orologio nascosto nel calcolatore. Ricordi che una finestra coincidente non dimostra la validità di una password monouso inviata.
La verifica richiede ancora il segreto condiviso, le impostazioni concordate di hash e numero di cifre, la protezione contro la ripetizione e criteri di tolleranza espliciti. Eviti di registrare segreti insieme a questi dati diagnostici temporali; periodo, timestamp, indice e conto alla rovescia sono sufficienti per analizzare la maggior parte dei problemi di sincronizzazione.
Casi d'uso
Diagnosticare l’allineamento dell’orologio dell’autenticatore
Confronti gli indici calcolati per i timestamp registrati dal client e dal server, così da individuare una differenza di orologio o periodo senza condividere un seed TOTP.
Creare un conto alla rovescia per il cambio
Mostri quanti secondi interi restano prima che il contatore TOTP attivo avanzi e che un codice appena generato appartenga alla finestra successiva.
Verificare i limiti esatti delle finestre
Usi timestamp Unix fissi subito prima e in corrispondenza di un limite per rendere deterministici e ripetibili i test temporali di autenticazione.
Domande frequenti
Quanto costa questa capacità?
La versione per browser può eseguire localmente lo stesso calcolo deterministico.
Genera o verifica un codice TOTP?
No. Calcola esclusivamente metadati temporali e non accetta mai un segreto condiviso né una password monouso.
Perché al limite esatto viene restituito l’intero periodo?
La nuova finestra è appena iniziata, quindi non è trascorso alcun secondo intero e rimane disponibile tutto il periodo.
Devo inserire il tempo in secondi o in millisecondi?
In secondi Unix interi, mai in millisecondi. Un valore in millisecondi indicherebbe una finestra molto lontana nel futuro. Usare un timestamp esplicito le permette anche di ripetere il risultato in test, registri o rapporti sugli incidenti.
Se due sistemi condividono la stessa finestra, il codice è valido?
Non necessariamente. Una finestra uguale mostra solo che le due parti concordano sull’ora. Per convalidare un codice servono anche il segreto condiviso, le impostazioni concordate, la protezione dal riutilizzo e una tolleranza chiara allo scostamento dell’orologio.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo stack
curl -X POST https://api.kit.forhosting.com/security/otp-time-window-calc \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"period":30,"current_time":1700000000}'const res = await fetch("https://api.kit.forhosting.com/security/otp-time-window-calc", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"period": 30,
"current_time": 1700000000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/security/otp-time-window-calc",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"period": 30,
"current_time": 1700000000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/security/otp-time-window-calc", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"period":30,"current_time":1700000000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"period":30,"current_time":1700000000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/security/otp-time-window-calc", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Esempio di richiesta
{
"period": 30,
"current_time": 1700000000
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "security.otp_time_window_calc",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Comprenda che cosa rappresenta una finestra temporale TOTP
Inserisca esplicitamente il timestamp in secondi Unix, non in millisecondi, così da poter riprodurre il risultato nei log, nei test e nelle note sugli incidenti senza dipendere dall’orologio del browser o del processo API.
Scelga gli input e interpreti il risultato
Fornisca poi current_time come timestamp Unix non negativo in secondi interi. La risposta contiene seconds_remaining e window_index. Per esempio, se sono trascorsi dieci secondi nella finestra corrente di un periodo di trenta secondi, seconds_remaining è pari a venti.
Usi il calcolatore in sicurezza nei test e nelle operazioni
Un processo di monitoraggio può calcolare l’indice corrente da un timestamp registrato, mentre un’interfaccia può usare seconds_remaining per segnalare che un codice sta per cambiare. Ogni chiamata API costa $0.002, mentre la versione per browser può essere eseguita localmente. Poiché l’algoritmo effettua operazioni aritmetiche in tempo costante e non accede alla rete, a fonti casuali o all’orologio, chiamate ripetute con input identici restituiscono lo stesso JSON e sono adatte ai test di riferimento e ai registri di audit.
Domande tecniche
current_time deve essere espresso in secondi o millisecondi?
Usi secondi Unix interi. Converta in secondi un timestamp in millisecondi prima di inviarlo.
Che cosa accade se il periodo è zero o negativo?
La richiesta non riesce e restituisce un errore invalid_input, perché una finestra temporale TOTP deve avere durata positiva.