Model Card for SQL Injection Classifier
This model is designed to classify SQL queries as either normal (0) or as potential SQL injection attacks (1).
Model Details
Model Description
This model is trained to identify SQL injection attacks, which are a type of code injection technique where an attacker can execute arbitrary SQL code in a database query. By analyzing the structure of SQL queries, the model predicts whether a given query is a normal query or contains malicious code indicative of an SQL injection attack.
- Developed by: [More Information Needed]
- Funded by [optional]: [More Information Needed]
- Shared by [optional]: [More Information Needed]
- Model type: Fine-tuned Llama 8B model (Distilled Version)
- Language(s) (NLP): English
- License: [More Information Needed]
- Finetuned from model [optional]: [More Information Needed]
Model Sources [optional]
- Repository: [More Information Needed]
- Paper [optional]: [More Information Needed]
- Demo [optional]: [More Information Needed]
Uses
Colab Use
To use the SQL Injection Classifier model, you can follow the code snippet below. This example demonstrates how to predict whether a given SQL query is normal or an injection attack.
1# 1=sql injection query and 0=normal sql query
2from unsloth import FastLanguageModel
3from transformers import AutoTokenizer
4
5# Load the model and tokenizer
6model_name = "shukdevdatta123/sql_injection_classifier_DeepSeek_R1_fine_tuned_model"
7hf_token = "your hf tokens"
8
9model, tokenizer = FastLanguageModel.from_pretrained(
10 model_name=model_name,
11 load_in_4bit=True,
12 token=hf_token,
13)
14
15# Function for testing queries
16def predict_sql_injection(query):
17 # Prepare the model for inference
18 inference_model = FastLanguageModel.for_inference(model)
19
20 prompt = f"### Instruction:\nClassify the following SQL query as normal (0) or an injection attack (1).\n\n### Query:\n{query}\n\n### Classification:\n"
21 inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
22
23 # Use the inference model for generation
24 outputs = inference_model.generate(
25 input_ids=inputs.input_ids,
26 attention_mask=inputs.attention_mask,
27 max_new_tokens=1000,
28 use_cache=True,
29 )
30 prediction = tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]
31 return prediction.split("### Classification:\n")[-1].strip()
32
33# Example usage
34test_query = "SELECT * FROM users WHERE id = '1' OR '1'='1' --"
35result = predict_sql_injection(test_query)
36print(f"Query: {test_query}\nPrediction: {result}")
Downstream Use
This model can be integrated into applications requiring SQL injection detection, such as web application firewalls, database query analyzers, and security auditing tools. It can help identify and prevent potential vulnerabilities in SQL queries.
Out-of-Scope Use
This model should not be used for malicious purposes, such as testing vulnerabilities on unauthorized systems, or for making security decisions without human oversight. It is essential to understand that the model's predictions should be interpreted with caution and supplemented with additional security measures.
Bias, Risks, and Limitations
This model was trained on a dataset of SQL queries and may exhibit certain limitations:
- Bias: The model may have limited generalization across different types of SQL injections or databases outside those present in the training set.
- Risks: False positives or false negatives could lead to missed SQL injection attacks or incorrect identification of normal queries as injections.
- Limitations: The model may not perform well on highly obfuscated attacks or queries that exploit novel vulnerabilities not present in the training data.
Recommendations
Users (both direct and downstream) should be aware of the potential risks of relying on the model in security-sensitive applications. Additional domain-specific testing and validation are recommended before deployment.
How to Get Started with the Model (Colab Streamlit)
1!pip install unsloth
2
3%%writefile app.py
4# 1=sql injection query and 0=normal sql query
5import streamlit as st
6from unsloth import FastLanguageModel
7from transformers import AutoTokenizer
8
9# Streamlit UI for input
10st.title("SQL Injection Classifier")
11hf_token = st.text_input("Enter your Hugging Face Token", type="password")
12model_name = "shukdevdatta123/sql_injection_classifier_DeepSeek_R1_fine_tuned_model"
13
14# Load the model and tokenizer when HF token is provided
15if hf_token:
16 try:
17 model, tokenizer = FastLanguageModel.from_pretrained(
18 model_name=model_name,
19 load_in_4bit=True,
20 token=hf_token,
21 )
22
23 # Function for testing queries
24 def predict_sql_injection(query):
25 # Prepare the model for inference
26 inference_model = FastLanguageModel.for_inference(model)
27
28 prompt = f"### Instruction:\nClassify the following SQL query as normal (0) or an injection attack (1).\n\n### Query:\n{query}\n\n### Classification:\n"
29 inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
30
31 # Use the inference model for generation
32 outputs = inference_model.generate(
33 input_ids=inputs.input_ids,
34 attention_mask=inputs.attention_mask,
35 max_new_tokens=1000,
36 use_cache=True,
37 )
38 prediction = tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]
39 return prediction.split("### Classification:\n")[-1].strip()
40
41 # Input query from the user
42 query = st.text_area("Enter an SQL query to test for injection", "")
43
44 # Add a button to classify the query
45 if st.button("Classify SQL Injection"):
46 if query:
47 result = predict_sql_injection(query)
48 st.write(f"Prediction: {result}")
49 else:
50 st.write("Please enter a SQL query first.")
51
52 except Exception as e:
53 st.error(f"Error loading model: {str(e)}")
54else:
55 st.write("Please enter your Hugging Face token to proceed.")
56
57!pip install streamlit
58
59!streamlit run app.py & npx localtunnel --port 8501
Training Details
Training Data
The model was trained using a dataset of SQL queries, specifically focusing on SQL injection examples and normal queries. Each query is labeled as either normal (0) or an injection (1).
Training Procedure
The model was fine-tuned using the PEFT (Parameter Efficient Fine-Tuning) technique, optimizing a pre-trained Llama 8B model for the task of SQL injection detection.
Training Hyperparameters
- Training regime: Mixed precision (fp16).
- Learning rate: 2e-4.
- Batch size: 2 per device, with gradient accumulation steps of 4.
- Max steps: 200.
Evaluation
Testing Data, Factors & Metrics
Testing Data
The evaluation was performed on a separate set of labeled SQL queries designed to test the model’s ability to differentiate between normal queries and SQL injection attacks.
Metrics
- Accuracy: How accurately the model classifies the queries.
- Precision and Recall: Evaluating the model’s performance in detecting both true positives (injection attacks) and avoiding false positives.
Results
The model was evaluated based on the training loss across 200 steps. Below is the training loss progression during the training process:
| Step | Training Loss |
|---|
| 10 | 2.951600 |
| 20 | 1.572900 |
| 30 | 1.370200 |
| 40 | 1.081900 |
| 50 | 0.946200 |
| 60 | 1.028700 |
| 70 | 0.873700 |
| 80 | 0.793300 |
| 90 | 0.892700 |
| 100 | 0.863000 |
| 110 | 0.694700 |
| 120 | 0.685900 |
| 130 | 0.778400 |
| 140 | 0.748500 |
| 150 | 0.721600 |
| 160 | 0.714400 |
| 170 | 0.764900 |
| 180 | 0.750800 |
| 190 | 0.664200 |
| 200 | 0.700600 |
Summary
The model shows a significant reduction in training loss over the first 100 steps, indicating good convergence during the fine-tuning process. After step 100, the training loss becomes more stable but continues to fluctuate slightly. Overall, the model achieved a low loss by the final training step, suggesting effective learning and adaptation to the task of classifying SQL injections.
Technical Specifications
Model Architecture and Objective
The model is based on a fine-tuned Llama 8B architecture, utilizing the PEFT technique to reduce the number of parameters required for fine-tuning while still maintaining good performance.
Compute Infrastructure
The model was trained using a powerful GPU cluster, leveraging mixed precision and gradient accumulation for optimal performance on large datasets.
Hardware
T4 GPU of Colab
Software
- Libraries: Hugging Face Transformers, unsloth, TRL, PyTorch.
- Training Framework: PEFT.
Glossary
- SQL Injection: A type of attack where malicious SQL statements are executed in an application’s database.
- PEFT: Parameter Efficient Fine-Tuning, a technique used for fine-tuning large models with fewer parameters.
Model Card Authors
Model Card Contact
Framework versions
