Go SDK

go get github.com/AuthForgeCC/authforge-go/v2@latest

package main

import (
	"errors"
	"fmt"
	"os"

	"github.com/AuthForgeCC/authforge-go/v2"
)

func main() {
	licenseLost := make(chan *authforge.Error, 1)
	client, err := authforge.New(authforge.Config{
		AppID:     "YOUR_APP_ID",
		AppSecret: "YOUR_APP_SECRET",
		PublicKey: "YOUR_PUBLIC_KEY",
		OnHeartbeatFailure: func(err *authforge.Error) {
			if err.IsTransient() {
				return // network blip: the SDK checks in again next interval
			}
			select {
			case licenseLost <- err: // signal main instead of exiting on this goroutine
			default:
			}
		},
	})
	if err != nil {
		panic(err)
	}

	result, err := client.Login("XXXX-XXXX-XXXX-XXXX")
	if err != nil {
		switch {
		case errors.Is(err, authforge.ErrInvalidKey):
			fmt.Fprintln(os.Stderr, "Invalid license key.")
		default:
			fmt.Fprintf(os.Stderr, "Login failed: %v\n", err)
		}
		os.Exit(1)
	}

	fmt.Printf("Authenticated! Expires: %d\n", result.ExpiresIn)
	lost := <-licenseLost // your app's work runs elsewhere until this fires
	fmt.Fprintf(os.Stderr, "License check failed: %s\n", lost.Code)
	// Save the user's work here, then exit.
	os.Exit(1)
}

client, err := authforge.New(authforge.Config{
	AppID:             "YOUR_APP_ID",              // Required
	AppSecret:         "YOUR_APP_SECRET",          // Required for online Login/ValidateLicense; omit 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: 15 * time.Minute,           // Optional: background timer cadence (check-ins when online, local session checks otherwise)
	APIBaseURL:        "https://auth.authforge.cc",// Optional
	OnFailure:         nil,                        // Optional: func(error string); background failures as a message, unless OnHeartbeatFailure is set
	OnHeartbeatFailure: nil,                       // Optional: func(err *authforge.Error); typed background failures (1.4.0+)
	RequestTimeout:    15 * time.Second,           // Optional
	SessionTTL:        0,                          // Optional: time.Duration. Grace period. 0 = server default (24h). Clamped to [1h, 7d].
	HWIDOverride:      "",                         // Optional: custom identity (for example "tg:123456789")
})

client, _ := authforge.New(authforge.Config{
	AppID:      "...",
	AppSecret:  "...",
	PublicKey:  "YOUR_PUBLIC_KEY",
	SessionTTL: 72 * time.Hour, // 3-day grace period
})

result, err := client.Login(licenseKey)
result, err = client.ValidateLicense(licenseKey) // same validate + signatures, no background loop / session persistence
client.Logout()
ok := client.IsAuthenticated()
session := client.SessionData()
appVars := client.AppVariables()
licenseVars := client.LicenseVariables()

if err != nil {
	switch {
	case errors.Is(err, authforge.ErrInvalidApp):
		// invalid app credentials
	case errors.Is(err, authforge.ErrInvalidKey):
		// invalid key
	case errors.Is(err, authforge.ErrExpired):
		// license expired
	case errors.Is(err, authforge.ErrRevoked):
		// license revoked
	case errors.Is(err, authforge.ErrHwidMismatch):
		// HWID slots full (Login) or HWID no longer bound (check-in)
	case errors.Is(err, authforge.ErrNoCredits):
		// no credits
	case errors.Is(err, authforge.ErrBlocked):
		// blocked
	case errors.Is(err, authforge.ErrRateLimited):
		// rate limited (validate: per IP / per license; heartbeat: 6/min per license)
	case errors.Is(err, authforge.ErrReplayDetected):
		// replay detected (validate only)
	case errors.Is(err, authforge.ErrSessionExpired):
		// session expired (grace period ended)
	case errors.Is(err, authforge.ErrSignatureMismatch):
		// signature verification failed
	default:
		// transport or unexpected error
	}
}

licenseLost := make(chan *authforge.Error, 1)

client, err := authforge.New(authforge.Config{
	AppID:           "YOUR_APP_ID",
	AppSecret:       "YOUR_APP_SECRET",
	PublicKey:       "YOUR_PUBLIC_KEY",
	OnlineHeartbeat: true,
	SessionTTL:      time.Hour, // retry window for transient check-in failures
	OnHeartbeatFailure: func(err *authforge.Error) {
		if err.IsTransient() {
			// No verdict on the license: keep running. The SDK checks in again every
			// HeartbeatInterval and reports session_expired (definitive) once the
			// SessionTTL grace period is used up.
			log.Printf("AuthForge check-in failed (%s), retrying", err.Code)
			return
		}
		log.Printf("License check failed: %s", err.Code) // session already cleared
		select {
		case licenseLost <- err: // runs on the background goroutine: signal, don't exit here
		default:
		}
	},
})

// ... Login, then run your app's work on other goroutines ...

select {
case <-licenseLost:
	saveUserWork()
	client.Logout()
	os.Exit(1)
case <-appDone:
}

// Default: activate online, then run through the grace period (24h by default)
client, _ := authforge.New(authforge.Config{
	AppID:     "...",
	AppSecret: "...",
	PublicKey: "YOUR_PUBLIC_KEY",
})

// Strict policy: periodic online check-ins for fast revocation
client, _ := authforge.New(authforge.Config{
	AppID:           "...",
	AppSecret:       "...",
	PublicKey:       "YOUR_PUBLIC_KEY",
	OnlineHeartbeat: true,
})

client, _ := authforge.New(authforge.Config{AppID: "APP_ID", PublicKey: "PUBLIC_KEY"})

// Step 1 (customer machine): write an activation request the operator drops into the mint dialog.
request := client.CreateActivationRequest(authforge.ActivationRequestOptions{})

// Step 2 (customer machine, after you deliver the file): path or armored text.
lic, err := client.LoginFromFile("license.authforge")
switch {
case errors.Is(err, authforge.ErrOfflineExpired):
	log.Fatal("offline license expired - request a new file")
case errors.Is(err, authforge.ErrOfflineHwidMismatch):
	log.Fatal("this file is bound to a different machine")
case err != nil:
	log.Fatal(err)
}
fmt.Println("Offline license valid until", lic.ExpiresAt) // nil pointer = lifetime

client, _ := authforge.New(authforge.Config{AppID: "YOUR_APP_ID", AppSecret: "YOUR_APP_SECRET", PublicKey: "YOUR_PUBLIC_KEY"})

if _, err := client.LoginFromFile(licensePath); err != nil {
	// No file yet, or it is for other hardware: ask for the key and activate once.
	key := promptForKey()
	if err := client.ActivateOffline(key, licensePath); err != nil {
		switch {
		case errors.Is(err, authforge.ErrOfflineActivationLimitReached):
			log.Fatal("This key is already activated on the maximum number of computers. Contact support.")
		case errors.Is(err, authforge.ErrOfflineFileRejected):
			log.Fatalf("Activation failed: %v", err) // the verifier's reason is in the message
		default:
			log.Fatalf("Activation failed (%s).", authforge.ErrorCode(err))
		}
	}
}