AI Guard: Navigating the OWASP Top 10 with LLMs

Artificial Intelligence (AI) is emerging as a pillar of innovation in the digital age, driving advancements across various industries, including cybersecurity. At the forefront of this transformation are large language models (LLMs), AI systems capable of comprehending, generating, and interacting with human language on a vast scale. However, as LLMs are increasingly adopted, ensuring security has become a critical concern. A thorough understanding of potential vulnerabilities is essential to safeguarding the availability, integrity, and confidentiality of the systems they operate.

Examples of LLMs: GPT (Generative Pre-trained Transformer) Series by OpenAI, DALL·E by OpenAI, Gemini by Google, etc.

Note: The Open Web Application Security Project (OWASP) is a non-profit foundation that works to improve the security of software through its community-led open-source software projects, hundreds of chapters worldwide, tens of thousands of members, and by hosting conferences and educational events.

LLMs: What are they?

Large Language Models (LLMs) are advanced artificial intelligence systems designed to comprehend and generate human-like text based on their input. They undergo training on massive datasets, often comprising billions or trillions of words, enabling them to respond to questions and requests in a highly human-sounding manner. LLMs can produce a wide range of texts, including emails, songs, computer code, and poems. They excel in language translation by considering word context and cultural nuances, and they adeptly simplify complex information to enhance comprehension, leveraging vast knowledge to provide detailed answers to inquiries.

The OWASP Top 10 for LLMs: An in-depth look

The adaptation of the OWASP Top 10 for LLMs has been an important first step in identifying and mitigating the risks posed by these advanced AI models. This section assesses each risk, detailing its implications and the corresponding preventive measures.

LLM01: Prompt Injection

Description:

Malicious adversaries can manipulate large language models (LLMs) by crafting inputs that trigger unauthorized actions, leading to data breaches or compromised decision-making. Such manipulations may also erode the trustworthiness of automated systems, potentially causing users to question the reliability of AI-generated content.

There are two primary types of prompt injection: direct and indirect.

1. Direct Prompt Injection:
   • The attacker directly interacts with the LLM interface in this method, providing a crafted prompt designed to exploit the model’s response generation capabilities.
   • The attacker’s goal might be to bypass filters, extract sensitive information, or trigger the model to produce harmful content.
   • Direct prompt injection relies on the attacker’s ability to access the model’s input interface and understand how to formulate prompts that lead to the desired malicious output.
2. Indirect Prompt Injection:
   • Indirect prompt injection involves manipulating the model’s output without directly interacting with the prompt interface. Instead, attackers influence the model indirectly, such as through the data the model has been trained on or external data sources it might access.
   • This could involve tampering with the training data (data poisoning) to bias the model’s responses or manipulating external sources of information that the model uses to generate responses.
   • Indirect prompt injection is more subtle and can be harder to detect because it exploits the model’s underlying data processing mechanisms rather than its direct input-output interface.

Real-World Examples:

• A malicious user manipulates a Large Language Model (LLM) by injecting a specially crafted prompt. This prompt causes the LLM to disregard the instructions set by the application’s creator and execute a command that retrieves private, harmful, or otherwise inappropriate information.
• A malicious user submits a resume with a subtle command designed to manipulate the Large Language Model (LLM). This command is crafted to prompt the LLM to inform users that the document is outstanding, such as being an excellent choice for a job position. When an internal user uses the LLM to summarize the resume, the summary generated by the LLM incorrectly reports that the document is excellent.

Technical Impact:

Prompt injection attacks on Large Language Models (LLMs) can compromise data integrity, weaken user trust, and lead to significant financial losses from breaches and legal penalties. They also disrupt business operations by necessitating major security updates and damage control efforts, impacting a company’s reputation and competitive edge in the market.

Business Impact:

Systems may execute unintended actions or disclose sensitive information. Such occurrences can compromise user privacy and undermine the integrity of data security protocols.

Prevention:

1. Robust Input Validation:
   • Develop sophisticated algorithms to scrutinize user prompts for signs of malicious intent or content. This involves analyzing the syntax and semantics of inputs to filter out attempts to exploit the LLM.
2. Context-aware Filtering Systems:
   • Employ filtering mechanisms that understand the context and intent behind prompts. This allows the system to distinguish between benign and potentially harmful inputs, thereby reducing false positives while effectively blocking malicious activities.
