Modelos de Linguagem: segurança e mitigação de riscos

Fundamentos de segurança em LLMs - Apresentação

Apresentando o curso e o instrutor

Olá, pessoal. Bem-vindos à trilha de LLM Security (Segurança em LLM): Modelos de Linguagem: segurança e mitigação de riscos. Este é o primeiro curso da trilha.

Meu nome é Tharles Freire. Sou atualmente gerente de DevSecOps (Desenvolvimento, Segurança e Operações) e SRE (Engenharia de Confiabilidade de Sites), professor de Cloud Security (Segurança em Nuvem) na FIAP, mestre em Computação Aplicada pela Universidade Presbiteriana Mackenzie e trabalho como especialista em segurança de sistemas com LLM (Modelos de Linguagem de Grande Porte) em ambientes corporativos.

Detalhando os objetivos do curso

Falando sobre o que nós vamos ver neste curso:

• Compreender como os modelos de linguagem funcionam, no nível necessário para entender riscos, sem entrar em matemática avançada.
• Construir a superfície de ataque e interpretá-la.
• Identificar onde sistemas com modelos de linguagem apresentam falhas em ambientes corporativos.
• Abordar o OWASP Top 10 para LLMs.
• Construir uma referência de riscos e documentá-los, tornando-os visíveis diante da nova superfície que esses modelos trazem para dentro da aplicação.
• Tratar de mitigação e avaliação: construir controles, implementar defesas em camadas dentro da aplicação e avaliar a postura da aplicação.

Explicando a estrutura das aulas

Este curso tem seis aulas.

Na Aula 1, nós vamos entender conceitos importantes para que possamos tratar de LLM.

Na Aula 2, nós começaremos a interagir com riscos, definiremos um norte sobre por onde começar e abordaremos o OWASP Top 10 para LLMs. Partiremos dos riscos mais comuns: a lista do OWASP nos apresenta os riscos mais recorrentes em aplicações, bem como superfícies de ataque, dados e formas de mitigação.

Implementando controles e avaliando a aplicação

Entre a Aula 3, a Aula 4 e a Aula 5, nós vamos identificar onde esses riscos acontecem, implementar controles para alguns deles, observar a aplicação falhar e aprender a mitigar esses riscos dentro da própria aplicação.

Também trataremos da forma de avaliar essa aplicação por meio de Threat Modeling (modelagem de ameaças), construindo tudo em nosso laboratório, que veremos durante as aulas, e preparando a apresentação da postura de segurança da aplicação à alta gestão.

Conduzindo do risco à ação e iniciando o curso

Nós vamos passar do risco à ação: compreender os riscos, observá-los em funcionamento, utilizar nosso laboratório da CredSyn — uma aplicação em Docker que nos permite explorá-la — e, como objetivo final, avaliar o risco não para invadir, mas para blindar conscientemente nossa aplicação.

Vamos começar.

Fundamentos de segurança em LLMs - Entendendo a superfície de ataque em LLMs

Introduzindo o curso e objetivos

Olá, pessoal! Bem-vindos à primeira aula do curso Modelos de Linguagem: segurança e mitigação de riscos. Este é o primeiro curso da trilha de Segurança em Modelos de Linguagem, e esta aula tem como objetivo entender como um modelo funciona internamente, apresentar os conceitos necessários para esse entendimento e definir como montar uma estratégia de proteção e defesa contra esses riscos. Esta aula fornece a base para o restante do curso e é essencial para o entendimento do tema.

Por que entender o LLM por dentro importa para a segurança? Entender como o modelo opera e os conceitos a ele atrelados é fundamental para avaliarmos a superfície de ataque e definirmos uma estratégia de defesa. Precisamos compreender onde implementar controles para nos protegermos e executarmos essa estratégia de forma eficaz.

Comparando a segurança tradicional e aplicações com modelos de linguagem

Segurança tradicional versus aplicações com modelos de linguagem

• Velocidade de adoção As aplicações contemporâneas chegam ao mercado com muita rapidez. Já existem aplicações que utilizam modelos para responder a clientes, acessar bases de dados e executar ações de forma autônoma ou revisada. A capacidade de implementação dessas novas ferramentas e aplicações é superior à capacidade de avaliação dos riscos a elas relacionados.

• Instruções e dados no mesmo texto Em aplicações tradicionais, temos o código da aplicação definindo as instruções — onde e como executá-las — e um banco de dados armazenando as informações necessárias para a execução da aplicação. Existe, portanto, uma separação clara entre as instruções e os dados utilizados.

Em aplicações que utilizam modelos de linguagem, pela própria forma como o modelo opera, essa separação não existe. O modelo interpreta tudo em um único campo, um único texto. No mesmo local, o modelo interpreta instruções e dados; tudo se torna um texto unificado e, com isso, a barreira entre instrução e dado desaparece. O modelo não diferencia nem interpreta o que é instrução e o que é dado.

Analisando filtros tradicionais e interpretação por modelos de linguagem

Filtros tradicionais versus interpretação por LLM

