Rust SDK

cargo add authforge

[dependencies]
authforge = "2.0"

use authforge::{AuthForgeClient, AuthForgeConfig, AuthForgeError};
use std::sync::mpsc;

fn main() {
    let (license_lost, lost) = mpsc::channel::<AuthForgeError>();
    let client = AuthForgeClient::new(AuthForgeConfig {
        app_id: "your-app-id".into(),
        app_secret: "your-app-secret".into(),
        public_key: "YOUR_PUBLIC_KEY".into(),
        on_heartbeat_failure: Some(Box::new(move |err: &AuthForgeError| {
            if err.is_fatal() {
                // Runs on the heartbeat thread: signal main instead of exiting here.
                let _ = license_lost.send(err.clone());
            }
        })),
        ..Default::default()
    });

    match client.login("XXXX-XXXX-XXXX-XXXX") {
        Ok(result) => {
            println!("Authenticated!");
            println!("Session expires at unix time: {}", result.expires_in);
        }
        Err(err) => {
            eprintln!("Login failed: {:?}", err);
            std::process::exit(1);
        }
    }

    let err = lost.recv().expect("client dropped"); // your app's work runs elsewhere until this fires
    eprintln!("Auth failed: {}", err.code());
    // Save the user's work here, then exit.
    std::process::exit(1);
}

AuthForgeConfig {
    app_id: "your-app-id".into(),             // Required
    app_secret: "your-app-secret".into(),     // Required for online login/validate; leave empty for login_from_file only
    public_key: "YOUR_PUBLIC_KEY".into(),     // Required - Ed25519 public key from your AuthForge dashboard (base64)
    online_heartbeat: false,                  // Optional - true enables periodic online check-ins (/auth/heartbeat)
    heartbeat_interval: 900,                  // Optional, background timer cadence (check-ins when online, local session checks otherwise)
    api_base_url: "https://auth.authforge.cc".into(), // Optional
    on_failure: None,                         // Optional callback (&str)
    on_heartbeat_failure: None,               // Optional typed callback (&AuthForgeError) for background checks
    request_timeout: 15,                      // Optional, seconds
    session_ttl_seconds: None,                // Optional - grace period (session TTL). None = server default (24h). Clamped to [3600, 604800].
    hwid_override: None,                      // Optional - custom identity (for example "tg:123456789")
}

match client.validate_license("XXXX-XXXX-XXXX-XXXX") {
    Ok(result) => { /* use result.session_token, result.app_variables, … */ }
    Err(err) => { /* same AuthForgeError variants as login */ }
}

pub fn new(config: AuthForgeConfig) -> Self;
pub fn login(&self, license_key: &str) -> Result<LoginResult, AuthForgeError>;
pub fn validate_license(&self, license_key: &str) -> Result<LoginResult, AuthForgeError>;
pub fn logout(&self);
pub fn is_authenticated(&self) -> bool;
pub fn get_session_data(&self) -> Option<serde_json::Value>;
pub fn get_app_variables(&self) -> Option<std::collections::HashMap<String, serde_json::Value>>;
pub fn get_license_variables(&self) -> Option<std::collections::HashMap<String, serde_json::Value>>;

AuthForgeError::InvalidApp
AuthForgeError::InvalidKey
AuthForgeError::Expired            // server expired
AuthForgeError::Revoked
AuthForgeError::HwidMismatch
AuthForgeError::NoCredits
AuthForgeError::AppBurnCapReached
AuthForgeError::Blocked
AuthForgeError::RateLimited        // validate: per IP / per license; heartbeat: 6/min per license
AuthForgeError::ReplayDetected     // validate only; never returned from heartbeat
AuthForgeError::AppDisabled
AuthForgeError::SessionExpired     // server session_expired; also local session TTL expiry (the grace period ending)
AuthForgeError::RevokeRequiresSession
AuthForgeError::BadRequest         // bad_request
AuthForgeError::MalformedRequest   // malformed_request (2.0.0+)
AuthForgeError::SystemError
AuthForgeError::SignatureMismatch
AuthForgeError::NetworkError(String) // code() is network_error, timeout or invalid_json_response
AuthForgeError::Other(String)      // unknown server codes, http_error_502, unexpected_response, ...