3. Predefined Prompt Structures:
   • Use templates or structured prompt formats to limit the LLM’s interpretation capabilities within predefined boundaries. Constraining the commands the model can execute minimizes the risk of unauthorized actions.
4. Enhanced Natural Language Understanding (NLU):
   • To enhance the Natural Language Understanding (NLU) of Large Language Models (LLMs), it’s important to train them to pick up on subtle cues in language. This improved attention to detail helps them better interpret the true intentions behind words, especially when someone attempts to trick or manipulate the model with ambiguous or misleading prompts. By enhancing their NLU capabilities, these models can respond more accurately and protect themselves from potential misuse.
5. Regular Training Data Updates:
   • Continuously update the model’s training data with a diverse set of ethical and unbiased examples. This adaptation helps the LLM recognize and adjust to new patterns of legitimate use and potential abuse, making it less prone to manipulation.
6. Access Control:
   • Implement strict access control measures for interacting with the LLM. By controlling who can access the LLM and under what conditions, you can prevent unauthorized use and reduce the risk of injection attacks from occurring.
7. Separation of External Content:
   • Design a system to segregate external content or data from user-submitted prompts. This separation enhances overall security by preventing the inadvertent processing of potentially harmful external data as part of the prompt.

LLM02: Insecure Output Handling

Description:

Without proper validation, LLM outputs can lead to security breaches, including code execution that compromises systems. In some scenarios, this vulnerability can lead to consequences such as Cross-Site Scripting (XSS), Cross-Site Request Forgery (CSRF), Server-Side Request Forgery (SSRF), and remote code execution on backend systems.

Real-World Examples:

• An LLM plugin is utilized by an application to generate chatbot responses. However, without conducting necessary validation, the application directly delivers the LLM-generated response to an internal function responsible for executing system commands. This scenario enables an attacker to gain unauthorized access or inadvertently modify the system by manipulating the LLM output to execute arbitrary commands on the underlying system.
• There is a website where users input text, and it utilizes an LLM to generate responses. However, there is a caveat: the website does not validate the input. Therefore, if someone enters a malicious command, they could manipulate the website into generating dangerous SQL injection queries instead of standard text.

Technical Impact:

Insecure output handling in LLMs can lead to significant technical vulnerabilities, exposing systems to SQL injections, XSS, and other security threats. These vulnerabilities compromise data integrity and system stability, thereby increasing the risk of unauthorized access and manipulation of sensitive data.

Business Impact:

From a business perspective, insecure output handling can undermine customer trust and invite costly data breaches, regulatory scrutiny, and penalties. Such incidents can cause operational disruptions, tarnish the company’s reputation, and result in lost revenue and competitive disadvantage.

Prevention:

1. Comprehensive Content Sanitization:
   • Apply comprehensive sanitization procedures to the content produced by LLMs to eliminate any malicious elements and mitigate unintended security threats.
2. Strict Content Filtering:
   • Set up rigorous rules for content filtering to guarantee that only secure and approved information is allowed in the LLM’s output, thereby reducing the chances of insecure outcomes.
3. Robust Output Validation:
   • Implement strong validation checks for outputs to confirm both the integrity and security of the content before it is processed by backend systems, thus preventing potential exploits.
4. Code Interpretation Mitigation:
   • Prevent misinterpretation of code by encoding the model’s output before it is displayed to users.
5. Output Sanitization and Monitoring:
   • Develop routines for output sanitization and continuously monitor the responses from LLMs for any unusual activity.

LLM03: Training Data Poisoning

Description:

Data plays a vital role in the development of large language models (LLMs) across several stages: pre-training enhances language understanding, fine-tuning allows for quality improvements, and embedding integrates specialized knowledge.

However, these critical datasets are vulnerable to interference, which can allow attackers to alter them. This type of interference, often referred to as poisoning, has the potential to degrade the performance of LLMs and generate content with malicious intent. Compromised training data can distort LLMs’ responses, impacting their security, accuracy, and adherence to ethical guidelines.

Real-World Examples:

• A competitor or malicious actor aims to provide harmful or misleading documents directed at a model’s training data, thereby training the model through inputs. This forged information is used by the victim model during training, and the result is outputs of generative AI prompts to users.
• During the early training stage, someone sneaks in false information that affects the AI’s knowledge on certain topics. Later, when this AI is used, it might give biased or incorrect answers because of that false information.

Technical Impact:

