This content originally appeared on DEV Community and was authored by Francis Targanski
A introdução massiva de Inteligência Artificial (IA) no desenvolvimento de software transformou o trabalho dos engenheiros. Ferramentas como GitHub Copilot, ChatGPT e CodeWhisperer aceleram a escrita de código, mas também levantam dúvidas: a IA gera código de baixa qualidade ou mesmo inseguro? Seria ela apenas uma mão de obra extra na construção de software, ou um novo vetor de ataques?
Neste artigo, exploro como a IA pode ser tanto ameaça quanto aliada da segurança de software. Discuto riscos como falhas de validação de entrada e geração de vulnerabilidades, mas também trago aspectos de como a própria IA está sendo usada para reforçar a segurança (por exemplo, SAST baseado em IA, geração de casos de teste via fuzzing, etc.). For fim, busco conexões com ideias da filosofia grega clássica, analisando o contraste entre tecnê (técnica) e epistêmê (conhecimento) em Aristóteles, ou a alegoria da caverna de Platão como metáfora para as ilusões geradas pela IA.
Evolução da IA em Segurança de Software
A aplicação de IA em segurança não é totalmente nova. Nos anos 1980 começamos com sistemas especialistas simples, baseados em regras fixas, como assinaturas de anti-vírus e padrões de ataque. Essas ferramentas pioneiras eram reativas: só detectavam ameaças conhecidas, exigindo atualização constante de assinaturas. Na virada do milênio, com o boom da internet e o volume astronômico de dados, Machine Learning passou a ser empregado para análise comportamental. Algoritmos de ML aprendiam padrões de tráfego “normal” e sinalizavam anomalias possivelmente maliciosas. Surgiram sistemas que, em vez de apenas detectar vírus conhecidos, procuravam desvios no comportamento de usuários e sistemas.
Nos anos 2010, entramos na era do Deep Learning: redes neurais convolucionais (CNNs) e recorrentes (RNNs) passaram a reforçar a segurança. Por exemplo, CNNs foram usadas para detectar padrões complexos em e-mails de phishing, e RNNs para monitorar sequências de ações de usuário identificando roubos de credenciais. Esses sistemas mais sofisticados até podem responder a ameaças autonomamente, por exemplo: ao detectar atividade suspeita isolam processos suspeitos em tempo real. Porém, foram introduzidos novos desafios, como ataques adversariais onde invasores enganam redes neurais, colocando inputs maliciosos que “derrotam” a IA.
Por fim, na década de 2020 consolidam-se os grandes modelos de linguagem (LLMs). Modelos como ChatGPT, Llama2, GPT-4 e, mais atualmente GPT-5, que são capazes de gerar código e analisar linguagem quase como humanos. Na segurança esses LLMs trazem duas vertentes: podem analisar grandes volumes de texto (logs, fóruns de segurança, fluxos de rede) para identificar padrões de ataque antes invisíveis, mas também se tornam um alvo e uma ferramenta de ataque. Surgiram categorias de riscos específicas de LLMs, como injeção de prompt, onde o invasor manipula a instrução dada ao modelo, e vazamento de dados sensíveis e envenenamento de modelos, como um treinamento malicioso. Esse ciclo mostra que a história da IA em segurança é um contínuo “gato e rato”: cada avanço tecnológico gera novos métodos de defesa e simultaneamente novas formas de ataque.
Riscos: IA Gerando Código Inseguro
A parte mais visível dessa questão é que IA emite código com falhas. Pesquisas apontam números alarmantes: 30–50% do código sugerido por assistentes de codificação de IA contém vulnerabilidades conhecidas. Em experimentos mais controlados, o modelo GPT-3.5 gerou um conjunto de 112 mil sistemas em C no qual 52% continham pelo menos uma falha explorável. Estudos ampliados incluindo GPT-4 e outros modelos (falcon, CodeLlama, etc.) indicam que, no geral, pelo menos 63% do código auto-gerado pode ser vulnerável. Em resumo, um em cada três trechos de código sugeridos pela IA tende a esconder alguma fragilidade.
Os tipos de vulnerabilidade introduzidas pela IA costumam ser as clássicas (segurança da informação) e novas. Em linguagens de baixo nível (C/C++), predominam erros de memória: buffer overflow e vazamento de memória. Em aplicações web e alto-nível, destacam-se falhas de injeção (SQL injection) e Cross-Site Scripting (XSS), fruto de tratamento inadequado de entradas do usuário. Também foram observados códigos com credenciais embutidas, criptografia fraca ou lógica de autorização faltando checagens, como a omissão de validação de permissões. De fato, como alertado em grandes levantamentos, os LLMs frequentemente sugerem métodos de acesso construídos com strings não sanitizadas, o que leva a injeções sem querer. Em suma, o código gerado por IA pode introduzir qualquer vulnerabilidade tradicional e, em alguns casos, até agravá-la por escrever soluções mais complexas e propensas a erros sutis.
Além disso, existem riscos específicos de LLMs: por exemplo, injeção de prompt, quando entradas maliciosas levam o modelo a “injetar” comandos indesejados no código; vazamento de dados (se o modelo lembrar informações sensíveis do treinamento), e até ataques que envenenam o próprio modelo de linguagem para induzir a gerar código inseguro deliberadamente. Esses aspectos trazem vulnerabilidades inéditas: imagine um chatbot de programação sendo manipulado a introduzir falhas em prol de um atacante.
Em termos filosóficos, esse fenômeno lembra a Alegoria da Caverna de Platão: muitas vezes o programador vê apenas a “sombra” gerada pelo modelo de IA (o código-sugestão aparente), sem conhecer a realidade (o entendimento profundo do que cada linha faz). Como Platão alertou, podemos nos iludir confundindo aparências com verdades. A IA produz saídas convincentes, mas não “sabe” o que faz: só simula respostas linguísticas plausíveis. Em outras palavras, ela oferece a sombra do conhecimento, não o conhecimento em si, o que exige o olhar crítico (a ascensão à luz fora da caverna) do desenvolvedor para verificar o que de fato foi gerado.
Para ilustrar, podemos listar alguns problemas típicos do código sem supervisão suficiente:
- Buffer Overflow e Erros de Memória: Funções em C/C++ podem ser geradas sem limites de array, levando a corrupções de memória graves.
- Injeção (SQL, Comando OS): Trechos construindo queries SQL ou comandos do sistema diretamente da entrada do usuário, sem sanitização, abrem portas para injeção (CWE-89/CWE-78).
- Cross-Site Scripting (XSS): Em códigos web, falta de escape em dados que vão para páginas HTML.
- Credenciais Hardcoded: Modelos podem inserir chaves ou senhas como strings literais no código (CWE-798).
- Falhas de Autorização: Lógica de acesso a recursos pode ser gerada sem validar todas as condições de permissão, levando a controles quebrados (CWE-284).
- Autogeração de Funções Sensíveis: Um modelo pode gerar uma função que executa um comando do sistema ou altera configurações sem perguntar se isso é seguro.
Esses exemplos fazem lembrar o que Sócrates alertou sobre a escrita: confiar cegamente em palavras impressas leva a um conhecimento ilusório, “não uma verdadeira sabedoria, mas somente um semblante dela”. Do mesmo modo, confiar passivamente no código gerado pela IA sem questioná-lo é risco: a IA “fala” de forma confiante, mas sua “sabedoria” é superficial.
IA como Ferramenta de Reforço da Segurança
Por outro lado, a IA também reforça a segurança se bem empregada. Hoje engenheiros de software usam IA para automatizar e escalar testes que antes exigiam muito esforço humano. A visão moderna de DevSecOps (segurança integrada ao desenvolvimento) recomenda pipeline de defesa em camadas. Isso envolve, por exemplo, combinar SAST (análise estática) + SCA (análise de composição de software) + DAST (teste dinâmico) em CI/CD, impondo restrições antes do deploy (bloqueando merges com falhas críticas). Ferramentas inteligentes ajudam em cada camada:
SAST Potencializado por IA: Ferramentas como GitHub CodeQL ou Semgrep já usam IA para criar e aprimorar queries de segurança. O GitHub introduziu o Copilot Autofix, que analisa alertas de SAST e sugere correções automáticas. Em testes com Copilot Autofix, desenvolvedores corrigiram vulnerabilidades 3 vezes mais rápido do que manualmente. De fato, estatísticas mostraram que o tempo médio para remediar uma falha caiu de 1,5 hora para ~28 minutos usando o autofix. Ou seja, a IA “aprende” as melhores práticas de correção e as aplica instantaneamente, aliviando o esforço de segurança do desenvolvedor. Como consequência, criar um pull request que antes exigiria pesquisa extensa de mitigações agora pode ser feito quase no ato, reduzindo o acúmulo de dívida técnica de segurança.
Análise de Código Aberto (SCA) com IA: Muitos projetos open source empregam verificadores de vulnerabilidades em bibliotecas (OWASP Dependency-Check, Snyk). Agora há ferramentas baseadas em IA que escaneiam dependências e sugerem upgrades ou remediações inteligentes. Por exemplo, a ferramenta Corgea é um SAST “nativo em IA” que detecta falhas de autenticação e lógica e gera correções automáticas para o desenvolvedor revisar. Plataformas como Aikido integram rastreamento de dependências, IA para fix automático e SAST em um dashboard unificado. Essas abordagens aproximam a segurança do desenvolvimento contínuo: toda mudança de código já é escaneada e tratada por agentes inteligentes.
Testes Dinâmicos e Fuzzing com IA: Testes de fuzz (inputs aleatórios) são cruciais para achar erros em tempo de execução. A inovação recente é usar IA para gerar casos de teste mais inteligentes e variados. O Google, por exemplo, integrou LLMs ao OSS-Fuzz (plataforma de fuzzing contínuo de código aberto) e descobriu 26 novas vulnerabilidades em projetos de C/C++, incluindo uma falha crítica no OpenSSL que passou décadas despercebida. Esse avanço não é surpresa: a IA consegue varrer grandes códigos e produzir entradas de teste complexas, cobrindo caminhos que humanos dificilmente criariam por conta própria. A IA pode “processar vastos códigos para identificar áreas propensas a vulnerabilidades” e criar inputs complexos para acionar caminhos raros. Em suma, o fuzzing alimentado por IA amplia a cobertura de testes: mesmo código já testado de forma tradicional pode revelar falhas ocultas quando sondado por um agente inteligente.
Geração de Testes Automatizados: Além de fuzzing, existem IAs que criam testes unitários e de integração automaticamente. Plugins em IDEs podem escrever esqueleto de testes de segurança, sugerindo cenários de invasão. Técnicas de Prompt Fuzzing (fuzz em prompts de IA) também surgem para testar a própria segurança de chatbots que geram código. Embora ainda em estágio inicial, essas ferramentas usam IA para antecipar como um invasor poderia explorar uma API ou função, criando contra-exemplos antes do deploy.
Para organizar tudo isso, recomenda-se seguir as práticas DevSecOps com suporte de IA, como integrar verificações de segurança já nos pull requests (usando CodeQL, Semgrep, etc.), e depois usar o autofix com IA para corrigir imediatamente problemas de baixa e média severidade. Em seguida, aplicar DAST (escaneadores automáticos web como OWASP ZAP) para um teste de caixa-preta, e tudo isso o mais automatizado possível. Em linhas gerais, a lição das referências é clara: automatizar onde der. A IA assume a parte tediosa (varrer código, propor correções, gerar entradas de teste) e deixa o desenvolvedor livre para decisões criativas. Deve-se “institucionalizar a validação automática hoje para aproveitar a produtividade da IA sem sacrificar a confiança ou conformidade”.
Entretanto, este arsenal defensivo também serve ao invasor, pois “se a tecnologia pode ser usada para o bem, pode ser usada para o mal”, e invasores podem usar as mesmas IAs de fuzzing para descobrir brechas e explorá-las. Além disso, nada garante que uma correção sugerida pela IA seja sempre a melhor: às vezes a fixação automática pode introduzir novos erros. Por isso, a recomendação de Aristóteles vale aqui: usar sabedoria prática (phronesis) e moderação. Não devemos aceitar ou rejeitar a IA cegamente, mas julgá-la criticamente.
Princípios Filosóficos e Reflexão Crítica
Ao refletir sobre essa dualidade IA vs. segurança, é útil recorrer à filosofia grega clássica para ganhar perspectiva.
Epistêmê vs Technê (Aristóteles) – Aristóteles distinguiu epistêmê (conhecimento teórico) de technê (habilidade prática), mas ressaltou que toda technê é também epistemê, pois requer uma “conta” ou explicação racional. Para engenheiros de software, isso significa que nossa arte de programar não pode ser vazia: gerar código é technê, mas demanda epistemê para ser segura. Ou seja, confiar numa IA assume que o próprio modelo ou quem o criou detém a sabedoria necessária. Assim como Aristóteles via a virtude no equilíbrio (não em extremos), o desenvolvedor moderno deve equilibrar a automação (confiança na IA) com conhecimento próprio do código. Não basta aceitar passivamente tudo que a “Caixa Preta” da IA sugere, é preciso compreendê-lo e validá-lo com os próprios critérios de correção e razão.
Alegoria da Caverna (Platão) – Platão mostrava prisioneiros que confundem sombras com realidade. Na analogia moderna, IA e algoritmos complexos são os artífices das sombras: eles projetam textos, imagens e até código que parecem “reais”, mas não oferecem o conhecimento por trás do que fazem. Quem os usa deve lembrar de sair da caverna, isto é, questionar e validar as “sugestões” da IA para alcançar o verdadeiro entendimento. A IA pode servir de ajudante iluminado, mas só se o usuário estiver disposto a “olhar para a luz” e não se contentar só com as sombras do suporte computacional.
Método Socrático – Sócrates pregava a dúvida metódica e o diálogo construtivo. Seu receio com a escrita, que ela cria esquecimento e apenas “sombra” de sabedoria, nos lembra do perigo de externalizar totalmente nosso raciocínio. No contexto atual, “conversar” com a IA pode até parecer um método socrático moderno (faz-se pergunta e ela responde), mas é preciso usar essas respostas como pontos de partida para reflexão, não como respostas finais. O engenheiro deve continuar perguntando “por quê” das escolhas feitas pelo AI, revalidando cada premissa.
Ética e Responsabilidade – Pensadores estóicos (como Marco Aurélio) ensinavam viver em conformidade com a razão e a natureza. Analogamente, a adoção da IA no desenvolvimento requer temperança ética: treinar modelos com dados limpos, respeitar propriedades intelectuais, e garantir transparência no uso (não copiar código indevidamente, não expor dados sensíveis). Isso retoma a lição de Sócrates: a tecnologia é neutra, mas somos responsáveis pelo uso que fazemos. Se Platão via a necessidade de “descer da caverna” pela educação, hoje precisamos de educação sobre IA para não sermos enganados pelas aparências.
Em última análise, a filosofia grega nos ensina equilíbrio e reflexão crítica. Devemos usar a IA como ferramenta, não idolatrá-la como gênio da lâmpada. Empregar algoritmos de IA na busca de segurança, mas sempre aliando ao “saber humano”, lembrando da distinção entre conhecer algo de fato (episteme) e apenas saber usar uma ferramenta (technê). Se seguirmos esse caminho moderado, a IA deixará de ser um novo vetor incontrolável de ataque e passará a ser a tocha de Prometeu: um fogo poderoso nas mãos do engenheiro prudente, capaz de iluminar projetos e proteger sistemas, em vez de consumi-los.
Conclusão
IA e segurança de software formam uma relação ambígua. Por um lado, a IA acelera o desenvolvimento e abre novas fronteiras, mas por outro introduz vulnerabilidades inéditas se usada sem cuidado. O que Aristóteles chamaria de phronesis (sabedoria prática) é essencial para navegarmos esse desafio. Devemos integrar ferramentas de IA em nossas práticas (SAST/DAST automatizados, testes inteligentes, autofix, fuzzing orientado por IA) mantendo, no entanto, vigilância humana. Em outras palavras, usar a razão grega clássica: nem rejeitar o progresso, nem adoecê-lo de confiança cega.
Para o desenvolvedor moderno, a lição filosófica é clara: conheça seu saber e sua oficina. Não se deixe ludibriar pelas “sombras” convincentes de código gerado por IA sem questionamento. Mas também aproveite a chama de conhecimento que ela oferece, reforçando testes e correções de segurança de forma inédita. Só assim transformaremos a IA na poderosa aliada que Aristóteles desejaria, uma technê aperfeiçoada pela epistêmê, e não em um novo talismã da desatenção.
Referências:
- Choi, N. (2024). How AI enhances static application security testing (SAST). GitHub Blog.
- Dechand, S. (2023). The Risks of AI-Generated Code. Code Intelligence (blog).
- Hanley, M. (2024). Found means fixed: Secure code more than three times faster with Copilot Autofix. GitHub Blog.
- Masood, A. (2025). Security Analysis and Validation of Generative-AI-Produced Code. Medium.
- McIntosh, M. A. (2025). Shadows and Circuits: Plato’s Allegory of the Cave and the Rise of Artificial Intelligence. Brewminate.
- Mello Jr., J. P. (2024). AI-based fuzzing targets open-source LLM vulnerabilities. ReversingLabs Blog.
- Robinson, M. (Ed.) (2003, rev. 2024). Episteme and Techne. Stanford Encyclopedia of Philosophy.
- Tihanyi, N., Bisztray, T., Ferrag, M. A., Jain, R., & Cordeiro, L. C. (2024). Do Neutral Prompts Produce Insecure Code? FormAI-v2 Dataset: Labelling Vulnerabilities in Code Generated by Large Language Models. arXiv preprint.
- OWASP Foundation. (n.d.). Free for Open Source Application Security Tools. OWASP (pág. online).
This content originally appeared on DEV Community and was authored by Francis Targanski
Francis Targanski | Sciencx (2025-08-27T00:59:23+00:00) IA e Segurança de Software: Automação ou Novo Vetor de Ataques?. Retrieved from https://www.scien.cx/2025/08/27/ia-e-seguranca-de-software-automacao-ou-novo-vetor-de-ataques/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.