use authforge::{AuthForgeClient, AuthForgeConfig, AuthForgeError};
use std::sync::mpsc;

let (license_lost, lost) = mpsc::channel::<AuthForgeError>();

let client = AuthForgeClient::new(AuthForgeConfig {
    app_id: "YOUR_APP_ID".into(),
    app_secret: "YOUR_APP_SECRET".into(),
    public_key: "YOUR_PUBLIC_KEY".into(),
    online_heartbeat: true,
    on_heartbeat_failure: Some(Box::new(move |err: &AuthForgeError| {
        if err.is_transient() {
            eprintln!("authforge: check-in failed ({}), retrying next interval", err.code());
            return;
        }
        eprintln!("authforge: license no longer valid: {}", err.code()); // session already cleared
        // Runs on the heartbeat thread: signal the main thread instead of exiting here.
        let _ = license_lost.send(err.clone());
    })),
    ..Default::default()
});

// ... login ...

while lost.try_recv().is_err() {
    do_one_unit_of_work(); // keep units short so the loop notices the signal quickly
}
save_user_work();
client.logout();
std::process::exit(1);

// Default: activate online, then run through the grace period (24h by default)
let client = AuthForgeClient::new(AuthForgeConfig {
    app_id: "...".into(),
    app_secret: "...".into(),
    public_key: "YOUR_PUBLIC_KEY".into(),
    session_ttl_seconds: Some(259200), // Optional: extend the grace period to 3 days (clamped to 1h-7d)
    ..Default::default()
});

// Strict policy: periodic online check-ins for fast revocation
let strict_client = AuthForgeClient::new(AuthForgeConfig {
    app_id: "...".into(),
    app_secret: "...".into(),
    public_key: "YOUR_PUBLIC_KEY".into(),
    online_heartbeat: true,
    ..Default::default()
});

use authforge::OfflineLicenseError;

let client = AuthForgeClient::new(AuthForgeConfig {
    app_id: "APP_ID".into(),
    public_key: "PUBLIC_KEY".into(),
    ..Default::default()
});

// Step 1 (customer machine): write an activation request the operator drops into the mint dialog.
std::fs::write("machine.authforge-request", client.create_activation_request(Default::default())).expect("write request");

// Step 2 (customer machine, after you deliver the file): path or armored text.
match client.login_from_file("license.authforge") {
    Ok(lic) => println!("Offline license valid until {:?}", lic.expires_at), // None = lifetime
    Err(OfflineLicenseError::Expired) => eprintln!("offline license expired - request a new file"),
    Err(OfflineLicenseError::HwidMismatch) => eprintln!("this file is bound to a different machine"),
    Err(err) => eprintln!("offline license rejected: {err}"),
}

use std::path::Path;
use authforge::{AuthForgeClient, AuthForgeConfig};

let client = AuthForgeClient::new(AuthForgeConfig {
    app_id: "YOUR_APP_ID".into(),
    app_secret: "YOUR_APP_SECRET".into(),
    public_key: "YOUR_PUBLIC_KEY".into(),
    ..Default::default()
});

if client.login_from_file(LICENSE_PATH).is_err() {
    // No file yet, or it is for other hardware: ask for the key and activate once.
    let key = prompt_for_key();
    if let Err(err) = client.activate_offline(&key, Some(Path::new(LICENSE_PATH))) {
        if err.code() == "offline_activation_limit_reached" {
            eprintln!("This key is already activated on the maximum number of computers. Contact support.");
        } else {
            eprintln!("Activation failed ({}).", err.code());
        }
        std::process::exit(1);
    }
}