Checksum System V
A palavra hello dá checksum 532 e 1 bloco, exatamente o que o sum -s mostra no Unix. Cole um texto para reproduzir o número clássico do System V, e não a variante BSD, em scripts legados, documentação e aulas. 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
- Texto
- hello
- Soma de verificação
- 532
- Blocos
- 1
- Contagem de bytes
- 5
- Algoritmo
- System V sum (sum -s)
System V sum é o algoritmo alternativo de checksum de arquivos impresso pelo utilitário clássico sum do Unix quando se usa a opção -s, o caminho habitual em sistemas derivados de System V e ainda disponível no GNU coreutils. Ao contrário de hashes criptográficos, produz um residual compacto de dezesseis bits mais uma contagem de blocos de quinhentos e doze bytes, pensado para verificações rápidas de integridade em cargas curtas e scripts legados que ainda analisam a saída de sum. Esta capacidade aceita uma cadeia de texto, codifica-a como UTF-8, executa os mesmos passos de acumulação e dobra que sum -s aplica aos bytes de um arquivo e devolve o checksum junto com a contagem de blocos e o comprimento em bytes. Entrada vazia é aceita de propósito e reportada com clareza: checksum zero, zero blocos e um aviso explícito de vazio para que a automação nunca confunda uma carga em branco com um campo ausente.
O que é System V sum e como difere de BSD sum e de digests modernos
O algoritmo System V acumula cada byte de entrada em um total corrente e depois dobra esse total para dezesseis bits somando a metade alta à metade baixa duas vezes, de forma que o overflow da primeira dobra seja absorvido pela segunda. O resultado é um inteiro não negativo no intervalo de zero a sessenta e cinco mil quinhentos e trinta e cinco, historicamente impresso como checksum decimal ao lado de uma contagem de blocos.
Blocos não são o tamanho lógico de registro de um banco de dados; são unidades de quinhentos e doze bytes arredondadas para cima, de modo que uma cadeia de cinco bytes ainda conta como um bloco e um arquivo vazio conta como zero. Este perfil é exatamente o que o GNU sum implementa com sum -s e o que muitos scripts de shell ainda extraem ao comparar duas cópias de um arquivo pequeno em hosts Unix antigos.
É deliberadamente fraco pelos padrões modernos: colisões são fáceis e não substitui SHA-256, CRC-32 nem autenticação criptográfica de mensagens. Sua função é interoperabilidade com sum -s, com documentação de arquivo que cita checksums System V, e com material didático que contrasta o algoritmo BSD de rotacionar e somar com a soma simples System V.
Quando o checksum System V ainda é útil
Projetos de migração legada recalculam valores sum -s ao mover arquivos de shell e distribuições da era do disquete para armazenamento de objetos, fixando checksums e contagens de blocos dourados em integração contínua para que uma reescrita moderna ainda coincida com o residual histórico. Equipes embarcadas e industriais que herdaram verificações de integridade no estilo System V em notas de protocolo podem verificar cadeias de comando curtas sem instalar coreutils completo em cada imagem de build.
Educadores e sites de documentação que ranqueiam por System V sum ou checksum sum -s ganham uma calculadora ao vivo cujo caminho gratuito do navegador coincide byte a byte com o de automação, incluindo o caso extremo do arquivo vazio que confunde alunos na primeira vez que executam sum -s em /dev/null ou em um arquivo touch vazio.
Autores de conteúdo sobre algoritmos BSD versus System V podem mostrar ambos os residuais lado a lado emparelhando esta capacidade com um caminho BSD separado quando disponível, sem afirmar que qualquer um seja um hash criptográfico. Validação falha não consome saldo. Fixe hello igual a quinhentos e trinta e dois com um bloco e vazio igual a zero com zero blocos em suites de regressão, e você obtém checksums legados reproduzíveis para scripts, demos LMS e workers de borda sem levantar um userspace Unix só para chamar sum.
Casos de uso
Verificação legada de sum -s
Recalcule checksums System V e contagens de blocos de 512 bytes para cargas de texto curtas, para que ferramentas modernas coincidam com a saída histórica de sum -s em scripts de migração e auditoria.
Goldens de CI para entradas vazias e curtas
Afirme checksum 0 e blocks 0 para texto vazio, e fixe vetores conhecidos como hello → 532 / 1 bloco, para que refatorações não alterem o algoritmo em silêncio.
Ensino de BSD versus System V sum
Mostre aos alunos o residual System V e a contagem de blocos ao lado da documentação do algoritmo alternativo de sum, com aviso claro de entrada vazia para o caso de comprimento zero.
Perguntas frequentes
É o mesmo que sum -s?
Sim. Implementa o algoritmo alternativo System V usado por sum -s: soma de bytes, duas dobras de 16 bits e blocos ceil(length/512). Não é o algoritmo BSD padrão de sum.
System V sum é um hash seguro?
Não. É um checksum legado de 16 bits para interoperar com sum -s e para ensino. Use digests criptográficos como SHA-256 quando precisar de resistência a colisões.
Como o checksum System V é calculado?
Cada byte do texto é somado a um total acumulado. Depois esse total é dobrado para 16 bits somando a metade alta à metade baixa duas vezes, de modo que o excesso da primeira dobra é absorvido pela segunda. O resultado vai de 0 a 65535.
O que significa a contagem de blocos?
É o número de unidades de 512 bytes que o texto ocupa, arredondado para cima. Uma palavra de cinco letras como hello conta como 1 bloco, e um texto vazio dá 0 blocos e checksum 0.
Como letras acentuadas e emojis são contados?
O texto vira primeiro bytes UTF-8 e cada byte entra no total. Um caractere que ocupa vários bytes, como uma letra acentuada ou um emoji, soma portanto mais de um valor ao checksum.
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/enc/sysv-sum \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"hello"}'const res = await fetch("https://api.kit.forhosting.com/enc/sysv-sum", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "hello"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/sysv-sum",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "hello"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/sysv-sum", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"hello"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"hello"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/sysv-sum", 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
{
"text": "hello"
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.sysv_sum",
"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
O que é System V sum e como difere de BSD sum e de digests modernos
Use este endpoint quando precisar desse residual específico, não quando precisar de resistência a colisões. Quando chega texto vazio, o residual é zero e a contagem de blocos é zero, o que coincide com sum -s em um arquivo vazio e é exposto com o campo empty_notice para que clientes mostrem um status legível sem inventar a própria redação.
Contrato de entrada, campos de resposta e texto vazio versus texto ausente
A string é codificada como UTF-8 e cada byte resultante entra no acumulador System V; caracteres Unicode multibyte contribuem com cada unidade de código UTF-8, não com um único code point. Exemplo: as cinco letras ASCII hello produzem checksum quinhentos e trinta e dois, um bloco e cinco bytes, coincidindo com sum -s. Mantenha cargas modestas no navegador; o algoritmo é linear no comprimento em bytes e opera só em memória, sem rede nem sistema de arquivos. Envie por POST um corpo JSON com o campo de string obrigatório text. As chaves alias data, payload, value, input e content são aceitas para a mesma carga, para que geradores e formulários reutilizem nomes de campo existentes. Um campo text completamente ausente, um valor null ou um objeto que não seja string falha com invalid_input e uma mensagem que nomeia o campo ausente ou inválido; essas falhas não são cobradas e não devem ser confundidas com o caminho de sucesso em vazio. Em sucesso o corpo sempre inclui checksum como residual de dezesseis bits, blocks como contagem de blocos de quinhentos e doze bytes, byte_count da codificação UTF-8, empty como booleano, algorithm com o rótulo fixo System V sum (sum -s) e block_size quinhentos e doze. O empty_notice opcional aparece apenas quando empty é true, seguindo a regra de omitir campos opcionais em vez de defini-los como null.
Onde uma API de checksum System V sum agrega valor
Como a implementação é parse pura tier A, cada chamada bem-sucedida custa o preço base publicado US$ 0,002 sem tokens de modelo e sem rede de saída.
Perguntas técnicas
Como calcular um checksum System V sum?
Envie um campo string JSON text (UTF-8). A API devolve checksum (0–65535), blocks de 512 bytes, byte_count, empty e algorithm System V sum (sum -s).
O que acontece com entrada vazia?
String vazia é válida. Você obtém checksum 0, blocks 0, byte_count 0, empty true e empty_notice descrevendo a entrada vazia. text ausente é invalid_input e não é cobrado.
Quanto custa a ferramenta de checksum System V sum?
A ferramenta no navegador é gratuita. Solicitações API usam saldo pré-pago KIT a US$ 0,002 por chamada bem-sucedida; entrada inválida não é cobrada.