A transição de um desenvolvedor Java para a área de Engenharia de Segurança frequentemente esbarra na falta de conexão entre as habilidades de desenvolvimento corporativo e as demandas de segurança. O grande diferencial de um profissional Java está no domínio de arquiteturas empresariais, como Spring Boot, JDBC e Maven, que são exatamente os alvos e as bases para auditoria de código, proteção contra injeção de SQL e empacotamento de ferramentas de segurança.

Mapeamento de Competências: Do Java para a Segurança

Em vez de começar do zero, o desenvolvedor Java deve aplicar uma dimensão de segurança às suas competências atuais:

• Spring Boot / MVC: Auditoria de aplicações corporativas. O conhecimento das camadas Controller e Service permite identificar parâmetros não filtrados (Injeção de SQL) e falhas de lógica de negócios (Quebra de Controle de Acesso).
• Sintaxe Java (Regex / IO): Desenvolvimento de ferramentas. Expressões regulares são essenciais para detectar padrões de ataque, enquanto o manejo de IO é usado para processar logs e gerar relatórios.
• JDBC / MyBatis: Proteção de dados. Entender a concatenação de strings ajuda a identificar vulnerabilidades, e o domínio de consultas parametrizadas é a base para criar soluções de mitigação.
• Maven / Gradle: Integração de segurança. Empacotamento de ferramentas em JARs executáveis e integração de plugins de análise de dependências (como OWASP) em pipelines de CI/CD.

Projetos Práticos de Engenharia de Segurança

1. Scanner de Injeção SQL para Endpoints Web

Desenvolvimento de uma ferramenta para testar endpoints contra falhas de SQLi, gerando relatórios em HTML.

Tecnologias: Java SE (HttpClient), Freemarker, Maven.

import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.entity.UrlEncodedFormEntity;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.NameValuePair;
import org.apache.http.util.EntityUtils;
import org.apache.http.client.methods.CloseableHttpResponse;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class EndpointVulnerabilityScanner {

    private final CloseableHttpClient client;
    private final String[] maliciousPayloads = {"' OR '1'='1", "\" OR \"1\"=\"1", "' UNION SELECT NULL--"};

    public EndpointVulnerabilityScanner() {
        this.client = HttpClients.createDefault();
    }

    public boolean scanEndpoint(String targetUrl, Map<String, String> baseParams) throws IOException {
        HttpPost request = new HttpPost(targetUrl);

        for (String payload : maliciousPayloads) {
            List<NameValuePair> formData = new ArrayList<>();
            for (Map.Entry<String, String> param : baseParams.entrySet()) {
                formData.add(new BasicNameValuePair(param.getKey(), param.getValue() + payload));
            }
            
            request.setEntity(new UrlEncodedFormEntity(formData, "UTF-8"));
            
            try (CloseableHttpResponse response = client.execute(request)) {
                String body = EntityUtils.toString(response.getEntity());
                if (detectDatabaseError(body)) {
                    System.out.println("Vulnerabilidade detectada com o payload: " + payload);
                    return true;
                }
            }
        }
        return false;
    }

    private boolean detectDatabaseError(String responseBody) {
        String[] errorSignatures = {"SQL syntax", "MySQLSyntaxErrorException", "ORA-00936", "PostgreSQL"};
        for (String signature : errorSignatures) {
            if (responseBody.contains(signature)) {
                return true;
            }
        }
        return false;
    }
}

Geração de Relatório:

import freemarker.template.Configuration;
import freemarker.template.Template;
import freemarker.template.TemplateException;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class HtmlReportBuilder {

    private final Configuration freemarkerConfig;

    public HtmlReportBuilder() throws IOException {
        freemarkerConfig = new Configuration(Configuration.VERSION_2_3_32);
        freemarkerConfig.setDirectoryForTemplateLoading(new File("src/main/resources/templates"));
    }

    public void buildReport(ScanResult result, String destinationPath) throws TemplateException, IOException {
        Map<String, Object> templateData = new HashMap<>();
        templateData.put("targetUrl", result.getUrl());
        templateData.put("hasVulnerability", result.isVulnerable());
        templateData.put("usedPayload", result.getPayload());
        templateData.put("executionDate", new SimpleDateFormat("dd/MM/yyyy HH:mm").format(new Date()));

        Template template = freemarkerConfig.getTemplate("vulnerability_report.ftl");
        try (Writer writer = new FileWriter(new File(destinationPath))) {
            template.process(templateData, writer);
        }
    }
}

2. Analisador de Logs de Segurança e Alertas

