Relintio Rust Agent SDK

The official in-process protection agent for Rust web application frameworks (Axum and Actix-web). Relintio blocks bots, credential stuffing, scraping, and other automated abuse in real-time.

Features

Dynamic Ruleset Caching: Fetches WAF rules dynamically from the Relintio API and caches them locally to ensure offline safety and minimal lookup latency.
Additive Scoring Engine: Inspects requests for client characteristics (missing headers, automated client user-agents, request rate bursts) and adds points up to 100.
Token-bucket Rate Limiter: Built-in rate limits per client IP.
Obsidian Layer (Axum): Injects anti-copy, right-click disabling, and DevTools blocking directly into HTML response payloads.
Multiple Frameworks: First-class integrations for Axum and Actix-web.

Installation

Add this to your Cargo.toml:

[dependencies]
relintio-agent = "0.1.0"

To enable only a specific framework integration, disable default features:

[dependencies]
relintio-agent = { version = "0.1.0", default-features = false, features = ["axum"] }

Quickstart

1. Axum Example

use std::sync::Arc;
use axum::{routing::get, Router, middleware};
use relintio_agent::{RelintioAgent, RelintioConfig, middleware::axum::relintio_middleware};

#[tokio::main]
async fn main() {
    let config = RelintioConfig {
        license_key: "YOUR_LICENSE_KEY".to_string(),
        api_url: "https://api.relintio.com/v1".to_string(),
        sync_interval_seconds: 10,
    };

    let agent = Arc::new(RelintioAgent::new(config));

    let app = Router::new()
        .route("/", get(|| async { "Hello, Protected World!" }))
        .layer(middleware::from_fn(move |req, next| {
            relintio_middleware(agent.clone(), req, next)
        }));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

2. Actix-web Example

use std::sync::Arc;
use actix_web::{get, App, HttpServer, Responder};
use relintio_agent::{RelintioAgent, RelintioConfig, middleware::actix::RelintioActixMiddleware};

#[get("/")]
async fn hello() -> impl Responder {
    "Hello, Protected World!"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let config = RelintioConfig {
        license_key: "YOUR_LICENSE_KEY".to_string(),
        api_url: "https://api.relintio.com/v1".to_string(),
        sync_interval_seconds: 10,
    };

    let agent = Arc::new(RelintioAgent::new(config));

    HttpServer::new(move || {
        App::new()
            .wrap(RelintioActixMiddleware::new(agent.clone()))
            .service(hello)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

How It Works

Rule Syncing: The agent pulls your custom security configuration (banned IPs, geo-fencing rules, rate limits) on boot, and updates it in a background thread every sync_interval_seconds seconds.
Request Scoring: Incoming requests are evaluated dynamically. If the total score hits blocking thresholds, the middleware intercepts the call and serves a decoy, security challenge, or block screen.
Fail-Open Policy: If the Relintio API is down, the agent fails open, ensuring no downtime for legitimate users.

License

This project is licensed under the MIT License.

Dashboard Deployment Workflow

Open Dashboard → Deployment, select Rust, and download the prepared Axum starter.
Merge the dependency and middleware registration into the application before protected routes.
Restart the service, then open one public HTTP route.
Enter that exact URL or public IP endpoint in Relintio and select Verify target.

The SDK reports runtime kind rust and its version during rule synchronization. Policy revisions are received by the running agent automatically.

relintio-agent 0.1.2