Outro ponto importante é entender como ferramentas tradicionais fazem análise e proteção e como um LLM interpreta esses controles e barreiras. Quando falamos de filtros de padrão e filtros de palavras, esses mecanismos não capturam o sentido. Em soluções como Web Application Firewall (WAF) (firewall de aplicações web), em assinaturas e em blocklist (lista de bloqueio), esses filtros buscam a grafia, isto é, a forma como a palavra está escrita.

Como o LLM entende o significado da palavra ou da instrução, o uso de sinônimos, palavras em outros idiomas, paráfrases ou caracteres inseridos junto à palavra consegue atravessar esses filtros baseados em correspondência literal.

Expondo a superfície de ataque e novos riscos

Superfície de ataque e novos riscos

A adoção de modelos dentro das aplicações introduz ferramentas e componentes novos que não existiam em uma aplicação tradicional. Isso amplia a superfície dessa aplicação e expõe pontos dessa superfície que não eram revisados com a devida importância. Esses pontos trazem novos riscos, resultando em uma superfície de ataque maior, e precisam ser reavaliados com maior prioridade.

Definindo o plano de defesa

Plano de defesa

O plano final é entender como o modelo funciona internamente, identificar onde ele falha e, com isso, construir uma estratégia de defesa.

Apresentando o conteúdo da aula

O que vamos aprender nesta aula

• Tokens, geração e atenção:

  • Como o modelo interpreta a instrução que enviamos.
  • Como separa o texto em tokens (unidades de texto).
  • Como constrói e gera textos.
  • Como mantém coerência na construção de textos durante instruções e contextos longos.
  • Em síntese, como o modelo lê e produz texto.

• Treinamento, fine-tuning (ajuste fino) e aprendizagem por reforço com feedback humano (Reinforcement Learning from Human Feedback - RLHF):

  • Como ajustar o comportamento do modelo.
  • Como definir o processo de treinamento, o que esperamos como saída e o que entendemos como a melhor resposta vinda do modelo.

• Contexto e memória:

  • Como cada entrada molda a resposta do modelo.
  • Por que, às vezes, o modelo “se esquece” de informações e, após certo tempo, não recorda instruções que foram passadas.

• Software, modelos proprietários e modelos open source (código aberto):

  • A cadeia de gerenciamento desses modelos.
  • A superfície de cada modelo e suas dependências.

• Prática:

  • Avaliar como o modelo interpreta tokens.
  • Construir filtros burláveis e entender suas limitações.
  • Investigar por que o modelo alucina.
  • Discutir prompt injection (injeção de prompt).

Fundamentos de segurança em LLMs - Entendendo tokens e geração de texto

Explicando tokens e subpalavras

Vamos começar a falar sobre tokens (unidades de subpalavras). Há uma pergunta importante: como o modelo lê o texto que digitamos? Ele não lê palavras inteiras; divide o texto em pedaços que chamamos de tokens (unidades de subpalavras). Por exemplo, a palavra "EXFILTRAÇÃO". O modelo divide essa palavra em subpalavras, como a subpalavra "EXFILTRAÇÃO" e a subpalavra "RAÇÃO". Cada pedaço dessa palavra, cada subpalavra que o modelo lê, é interpretado como um número. É isso que o modelo entende e processa: números, não letras.

Um detalhe prático é que o número de tokens (unidades de subpalavras) nunca coincide com o número de palavras.

Por que trabalhar em pedaços? Para construir um vocabulário fixo. Os tokens (unidades de subpalavras) são definidos antes do treinamento do modelo em si. Cada modelo tem uma lista bem definida, finita, de tokens (unidades de subpalavras), e esses tokens (unidades de subpalavras) precisam cobrir todas as palavras dentro de um vocabulário. Quando falamos da língua escrita e falada, ela é, na prática, ilimitada. A forma como o modelo aborda todas essas palavras é por meio de subpalavras: palavras comuns se mantêm por completo, por exemplo, "segurança", e palavras diferentes ou pouco comuns, como "exfiltração", são divididas em subpalavras. Dessa forma, usamos a subpalavra como um meio-termo. Com isso, o modelo consegue interpretar e cobrir o máximo de vocabulário possível, o que evita que não conheça uma palavra introduzida. Ao unir essas subpalavras, o modelo consegue interpretar qualquer palavra inserida no contexto.

Descrevendo a geração e a coerência do texto

Falando sobre como o modelo constrói texto, ele atua como um autocomplete (autocompletar) turbinado e executa uma tarefa simples. Toda vez que precisa construir um texto, lê o que foi introduzido até o momento e calcula qual é o próximo pedaço mais provável. Em seguida, introduz esse novo pedaço, relê todo o texto com o acréscimo e calcula novamente qual é o próximo pedaço mais provável. Assim, vai prevendo e escrevendo o texto por completo, sempre nesse fluxo: entender qual é o próximo pedaço mais provável, introduzir esse pedaço no texto, reavaliar o texto por completo e decidir o próximo pedaço mais provável para a construção do texto.