Script para monitorar logs em busca de padrões de ataque, como força bruta SSH, enviando alertas quando limites são excedidos.

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ThreatLogAnalyzer {

    private static final int MAX_FAILED_ATTEMPTS = 5;
    private final Map<String, Integer> failedAttemptsTracker = new HashMap<>();
    private final Pattern sshFailPattern = Pattern.compile("Failed password for .* from (\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})");

    public void processLogStream(List<String> logEntries) {
        for (String entry : logEntries) {
            Matcher matcher = sshFailPattern.matcher(entry);
            if (matcher.find()) {
                String attackerIp = matcher.group(1);
                int currentCount = failedAttemptsTracker.getOrDefault(attackerIp, 0) + 1;
                failedAttemptsTracker.put(attackerIp, currentCount);

                if (currentCount >= MAX_FAILED_ATTEMPTS) {
                    dispatchSecurityAlert(attackerIp, currentCount);
                    failedAttemptsTracker.put(attackerIp, 0);
                }
            }
        }
    }

    private void dispatchSecurityAlert(String ip, int attempts) {
        String alertMessage = String.format("Alerta de Força Bruta: IP %s excedeu %d tentativas de login.", ip, attempts);
        System.out.println("ALERTA: " + alertMessage);
    }
}

3. Filtro RASP para Mitigação de XSS

Implementação de um filtro de segurança (RASP básico) usando Servlet Filters para sanitizar entradas e prevenir Cross-Site Scripting (XSS) sem alterar o código de negócio.

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;
import java.io.IOException;

@WebFilter("/*")
public class MaliciousPayloadFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        SanitizedRequestWrapper wrappedRequest = new SanitizedRequestWrapper(httpRequest);
        chain.doFilter(wrappedRequest, response);
    }

    private static class SanitizedRequestWrapper extends HttpServletRequestWrapper {

        public SanitizedRequestWrapper(HttpServletRequest request) {
            super(request);
        }

        @Override
        public String getParameter(String name) {
            String originalValue = super.getParameter(name);
            return originalValue != null ? sanitizeInput(originalValue) : null;
        }

        private String sanitizeInput(String dirtyValue) {
            String cleanValue = dirtyValue.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
            cleanValue = cleanValue.replaceAll("\\(", "&#40;").replaceAll("\\)", "&#41;");
            cleanValue = cleanValue.replaceAll("'", "&#39;");
            return cleanValue.replaceAll("(?i)script", "");
        }
    }
}

Otimização de Currículo para Engenharia de Segurança

Para transicionar com sucesso, o currículo deve destacar a interseção entre desenvolvimento Java e segurança. Utilize o método STAR (Situação, Tarefa, Ação, Resultado) para descrever experiências.

Exemplo de Descrição de Projeto:

• Projeto: Hardening de Segurança e Integração de Plugin RASP em Módulo de Pagamentos.
• Situação: O módulo de pagamentos apresentava riscos de injeção SQL e XSS, com histórico de vazamento de dados.
• Tarefa: Realizar auditoria de código, corrigir vulnerabilidades e implementar um filtro de segurança zero-trust.
• Ação: Auditoria com FindSecBugs identificou parâmetros não sanitizados. Correção via consultas parametrizadas no MyBatis. Desenvolvimento de um Filter Spring para sanitização global de requisições e integração no pipeline Jenkins para bloqueio de builds com vulnerabilidades críticas.
• Resultado: Redução de incidentes de segurança em 100% no módulo. O plugin RASP bloqueia em média 20 tentativas de XSS mensais com taxa de falsos positivos inferior a 2%.

Roteiro de Aprendizado e Armadilhas Comuns

Fases de Transição:

1. Meses 1-2 (Auditoria de Código): Estudar OWASP Top 10 focado em Java. Utilizar FindSecBugs em projetos Spring Boot próprios. Analisar CVEs de frameworks como Struts ou Spring.
2. Meses 3-4 (Desenvolvimento de Ferramentas): Construir o Scanner de SQLi e o Analisador de Logs. Publicar no GitHub com documentação detalhada.
3. Mês 5 (DevSecOps e RASP): Estudar Servlet Filters e Interceptadores Spring. Criar plugins de proteção. Integrar ferramentas de segurança em pipelines CI/CD (Jenkins/GitLab CI).
4. Mês 6 (Preparação para Entrevistas): Refatorar o currículo, focando em projetos de segurança. Praticar entrevistas técnicas sobre mitigação de vulnerabilidades em arquiteturas distribuídas.

Armadilhas a Evitar:

• Focar em Engenharia Reversa: Especialistas em Java devem evitar perder tempo com reversing de binários C/C++ ou APKs Android no início. O foco deve ser segurança de aplicações web e corporativas.
• Teoria sem Prática: Apenas memorizar o OWASP Top 10 não gera empregabilidade. É obrigatório criar ferramentas, mesmo que simples, e disponibilizá-las em repositórios públicos.
• Ignorar o DevSecOps: As empresas buscam profissionais que saibam integrar segurança ao fluxo de desenvolvimento (CI/CD), e não apenas criar ferramentas isoladas.