HTTP profundo (headers, métodos, status)

O protocolo HTTP (Hypertext Transfer Protocol) é a base da comunicação na web. Ele define como as mensagens são formatadas e transmitidas entre clientes (como navegadores) e servidores. Neste artigo, vamos explorar em detalhes os headers, métodos e status codes do HTTP, que são componentes essenciais para entender como a web funciona.

Headers

Strict-Transport-Security (HSTS)

O header Strict-Transport-Security (HSTS) é uma medida de segurança que instrui os navegadores a se comunicarem apenas por meio de conexões HTTPS seguras. Ele ajuda a prevenir ataques de downgrade e sequestro de cookies, garantindo que todas as comunicações futuras com o servidor sejam feitas de forma segura.

max-age=3153600 - Define o tempo em segundos que o navegador deve lembrar de usar HTTPS (neste caso, 1 hora).

includeSubDomains - Aplica a política HSTS a todos os subdomínios do domínio principal. preload - Indica que o domínio deve ser incluído na lista de pré-carregamento HSTS mantida pelos navegadores.

x-frame-options(obsoleto) - O header X-Frame-Options é usado para proteger contra ataques de clickjacking, controlando se uma página pode ser incorporada em um iframe. Ele pode ter os seguintes valores:

DENY - Impede que a página seja carregada em qualquer iframe. SAMEORIGIN - Permite que a página seja carregada em iframes apenas do mesmo domínio. ALLOW-FROM uri - Permite que a página seja carregada em iframes de um URI específico.

content-security-policy - O header Content-Security-Policy (CSP) é uma medida de segurança que ajuda a prevenir ataques de injeção de código, como Cross-Site Scripting (XSS). Ele permite que os administradores definam políticas de segurança para controlar quais recursos podem ser carregados e executados em uma página web.

X-Content-Type-Options

Content-Type-Options - Define como o navegador deve interpretar os tipos de conteúdo recebidos do servidor.

O header X-Content-Type-Options é usado para evitar que os navegadores façam "sniffing" do tipo de conteúdo, o que pode levar a vulnerabilidades de segurança. O valor mais comum para este header é "nosniff", que instrui o navegador a seguir estritamente o tipo de conteúdo declarado no header Content-Type.

Options: nosniff - Instruir o navegador a não fazer "sniffing" do tipo de conteúdo.

Content-Security-Policy (CSP)

O header Content-Security-Policy (CSP) é uma medida de segurança que ajuda a prevenir ataques de injeção de código, como Cross-Site Scripting (XSS). Ele permite que os administradores definam políticas de segurança para controlar quais recursos podem ser carregados e executados em uma página web.

Valor default: default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'; connect-src 'self'; frame-src 'self'; object-src 'none'; base-uri 'self'; form-action 'self'; frame-ancestors 'none';

Exemplo

.headers(headers -> headers
    .contentSecurityPolicy(csp -> csp
        .policyDirectives(
            "default-src 'self'; " +
            "script-src 'self'; " +
            "style-src 'self'; " +
            "img-src 'self' data:; " +
            "font-src 'self'; " +
            "connect-src 'self'; " +
            "frame-ancestors 'none'; " +
            "object-src 'none'; " +
            "base-uri 'self'; " +
            "form-action 'self'"
        )
    )
)

🔴 Alerta de pentest Uso de:

'unsafe-inline' 'unsafe-eval'

→ abre vetor direto para XSS Isso vira finding de severidade alta em relatório.

Referrer-Policy

O header Referrer-Policy controla como e quando o navegador deve enviar informações de referência (referrer) ao fazer solicitações para outros sites. Ele ajuda a proteger a privacidade do usuário, limitando a quantidade de informações compartilhadas entre sites.

Valor default: no-referrer no-referrer-when-downgrade same-origin origin strict-origin origin-when-cross-origin unsafe-url

Fallback-policy

O header Fallback-policy é usado para definir políticas de fallback para recursos que não podem ser carregados corretamente. Ele ajuda a garantir que, mesmo que um recurso específico não esteja disponível, o site ainda possa funcionar de maneira adequada, fornecendo alternativas ou comportamentos padrão.

Valor default: strinck-origin same-origin no-referrer

Clear-Site-Data

O header Clear-Site-Data é usado para instruir o navegador a limpar dados específicos relacionados ao site atual. Ele pode ser usado para melhorar a privacidade do usuário, removendo informações armazenadas localmente, como cookies, cache e armazenamento local.

Valor default: "cache", "cookies", "storage", "executionContexts", "indexedDB", "localstorage"

Cache-Control

O header Cache-Control é usado para definir políticas de cache para recursos web. Ele instrui os navegadores e proxies sobre como armazenar e reutilizar recursos, ajudando a melhorar o desempenho e a eficiência do carregamento de páginas.

