Você migrou para o Spring Boot 4.0, testou tudo com cuidado, ajustou as breaking changes, subiu em produção. Tudo funcionando. Mas existe uma categoria de vulnerabilidade que os testes de integração raramente pegam: o Server-Side Request Forgery (SSRF). Enquanto sua API processa requests normalmente, um atacante pode estar usando seus HTTP clients para fazer a aplicação requisitar recursos internos que jamais deveriam ser acessíveis.
O Spring Boot 4.1 RC1, liberado em 23 de abril de 2026, trouxe mitigação nativa de SSRF via InetAddressFilter — e se você ainda está no 4.0, precisa entender o que mudou e o que fazer até o GA chegar.
O que é SSRF e por que afeta aplicações Spring Boot
Server-Side Request Forgery (SSRF) é uma vulnerabilidade onde o atacante consegue fazer com que o servidor realize requisições HTTP para destinos controlados pelo atacante — incluindo serviços internos, metadata endpoints de cloud (AWS IMDSv1, Azure IMDS) ou recursos na rede interna que o cliente jamais teria acesso direto.
Imagine que sua API tem um endpoint que aceita uma URL e busca o conteúdo para o cliente — algo como um proxy de imagens ou um webhook validator. Sem proteção, esse endpoint pode ser usado para:
- Acessar
http://169.254.169.254/latest/meta-data/e roubar credenciais IAM em instâncias AWS - Varrer portas internas da rede (
http://192.168.1.x:8080/actuator) - Acessar serviços internos que assumem que apenas requests legítimas chegam da própria VPC
Como Tech Leader, aprendi que o problema é ainda maior em arquiteturas de microservices: cada serviço que faz HTTP calls para URLs configuráveis (via banco, via parâmetro de request) é um vetor potencial. E o Spring Boot, até o 4.0, não oferecia nenhuma proteção automática para isso nos HTTP clients nativos.
O que o Spring Boot 4.1 traz: InetAddressFilter
O Spring Boot 4.1 introduz o InetAddressFilter, uma proteção automática que valida os endereços IP de destino antes de qualquer requisição HTTP ser efetuada pelos clients gerenciados pelo Spring. Na prática, ele bloqueia por padrão:
- Endereços de loopback (
127.0.0.0/8,::1) - Ranges de link-local (
169.254.0.0/16— o famoso endpoint de metadata da AWS) - Ranges de site-local / RFC-1918 (
10.0.0.0/8,172.16.0.0/12,192.168.0.0/16)
Bora ver como ativar e configurar no Spring Boot 4.1:
# application.yaml
spring:
http:
client:
inet-address-filter:
enabled: true
allow-loopback: false
allow-link-local: false
allow-site-local: falseE se você usa o RestClient (substituto do RestTemplate no Boot 4), a auto-configuração já aplica o filtro automaticamente quando a dependência está no classpath:
@Configuration
public class HttpClientConfig {
@Bean
public RestClient restClient(RestClient.Builder builder) {
// InetAddressFilter é aplicado automaticamente com Boot 4.1
return builder
.baseUrl("https://api.exemplo.com")
.build();
}
}E no Spring Boot 4.0? O que fazer agora
Se você está no Spring Boot 4.0 e não pode esperar pelo GA do 4.1, dá para implementar proteção similar manualmente usando um ClientHttpRequestInterceptor:
public class SsrfProtectionInterceptor implements ClientHttpRequestInterceptor {
private static final List<String> BLOCKED_PREFIXES = List.of(
"127.", "10.", "169.254.", "192.168."
);
@Override
public ClientHttpResponse intercept(
HttpRequest request,
byte[] body,
ClientHttpRequestExecution execution
) throws IOException {
String host = request.getURI().getHost();
InetAddress address = InetAddress.getByName(host);
String ip = address.getHostAddress();
boolean isBlocked = address.isLoopbackAddress()
|| address.isLinkLocalAddress()
|| address.isSiteLocalAddress()
|| BLOCKED_PREFIXES.stream().anyMatch(ip::startsWith);
if (isBlocked) {
throw new SecurityException(
"SSRF Protection: requisição para " + ip + " bloqueada."
);
}
return execution.execute(request, body);
}
}@Configuration
public class RestClientConfig {
@Bean
public RestClient secureRestClient(RestClient.Builder builder) {
return builder
.requestInterceptor(new SsrfProtectionInterceptor())
.build();
}
}Certinho? Com essa implementação você já está protegido contra os vetores mais comuns enquanto aguarda o 4.1 GA.
Outras novidades do Spring Boot 4.1 RC1 que valem atenção
O SSRF mitigation é o destaque de segurança, mas o RC1 trouxe mais itens que afetam o dia a dia:
1. Propagação de contexto em métodos @Async
Uma dor antiga: quando você chamava um método @Async, o contexto do OpenTelemetry (trace ID, span ID) não era propagado para a nova thread. Resultado: buracos negros nos seus traces distribuídos.
@Service
public class NotificacaoService {
@Async
public CompletableFuture<Void> enviarEmail(String destinatario) {
// No Boot 4.1, o trace context do thread chamador é propagado aqui
log.info("Enviando email para {}", destinatario); // traceId correto!
return CompletableFuture.completedFuture(null);
}
}No Boot 4.1, a propagação é automática para @Async quando o OpenTelemetry starter está no classpath. Não precisa de configuração adicional.
2. Suporte a variáveis de ambiente do OpenTelemetry SDK
O Boot 4.1 reconhece variáveis de ambiente do OpenTelemetry SDK padrão diretamente, sem precisar mapeá-las manualmente:
management:
otlp:
tracing:
endpoint: ${OTEL_EXPORTER_OTLP_ENDPOINT:http://localhost:4318/v1/traces}3. Retorno do suporte ao Spock com Groovy 5
Para quem usa Spock Framework para testes, o Boot 4.1 restabelece o suporte completo com Groovy 5. No Boot 4.0, o suporte havia sido suspenso durante a migração da toolchain.
@SpringBootTest
class CalculadoraServiceSpec extends Specification {
@Autowired
CalculadoraService service
def "deve calcular juros compostos corretamente"() {
when:
def resultado = service.calcularJurosCompostos(1000, 0.01, 12)
then:
resultado == 1126.83
}
}Como testar a proteção SSRF antes de ir para produção
No mercado de hoje, implementar uma feature de segurança sem teste automatizado é metade do trabalho feito. Bora escrever um teste que garante que o bloqueio está funcionando:
@SpringBootTest
class SsrfProtectionTest {
@Autowired
private RestClient restClient;
@Test
void deveBloquearRequisicoesParaLoopback() {
assertThrows(SecurityException.class, () ->
restClient.get()
.uri("http://127.0.0.1:8080/actuator/health")
.retrieve()
.toBodilessEntity()
);
}
@Test
void deveBloquearRequisicoesParaMetadataAWS() {
assertThrows(SecurityException.class, () ->
restClient.get()
.uri("http://169.254.169.254/latest/meta-data/")
.retrieve()
.toBodilessEntity()
);
}
}FAQ
O InetAddressFilter do Boot 4.1 protege todos os HTTP clients ou só o RestClient?
No RC1, a proteção automática cobre RestClient e WebClient quando configurados via auto-configuration. Clientes criados manualmente precisam do interceptor manual descrito acima.
Tenho um serviço legítimo rodando em 192.168.x.x na rede interna. O filtro vai quebrar?
Sim — por padrão o filtro bloqueia RFC-1918. Use a whitelist: spring.http.client.inet-address-filter.allowed-hosts=192.168.1.100. Nunca desabilitar o filtro inteiro por causa de um caso específico.
SSRF é realmente relevante para APIs internas que não recebem input de usuário?
Sim. Na empresa em que trabalhei, descobrimos um vetor SSRF em um serviço de thumbnail que aceitava URLs via Kafka topic. Passava despercebido por anos.
Quando sai o Spring Boot 4.1 GA?
O RC1 saiu em 23/04/2026. A previsão é maio/2026 — acompanhe o spring.io/blog para confirmação oficial.
Próximos passos
O Spring Boot 4.1 está chegando e SSRF mitigation é só uma das melhorias. Se você ainda não fez a migração para o Boot 4.0, o checklist de breaking changes é o ponto de partida.
Comenta aqui embaixo: você já encontrou algum vetor SSRF em produção? Esse tipo de troca de experiência real vale mais do que qualquer tutorial.
Bora continuar evoluindo — até o próximo artigo!