Training data poisoning can degrade the performance and reliability of large language models (LLMs), leading to inaccurate or biased outputs. This vulnerability can directly impact the functionality of AI applications, causing them to fail in critical decision-making scenarios.

Business Impact:

From a business perspective, training data poisoning can undermine trust in AI systems, potentially resulting in a loss of customer confidence and market share. The financial costs of mitigating such attacks and dealing with their aftermath can be substantial, affecting a company’s overall profitability and operational efficiency.

Prevention:

1. Validate Training Data:
   • Thoroughly validate and examine training data at each stage to detect and mitigate potential poisoning attempts.
2. Implement Sandboxing:
   • Ensure robust sandboxing measures to prevent the model from inadvertently accessing unintended data sources.
3. Restrict Data Access:
   • Restrict access to training datasets, allowing only authorized personnel to modify or contribute to the data, thereby reducing the risk of malicious tampering.
4. Diverse Training Examples:
   • Incorporate diverse and representative examples in training datasets to mitigate the impact of biased or manipulated inputs.
5. Stringent Vetting of Inputs:
   • Implement stringent vetting or input filters for specific training data or categories of data sources to enhance security and prevent undesired data scraping. Secure the training data pipeline and apply strict input filters or validation to training data sets or data source types.

LLM04: Model Denial of Service

Description:

Operations that demand high resources can burden large language models (LLMs), leading to operational interruptions and economic challenges. A Model Denial of Service attack occurs when an LLM is deliberately flooded with excessive requests or inputs, impairing its normal function. Such attacks can cause the model to be temporarily or permanently unavailable, thereby affecting its usual performance and response times.

Real-World Examples:

• An attacker constantly floods the LLM with input larger than its context window. The attacker might exceed the LLM’s processing capacity by sending a large amount of data using automated applications or tools. Because of this, the LLM uses an excessive amount of processing power, which causes the system to slow down or stop responding altogether significantly.
• Variable-length input flood: The attacker overwhelms the LLM by sending a lot of inputs of different lengths, each one just long enough to max out the model’s capacity to handle data. This method tries to take advantage of how the LLM processes inputs of varying sizes, putting too much pressure on it and possibly making it stop responding.

Technical Impact:

A Model Denial of Service (DoS) attack on large language models (LLMs) can severely disrupt these systems’ operational capabilities. The model can become overloaded with excessive requests, leading to prolonged response times or total unavailability. This disruption compromises the model’s ability to process legitimate queries efficiently, impacting service reliability and data processing continuity.

Business Impact:

From a business standpoint, a Model Denial of Service attack can lead to significant financial losses due to downtime and the subsequent loss of user engagement or transaction revenue. It also harms the company’s reputation, potentially undermining customer trust in the stability and reliability of the services offered. Moreover, recovery and mitigation efforts can divert resources from development or expansion projects, further impacting the business’s strategic objectives.

Prevention:

1. Implement Rate Limiting:
   • Introduce rate-limiting mechanisms to control the number of requests an LLM can receive, preventing it from becoming overwhelmed.
2. Monitor Traffic Patterns:
   • Continuously monitor incoming traffic patterns to quickly identify and respond to unusual spikes that may indicate a denial-of-service attack.
3. Resource Management:
   • Manage resources effectively to accommodate the anticipated volume of requests, ensuring the LLM remains available during peak usage periods.
4. User Authentication:
   • Implement user authentication mechanisms to verify the legitimacy of requests, allowing for the prioritization of processing and protection against malicious flooding.

LLM05: Supply Chain Vulnerabilities

Description:

Dependence on compromised components or datasets can severely compromise the integrity of large language models LLMs). Vulnerabilities within the supply chain of these models pose significant risks. These vulnerabilities may include the potential compromise of training data, the machine learning models themselves, and the platforms on which they are deployed. Such compromises can result in biased outcomes, system failures, and security breaches, all of which undermine the overall integrity and reliability of the system.

Real-World Examples:

• Someone tricked model developers into downloading a harmful package from the PyPi registry. This allowed them to steal data and gain unauthorized access in the model development area.
• Vulnerabilities in traditional third-party packages, including outdated or deprecated components.

Technical Impact:

