Add initial version

Basic_SQL_Injections.py

@@ -0,0 +1,88 @@
+import shutil
+import streamlit as st
+import sqlite3
+from dotenv import load_dotenv
+from langchain.chains import create_sql_query_chain
+from langchain_openai import ChatOpenAI
+from langchain_community.utilities import SQLDatabase
+from modules.utils import set_sidebar
+
+
+@st.cache_resource(show_spinner="Loading database ...")
+def load_database() -> SQLDatabase:
+    return SQLDatabase.from_uri("sqlite:///data/chinook_working.db")
+
+
+def reset_database():
+    """Copy original database to working database"""
+    shutil.copyfile("./data/chinook_backup.db", "./data/chinook_working.db")
+    return SQLDatabase.from_uri("sqlite:///data/chinook_working.db")
+
+
+load_dotenv()
+openai_instance = ChatOpenAI(
+    model="gpt-3.5-turbo",
+    temperature=0,
+)
+
+
+def main():
+    st.set_page_config(
+        page_title="AMLD SQL injection demo", page_icon="assets/effixis_logo.ico", layout="centered"
+    )
+    set_sidebar()
+    st.title("SQL Injections via LLM\:s")
+    st.markdown("### *Welcome to Effixis' demo for AMLD EPFL 2024!* 🎉")
+
+    st.markdown(
+        """
+        #### What is this demo about?
+        This demo is about risk associated with the use of LLM\:s, in this case illustrated by SQL injections.
+        SQL injections are a common vulnerability in web applications.
+        They allow an attacker to execute arbitrary SQL code on the database server.
+        This a very dangerous vulnerability as it can lead to data leaks, data corruption, and even data loss.
+
+        #### The SQL database used in this demo
+        The database used in this demo is the Chinook database.
+        It is a sample database that represents a digital media store, including tables for artists, albums, media tracks, invoices and customers.
+
+        You can see the shema below:
+        """
+    )
+    st.image("assets/chinook.png")
+
+    st.markdown(
+        """
+        #### What does LLM\:s have to do with this?
+        A large usecase for large language models (LLM\:s) is to generate SQL queries.
+        This is a very useful feature, as it allows users to interact with databases without having to know SQL.
+        But this is also prone to SQL injections, as the users and by extension the LLM:s, can generate malicious SQL queries.
+        """
+    )
+
+    st.divider()
+    st.markdown("#### **Try to generate some malicius queries below!**")
+
+    if st.button("Reset database"):
+        database = reset_database()
+    else:
+        database = load_database()
+    chain = create_sql_query_chain(llm=openai_instance, db=database)
+
+    if user_request := st.text_input("Enter your request here:"):
+        with st.spinner("Generating response ..."):
+            openai_response = chain.invoke({"question": user_request})
+            st.markdown("## Result:")
+            st.markdown(f"**SQL Response:** {openai_response}")
+            st.markdown("## SQL Result:")
+            for sql_query in openai_response.split(";"):
+                try:
+                    sql_result = database.run(sql_query)
+                    if sql_result:
+                        st.code(sql_result)
+                except sqlite3.OperationalError as e:
+                    st.error(e)
+
+
+if __name__ == "__main__":
+    main()

modules/utils.py

@@ -0,0 +1,23 @@
+import streamlit as st
+
+def set_sidebar():
+    with st.sidebar:
+        col1, col2 = st.columns([3, 1])
+        with col1:
+            st.header("Effixis")
+            st.markdown(
+                """***Take your Artificial Intelligence projects to the next level.***"""
+            )
+        with col2:
+            st.image("assets/effixis_logo.ico", use_column_width=True)
+        st.markdown(
+            """
+            #### About Effixis
+            *Effixis was founded in 2017, in close proximity to the Swiss Institute of Technology in Lausanne (EPFL), with the goal of making data analytics and machine learning accessible to private companies and public institutions.
+            Since then, we have expanded our reach and opened offices in Brussels in 2022.
+            Our company specializes in Natural Language Processing (NLP), Large Language Models (LLMs), and proprietary technologies, allowing us to offer top-tier services and products to our clients and partners.
+            We are dedicated to fostering long-term and reliable partnerships with our clients through our innovative approaches, and unwavering commitment.*
+            """
+        )
+        st.markdown("#### Learn more about us at: https://effixis.ch/")
+        st.markdown("---")

