C# SDK

dotnet add package AuthForge

using AuthForge;

var client = new AuthForgeClient(
    appId: "YOUR_APP_ID",
    appSecret: "YOUR_APP_SECRET",
    publicKey: "YOUR_PUBLIC_KEY"
);

Console.Write("Enter license key: ");
var key = Console.ReadLine() ?? "";

if (client.Login(key))
{
    Console.WriteLine("Authenticated!");
    // Your app logic here; the signed session covers the grace period
}
else
{
    Console.WriteLine("Invalid license key.");
    Environment.Exit(1);
}

var client = new AuthForgeClient(
    appId: "...",                   // Required; from dashboard
    appSecret: "...",               // Required for online Login/ValidateLicense; pass "" for LoginFromFile only
    publicKey: "YOUR_PUBLIC_KEY",   // Required; Ed25519 public key from your AuthForge dashboard (base64)
    onlineHeartbeat: false,         // Optional; true enables periodic online check-ins (/auth/heartbeat)
    heartbeatInterval: 900,         // Optional; background timer cadence (check-ins when online, local session checks otherwise)
    apiBaseUrl: "https://auth.authforge.cc",  // Optional
    onFailure: null,                // Optional; Action<string, Exception?>; check-in errors are AuthForgeException
    requestTimeout: 15,             // Optional; HTTP timeout in seconds
    ttlSeconds: null,               // Optional; grace period (session TTL). null = server default (24h). Clamped to [3600, 604800].
    hwidOverride: null              // Optional; custom identity (for example "tg:123456789")
);

bool success = client.Login(licenseKey);

var result = client.ValidateLicense(licenseKey);
if (result.Valid) {
    Console.WriteLine(result.SessionToken);
} else {
    Console.WriteLine(result.ErrorCode);
}

using var licenseLost = new CancellationTokenSource();

var client = new AuthForgeClient(
    appId: "YOUR_APP_ID",
    appSecret: "YOUR_APP_SECRET",
    publicKey: "YOUR_PUBLIC_KEY",
    onlineHeartbeat: true,
    ttlSeconds: 3600, // retry window for transient check-in failures
    onFailure: (reason, ex) =>
    {
        if (reason == "heartbeat_failed" && ex is AuthForgeException { IsTransient: true } transient)
        {
            // No verdict on the license: keep running. The SDK checks in again every
            // heartbeatInterval and reports session_expired (definitive) once the
            // ttlSeconds grace period is used up.
            Console.Error.WriteLine($"AuthForge check-in failed ({transient.Code}), retrying");
            return;
        }
        Console.Error.WriteLine($"License check failed: {reason} ({(ex as AuthForgeException)?.Code ?? ex?.Message})");
        // This can run on the heartbeat thread: signal the main thread instead of exiting here.
        licenseLost.Cancel();
    }
);

if (!client.Login(licenseKey))
{
    return 1;
}

while (!licenseLost.IsCancellationRequested)
{
    DoOneUnitOfWork(licenseLost.Token); // keep units short, or pass the token to async work
}

SaveApplicationState();
client.Logout();
return 1;

if (client.Login(licenseKey))
{
    // App-wide variables
    var appVars = client.AppVariables;
    if (appVars.TryGetValue("maintenanceMode", out var maintenance) && maintenance is true)
    {
        Console.WriteLine("Server is under maintenance.");
        Environment.Exit(0);
    }

    // Per-license variables
    var plan = client.LicenseVariables.GetValueOrDefault("plan", "basic");
    if (plan?.ToString() == "pro")
    {
        EnableProFeatures();
    }
}

// Default: activate online, then run through the grace period (24h by default)
var client = new AuthForgeClient(
    appId: "...",
    appSecret: "...",
    publicKey: "YOUR_PUBLIC_KEY",
    ttlSeconds: 259200  // Optional: extend the grace period to 3 days (clamped to 1h-7d)
);

// Strict policy: periodic online check-ins for fast revocation
var strictClient = new AuthForgeClient(
    appId: "...",
    appSecret: "...",
    publicKey: "YOUR_PUBLIC_KEY",
    onlineHeartbeat: true,
    heartbeatInterval: 900  // 15 minutes (default)
);

var client = new AuthForgeClient(appId: "APP_ID", appSecret: "", publicKey: "PUBLIC_KEY");

// Step 1 (customer machine): write an activation request the operator drops into the mint dialog.
File.WriteAllText("machine.authforge-request", client.CreateActivationRequest());

// Step 2 (customer machine, after you deliver the file): path or armored text.
if (client.LoginFromFile("license.authforge"))
{
    var info = client.GetOfflineLicense()!;
    Console.WriteLine($"Offline license valid until {info.ExpiresAt ?? "forever"}");
}

using System.Windows;
using AuthForge;

public partial class App : Application
{
    private AuthForgeClient? _authClient;

    protected override void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);

        _authClient = new AuthForgeClient(
            appId: "YOUR_APP_ID",
            appSecret: "YOUR_APP_SECRET",
            publicKey: "YOUR_PUBLIC_KEY",
            onlineHeartbeat: true, // Optional strict policy: check in every 15 minutes
            onFailure: OnAuthFailure
        );

        var dialog = new LicenseDialog();
        if (dialog.ShowDialog() != true)
        {
            Shutdown();
            return;
        }

        if (!_authClient.Login(dialog.LicenseKey))
        {
            MessageBox.Show("Invalid license key.", "Authentication Failed",
                MessageBoxButton.OK, MessageBoxImage.Error);
            Shutdown();
            return;
        }

        var mainWindow = new MainWindow();
        mainWindow.Show();
    }

    private void OnAuthFailure(string reason, Exception? ex)
    {
        // Transient check-in failure: the session is kept and the SDK checks in again.
        if (reason == "heartbeat_failed" && ex is AuthForgeException { IsTransient: true })
            return;

        // Runs on the heartbeat thread: queue the shutdown on the UI thread instead of exiting here.
        Dispatcher.InvokeAsync(() =>
        {
            // Save user's work before shutting down
            (MainWindow as MainWindow)?.SaveState();

            MessageBox.Show(
                "License verification failed. Your work has been saved.",
                "Authentication Error",
                MessageBoxButton.OK,
                MessageBoxImage.Warning
            );

            Shutdown();
        });
    }
}