Technical Summary: Prediction of SQL Injection Using Machine Learning

Problem Statement

SQL Injection (SQLi) remains a critical vulnerability in web applications, allowing attackers to manipulate database queries to access, modify, or delete data without authorization. These attacks compromise the confidentiality, integrity, and availability of data and can lead to denial-of-service attacks or full server compromise. While various Artificial Intelligence (AI) techniques have been proposed to detect these threats, this research aims to systematically examine and compare the effectiveness of diverse Machine Learning (ML) and Deep Learning (DL) algorithms in recognizing SQL injection attacks. The study addresses the challenge of distinguishing between benign SQL queries and malicious injection payloads to prevent unauthorized database access.

Methodology

The research utilizes the SQLiv3 dataset sourced from Kaggle, which contains labeled SQL queries: label 0 for normal (benign) queries and label 1 for SQL injection queries. The methodology involves a rigorous data preprocessing and model training pipeline:

1. Data Preprocessing:

   • Cleaning: The dataset was cleaned to remove SQL statements containing punctuation errors (e.g., mismatched single or double quotes) that generated compilation errors, ensuring the model focuses on logical injection patterns rather than syntax noise.
   • Labeling: Queries were strictly categorized into binary classes (0 for safe, 1 for attack).

2. Algorithm Implementation:
   The study applied and compared the following algorithms:

   • Support Vector Machine (SVM): Utilized CountVectorizer for text vectorization (Bag-of-Words) and Linear SVC for classification.
   • Random Forest Regression: Employed CountVectorizer for feature extraction and RandomForestClassifier for pattern recognition.
   • Decision Tree Regression: Relied on manually extracted numerical features, including query length, count of questionable SQL terms, special character counts, tautology patterns (e.g., 1=1), and the presence of SQL comment markers (--, /*).
   • Long Short-Term Memory (LSTM): A deep learning approach involving tokenization and padding to handle variable query lengths. The architecture included an embedding layer and an LSTM layer, trained using binary cross-entropy for binary classification.
   • Agglomerative Clustering: Used TF-IDF for feature extraction to group queries into clusters (specifically n_clusters=2).
   • Logistic Regression: Applied CountVectorizer for bag-of-words representation followed by binary classification training.

3. Experimental Conditions:
   A critical aspect of the methodology was testing model performance under different training data compositions:

   • Training on only normal queries (label 0).
   • Training on only injection queries (label 1).
   • Training on a balanced mix of both classes (labels 0 and 1).

Key Results

The experimental results highlight the dependency of model accuracy on the diversity of the training dataset:

• Impact of Training Data Composition:

  • Models trained exclusively on one class (either only normal or only injection queries) consistently failed to generalize. For instance, when trained only on normal queries, models misclassified injection attempts as benign, and vice versa.
  • SVM and Logistic Regression could not achieve accuracy if trained on a single class; they required both label values to function, achieving accuracies between 0.98 and 0.99 when both classes were present.
  • Random Forest, Decision Tree, and LSTM also misinterpreted statements when trained on a single class but showed significant improvement when trained on a combined dataset.

• Performance Metrics (Balanced Dataset):
  When trained with a sufficient number of entries containing both label values (0 and 1), the algorithms achieved the following accuracies:

  • LSTM: Achieved 100% (1.0) accuracy after a few epochs. Notably, it maintained high accuracy even with a smaller number of entries compared to other models.
  • Support Vector Machine (SVM): Achieved accuracy above 99%.
  • Random Forest Regression: Achieved 99% accuracy.
  • Logistic Regression: Achieved 98.5% accuracy.
  • Decision Tree Regression: Achieved 97.8% accuracy.
  • Agglomerative Clustering: Achieved 97% accuracy (initially lower at 84% or 25% depending on specific training subsets, but improved with diverse data).

• Specific Observations:

  • Agglomerative Clustering showed discrepancies in matching cluster values to labels for statements containing specific operators like AND or @declare until diverse entries were added to the training set.
  • LSTM demonstrated superior capability in interpreting test queries correctly even with fewer training samples, provided both classes were represented.

Key Contributions

1. Comparative Analysis: The paper provides a direct comparison of traditional ML algorithms (SVM, Random Forest, Decision Tree, Logistic Regression) against Deep Learning (LSTM) and unsupervised learning (Agglomerative Clustering) specifically for SQLi detection.
2. Data Dependency Insight: The study explicitly demonstrates that the presence of both normal and malicious query classes in the training set is a prerequisite for high accuracy. It highlights that models trained on imbalanced or single-class data fail to distinguish between benign and malicious traffic.
3. Feature Engineering Evaluation: The research evaluates different feature extraction methods, ranging from automated text vectorization (CountVectorizer, TF-IDF) to manual feature engineering (query length, tautology patterns), showing the efficacy of each in the context of specific algorithms.

Significance and Claims

The authors claim that the primary significance of this work lies in the successful detection of SQL injection attacks with high accuracy using both machine learning and deep learning techniques. The study concludes that SVM and LSTM are the most effective algorithms for this specific task, with LSTM achieving perfect accuracy (100%) under optimal training conditions.

The paper modestly frames its contribution as a comparative study to identify which algorithms perform best for SQLi detection. It does not claim to solve all variations of SQL injection or to replace existing Web Application Firewalls (WAFs) entirely. Instead, it positions these models as tools to improve detection rates. The authors note that while current results are promising, the work is a step toward developing models capable of detecting different types of SQL injection attacks in the future. The research emphasizes that increasing the volume of diverse training data (both normal and injected queries) is essential for maximizing the performance of these predictive models.