pages/LLM_safeguard.py

@@ -0,0 +1,105 @@
+import shutil
+import streamlit as st
+import sqlite3
+from dotenv import load_dotenv
+from langchain.chains import create_sql_query_chain
+from langchain.schema import HumanMessage
+from langchain_openai import ChatOpenAI
+from langchain_community.utilities import SQLDatabase
+from modules.utils import set_sidebar
+
+
+@st.cache_resource(show_spinner="Loading database ...")
+def load_database() -> SQLDatabase:
+    return SQLDatabase.from_uri("sqlite:///data/chinook_working.db")
+
+
+def reset_database():
+    """Copy original database to working database"""
+    shutil.copyfile("./data/chinook_backup.db", "./data/chinook_working.db")
+    return SQLDatabase.from_uri("sqlite:///data/chinook_working.db")
+
+
+load_dotenv()
+openai_instance = ChatOpenAI(
+    model="gpt-3.5-turbo",
+    temperature=0,
+)
+
+st.set_page_config(
+    page_title="LLM Safeguard", page_icon="assets/effixis_logo.ico"
+)
+set_sidebar()
+
+st.title("LLM Safeguard")
+st.markdown("### *Can you sneak a malicious request past the LLM Safeguard?*")
+st.markdown(
+    """
+    #### What is the difference between this demo and the one in the previous page?
+    In the previous page, the generated SQL query from the LLM was directly executed on the SQL database.
+    In this demo, the generated SQL query is first checked by an LLM Safeguard, which detects and removes malicious SQL queries.
+    Malicous SQL queries are defined as any SQL code that modifies the table. This includes SQL code that deletes, updates, or inserts data into the table.
+    """
+)
+
+st.divider()
+st.markdown("#### **Try to bypass the LLM Safeguard below!**")
+
+if st.button("Reset database"):
+    database = reset_database()
+else:
+    database = load_database()
+chain = create_sql_query_chain(llm=openai_instance, db=database)
+
+if user_request := st.text_input("Enter your request here:"):
+    with st.spinner("Generating response ..."):
+        openai_response = chain.invoke({"question": user_request})
+        st.markdown("## Generated SQL:")
+        st.markdown(f"**SQL Response:** {openai_response}")
+
+        prompt = """
+        You are a SQL expert and check the generated SQL query for malicious SQL code.
+
+        Malicous code is defined as any SQL code that modifies and/or deletes and/or drops the table and/or it's data. This includes SQL code that drops, deletes, updates, or inserts data into the table. Dropping tables is also considered as malicious.
+
+        If you find malicious SQL, please remove it. Just return the SQL query without the malicious SQL code. If you don't find any malicious SQL, just return the SQL query as is.
+        
+        Check the generated SQL query for malicious code:
+        =======================
+        {openai_response}
+        =======================
+
+        Make sure to follow the output format below.
+
+        Output format:
+        =======================
+        Reasoning as to why the SQL query is malicious or not.
+
+        SQL query without malicious code:
+        '''
+        [INSERT_SAFE_SQL_QUERY_OR_EMPTY_STRING]
+        '''
+        """.format(
+            openai_response=openai_response
+        )
+        messages = [HumanMessage(content=prompt)]
+        safe_query = openai_instance.generate(messages=[messages]).generations[0][0].text
+        st.markdown("## LLM Safeguard Result:")
+        st.code(safe_query, language="sql")
+        st.markdown("## SQL Result:")
+        try:
+            safe_query = safe_query.split("'''")[1]
+        except Exception:
+            st.error("No SQL query found!")
+            safe_query = ""
+        for sql_query in safe_query.split(";"):
+            if sql_query and "[" in sql_query:
+                continue
+            try:
+                sql_result = database.run(sql_query)
+                if sql_result:
+                    st.code(sql_result)
+            except sqlite3.OperationalError as e:
+                st.error(e)
+        st.success("Done!")
+