diff --git a/2_0_vulns/translations/pt-BR/LLM07_SystemPromptLeakage.md b/2_0_vulns/translations/pt-BR/LLM07_SystemPromptLeakage.md deleted file mode 100644 index 16fe235d..00000000 --- a/2_0_vulns/translations/pt-BR/LLM07_SystemPromptLeakage.md +++ /dev/null @@ -1,59 +0,0 @@ -## LLM07:2025 System Prompt Leakage - -### Description - -The system prompt leakage vulnerability in LLMs refers to the risk that the system prompts or instructions used to steer the behavior of the model can also contain sensitive information that was not intended to be discovered. System prompts are designed to guide the model's output based on the requirements of the application, but may inadvertently contain secrets. When discovered, this information can be used to facilitate other attacks. - -It's important to understand that the system prompt should not be considered a secret, nor should it be used as a security control. Accordingly, sensitive data such as credentials, connection strings, etc. should not be contained within the system prompt language. - -Similarly, if a system prompt contains information describing different roles and permissions, or sensitive data like connection strings or passwords, while the disclosure of such information may be helpful, the fundamental security risk is not that these have been disclosed, it is that the application allows bypassing strong session management and authorization checks by delegating these to the LLM, and that sensitive data is being stored in a place that it should not be. - -In short: disclosure of the system prompt itself does not present the real risk -- the security risk lies with the underlying elements, whether that be sensitive information disclosure, system guardrails bypass, improper separation of privileges, etc. Even if the exact wording is not disclosed, attackers interacting with the system will almost certainly be able to determine many of the guardrails and formatting restrictions that are present in system prompt language in the course of using the application, sending utterances to the model, and observing the results. - -### Common Examples of Risk - -#### 1. Exposure of Sensitive Functionality - The system prompt of the application may reveal sensitive information or functionality that is intended to be kept confidential, such as sensitive system architecture, API keys, database credentials, or user tokens. These can be extracted or used by attackers to gain unauthorized access into the application. For example, a system prompt that contains the type of database used for a tool could allow the attacker to target it for SQL injection attacks. -#### 2. Exposure of Internal Rules - The system prompt of the application reveals information on internal decision-making processes that should be kept confidential. This information allows attackers to gain insights into how the application works which could allow attackers to exploit weaknesses or bypass controls in the application. For example - There is a banking application that has a chatbot and its system prompt may reveal information like - >"The Transaction limit is set to $5000 per day for a user. The Total Loan Amount for a user is $10,000". - This information allows the attackers to bypass the security controls in the application like doing transactions more than the set limit or bypassing the total loan amount. -#### 3. Revealing of Filtering Criteria - A system prompt might ask the model to filter or reject sensitive content. For example, a model might have a system prompt like, - >“If a user requests information about another user, always respond with ‘Sorry, I cannot assist with that request’”. -#### 4. Disclosure of Permissions and User Roles - The system prompt could reveal the internal role structures or permission levels of the application. For instance, a system prompt might reveal, - >“Admin user role grants full access to modify user records.” - If the attackers learn about these role-based permissions, they could look for a privilege escalation attack. - -### Prevention and Mitigation Strategies - -#### 1. Separate Sensitive Data from System Prompts - Avoid embedding any sensitive information (e.g. API keys, auth keys, database names, user roles, permission structure of the application) directly in the system prompts. Instead, externalize such information to the systems that the model does not directly access. -#### 2. Avoid Reliance on System Prompts for Strict Behavior Control - Since LLMs are susceptible to other attacks like prompt injections which can alter the system prompt, it is recommended to avoid using system prompts to control the model behavior where possible. Instead, rely on systems outside of the LLM to ensure this behavior. For example, detecting and preventing harmful content should be done in external systems. -#### 3. Implement Guardrails - Implement a system of guardrails outside of the LLM itself. While training particular behavior into a model can be effective, such as training it not to reveal its system prompt, it is not a guarantee that the model will always adhere to this. An independent system that can inspect the output to determine if the model is in compliance with expectations is preferable to system prompt instructions. -#### 4. Ensure that security controls are enforced independently from the LLM - Critical controls such as privilege separation, authorization bounds checks, and similar must not be delegated to the LLM, either through the system prompt or otherwise. These controls need to occur in a deterministic, auditable manner, and LLMs are not (currently) conducive to this. In cases where an agent is performing tasks, if those tasks require different levels of access, then multiple agents should be used, each configured with the least privileges needed to perform the desired tasks. - -### Example Attack Scenarios - -#### Scenario #1 - An LLM has a system prompt that contains a set of credentials used for a tool that it has been given access to. The system prompt is leaked to an attacker, who then is able to use these credentials for other purposes. -#### Scenario #2 - An LLM has a system prompt prohibiting the generation of offensive content, external links, and code execution. An attacker extracts this system prompt and then uses a prompt injection attack to bypass these instructions, facilitating a remote code execution attack. - -### Reference Links - -1. [SYSTEM PROMPT LEAK](https://x.com/elder_plinius/status/1801393358964994062): Pliny the prompter -2. [Prompt Leak](https://www.prompt.security/vulnerabilities/prompt-leak): Prompt Security -3. [chatgpt_system_prompt](https://github.com/LouisShark/chatgpt_system_prompt): LouisShark -4. [leaked-system-prompts](https://github.com/jujumilk3/leaked-system-prompts): Jujumilk3 -5. [OpenAI Advanced Voice Mode System Prompt](https://x.com/Green_terminals/status/1839141326329360579): Green_Terminals - -### Related Frameworks and Taxonomies - -Refer to this section for comprehensive information, scenarios strategies relating to infrastructure deployment, applied environment controls and other best practices. - -- [AML.T0051.000 - LLM Prompt Injection: Direct (Meta Prompt Extraction)](https://atlas.mitre.org/techniques/AML.T0051.000) **MITRE ATLAS** diff --git a/2_0_vulns/translations/pt-BR/LLM07_VazamentodePromptdoSistema.md b/2_0_vulns/translations/pt-BR/LLM07_VazamentodePromptdoSistema.md new file mode 100644 index 00000000..43e7142a --- /dev/null +++ b/2_0_vulns/translations/pt-BR/LLM07_VazamentodePromptdoSistema.md @@ -0,0 +1,66 @@ +## LLM07:2025 Vazamento de Prompt do Sistema + +### Descrição + +A vulnerabilidade de vazamento de prompt do sistema em LLMs refere-se ao risco de que os prompts do sistema ou instruções usados para orientar o comportamento do modelo possam conter informações sensíveis que não deveriam ser descobertas. Prompts do sistema são projetados para guiar a saída do modelo com base nos requisitos da aplicação, mas podem, inadvertidamente, conter segredos. Quando descobertas, essas informações podem ser usadas para facilitar outros ataques. + +É importante entender que o prompt do sistema não deve ser considerado um segredo, nem utilizado como um controle de segurança. Assim, dados sensíveis como credenciais, strings de conexão, etc., não devem estar contidos na linguagem do prompt do sistema. + +Da mesma forma, se um prompt do sistema contém informações sobre diferentes papéis e permissões, ou dados sensíveis como strings de conexão ou senhas, o problema fundamental de segurança não é que esses dados foram divulgados, mas que a aplicação permite a violação de gerenciamento de sessão e verificações de autorização robustas ao delegar essas tarefas ao LLM, além de armazenar dados sensíveis em locais inadequados. + +Em resumo: a divulgação do próprio prompt do sistema não apresenta o risco real – o risco de segurança reside nos elementos subjacentes, seja divulgação de informações sensíveis, violação de restrições do sistema, separação inadequada de privilégios, etc. Mesmo que a redação exata não seja divulgada, atacantes interagindo com o sistema quase certamente serão capazes de deduzir muitos dos controles e restrições de formatação presentes na linguagem do prompt do sistema ao usar a aplicação, enviando comandos ao modelo e observando os resultados. + +### Exemplos Comuns de Risco + +#### 1. Exposição de Funcionalidade Sensível + O prompt do sistema pode revelar informações ou funcionalidades confidenciais, como arquitetura interna do sistema, chaves de API, credenciais de banco de dados ou tokens de usuários. Essas informações podem ser extraídas ou usadas por atacantes para obter acesso não autorizado à aplicação. Exemplo: um prompt do sistema que contém o tipo de banco de dados usado pode permitir que um atacante o direcione para ataques de injeção de SQL. + +#### 2. Exposição de Regras Internas + O prompt do sistema revela processos de tomada de decisão interna que deveriam ser mantidos confidenciais. Essas informações podem permitir que atacantes explorem fraquezas ou contornem controles da aplicação. Exemplo: em um aplicativo bancário, um prompt pode conter: + > "O limite de transação é de $5000 por dia para um usuário. O limite total de empréstimo é de $10.000." + Essas informações podem permitir que atacantes contornem limites de segurança, como realizar transações acima do limite estabelecido. + +#### 3. Divulgação de Critérios de Filtragem + Um prompt do sistema pode solicitar ao modelo que filtre ou rejeite conteúdo sensível. Exemplo: + > "Se um usuário solicitar informações sobre outro usuário, sempre responda com: ‘Desculpe, não posso ajudar com essa solicitação.’" + +#### 4. Divulgação de Permissões e Papéis de Usuário + O prompt do sistema pode revelar estruturas internas de papéis ou níveis de permissão. Exemplo: + > "O papel de administrador concede acesso total para modificar registros de usuários." + Se os atacantes descobrirem essas permissões, podem tentar ataques de escalonamento de privilégios. + +### Estratégias de Prevenção e Mitigação + +#### 1. Separe Dados Sensíveis dos Prompts do Sistema + Evite incorporar informações sensíveis (e.g., chaves de API, chaves de autenticação, nomes de banco de dados, papéis de usuários, estrutura de permissões) diretamente nos prompts do sistema. Externize esses dados para sistemas aos quais o modelo não tenha acesso direto. + +#### 2. Evite Dependência de Prompts do Sistema para Controle Rigoroso de Comportamento + Como os LLMs são suscetíveis a ataques como injeções de prompts, recomenda-se evitar o uso de prompts do sistema para controlar o comportamento do modelo sempre que possível. Utilize sistemas externos ao LLM para garantir esses comportamentos. + +#### 3. Implemente Guardrails + Estabeleça um sistema de barreiras externas ao próprio LLM. Embora treinar comportamentos específicos no modelo seja eficaz, como ensiná-lo a não revelar seu prompt do sistema, isso não garante que o modelo sempre seguirá essas instruções. Um sistema independente que inspecione as saídas para verificar conformidade com as expectativas é preferível a confiar apenas nas instruções do prompt do sistema. + +#### 4. Garanta que controles de segurança sejam aplicados independentemente do LLM + Controles críticos, como separação de privilégios e verificações de limites de autorização, não devem ser delegados ao LLM, seja por meio do prompt do sistema ou de outra forma. Esses controles devem ocorrer de maneira determinística e auditável. Em casos onde um agente realiza tarefas que exigem diferentes níveis de acesso, múltiplos agentes devem ser usados, cada um configurado com os privilégios mínimos necessários para realizar as tarefas. + +### Cenários de Ataques Exemplares + +#### Cenário #1 + Um LLM possui um prompt do sistema que contém credenciais usadas para uma ferramenta à qual ele tem acesso. O prompt do sistema é vazado para um atacante, que então usa essas credenciais para outros fins. + +#### Cenário #2 + Um LLM tem um prompt do sistema proibindo a geração de conteúdo ofensivo, links externos e execução de código. Um atacante extrai esse prompt e utiliza um ataque de injeção de prompt para contornar essas instruções, facilitando um ataque de execução remota de código. + +### Links de Referência + +1. [SYSTEM PROMPT LEAK](https://x.com/elder_plinius/status/1801393358964994062): **Pliny the Prompter** +2. [Prompt Leak](https://www.prompt.security/vulnerabilities/prompt-leak): **Prompt Security** +3. [chatgpt_system_prompt](https://github.com/LouisShark/chatgpt_system_prompt): **LouisShark** +4. [leaked-system-prompts](https://github.com/jujumilk3/leaked-system-prompts): **Jujumilk3** +5. [OpenAI Advanced Voice Mode System Prompt](https://x.com/Green_terminals/status/1839141326329360579): **Green_Terminals** + +### Frameworks e Taxonomias Relacionados + +Consulte esta seção para informações abrangentes, cenários e estratégias relacionados à implantação de infraestrutura, controles no ambiente aplicado e outras melhores práticas. + +- [AML.T0051.000 - LLM Prompt Injection: Direct (Meta Prompt Extraction)](https://atlas.mitre.org/techniques/AML.T0051.000): **MITRE ATLAS**