Supply chain vulnerabilities in large language models (LLMs) can lead to a cascade of technical issues. These include the injection of biased or malicious data into training datasets, corruption of machine learning algorithms, and exploitation of weaknesses in deployment platforms. Such vulnerabilities compromise LLMs’ accuracy, reliability, and security, potentially leading to system failures or incorrect data processing, directly impacting the model’s functionality and effectiveness.

Business Impact:

From a business perspective, vulnerabilities in the supply chain can have severe consequences including loss of customer trust, legal liabilities, and financial losses. When critical systems fail or data integrity is compromised, it can lead to significant disruptions in service and operations, affecting customer satisfaction and competitive advantage.

Prevention:

1. Validate Third-Party Components:
   • Ensure that all third-party components are thoroughly validated and that safe supply chain practices are implemented to safeguard system integrity.
2. Verify and Select Reliable Sources:
   • Carefully verify and select reliable sources for your models and data to ensure that they do not misuse your private information without your consent.
3. Assess Supplier Security Practices:
   • Evaluate the security practices of suppliers and collaborators involved in the supply chain, ensuring that they adhere to robust security standards.
4. Monitor and Test Security:
   • Monitor all supply chain stages, conduct comprehensive security testing to identify vulnerabilities, and implement an efficient patch management process for swift security updates.

LLM06: Sensitive Information Disclosure

Description:

If large language models (LLMs) don’t protect sensitive information well in their outputs, it can cause serious legal problems and give competitors an advantage. When building apps with LLMs, there’s a risk of accidentally using sensitive data to improve the model (a process called fine-tuning), which could lead to data leaks. For example, an LLM might accidentally share private information if not carefully controlled.

Real-World Examples:

• To cause the LLM to expose sensitive information (PII) about other application users, User A carefully crafts a series of prompts to bypass input filters and sanitization.
• Accidental disclosure of personal data in generated content.
• Leakage of proprietary information through model outputs.
• Exposing confidential business strategies or customer data.

Technical Impact:

Sensitive information disclosure can compromise data integrity and system security, necessitating costly and extensive remediation efforts to secure affected systems and prevent future incidents.

Business Impact:

Disclosure of sensitive data can damage a company’s reputation, undermine customer trust, and lead to legal penalties and regulatory fines. The financial costs of remediation, legal fees, and increased security measures can significantly impact a company’s profitability.

Prevention:

1. Data Protection Measures:
   • Implement data protection measures to ensure the training data does not include sensitive information. Properly sanitize and inspect the data before using it to train the model.
2. Thorough Data Sanitization:
   • Implement thorough data sanitization processes to remove sensitive information from the training data.
3. Educate Users:
   • Educate users about potential risks associated with sensitive data, promoting awareness and responsible use of LLM applications.
4. Enhance Transparency:
   • Enhance transparency in how LLM applications process data, providing clear information to users about how their information is utilized and protected.
5. Vendor Assurances:
   • Seek assurances from LLM vendors regarding their data handling practices and verify that they align with stringent security standards.
6. Real-Time Monitoring:
   • Implement continuous real-time monitoring mechanisms to detect and respond to unusual activities or potential data leaks.

LLM07: Insecure Plugin Design

Description:

Plugins, while providing functionalities such as web scraping and code execution, can also present significant security risks to systems like LLMs, including ChatGPT4. When lacking robust security measures, these additional software components can leave systems vulnerable to various threats. Potential exploits include the leakage of sensitive data to external parties, the injection of unauthorized prompts, and breaches in authentication within third-party applications.

Real-World Examples:

• To get weather forecasts that are incorporated in handling the user request, a plugin takes a basic URL and directs the LLM to combine the URL with a query. By creating a request that points to a domain they own, a malicious user can utilize that domain to introduce their own content into the LLM system.
• A plugin takes direct SQL or code statements instead of simpler inputs.
• A plugin processes all content from a Large Language Model (LLM) as if it were entirely user-generated and carries out any actions requested without needing further permission.

Technical Impact:

Insecure plugin design can compromise the underlying security of systems by introducing vulnerabilities such as data leaks, unauthorized access, and the execution of malicious code.

Business Impact:

From a business perspective, insecure plugins can lead to significant repercussions including loss of customer trust, damage to brand reputation, and potential legal and regulatory penalties. The financial implications of addressing security breaches, alongside the potential for lost revenue due to service disruptions, can adversely affect a company’s profitability and long-term viability.

Prevention:

1. Security-First Design:
   • Design plugins with security as a priority, implementing strong validation and checks on all inputs to close off avenues that adversaries might exploit.
