Janela TOTP: segundos restantes e índice
No instante Unix 1700000000, com período de 30 segundos, você está na janela 56666666 e faltam 10 segundos para o contador avançar. Informe o período e o carimbo de tempo para investigar códigos que parecem expirar antes, sem usar segredo algum. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Período
- 30
- Hora atual
- 1.700.000.000
- Segundos restantes
- 10
- Índice da janela
- 56.666.666
Esta calculadora de janela de tempo TOTP transforma a duração de um período e um timestamp Unix em dois valores práticos: o índice da janela ativa e a quantidade de segundos inteiros restantes antes do início da próxima. Ela é útil para desenvolver, testar ou diagnosticar sistemas de senha de uso único baseada em tempo, sobretudo quando um código parece expirar antes do esperado. O cálculo é determinístico, não usa chave secreta, não gera senha e nunca consulta o relógio do seu dispositivo; assim, a mesma entrada sempre produz o mesmo resultado.
Entenda o que uma janela de tempo TOTP representa
Um sistema TOTP divide o tempo Unix em janelas consecutivas de mesma duração. Trinta segundos é um período comum, mas o cálculo funciona com qualquer número inteiro positivo de segundos. O índice da janela é o timestamp Unix dividido pelo período e arredondado para baixo.
Todo timestamp que produz o mesmo quociente pertence à mesma janela, permitindo que um autenticador e um servidor selecionem de maneira independente o mesmo contador variável. Esta calculadora apresenta esse contador diretamente, sem solicitar um segredo compartilhado nem gerar um código de autenticação. Ela também informa quantos segundos inteiros restam antes do avanço do contador.
No primeiro segundo exato de uma janela, resta o período completo; no último, resta um segundo. Essa convenção de limite torna as contagens regressivas úteis e evita a exibição de zero enquanto a janela atual ainda está ativa.
Escolha as entradas e interprete o resultado
Defina period como a duração configurada de uma etapa TOTP, expressa como um número inteiro positivo de segundos. O índice começa em zero na época Unix e normalmente é um número inteiro grande para timestamps atuais. Ele não é um código e não deve ser comparado aos dígitos exibidos por um autenticador.
Em vez disso, compare os índices das janelas ao verificar se dois componentes concordam sobre o horário, ou use o valor restante para decidir quando um teste deve aguardar o próximo limite. A função não aplica tolerância ao desvio de relógio, aceitação de janelas adjacentes, correções de segundos intercalares nem atraso de rede. Essas são decisões de política do verificador.
O resultado descreve apenas a janela matematicamente ativa para o timestamp e o período fornecidos, mantendo os testes automatizados previsíveis e facilitando o isolamento de divergências.
Use a calculadora com segurança em testes e operações
Use esta capacidade quando precisar de informações de tempo sem expor uma semente TOTP. Em testes de integração, timestamps fixos permitem verificar o comportamento imediatamente antes, no momento e depois de um limite sem simular um relógio oculto dentro desta calculadora. Lembre-se de que uma janela correspondente não prova que uma senha de uso único enviada seja válida.
A verificação ainda exige o segredo compartilhado, as configurações acordadas de hash e quantidade de dígitos, proteção contra repetição e uma política explícita de tolerância. Evite registrar segredos junto com esses diagnósticos de tempo; o período, o timestamp, o índice e a contagem regressiva bastam para investigar a maioria dos problemas de sincronização.
Casos de uso
Diagnosticar o alinhamento do relógio do autenticador
Compare os índices calculados para timestamps registrados no cliente e no servidor para identificar divergências de relógio ou período sem compartilhar uma semente TOTP.
Criar uma contagem regressiva de troca
Mostre quantos segundos inteiros restam antes que o contador TOTP ativo avance e um código recém-gerado passe a pertencer à próxima janela.
Testar limites exatos das janelas
Use timestamps Unix fixos imediatamente antes e no momento de um limite para tornar os testes de autenticação determinísticos e repetíveis.
Perguntas frequentes
Quanto custa esta capacidade?
A versão do navegador pode executar localmente o mesmo cálculo determinístico.
Ela gera ou verifica um código TOTP?
Não. Ela calcula apenas metadados de tempo e nunca aceita um segredo compartilhado nem uma senha de uso único.
Por que o período completo é retornado em um limite exato?
A nova janela acabou de começar; portanto, nenhum de seus segundos inteiros transcorreu e o período completo permanece.
Devo informar o tempo em segundos ou em milissegundos?
Em segundos Unix inteiros, nunca em milissegundos. Um valor em milissegundos apontaria para uma janela muito distante no futuro. Usar um carimbo de tempo explícito também permite repetir o resultado em testes, registros ou relatórios de incidentes.
Se dois sistemas estão na mesma janela, o código é válido?
Não necessariamente. Coincidir a janela só mostra que os dois lados concordam sobre o horário. Para validar um código ainda são necessários o segredo compartilhado, as configurações combinadas, proteção contra reutilização e uma tolerância clara ao desvio do relógio.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
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)Exemplo de requisição
{
"period": 30,
"current_time": 1700000000
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "security.otp_time_window_calc",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Entenda o que uma janela de tempo TOTP representa
Informe explicitamente o timestamp em segundos Unix, e não em milissegundos, para que o resultado possa ser reproduzido em logs, testes e registros de incidentes sem depender do relógio do navegador ou do executor da API.
Escolha as entradas e interprete o resultado
Em seguida, forneça current_time como um timestamp Unix não negativo em segundos inteiros. A resposta contém seconds_remaining e window_index. Por exemplo, se dez segundos tiverem transcorrido dentro da janela atual de um período de trinta segundos, seconds_remaining será vinte.
Use a calculadora com segurança em testes e operações
Uma rotina de monitoramento pode calcular o índice atual a partir de um timestamp registrado, enquanto uma interface pode usar seconds_remaining para avisar que um código está próximo da troca. Cada chamada à API custa US$ 0,002, enquanto a versão do navegador pode ser executada localmente. Como o algoritmo realiza aritmética em tempo constante e não acessa rede, fonte aleatória nem relógio, chamadas repetidas com entradas idênticas retornam o mesmo JSON e são adequadas para testes de referência e registros de auditoria.
Perguntas técnicas
current_time deve estar em segundos ou milissegundos?
Use segundos Unix inteiros. Converta um timestamp em milissegundos para segundos antes de enviá-lo.
O que acontece se o período for zero ou negativo?
A solicitação falha com um erro invalid_input porque uma janela de tempo TOTP deve ter duração positiva.