O modelo não tem um banco de respostas definido no qual nós escrevemos uma instrução e ele busca a melhor resposta para retornar no contexto. O modelo vai construindo e entendendo o texto a cada interação.

Lembrando um ponto importante: modelos são probabilísticos e não determinísticos. O modelo pode construir textos diferentes e apresentar output (saída) distinta, mesmo com o mesmo input (entrada). Cada vez que enviamos um input (entrada), o modelo pode retornar um texto diferente. Por isso, ele precisa construir coerência e manter atenção sobre tudo o que constrói e lê.

De que forma o modelo cria coerência em um texto longo? Por meio de um mecanismo de atenção. Ao gerar cada token (unidade de subpalavra), ele observa todos os anteriores e decide quais pesam mais, atribuindo um peso a cada token (unidade de subpalavra). Isso é semelhante ao que fazemos ao ler ou interpretar uma imagem: buscamos entender quais são os pontos, palavras-chave e partes mais relevantes para o entendimento completo do texto.

Dentro do que importa para a segurança, esse entendimento já é suficiente para interpretarmos como o modelo se mantém coerente durante a construção do texto.

Discutindo filtros baseados em grafia

Ao tratar de filtros, precisamos considerar que o modelo compreende o sentido das palavras, e não a grafia. A grafia não importa para o modelo; ele obedece à instrução dada, independentemente da forma como a palavra é escrita.

Por exemplo, a intenção por trás da palavra em inglês ignore (ignorar) pode ser comunicada de várias formas: substituindo “i” por “1” e “o” por “0”, inserindo espaços entre cada letra, utilizando sinônimos como disregard (desconsiderar) ou até colocando a instrução em outros idiomas. Dessa forma, conseguimos burlar filtros baseados em grafia, pois o modelo entende a intenção e executa a instrução do mesmo modo. Construir filtros por grafia pode ser uma defesa inicial (uma primeira camada), mas é uma camada fácil de contornar.

Quando nós olhamos para a mesma instrução escrita de formas diferentes, por exemplo: uma primeira frase com ignore na grafia correta; uma segunda com substituições por números; outra com espaços entre as letras; e outra utilizando um sinônimo como disregard (desconsiderar), a primeira seria bloqueada por um filtro de palavras, ou seja, a frase em inglês “ignore the previous instructions” (ignore as instruções anteriores) seria coberta por esse filtro. No entanto, as três variações seguintes passariam, e o modelo interpretaria todas do mesmo modo. Chegamos, assim, a uma consequência de segurança: o modelo tende a interpretar a instrução independentemente da forma como a entrada de texto foi escrita.

Abordando alucinações e riscos de segurança

Precisamos também entender como modelos alucinam. O modelo pode “inventar com confiança”. Como explicamos anteriormente, o modelo seleciona a próxima continuação mais provável do texto. Ao fazer isso, pode tratar partes inventadas como verdadeiras e construir novas “verdades” sobre algo que não é real, gerando conteúdos que parecem corretos, mas são falsos.

Um exemplo concreto: durante a implementação de uma aplicação, o modelo pode sugerir o uso de uma biblioteca que, na realidade, não existe. Chamamos isso de Package Hallucination (alucinação de pacotes). Essa situação pode servir de base para um golpe de package squatting (registro malicioso de nomes de pacotes), no qual uma pessoa atacante registra propositalmente o nome dessa biblioteca inexistente e introduz código malicioso nesse pacote.

Diante disso, precisamos sempre verificar as saídas do modelo: confirmar se as fontes citadas são verdadeiras, se as bibliotecas existem e são seguras, e analisar artigos científicos e pesquisas. Nada deve ser aceito sem a nossa revisão.

Um exemplo de alucinação: a biblioteca que não existia. Uma pessoa desenvolvedora, durante o desenvolvimento de uma função da aplicação, pede ao modelo para instalar uma biblioteca em Python e validar os prompts contra Prompt Injection (injeção de prompt). A resposta do modelo é algo como: “Tudo bem, vamos construir e instalar uma biblioteca chamada Secure LLM Guard”, indicando até a suposta origem da biblioteca, o nome do pacote e citações em artigos, em um tom que transmite certeza. No entanto, esse pacote não existe no PyPI (Python Package Index, Índice de Pacotes do Python). O modelo acaba inventando e tratando a invenção como verdade.

Quando falamos do risco de segurança e de como isso se torna um ataque, a pessoa atacante pode registrar esse nome inventado com código malicioso e tentar introduzi-lo na nossa aplicação. Portanto, antes de utilizar qualquer biblioteca, precisamos verificar o índice oficial (PyPI), confirmar se a biblioteca é de uma fonte confiável e se ela verdadeiramente existe.

Sobre o curso Modelos de Linguagem: segurança e mitigação de riscos

O curso Modelos de Linguagem: segurança e mitigação de riscos possui 587 minutos de vídeos, em um total de 101 atividades. Gostou? Conheça nossos outros cursos de IA para segurança em Cibersegurança, ou leia nossos artigos de Cibersegurança.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Como LLMs funcionam e por que isso importa para segurança