Valor default: no-cache - Indica que a resposta não deve ser armazenada em cache. no-store - Indica que a resposta não deve ser armazenada em cache de forma alguma. max-age=0 - Indica que a resposta é considerada imediatamente obsoleta. public - Indica que a resposta pode ser armazenada em cache por qualquer cache, mesmo que seja compartilhado. expires - Define uma data e hora específicas em que a resposta expira e não deve mais ser considerada válida. pragma - Usado para compatibilidade com HTTP/1.0, geralmente definido como "no-cache".

@GetMapping("/user/profile")
public ResponseEntity<UserDTO> profile() {
    return ResponseEntity.ok()
        .header("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0")
        .header("Pragma", "no-cache")
        .body(userService.getProfile());
}

🔎 Pentest insight Tokens JWT ou dados pessoais com cache habilitado = vulnerabilidade de privacidade.

Set-cookies

O header Set-Cookie é usado pelo servidor para enviar cookies ao navegador do cliente. Cookies são pequenos pedaços de dados que são armazenados no navegador e enviados de volta ao servidor em solicitações subsequentes. Eles são usados para manter sessões, rastrear usuários e armazenar preferências.

Propriedades comuns: Expires - Define a data e hora em que o cookie expira. Max-Age - Define o tempo em segundos até o cookie expirar. Domain - Especifica o domínio para o qual o cookie é válido. Path - Define o caminho no servidor para o qual o cookie é válido. Secure - Indica que o cookie deve ser enviado apenas por conexões HTTPS. HttpOnly - Indica que o cookie não deve ser acessível via JavaScript, ajudando a prevenir ataques XSS. SameSite - Controla se o cookie deve ser enviado em solicitações de terceiros, ajudando a prevenir ataques CSRF. Pode ter os valores "Strict", "Lax" ou "None".

ResponseCookie cookie = ResponseCookie.from("SESSIONID", "abc123")
    .httpOnly(true)
    .secure(true)
    .sameSite("Strict")
    .path("/")
    .maxAge(3600)
    .build();

return ResponseEntity.ok()
    .header(HttpHeaders.SET_COOKIE, cookie.toString())
    .body("OK");

Configuração típica correta: HttpOnly; Secure; SameSite=Strict

🔴 Pentest clássico

Cookie sem HttpOnly → XSS rouba sessão

Cookie sem SameSite → CSRF viável

X XSS-Protection

O header X-XSS-Protection é uma medida de segurança que ajuda a proteger contra ataques de Cross-Site Scripting (XSS). Ele instrui o navegador a ativar ou desativar o filtro de XSS embutido, que pode detectar e bloquear scripts maliciosos.

Valor default: 1 - Ativa o filtro de XSS. 0 - Desativa o filtro de XSS.

Exemplos

Headers de Segurança – Spring Boot

Essa é a abordagem oficial e mais limpa.

@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {

        http
            // Headers globais
            .headers(headers -> headers
                // HSTS
                .httpStrictTransportSecurity(hsts -> hsts
                    .includeSubDomains(true)
                    .preload(true)
                    .maxAgeInSeconds(31536000)
                )

                // Clickjacking
                .frameOptions(frame -> frame.deny())

                // MIME sniffing
                .contentTypeOptions(contentType -> {})

                // XSS (legado)
                .xssProtection(xss -> xss.block(true))

                // Referrer
                .referrerPolicy(referrer -> referrer
                    .policy(ReferrerPolicyHeaderWriter.ReferrerPolicy.NO_REFERRER)
                )

                // CSP
                .contentSecurityPolicy(csp -> csp
                    .policyDirectives(
                        "default-src 'self'; " +
                        "script-src 'self'; " +
                        "style-src 'self'; " +
                        "img-src 'self' data:; " +
                        "object-src 'none'; " +
                        "frame-ancestors 'none'"
                    )
                )
            )

            // Logout centralizado
            .logout(logout -> logout
                .logoutUrl("/logout")
                .invalidateHttpSession(true)
                .deleteCookies("JSESSIONID")
                .logoutSuccessHandler((request, response, authentication) -> {
                    response.setHeader(
                        "Clear-Site-Data",
                        "\"cache\", \"cookies\", \"storage\""
                    );
                    response.setStatus(HttpServletResponse.SC_NO_CONTENT);
                })
            );

        return http.build();
    }
}

Útil quando:

Você quer aplicar headers condicionalmente Diferenciar API / Admin / Público

@Component
public class GlobalSecurityHeadersFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain filterChain
    ) throws ServletException, IOException {

        response.setHeader("X-Frame-Options", "DENY");
        response.setHeader("X-Content-Type-Options", "nosniff");
        response.setHeader("Referrer-Policy", "no-referrer");
        response.setHeader("Content-Security-Policy",
            "default-src 'self'; frame-ancestors 'none'"
        );

        // Logout-aware
        if ("/logout".equals(request.getRequestURI())) {
            response.setHeader(
                "Clear-Site-Data",
                "\"cache\", \"cookies\", \"storage\""
            );
        }

        filterChain.doFilter(request, response);
    }
}