2. Strict Input Controls:
   • Enforce strict parameterized input controls, including type and range checks. Introduce a second layer of typed calls for enhanced validation and sanitization.
3. Regular Inspections and Testing:
   • Thoroughly inspect and test plugins to minimize the risks associated with insecure input exploitation. Regular updates should also be part of the maintenance routine.
4. Least-Privilege Access:
   • Implement least-privilege access control principles, exposing only minimal necessary functionality while ensuring the plugin performs its intended function efficiently.
5. Robust Authentication and Authorization:
   • For effective authorisation and access control, use strong authentication mechanisms, such as OAuth2. Employ API keys specifically tailored to secure plugin routes.

LLM08: Excessive Agency

Description:

Allowing large language models (LLMs) too much autonomy without adequate oversight can result in unintended and potentially harmful outcomes. Like smart assistants, LLM Agents represent a more advanced application of this technology. Developed using frameworks like AutoGPT, these agents can interact with various tools and APIs to execute tasks. However, if these LLM Agents are granted excessive agency or freedom, they might inadvertently cause harm. This could occur through unexpected responses to inputs that jeopardize information confidentiality, integrity, and availability.

Real-World Examples:

• Excessive Functionality: An AI agent can use plugins with more features than needed. For instance, a developer might want the AI to only read documents from a place, but the plugin they pick also lets it change and delete documents. Or a plugin used during testing might be replaced by a better one, but the old plugin is still accessible to the AI.
• Excessive Permissions: An AI plugin has more access to other systems than necessary for its intended use. For example, a plugin designed just to read data ends up connecting to a database with permissions to view data and update, add, and delete it.

Technical Impact:

Excessive agency in LLMs can lead to unpredictable responses and security breaches, affecting system integrity and necessitating costly technical corrections.

Business Impact:

Excessive agency can damage a company’s reputation and trust, leading to financial losses, legal liabilities, and increased regulatory scrutiny, which can impact overall business operations.

Prevention:

1. Strict Operational Limits:
   • Implement strict operational limits on LLM autonomy and ensure there is human oversight for critical decisions and actions.
2. User Consent Requirement:
   • Ensure that LLMs obtain explicit user consent or approval before taking any actions on behalf of a user.
3. Minimize Plugin Functions:
   • Limit the functions of plugins and tools to essential capabilities only, avoiding features that could lead to unintended actions like deletion or message sending.
4. Restrict Essential Functions:
   • Confine LLM agents to necessary functionalities, ensuring that any enabled plugins or tools are strictly required for their operations.
5. Track User Authorization:
   • Enforce user authorization checks, ensuring minimum privileges are granted for actions executed in downstream systems.
6. Limit Permissions:
   • Grant minimal permissions to LLM plugins and tools, ensuring they have limited access to external systems and can only perform tasks relevant to their specific roles.
7. Authorization in Downstream Systems:
   • Implement robust authorization mechanisms in downstream systems to validate all requests against established security policies.
8. Prefer Granular Functionalities:
   • Opt for granular functionalities and broad, open-ended functions to minimize risks and enhance overall system security.

LLM09: Overreliance

Description:

Excessive reliance on outputs from large language models (LLMs) without thorough scrutiny can create security vulnerabilities and lead to poor decision-making. While LLMs and generative AI offer considerable benefits, there are significant risks when organizations depend too heavily on these technologies without adequate validation. This overdependence, coupled with insufficient oversight, can result in factual inaccuracies within the generated content, potentially spreading misinformation and leading to misguidance.

Real-World Examples:

• An LLM is used by a software development company to help developers. The developer, trusting the AI, unintentionally inserts a harmful package into the company’s application when the LLM proposes a non-existent code library or package. This highlights how important it is to double-check AI recommendations, particularly when using third-party code or libraries.
• An AI recommends bad or wrong code, creating security risks in software.
• It creates biased hiring models, leading to unfair job selection.
• An AI mishandles privacy settings, exposing private user data.

Technical Impact:

Overreliance on LLM outputs without critical evaluation can lead to technical issues such as the propagation of inaccurate or biased information and security vulnerabilities in decision-making systems. This dependency can degrade the performance and reliability of technologies, as they may not effectively handle unexpected inputs or scenarios outside their training data, leading to errors and system failures.

Business Impact:

