libinjection

https://github.com/yaa110/libinjection-rs
Admin
Rust bindings for libinjection, a library for detecting SQL injection and XSS attacks in strings.
Tokens:2,066
Snippets:21
Trust Score:6.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Comprehensive Web Application Input Validation with libinjection-rs

Source: https://context7.com/yaa110/libinjection-rs/llms.txt

Combine `sqli` and `xss` functions to create a robust input validation layer for web applications. This example demonstrates checking user input for both SQL injection and XSS vulnerabilities before processing.

```rust
use libinjection::{sqli, xss};

/// Validates user input for common injection attacks
/// Returns Ok(()) if input is safe, Err with description if attack detected
fn validate_input(input: &str) -> Result<(), String> {
    // Check for SQL injection
    if let Some((is_sqli, fingerprint)) = sqli(input) {
        if is_sqli {
            return Err(format!("SQL injection detected (fingerprint: {})", fingerprint));
        }
    }

    // Check for XSS
    if let Some(is_xss) = xss(input) {
        if is_xss {
            return Err("XSS attack detected".to_string());
        }
    }

    Ok(())
}

fn main() {
    // Test various inputs
    let test_inputs = vec![
        "John Doe",                           // Safe
        "' OR '1'='1' --",                    // SQLi
        "<script>alert('xss')</script>",      // XSS
        "SELECT name FROM users",             // Safe SQL (not injection)
        "1; DELETE FROM users WHERE 1=1--",   // SQLi
    ];

    for input in test_inputs {
        match validate_input(input) {
            Ok(()) => println!("✓ Safe: {}", input),
            Err(reason) => println!("✗ Blocked: {} - {}", input, reason),
        }
    }
}
```

--------------------------------

### Import libinjection Crate

Source: https://github.com/yaa110/libinjection-rs/blob/main/README.md

Import the necessary functions from the libinjection crate into your Rust code.

```rust
use libinjection::{sqli, xss};
```

--------------------------------

### Add libinjection to Cargo.toml

Source: https://github.com/yaa110/libinjection-rs/blob/main/README.md

To use the libinjection-rs crate, add it as a dependency in your project's Cargo.toml file.

```toml
libinjection = "*"
```

--------------------------------

### Add libinjection to Cargo.toml

Source: https://context7.com/yaa110/libinjection-rs/llms.txt

Add this line to your Cargo.toml file to include libinjection as a project dependency. The build process requires git, make, and a C compiler.

```toml
[dependencies]
libinjection = "0.3.8"
```

--------------------------------

### Detect SQL Injection with libinjection-rs

Source: https://context7.com/yaa110/libinjection-rs/llms.txt

Use the `sqli` function to detect SQL injection patterns in input strings. It returns a tuple containing a boolean indicating detection and a fingerprint string for the attack type. Requires the `libinjection` crate.

```rust
use libinjection::sqli;

fn main() {
    // Detect classic SQL injection with OR bypass
    let input = "' OR '1'='1' --";
    match sqli(input) {
        Some((is_sqli, fingerprint)) => {
            if is_sqli {
                println!("SQLi detected!");
                println!("Attack fingerprint: {}", fingerprint);
                // Output: Attack fingerprint: s&sos
            } else {
                println!("Input is safe");
            }
        }
        None => println!("Failed to analyze input"),
    }

    // Test legitimate SQL query - no injection detected
    let safe_input = "SELECT * FROM users";
    let (is_sqli, fingerprint) = sqli(safe_input).unwrap();
    assert!(!is_sqli);
    assert!(fingerprint.is_empty());

    // Detect UNION-based injection
    let union_attack = "1 UNION SELECT username, password FROM users--";
    let (is_sqli, fingerprint) = sqli(union_attack).unwrap();
    println!("UNION attack detected: {}, fingerprint: {}", is_sqli, fingerprint);

    // Detect stacked queries injection
    let stacked = "1; DROP TABLE users--";
    let (is_sqli, fingerprint) = sqli(stacked).unwrap();
    println!("Stacked query detected: {}, fingerprint: {}", is_sqli, fingerprint);
}
```

--------------------------------

### Check User Input for SQLi and XSS in Rust

Source: https://context7.com/yaa110/libinjection-rs/llms.txt

This Rust code snippet demonstrates how to use the `sqli` and `xss` functions from the libinjection crate to check user input for potential security threats. It returns true if the input is safe from both SQL injection and XSS.

```rust
// In your application code
use libinjection::{sqli, xss};

// Basic usage pattern
fn check_user_input(input: &str) -> bool {
    let sqli_safe = sqli(input)
        .map(|(is_sqli, _)| !is_sqli)
        .unwrap_or(false);

    let xss_safe = xss(input)
        .map(|is_xss| !is_xss)
        .unwrap_or(false);

    sqli_safe && xss_safe
}
```

--------------------------------

### Detect Cross-Site Scripting (XSS) with libinjection-rs

Source: https://context7.com/yaa110/libinjection-rs/llms.txt

Utilize the `xss` function to identify Cross-Site Scripting attack patterns in input. It returns a boolean indicating whether XSS was detected. Ensure the `libinjection` crate is included.

```rust
use libinjection::xss;

fn main() {
    // Detect script tag injection
    let script_attack = "<script type='text/javascript'>alert('xss');</script>";
    match xss(script_attack) {
        Some(is_xss) => {
            if is_xss {
                println!("XSS attack detected in script tag!");
            }
        }
        None => println!("Failed to analyze input"),
    }

    // Test safe input - no XSS detected
    let safe_text = "is not XSS";
    let is_xss = xss(safe_text).unwrap();
    assert!(!is_xss);

    // Detect event handler injection
    let event_attack = "<img src=x onerror=alert('XSS')>";
    let is_xss = xss(event_attack).unwrap();
    println!("Event handler XSS detected: {}", is_xss);

    // Detect SVG-based XSS
    let svg_attack = "<svg onload=alert('XSS')>";
    let is_xss = xss(svg_attack).unwrap();
    println!("SVG XSS detected: {}", is_xss);
}
```

--------------------------------

### Detect SQL Injection

Source: https://github.com/yaa110/libinjection-rs/blob/main/README.md

Use the `sqli` function to detect SQL injection vulnerabilities in a given string. It returns a tuple containing a boolean indicating if it's an SQLi and a fingerprint string.

```rust
let (is_sqli, fingerprint) = sqli("' OR '1'='1' --").unwrap();
assert!(is_sqli);
assert_eq!("s&sos", fingerprint);
```

--------------------------------

### Detect XSS Vulnerability

Source: https://github.com/yaa110/libinjection-rs/blob/main/README.md

Use the `xss` function to detect cross-site scripting (XSS) vulnerabilities in a given string. It returns a boolean indicating if an XSS vulnerability is detected.

```rust
let is_xss = xss("<script type='text/javascript'>alert('xss');</script>").unwrap();
assert!(is_xss);
```
Tokens:
Raw