From aad207abce1cfef71f69572e70ef0742308480f1 Mon Sep 17 00:00:00 2001 From: emmanuelgjr <129134995+emmanuelgjr@users.noreply.github.com> Date: Wed, 11 Dec 2024 22:57:33 -0500 Subject: [PATCH] Update and rename LLM05_ImproperOutputHandling.md to LLM05_TratamentoImpropriodeSaida.md v0 Signed-off-by: emmanuelgjr <129134995+emmanuelgjr@users.noreply.github.com> --- .../pt-BR/LLM05_ImproperOutputHandling.md | 59 ----------------- .../pt-BR/LLM05_TratamentoImpropriodeSaida.md | 66 +++++++++++++++++++ 2 files changed, 66 insertions(+), 59 deletions(-) delete mode 100644 2_0_vulns/translations/pt-BR/LLM05_ImproperOutputHandling.md create mode 100644 2_0_vulns/translations/pt-BR/LLM05_TratamentoImpropriodeSaida.md diff --git a/2_0_vulns/translations/pt-BR/LLM05_ImproperOutputHandling.md b/2_0_vulns/translations/pt-BR/LLM05_ImproperOutputHandling.md deleted file mode 100644 index 734e4087..00000000 --- a/2_0_vulns/translations/pt-BR/LLM05_ImproperOutputHandling.md +++ /dev/null @@ -1,59 +0,0 @@ -## LLM05:2025 Improper Output Handling - -### Description - -Improper Output Handling refers specifically to insufficient validation, sanitization, and handling of the outputs generated by large language models before they are passed downstream to other components and systems. Since LLM-generated content can be controlled by prompt input, this behavior is similar to providing users indirect access to additional functionality. -Improper Output Handling differs from Overreliance in that it deals with LLM-generated outputs before they are passed downstream whereas Overreliance focuses on broader concerns around overdependence on the accuracy and appropriateness of LLM outputs. -Successful exploitation of an Improper Output Handling vulnerability can result in XSS and CSRF in web browsers as well as SSRF, privilege escalation, or remote code execution on backend systems. -The following conditions can increase the impact of this vulnerability: -- The application grants the LLM privileges beyond what is intended for end users, enabling escalation of privileges or remote code execution. -- The application is vulnerable to indirect prompt injection attacks, which could allow an attacker to gain privileged access to a target user's environment. -- 3rd party extensions do not adequately validate inputs. -- Lack of proper output encoding for different contexts (e.g., HTML, JavaScript, SQL) -- Insufficient monitoring and logging of LLM outputs -- Absence of rate limiting or anomaly detection for LLM usage - -### Common Examples of Vulnerability - -1. LLM output is entered directly into a system shell or similar function such as exec or eval, resulting in remote code execution. -2. JavaScript or Markdown is generated by the LLM and returned to a user. The code is then interpreted by the browser, resulting in XSS. -3. LLM-generated SQL queries are executed without proper parameterization, leading to SQL injection. -4. LLM output is used to construct file paths without proper sanitization, potentially resulting in path traversal vulnerabilities. -5. LLM-generated content is used in email templates without proper escaping, potentially leading to phishing attacks. - -### Prevention and Mitigation Strategies - -1. Treat the model as any other user, adopting a zero-trust approach, and apply proper input validation on responses coming from the model to backend functions. -2. Follow the OWASP ASVS (Application Security Verification Standard) guidelines to ensure effective input validation and sanitization. -3. Encode model output back to users to mitigate undesired code execution by JavaScript or Markdown. OWASP ASVS provides detailed guidance on output encoding. -4. Implement context-aware output encoding based on where the LLM output will be used (e.g., HTML encoding for web content, SQL escaping for database queries). -5. Use parameterized queries or prepared statements for all database operations involving LLM output. -6. Employ strict Content Security Policies (CSP) to mitigate the risk of XSS attacks from LLM-generated content. -7. Implement robust logging and monitoring systems to detect unusual patterns in LLM outputs that might indicate exploitation attempts. - -### Example Attack Scenarios - -#### Scenario #1 - An application utilizes an LLM extension to generate responses for a chatbot feature. The extension also offers a number of administrative functions accessible to another privileged LLM. The general purpose LLM directly passes its response, without proper output validation, to the extension causing the extension to shut down for maintenance. -#### Scenario #2 - A user utilizes a website summarizer tool powered by an LLM to generate a concise summary of an article. The website includes a prompt injection instructing the LLM to capture sensitive content from either the website or from the user's conversation. From there the LLM can encode the sensitive data and send it, without any output validation or filtering, to an attacker-controlled server. -#### Scenario #3 - An LLM allows users to craft SQL queries for a backend database through a chat-like feature. A user requests a query to delete all database tables. If the crafted query from the LLM is not scrutinized, then all database tables will be deleted. -#### Scenario #4 - A web app uses an LLM to generate content from user text prompts without output sanitization. An attacker could submit a crafted prompt causing the LLM to return an unsanitized JavaScript payload, leading to XSS when rendered on a victim's browser. Insufficient validation of prompts enabled this attack. -#### Scenario # 5 - An LLM is used to generate dynamic email templates for a marketing campaign. An attacker manipulates the LLM to include malicious JavaScript within the email content. If the application doesn't properly sanitize the LLM output, this could lead to XSS attacks on recipients who view the email in vulnerable email clients. -#### Scenario #6 - An LLM is used to generate code from natural language inputs in a software company, aiming to streamline development tasks. While efficient, this approach risks exposing sensitive information, creating insecure data handling methods, or introducing vulnerabilities like SQL injection. The AI may also hallucinate non-existent software packages, potentially leading developers to download malware-infected resources. Thorough code review and verification of suggested packages are crucial to prevent security breaches, unauthorized access, and system compromises. - -### Reference Links - -1. [Proof Pudding (CVE-2019-20634)](https://avidml.org/database/avid-2023-v009/) **AVID** (`moohax` & `monoxgas`) -2. [Arbitrary Code Execution](https://security.snyk.io/vuln/SNYK-PYTHON-LANGCHAIN-5411357): **Snyk Security Blog** -3. [ChatGPT Plugin Exploit Explained: From Prompt Injection to Accessing Private Data](https://embracethered.com/blog/posts/2023/chatgpt-cross-plugin-request-forgery-and-prompt-injection./): **Embrace The Red** -4. [New prompt injection attack on ChatGPT web version. Markdown images can steal your chat data.](https://systemweakness.com/new-prompt-injection-attack-on-chatgpt-web-version-ef717492c5c2?gi=8daec85e2116): **System Weakness** -5. [Don’t blindly trust LLM responses. Threats to chatbots](https://embracethered.com/blog/posts/2023/ai-injections-threats-context-matters/): **Embrace The Red** -6. [Threat Modeling LLM Applications](https://aivillage.org/large%20language%20models/threat-modeling-llm/): **AI Village** -7. [OWASP ASVS - 5 Validation, Sanitization and Encoding](https://owasp-aasvs4.readthedocs.io/en/latest/V5.html#validation-sanitization-and-encoding): **OWASP AASVS** -8. [AI hallucinates software packages and devs download them – even if potentially poisoned with malware](https://www.theregister.com/2024/03/28/ai_bots_hallucinate_software_packages/) **Theregiste** - diff --git a/2_0_vulns/translations/pt-BR/LLM05_TratamentoImpropriodeSaida.md b/2_0_vulns/translations/pt-BR/LLM05_TratamentoImpropriodeSaida.md new file mode 100644 index 00000000..a350133f --- /dev/null +++ b/2_0_vulns/translations/pt-BR/LLM05_TratamentoImpropriodeSaida.md @@ -0,0 +1,66 @@ +## LLM05:2025 Tratamento Impróprio de Saída + +### Descrição + +Tratamento Impróprio de Saída refere-se à validação, sanitização e manipulação insuficientes das saídas geradas por grandes modelos de linguagem (LLMs) antes de serem passadas para outros componentes e sistemas. Como o conteúdo gerado pelos LLMs pode ser controlado pela entrada de prompts, esse comportamento é semelhante a fornecer aos usuários acesso indireto a funcionalidades adicionais. + +Tratamento Impróprio de Saída difere de Dependência Excessiva, pois aborda as saídas geradas pelos LLMs antes de serem transmitidas, enquanto Dependência Excessiva enfoca preocupações mais amplas sobre a precisão e adequação das saídas dos LLMs. + +A exploração bem-sucedida de uma vulnerabilidade de Tratamento Impróprio de Saída pode resultar em XSS e CSRF em navegadores da web, bem como SSRF, escalonamento de privilégios ou execução remota de código em sistemas de backend. + +As seguintes condições podem aumentar o impacto dessa vulnerabilidade: +- A aplicação concede ao LLM privilégios além do que é intencionado para os usuários finais, possibilitando escalonamento de privilégios ou execução remota de código. +- A aplicação é vulnerável a ataques indiretos de injeção de prompts, permitindo que um invasor obtenha acesso privilegiado ao ambiente de um usuário-alvo. +- Extensões de terceiros não validam adequadamente as entradas. +- Falta de codificação de saída apropriada para diferentes contextos (e.g., HTML, JavaScript, SQL). +- Monitoramento e registro insuficientes das saídas dos LLMs. +- Ausência de limitação de taxa ou detecção de anomalias para o uso de LLMs. + +### Exemplos Comuns de Vulnerabilidades + +1. A saída do LLM é inserida diretamente em um shell do sistema ou função similar, como `exec` ou `eval`, resultando em execução remota de código. +2. JavaScript ou Markdown gerado pelo LLM é retornado ao usuário e interpretado pelo navegador, resultando em XSS. +3. Consultas SQL geradas pelo LLM são executadas sem a devida parametrização, levando a injeção de SQL. +4. A saída do LLM é usada para construir caminhos de arquivos sem sanitização adequada, resultando em vulnerabilidades de travessia de diretórios. +5. Conteúdo gerado pelo LLM é usado em modelos de e-mail sem escape adequado, possibilitando ataques de phishing. + +### Estratégias de Prevenção e Mitigação + +1. Trate o modelo como qualquer outro usuário, adotando uma abordagem de confiança zero e aplicando validação adequada nas respostas provenientes do modelo para funções de backend. +2. Siga as diretrizes do OWASP ASVS (Padrão de Verificação de Segurança de Aplicações) para garantir validação e sanitização de entrada eficazes. +3. Codifique as saídas do modelo para os usuários, mitigando a execução indesejada de código em JavaScript ou Markdown. O OWASP ASVS fornece orientações detalhadas sobre codificação de saída. +4. Implemente codificação de saída sensível ao contexto com base no uso das saídas do LLM (e.g., codificação HTML para conteúdo da web, escape SQL para consultas de banco de dados). +5. Use consultas parametrizadas ou instruções preparadas para todas as operações de banco de dados envolvendo saídas do LLM. +6. Adote Políticas de Segurança de Conteúdo (CSP) rigorosas para mitigar o risco de ataques XSS provenientes de conteúdo gerado por LLMs. +7. Implemente sistemas robustos de registro e monitoramento para detectar padrões incomuns nas saídas dos LLMs que possam indicar tentativas de exploração. + +### Cenários de Ataques Exemplares + +#### Cenário #1 + Uma aplicação utiliza uma extensão LLM para gerar respostas para um recurso de chatbot. A extensão também oferece diversas funções administrativas acessíveis a outro LLM privilegiado. O LLM de uso geral passa diretamente sua resposta, sem validação adequada, para a extensão, fazendo com que ela entre em manutenção. + +#### Cenário #2 + Um usuário utiliza uma ferramenta de resumo de websites alimentada por um LLM para gerar um resumo de um artigo. O site inclui uma injeção de prompt instruindo o LLM a capturar conteúdo sensível do site ou da conversa do usuário. O LLM então envia os dados capturados, sem validação ou filtragem, para um servidor controlado pelo invasor. + +#### Cenário #3 + Um LLM permite que usuários criem consultas SQL para um banco de dados de backend por meio de uma interface de chat. Um usuário solicita uma consulta para excluir todas as tabelas do banco de dados. Se a consulta criada pelo LLM não for analisada, todas as tabelas do banco de dados serão excluídas. + +#### Cenário #4 + Um aplicativo da web usa um LLM para gerar conteúdo a partir de prompts de texto de usuários sem sanitização das saídas. Um invasor pode enviar um prompt criado para fazer o LLM retornar um payload JavaScript não sanitizado, levando a XSS ao ser renderizado no navegador de uma vítima. + +#### Cenário #5 + Um LLM é usado para gerar modelos dinâmicos de e-mails para uma campanha de marketing. Um invasor manipula o LLM para incluir JavaScript malicioso no conteúdo do e-mail. Se a aplicação não sanitizar adequadamente a saída do LLM, isso pode levar a ataques XSS em destinatários que visualizem o e-mail em clientes vulneráveis. + +#### Cenário #6 + Um LLM é usado para gerar código a partir de entradas em linguagem natural em uma empresa de software, visando simplificar tarefas de desenvolvimento. Esse método pode expor informações sensíveis, criar métodos inseguros de manipulação de dados ou introduzir vulnerabilidades como injeção de SQL. A revisão minuciosa do código e a verificação de pacotes sugeridos são cruciais para evitar violações de segurança, acessos não autorizados e comprometimentos do sistema. + +### Links de Referência + +1. [Proof Pudding (CVE-2019-20634)](https://avidml.org/database/avid-2023-v009/) **AVID** (`moohax` & `monoxgas`) +2. [Arbitrary Code Execution](https://security.snyk.io/vuln/SNYK-PYTHON-LANGCHAIN-5411357): **Snyk Security Blog** +3. [ChatGPT Plugin Exploit Explained: From Prompt Injection to Accessing Private Data](https://embracethered.com/blog/posts/2023/chatgpt-cross-plugin-request-forgery-and-prompt-injection./): **Embrace The Red** +4. [New prompt injection attack on ChatGPT web version. Markdown images can steal your chat data.](https://systemweakness.com/new-prompt-injection-attack-on-chatgpt-web-version-ef717492c5c2?gi=8daec85e2116): **System Weakness** +5. [Don’t blindly trust LLM responses. Threats to chatbots](https://embracethered.com/blog/posts/2023/ai-injections-threats-context-matters/): **Embrace The Red** +6. [Threat Modeling LLM Applications](https://aivillage.org/large%20language%20models/threat-modeling-llm/): **AI Village** +7. [OWASP ASVS - 5 Validation, Sanitization and Encoding](https://owasp-aasvs4.readthedocs.io/en/latest/V5.html#validation-sanitization-and-encoding): **OWASP AASVS** +8. [AI hallucinates software packages and devs download them – even if potentially poisoned with malware](https://www.theregister.com/2024/03/28/ai_bots_hallucinate_software_packages/): **Theregister**