Bits de hash para resistência a colisões
Guardar 1.000.000 de itens com no máximo uma chance em um milhão de colisão exige 59 bits de hash, a menor largura que atende ao limite do aniversário. Você também vê o espaço de hash e o risco estimado nessa largura. 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
- Itens
- 1.000.000
- Probabilidade máxima
- 0,000001
- Bits necessários
- 59
- Probabilidade de colisão aproximada
- 0,0000008674
- Espaço de hash
- 2^59
Ao escolher o comprimento de um hash para identificadores, chaves de cache, digests de conteúdo ou códigos curtos, a pergunta difícil não é só se o digest basta para segurança de pré-imagem, mas quantos itens você pode armazenar antes que dois hashes colidam por acaso. Esta calculadora resolve esse dimensionamento com a cota clássica do aniversário. Você informa o número esperado de itens e a probabilidade máxima de colisão que aceita; recebe a menor largura inteira em bits que mantém o risco aproximado de colisão por pares no ou abaixo desse alvo, mais o tamanho do espaço de hash e a probabilidade aproximada nessa largura.
Cota do aniversário e por que o comprimento do hash cresce com o quadrado do conjunto
Um hash aleatório uniforme de b bits mapeia cada item em um espaço de tamanho dois elevado a b. Com um único item não há com o que colidir, mas ao inserir muitos valores o número de pares não ordenados cresce como n escolhe dois. Cada par colide com probabilidade de cerca de um sobre o tamanho do espaço, de modo que o número esperado de pares em colisão é aproximadamente n vezes n menos um sobre dois vezes dois elevado a b.
Quando essa expectativa é pequena, também é uma boa aproximação da probabilidade de pelo menos uma colisão. Isolando para uma probabilidade-alvo p obtém-se a regra de dimensionamento: bits igual ao teto do logaritmo na base dois de n vezes n menos um sobre dois p. De forma equivalente, bits é cerca de duas vezes o log de n menos o log de p, menos um.
Essa estrutura de raiz quadrada é o famoso paradoxo do aniversário em roupa de engenharia: para manter colisões raras com um bilhão de itens você precisa de bem mais que trinta bits de hash, e a resistência criptográfica a colisões contra um adversário que pode tentar dois elevado a sessenta e quatro hashes empurra classicamente para digests de cento e vinte e oito bits ou maiores.
Esta ferramenta usa apenas a aproximação da cota do aniversário —não modela hashes não uniformes, construções HMAC truncadas nem ataques de multicolisão além do par básico—, então trate a resposta como limite inferior de planejamento para digests de aparência aleatória e acrescente margem para peculiaridades de implementação e modelos de ameaça além de colisões por acaso.
Casos de uso
Planejamento de comprimento de identificadores e códigos curtos
Engenheiros de produto dimensionam a largura em bits de hashes truncados ou IDs aleatórios para que colisões esperadas entre contagens projetadas de usuários ou objetos fiquem sob um orçamento de risco escrito.
Chaves de cache e digests de conteúdo
Equipes de plataforma escolhem comprimentos de digest para caches e índices de deduplicação varrendo contagens de itens e probabilidades-alvo em vez de chutar números redondos.
Ensinar a cota do aniversário
Instrutores e ferramentas de preparação para entrevistas demonstram por que o risco de colisão escala com n ao quadrado e recuperam de forma determinística os limiares clássicos de sala de sessenta e quatro bits.
Perguntas frequentes
Qual fórmula a cota do aniversário usa?
A probabilidade de colisão é aproximada como n(n-1)/(2·2^b).
A calculadora de bits de hash é grátis?
A ferramenta do navegador roda grátis no seu dispositivo.
Isso substitui uma revisão de segurança criptográfica?
Não. Dimensiona apenas colisões por acaso entre pares para hashes uniformes. Escolha de algoritmo, truncamento, busca adversária de colisões e força de pré-imagem ainda exigem análise de segurança separada.
Por que as colisões de hash aparecem antes do esperado?
Porque o que conta são os pares, não os itens. O número de pares cresce mais ou menos com o quadrado da quantidade de itens e cada par pode colidir, então o risco sobe bem mais rápido que a quantidade. É o paradoxo do aniversário.
Quais valores posso informar?
A quantidade de itens vai de 1 até um quatrilhão, e a probabilidade máxima precisa ficar estritamente entre zero e um. Valores fora dessas faixas, assim como zero ou um exatos, são recusados.
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/dev/hash-bits-for-collision \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"items":1000000,"max_probability":0.000001}'const res = await fetch("https://api.kit.forhosting.com/dev/hash-bits-for-collision", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"items": 1000000,
"max_probability": 0.000001
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/hash-bits-for-collision",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"items": 1000000,
"max_probability": 0.000001
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/hash-bits-for-collision", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"items":1000000,"max_probability":0.000001}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"items":1000000,"max_probability":0.000001}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/hash-bits-for-collision", 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
{
"items": 1000000,
"max_probability": 0.000001
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.hash_bits_for_collision",
"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
A mesma aritmética pura roda grátis no navegador e como item de API faturável, de modo que demos didáticas, documentos de projeto e scripts de automação compartilham um contrato determinístico sem ruído de amostragem e sem modelo de linguagem.
Contrato de entrada, regras de validação e campos de resposta
Exemplo: um milhão de itens com alvo de um em um milhão rende da ordem de cinquenta e nove bits e um espaço de hash de dois a essa potência. Checagens clássicas de sala como cerca de quatro bilhões de itens com cinquenta por cento de risco recuperam a familiar figura de sessenta e quatro bits. Envie um corpo JSON com dois campos obrigatórios. items é um inteiro positivo de um até um quatrilhão (um vezes dez elevado a quinze) descrevendo quantos valores você espera hashear ou armazenar; os aliases n, count e num_items são aceitos. max_probability é um número finito estritamente entre zero e um com a maior probabilidade de colisão que você tolerará sob a cota; os aliases p, probability, target_probability e max_collision_probability funcionam igual. Campos ausentes, não inteiros em items, probabilidades não finitas, contagens zero ou negativas, probabilidades de zero ou um ou fora da faixa publicada falham com invalid_input e não são faturados. Em sucesso a resposta ecoa items e max_probability, devolve bits_needed como a menor largura inteira não negativa em bits, approximate_collision_probability como a estimativa da cota nessa largura (usando um menos exp de menos lambda quando lambda não é minúsculo), hash_space como a string dois circunflexo bits_needed, e uma string curta de fórmula documentando a regra.
Quando usar a calculadora, preços e limites honestos do modelo
Use a ferramenta gratuita do navegador ao rascunhar esquemas de identificadores, escolher comprimentos de hash truncado para URLs ou chaves de banco, ou ensinar por que dobrar o tamanho do conjunto custa cerca de um bit extra e não zero. O modelo assume hashes ideais uniformes e independentes e a aproximação padrão de pares do aniversário; não avisará sobre entradas estruturadas que quebram a uniformidade, sobre segunda pré-imagem ou extensão de comprimento, nem sobre busca adversária de colisões mais barata que força bruta em uma família de hash quebrada. Use a API quando um pipeline de projeto, um auxiliar de questionários de segurança, um planejador de capacidade ou uma plataforma curricular precisar de JSON estável para muitos pares n e p sob um único contrato. Cada requisição bem-sucedida é um item faturável a US$ 0,002; validação falha não consome saldo. Interprete sempre bits_needed como quão largo deve ser um digest de aparência aleatória para que colisões por acaso entre n itens fiquem abaixo de p, e valide o algoritmo real e a política de truncamento separadamente.
Perguntas técnicas
Como calculo bits de hash para resistência a colisões?
Envie inteiros items (ou n) e um max_probability p estritamente entre 0 e 1. A API devolve bits_needed = ceil(log2(n*(n-1)/(2*p))) sob a cota do aniversário, mais a probabilidade aproximada e hash_space.
E se items for 1?
Com um único item não há par para colidir, então bits_needed é 0 e approximate_collision_probability é 0. Contagens abaixo de 1 são rejeitadas como invalid_input.