Excessive dependence on LLMs can have serious business implications, including damage to the organization’s credibility if unreliable or incorrect outputs lead to public errors. Misinformed decisions based on flawed data can result in strategic missteps, potentially causing financial losses and undermining competitive advantage.

Prevention:

1. Cultivate Critical Evaluation:
   • Foster a culture of critical evaluation, integrating human expertise with AI insights to implement checks and balances on LLM outputs.
2. Inform Users:
   • Clearly communicate potential issues such as incorrect data or additional risks associated with using LLMs, enhancing user awareness.
3. Monitor Outputs:
   • Regularly monitor LLM outputs using techniques like self-consistency checks or voting methods to ensure reliability and accuracy.
4. Cross-Check Accuracy:
   • Validate LLM outputs by cross-checking them with trusted external sources to confirm their accuracy.
5. Enhance Model Quality:
   • Continuously improve model quality through domain-specific fine-tuning and embedding to adapt to specific needs and enhance accuracy.
6. Automatic Validation:
   • Implement automatic validation mechanisms that cross-verify generated content against known facts to prevent misinformation.
7. Secure Coding Practices:
   • Establish secure coding practices when integrating LLMs into development environments to prevent security vulnerabilities.
8. Task Management:
   • Break down complex tasks into simpler subtasks managed by different agents to mitigate risks of errors and reduce hallucination in outputs. 
9. Communicate Limitations:
   • Effectively communicate the risks and limitations of LLMs to users to ensure they make informed decisions based on a clear understanding of the technology’s capabilities and weaknesses.

LLM10: Model Theft

Description:

Unauthorized access, copying, or theft of proprietary large language models (LLMs), commonly called Model Theft, poses a serious security threat. This form of security breach can lead to significant consequences, including losing competitive advantage as proprietary innovations and strategies become exposed.

Real-World Examples:

• An attacker obtains unauthorized access to a firm’s LLM model repository by exploiting a vulnerability in the company’s infrastructure. The attacker then steals important LLM models, which they utilize to either start another language processing business or collect private data, causing significant damage to the original company’s finances.
• An adversary manages to get around the AI’s defences to carry out an attack, stealing important information about the AI’s setup and sending it to a controlled location.
• Using a side-channel attack, a malicious attacker can bypass the LLM’s input filtering mechanisms and eventually gather model weights and architecture data to send to a remotely controlled resource.

Technical Impact:

Model Theft in LLMs can compromise model integrity and expose security vulnerabilities, affecting the model’s uniqueness and leading to potential system exploits.

Business Impact:

The theft of proprietary LLMs erodes competitive advantage, resulting in financial losses and legal challenges while also damaging customer trust and business reputation.

Prevention:

1. Encrypt Models:
   • Secure models through encryption to protect data integrity and prevent unauthorized access.
2. Implement Access Controls:
   • Establish stringent access controls to limit who can interact with the LLM and under what circumstances.
3. Legal Protections:
   • Strengthen security by implementing robust legal protections that deter potential theft and misuse.
4. Monitor for Unauthorized Use:
   • Regularly monitor any unauthorized access or use of proprietary models to address potential breaches quickly.
5. Rate Limiting and Filters:
   • Implement rate limiting or filters for API calls to reduce the risk of data exfiltration.
6. Restrict Network Access:
   • Limit LLM access to network resources, internal services, and APIs to prevent external attacks and internal leaks.
7. Audit Access Logs:
   • Conduct regular monitoring and auditing of access logs to detect and respond to suspicious behavior promptly.
8. Utilize Watermarking:
   • Implement a watermarking framework during model development’s embedding and detection stages for added security and traceability.

Conclusion

As LLMs continue spreading throughout many industries, knowing about and reducing related risks is critical. The OWASP Top 10 for LLMs offers an essential basis for identifying and addressing these vulnerabilities, ensuring the safe and efficient use of AI and LLM technology. Organizations can effectively manage the complex issues of AI security and safeguard against the constantly changing threat landscape by implementing thorough security measures, conducting regular audits, and encouraging a culture of continuous learning and adaptation.

Reference:

• https://owasp.org/www-project-top-10-for-large-language-model-applications/
• https://github.com/OWASP/www-project-top-10-for-large-language-model-applications
• https://owasp.org/www-project-top-10-for-large-language-model-applications/llm-top-10-governance-doc/LLM_AI_Security_and_Governance_Checklist-v1.1.pdf