Use After Free in Actix with Hmac Signatures

Use After Free (UAF) in Actix when Hmac Signatures are used typically arises from how headers or payload references are handled during request parsing and signature verification. In Actix-web, middleware or handlers may extract headers such as x-api-key or x-signature, then compute an HMAC over parts of the request. If the implementation retains pointers or references to request parts (e.g., body bytes or header slices) beyond the lifetime of the request, and those are used after the underlying buffer has been freed or reused, a UAF condition can occur.

Consider a scenario where signature verification involves pinning a body reference for later asynchronous validation. If the request body is moved or dropped before the async verification completes, the verification logic may access memory that has been reallocated. This is especially relevant when integrating Hmac Signatures with streaming bodies or when buffering large payloads. An attacker can trigger this by sending rapid requests with varying headers or body sizes, attempting to influence memory layout and increase the chance of hitting a dangling reference, leading to undefined behavior or information disclosure.

Real-world parallels include issues found in parsers that process JSON or form data where references are kept across await points. For example, a handler might extract a JSON field for inclusion in an Hmac payload, store it in a future, and then use it after the original request has been deallocated. This mirrors classes like CVE-2023-26143 (in other ecosystems) where use-after-free was triggered via crafted headers or multipart boundaries. In the context of Hmac Signatures, the risk is that an attacker can manipulate the input that is signed and potentially the memory backing that input, creating conditions where verification logic operates on freed data.

Because middleBrick tests unauthenticated attack surfaces and runs 12 security checks in parallel, it can flag inconsistent handling of request lifetimes around signature verification under the Property Authorization and Input Validation checks. The scanner does not rely on internal architecture; it observes whether different request permutations cause unstable behavior when Hmac Signatures are involved, such as crashes or inconsistent responses that suggest memory safety issues.

To reduce risk, ensure that any data used in Hmac computation is copied into an owned structure before being passed across async boundaries. Avoid holding references to request parts beyond the handler’s synchronous scope. This aligns with secure coding practices for memory safety and helps prevent UAF regardless of the web framework.

Remediation focuses on ensuring that data used in Hmac verification is owned and does not reference request buffers that may be freed. Below are two concrete Actix patterns: one vulnerable and one corrected.

Vulnerable pattern (avoid): Keeping a reference to request bytes across an async block.

use actix_web::{web, HttpRequest, HttpResponse, Result};
use hmac::{Hmac, Mac};
use sha2::Sha256;

type HmacSha256 = Hmac;

async fn verify_signature(req: HttpRequest, body: web::Bytes) -> Result<HttpResponse> {
    let signature = req.headers().get("x-signature")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("");
    // DANGER: `body` may be freed before this async block completes
    let data = &body[..];
    tokio::spawn(async move {
        let mut mac = HmacSha256::new_from_slice(b"secret-key").expect("valid key");
        mac.update(data);
        let result = mac.finalize();
        // Using `data` here after the request may have been dropped is unsafe
        println!("Result: {:?}", result);
    });
    Ok(HttpResponse::Ok().finish())
}

The closure captures a reference to body, which is tied to the request’s lifetime. If the request ends before the spawned task finishes, the reference becomes dangling.

Corrected pattern: Clone the bytes into an owned Vec<u8> before moving it into the async task.

use actix_web::{web, HttpRequest, HttpResponse, Result};
use hmac::{Hmac, Mac};
use sha2::Sha256;

type HmacSha256 = Hmac;

async fn verify_signature_safe(req: HttpRequest, body: web::Bytes) -> Result<HttpResponse> {
    let signature = req.headers().get("x-signature")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("");
    // Copy data into an owned vector to extend its lifetime beyond the request
    let data: Vec<u8> = body.to_vec();
    tokio::spawn(async move {
        let mut mac = HmacSha256::new_from_slice(b"secret-key").expect("valid key");
        mac.update(&data);
        let result = mac.finalize();
        // Safe: `data` is owned and lives as long as the task
        println!("Result: {:?}", result);
    });
    Ok(HttpResponse::Ok().finish())
}

For structured payloads (e.g., JSON), deserialize into an owned type before verification:

use actix_web::{web, HttpRequest, HttpResponse, Result};
use hmac::{Hmac, Mac};
use serde::Deserialize;
use sha2::Sha256;

type HmacSha256 = Hmac;

#[derive(Deserialize)]
struct Payload {
    action: String,
    value: String,
}

async fn verify_structured_safe(req: HttpRequest, body: web::Json<Payload>) -> Result<HttpResponse> {
    let signature = req.headers().get("x-signature")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("");
    // Clone owned data from deserialized struct
    let payload = body.into_inner();
    tokio::spawn(async move {
        let mut mac = HmacSha256::new_from_slice(b"secret-key").expect("valid key");
        let to_sign = format!("{}{}", payload.action, payload.value);
        mac.update(to_sign.as_bytes());
        let result = mac.finalize();
        println!("Signature verified: {:?}", result);
    });
    Ok(HttpResponse::Ok().finish())
}

Additional guidance: always prefer owned data structures for cross-boundary work. If you use Actix extractors that borrow (e.g., web::Query), copy the values before spawning tasks. Also ensure that Hmac key material is stored securely and not exposed through logs or error messages. These practices mitigate UAF and keep signature verification robust.