Prototype Pollution in Actix

Prototype pollution in Actix applications typically occurs through request parameter deserialization and query string parsing. Actix-web's default query extractor uses the serde_urlencoded crate, which can be vulnerable when combined with certain deserialization patterns.

The most common attack vector involves exploiting how Actix handles nested query parameters. Consider this Actix route:

async fn update_user(mut payload: web::Json<User>) -> impl Responder {
    let user: User = payload.into_inner();
    // Process user data
    HttpResponse::Ok().finish()
}

An attacker can send a request like:

POST /update_user
Content-Type: application/json

{"__proto__": {"isAdmin": true}}

This payload attempts to modify the prototype chain of the deserialized object. If the application uses the resulting object without proper validation, the attacker can gain unauthorized privileges.

Another Actix-specific pattern involves the web::Query extractor with nested structures:

#[derive(Deserialize)]
struct Settings {
    theme: String,
    notifications: bool,
}

async fn get_settings(
    info: web::Path<(String, String)>,
    query: web::Query<Settings>,
) -> impl Responder {
    // Settings object used directly
    HttpResponse::Ok().finish()
}

Attackers can craft query strings like:

?theme=dark&__proto__.dangerous=true

This exploits the fact that Actix's query deserialization doesn't always properly sanitize prototype keys, allowing prototype pollution to occur during the extraction process.

The risk is amplified when Actix applications use dynamic configuration loading or when user input is used to construct function calls or access object properties dynamically. For example:

async fn dynamic_config(
    query: web::Query<HashMap<String, String>>,
) -> impl Responder {
    let config = query.into_inner();
    let feature = config.get("feature").unwrap_or(&"default");
    // Dynamic property access based on user input
    let result = CONFIG.get(feature).unwrap()();
    HttpResponse::Ok().json(result)
}

If an attacker can control the feature parameter and pollute the prototype chain, they might access unintended configuration properties or methods.

Detecting prototype pollution in Actix applications requires a combination of static analysis and runtime testing. middleBrick's black-box scanning approach is particularly effective for Actix APIs because it tests the actual attack surface without requiring source code access.

When middleBrick scans an Actix endpoint, it specifically tests for prototype pollution patterns that Actix applications commonly face. The scanner sends crafted payloads targeting the __proto__, constructor, and prototype keys that Actix's deserialization layers might mishandle.

For Actix applications using web::Json or web::Query extractors, middleBrick tests payloads like:

{"__proto__": {"admin": true}}
{"constructor": {"prototype": {"dangerousMethod": true}}}
{"prototype": {"unsafeProperty": "malicious"}}

The scanner also tests nested query parameter pollution patterns specific to Actix's query string handling:

?param=value&__proto__.polluted=true
?data[0]=valid&__proto__.dangerous=false

middleBrick's LLM/AI security module adds another layer of detection for Actix applications that use AI features. It tests for system prompt leakage and prompt injection that could exploit prototype pollution in AI-related Actix endpoints.

For continuous monitoring, the middleBrick GitHub Action can be configured to scan Actix staging APIs before deployment:

name: API Security Scan
on: [pull_request]

jobs:
  security-scan:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Run middleBrick Scan
      run: |
        npx middlebrick scan https://staging.example.com/api
      env:
        MIDDLEBRICK_API_KEY: ${{ secrets.MIDDLEBRICK_API_KEY }}
    - name: Fail on High Risk
      run: |
        if [ $(npx middlebrick report | grep -c "High") -gt 0 ]; then exit 1; fi

This ensures prototype pollution vulnerabilities are caught before they reach production Actix deployments.

Remediating prototype pollution in Actix requires a defense-in-depth approach. The first layer is input sanitization using Actix's built-in validation features:

use actix_web::web;
use serde::Deserialize;
use validator::Validate;

#[derive(Deserialize, Validate)]
struct UserSettings {
    #[validate(length(min = 1, max = 50))]
    theme: String,
    #[validate]
    notifications: bool,
}

async fn update_settings(
    web::Query<UserSettings>,
) -> impl Responder {
    // Safe to use - validated and sanitized
    HttpResponse::Ok().finish()
}

For JSON payloads, use strict deserialization with allowed keys:

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct UserData {
    username: String,
    email: String,
    role: String,
}

async fn create_user(
    payload: web::Json<UserData>,
) -> impl Responder {
    let user = payload.into_inner();
    // Only valid fields are present - prototype pollution blocked
    HttpResponse::Created().finish()
}

Another effective approach is using Actix's extractor middleware for prototype pollution prevention:

use actix_web::{dev::Payload, FromRequest, HttpRequest};

struct SafeQuery(HashMap<String, String>);

#[async_trait::async_trait]
impl FromRequest for SafeQuery {
    type Config = ();
    type Error = actix_web::Error;
    type Future = Ready<Result<Self, Self::Error>>;

    fn from_request(
        req: &HttpRequest,
        _payload: &mut Payload,
    ) -> Self::Future {
        let query = req.query_string();
        // Filter out dangerous keys
        let safe_params = query
            .split('&')
            .filter(|pair| !pair.contains("__proto__")
                        && !pair.contains("constructor")
                        && !pair.contains("prototype"))
            .map(|pair| pair.split_once('='))
            .filter_map(|(k, v)| Some((k.to_string(), v.to_string())))
            .collect();
        
        ok(SafeQuery(safe_params))
    }
}

For applications using Actix with external data sources, implement strict type checking:

async fn process_config(
    config: web::Json<Value>,
) -> impl Responder {
    let config = config.into_inner();
    
    // Ensure no prototype pollution in nested structures
    if let Some(obj) = config.as_object() {
        for (key, value) in obj {
            if key.starts_with("__") || key == "constructor" || key == "prototype" {
                return HttpResponse::BadRequest().body("Invalid configuration");
            }
            // Recursively validate nested objects
            validate_no_prototype(value);
        }
    }
    
    HttpResponse::Ok().finish()
}

fn validate_no_prototype(value: &Value) {
    if let Some(obj) = value.as_object() {
        for (key, value) in obj {
            if key.starts_with("__") || key == "constructor" || key == "prototype" {
                panic!("Prototype pollution detected");
            }
            validate_no_prototype(value);
        }
    }
}

Finally, use middleBrick's continuous monitoring to verify your Actix application remains protected against prototype pollution attacks over time.