Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
package licensing
import (
"crypto/ed25519"
"crypto/rand"
"encoding/base64"
"encoding/json"
"strings"
"testing"
"time"
)
// mintTestProviderMSPLicense signs an MSP license with the shared test root
// key, binding the given lease signing public key. setupTestPublicKey must be
// installed for ValidateLicense to accept it.
func mintTestProviderMSPLicense(t *testing.T, tier Tier, leaseSigningPublicKey ed25519.PublicKey, expiresIn time.Duration) string {
t.Helper()
testKeyPairInit()
claims := Claims{
LicenseID: "lic_provider_chain_test",
Email: "[email protected]",
Tier: tier,
IssuedAt: time.Now().Unix(),
PlanVersion: "msp_starter",
}
if expiresIn != 0 {
claims.ExpiresAt = time.Now().Add(expiresIn).Unix()
}
if len(leaseSigningPublicKey) > 0 {
claims.EntitlementSigningPublicKey = base64.StdEncoding.EncodeToString(leaseSigningPublicKey)
}
payload, err := json.Marshal(claims)
if err != nil {
t.Fatalf("marshal provider license claims: %v", err)
}
return signTestJWT(t, payload, testPrivateKey)
}
func signTestProviderLease(t *testing.T, signingKey ed25519.PrivateKey, providerLicense string, capabilities []string) string {
t.Helper()
claims := EntitlementLeaseClaims{
OrgID: "default",
InstanceHost: "t-acme.pulse.example-msp.com",
PlanVersion: "msp_starter",
SubscriptionState: SubStateActive,
Capabilities: capabilities,
ProviderLicense: providerLicense,
}
token, err := SignEntitlementLeaseToken(signingKey, claims)
if err != nil {
t.Fatalf("sign provider lease: %v", err)
}
return token
}
func TestEntitlementLeaseProviderChainVerifies(t *testing.T) {
setupTestPublicKey(t)
providerPub, providerPriv, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
t.Fatalf("generate provider key pair: %v", err)
}
license := mintTestProviderMSPLicense(t, TierMSP, providerPub, 30*24*time.Hour)
token := signTestProviderLease(t, providerPriv, license, []string{FeatureWhiteLabel, FeatureMultiTenant})
claims, err := VerifyEntitlementLeaseToken(token, testPublicKey, "t-acme.pulse.example-msp.com", time.Now())
if err != nil {
t.Fatalf("VerifyEntitlementLeaseToken() error = %v, want chain-verified lease", err)
}
got := strings.Join(claims.Capabilities, ",")
if !strings.Contains(got, FeatureWhiteLabel) {
t.Fatalf("chain-verified lease lost white_label: capabilities = %q", got)
}
}
func TestEntitlementLeaseProviderChainCapsCapabilities(t *testing.T) {
setupTestPublicKey(t)
providerPub, providerPriv, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
t.Fatalf("generate provider key pair: %v", err)
}
license := mintTestProviderMSPLicense(t, TierMSP, providerPub, 30*24*time.Hour)
// multi_user is enterprise-only and relay is Pulse-service-backed; a
// provider-minted lease must not be able to grant either even though
// the lease signature verifies.
token := signTestProviderLease(t, providerPriv, license, []string{FeatureWhiteLabel, FeatureMultiUser, FeatureRelay})
claims, err := VerifyEntitlementLeaseToken(token, testPublicKey, "t-acme.pulse.example-msp.com", time.Now())
if err != nil {
t.Fatalf("VerifyEntitlementLeaseToken() error = %v", err)
}
for _, capability := range claims.Capabilities {
switch capability {
case FeatureMultiUser:
t.Fatalf("chained lease escaped the MSP capability ceiling: %v", claims.Capabilities)
case FeatureRelay, FeatureMobileApp, FeaturePushNotifications:
t.Fatalf("chained lease must not grant Pulse-service-backed capability %q: %v", capability, claims.Capabilities)
}
}
if got := strings.Join(claims.Capabilities, ","); !strings.Contains(got, FeatureWhiteLabel) {
t.Fatalf("capability cap removed white_label, which MSP leases legitimately carry: %q", got)
}
}
func TestEntitlementLeaseProviderChainRejectsWrongSigner(t *testing.T) {
setupTestPublicKey(t)
providerPub, _, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
t.Fatalf("generate provider key pair: %v", err)
}
_, otherPriv, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
t.Fatalf("generate other key pair: %v", err)
}
license := mintTestProviderMSPLicense(t, TierMSP, providerPub, 30*24*time.Hour)
token := signTestProviderLease(t, otherPriv, license, []string{FeatureWhiteLabel})
if _, err := VerifyEntitlementLeaseToken(token, testPublicKey, "t-acme.pulse.example-msp.com", time.Now()); err == nil {
t.Fatal("lease signed by a key the provider license does not bind must be rejected")
}
}
func TestEntitlementLeaseProviderChainRejectsNonMSPLicense(t *testing.T) {
setupTestPublicKey(t)
providerPub, providerPriv, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
t.Fatalf("generate provider key pair: %v", err)
}
license := mintTestProviderMSPLicense(t, TierPro, providerPub, 30*24*time.Hour)
token := signTestProviderLease(t, providerPriv, license, []string{FeatureWhiteLabel})
if _, err := VerifyEntitlementLeaseToken(token, testPublicKey, "t-acme.pulse.example-msp.com", time.Now()); err == nil {
t.Fatal("non-MSP license must not bind an entitlement lease signing key")
}
}
func TestEntitlementLeaseProviderChainRejectsUnboundLicense(t *testing.T) {
setupTestPublicKey(t)
_, providerPriv, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
t.Fatalf("generate provider key pair: %v", err)
}
license := mintTestProviderMSPLicense(t, TierMSP, nil, 30*24*time.Hour)
token := signTestProviderLease(t, providerPriv, license, []string{FeatureWhiteLabel})
if _, err := VerifyEntitlementLeaseToken(token, testPublicKey, "t-acme.pulse.example-msp.com", time.Now()); err == nil {
t.Fatal("license without an entitlement signing key binding must not chain")
}
}
func TestEntitlementLeaseProviderChainRejectsForgedLicense(t *testing.T) {
setupTestPublicKey(t)
providerPub, providerPriv, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
t.Fatalf("generate provider key pair: %v", err)
}
// License signed by the provider's own key instead of the Pulse root: a
// self-issued chain must die at license validation.
claims := Claims{
LicenseID: "lic_forged",
Email: "[email protected]",
Tier: TierMSP,
IssuedAt: time.Now().Unix(),
ExpiresAt: time.Now().Add(30 * 24 * time.Hour).Unix(),
PlanVersion: "msp_starter",
EntitlementSigningPublicKey: base64.StdEncoding.EncodeToString(providerPub),
}
payload, err := json.Marshal(claims)
if err != nil {
t.Fatalf("marshal forged license claims: %v", err)
}
forgedLicense := signTestJWT(t, payload, providerPriv)
token := signTestProviderLease(t, providerPriv, forgedLicense, []string{FeatureWhiteLabel})
if _, err := VerifyEntitlementLeaseToken(token, testPublicKey, "t-acme.pulse.example-msp.com", time.Now()); err == nil {
t.Fatal("a provider license not signed by the Pulse root must not chain")
}
}
func TestEntitlementLeaseWithoutProviderLicenseUsesDirectRoot(t *testing.T) {
setupTestPublicKey(t)
token := signTestProviderLease(t, testPrivateKey, "", []string{FeatureWhiteLabel})
claims, err := VerifyEntitlementLeaseToken(token, testPublicKey, "t-acme.pulse.example-msp.com", time.Now())
if err != nil {
t.Fatalf("direct-root lease verification regressed: %v", err)
}
// Direct-root leases are not capability-capped; the signer is Pulse.
if got := strings.Join(claims.Capabilities, ","); !strings.Contains(got, FeatureWhiteLabel) {
t.Fatalf("direct-root lease capabilities = %q", got)
}
}