Conteúdo do curso Lição 33 de 156 · HTTP por dentro
HTTP por dentro

Interpretar uma requisição HTTP bruta

Por que isso importa Toda página que você carrega começa como um pequeno texto que o seu navegador envia a um servidor, e é nesse texto que viaja a maior parte da informação de rastreamento: seus cookies, a página de onde você veio, o seu idioma. Quando você consegue lê-lo, nada nele fica escondido de você, e toda ferramenta desta etapa (o rastreador, o bloqueador, as medições) é construída em cima dele.

Pense numa requisição HTTP como uma carta num formato muito rígido. A primeira linha diz o que você quer, depois vêm anotações com rótulo no envelope, depois uma linha em branco, depois (às vezes) o conteúdo. Uma resposta é a carta de volta, no mesmo formato. Seu navegador escreve e lê milhares delas por dia.

HTTP: HyperText Transfer Protocol, o formato combinado que navegadores e servidores usam para pedir e enviar páginas, imagens e dados.

Requisição: a mensagem que o navegador envia: um método (o que fazer, como GET para buscar ou POST para enviar um formulário), um alvo (qual caminho no servidor) e uma versão.

Cabeçalho: uma anotação com rótulo na mensagem, escrita como Name: value numa linha própria, como Accept-Language: en-GB.

Como é uma requisição bruta

Aqui está uma requisição que o navegador de prática enviou para a página da barraca da ShopA. Toda linha termina em dois caracteres invisíveis, retorno de carro e avanço de linha, escritos \r\n em Python. Uma linha vazia (ou seja, \r\n\r\n em sequência) marca o fim da cabeça.

GET /p/tent HTTP/1.1
Host: shopa.example
User-Agent: PracticeBrowser/1.0 (Linux) Practice Firefox 144
Accept-Language: en-ZA
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-Dest: document
  • Linha de requisição: GET /p/tent HTTP/1.1, três partes separadas por espaços simples.
  • Cabeçalhos: um por linha, o nome, dois-pontos, depois o valor.
  • Linha em branco: a cabeça terminou.
  • Corpo: o que vier depois. Um GET costuma não ter; um POST de formulário leva os campos do formulário, como user=sam.

Uma resposta tem o mesmo formato, mas a primeira linha é uma linha de status: HTTP/1.1 200 OK. A parte do meio é o código de status (200 significa tudo certo, 302 significa "vá para outro lugar", 404 significa "não encontrado") e o resto é a frase de motivo, um rótulo para humanos que pode ter espaços (Moved Permanently) ou nem existir.

Código de status: um número de três dígitos no início de uma resposta que diz como as coisas foram. 2xx sucesso, 3xx redirecionamento, 4xx um problema com a requisição, 5xx um problema no servidor.

Três ferramentas de Python de que você precisa

text.partition(sep) divide no primeiro sep e devolve três pedaços: antes, o separador, depois. text.split(sep, 2) divide no máximo duas vezes, então uma frase de motivo com espaços fica num pedaço só. text.strip() remove espaços das duas pontas.

"Referer: https://shopa.example/".partition(":")
# ('Referer', ':', ' https://shopa.example/')
"HTTP/1.1 301 Moved Permanently".split(" ", 2)
# ['HTTP/1.1', '301', 'Moved Permanently']

Um erro comum

Dividir uma linha de cabeçalho em todos os dois-pontos. Referer: https://shopa.example/ tem dois-pontos dentro do valor, então line.split(":") corta o endereço ao meio. Sempre divida só nos primeiros dois-pontos. Os navegadores reais aprenderam isso do jeito difícil: parsers descuidados são uma fonte clássica de falhas de segurança, em que dois programas leem a mesma mensagem de jeitos diferentes.

A web real ainda é assim?

Em espírito, quase sempre. Os navegadores hoje costumam falar HTTP/2 ou HTTP/3, que enviam os mesmos métodos, cabeçalhos e corpos empacotados em quadros binários em vez de linhas de texto. O DevTools os mostra como texto de qualquer jeito, então os campos que você aprende aqui são exatamente os que vai ver lá (verificado em outubro de 2026). O mundo de prática escreve tudo como texto HTTP/1.1, que ainda é o que muitos servidores e ferramentas usam.

Experimente Abra o DevTools (F12, ou Cmd+Option+I no Mac), escolha a aba Network e recarregue qualquer página. Clique na primeira requisição e olhe os Request Headers. Muitos navegadores oferecem uma chave "Raw" que mostra a cabeça exatamente neste formato.

Em outras linguagens

JavaScript:

function parseRequest(raw) {
  const [head, ...rest] = raw.split("\r\n\r\n");
  const lines = head.split("\r\n");
  const [method, target, version] = lines[0].split(" ");
  const headers = lines.slice(1).map(line => {
    const i = line.indexOf(":");            // first colon only
    return [line.slice(0, i).trim(), line.slice(i + 1).trim()];
  });
  return { method, target, version, headers, body: rest.join("\r\n\r\n") };
}

Go:

// the standard library has a real parser: net/http.ReadRequest
req, err := http.ReadRequest(bufio.NewReader(strings.NewReader(raw)))
if err == nil {
    fmt.Println(req.Method, req.URL.Path, req.Header.Get("User-Agent"))
}

Rust:

let (head, body) = raw.split_once("\r\n\r\n").unwrap_or((raw, ""));
let mut lines = head.split("\r\n");
let mut first = lines.next().unwrap().splitn(3, ' ');
let (method, target) = (first.next(), first.next());
let headers: Vec<(&str, &str)> = lines
    .filter_map(|l| l.split_once(':'))
    .map(|(n, v)| (n.trim(), v.trim()))
    .collect();

Resumo

  • Uma requisição é uma linha de requisição, cabeçalhos, uma linha em branco e depois um corpo opcional; uma resposta começa com uma linha de status em vez disso.
  • Separe a cabeça do corpo no primeiro \r\n\r\n, e cada cabeçalho nos seus primeiros dois-pontos.
  • A frase de motivo pode ter espaços ou faltar, então divida a linha de status no máximo duas vezes.
  • HTTP/2 e HTTP/3 levam os mesmos campos em binário, então este retrato continua valendo.
Sua vez

Escreva parse_request(raw), que retorna um dict com "method", "target" (caminho mais consulta), "version", "headers" (uma lista de pares (name, value) em ordem, divididos nos primeiros dois-pontos, os dois sem espaços nas pontas) e "body" (tudo depois da primeira linha em branco, "" se não houver). Depois escreva parse_response(raw), que retorna "version", "status" (um int), "reason" ("" se faltar), "headers" e "body" do mesmo jeito.

Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição

Este exercício abre em breve

Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.