Eine Keyright-Lizenz auf eine Umgebung begrenzen
Dieselbe Lizenzdatei wandert gern von der Produktion ins Staging, auf den Laptop eines Entwicklers und durch die CI, bis niemand mehr weiß, aus welcher Umgebung eine Validierung kam, und ein geleakter Staging-Schlüssel unbemerkt die Produktion freischaltet. Dies ist eine Migrationsanleitung: Vergleichen Sie die drei Wege, auf denen Teams Umgebungen trennen — ein Produkt pro Umgebung, eine schlichte Datei pro Umgebung und ein einziges Produkt mit einem signierten env-Entitlement — und migrieren Sie dann ohne Stichtag auf Keyright zum letzten. Er behandelt, wo die Anwendung ihre eigene Umgebung erfährt (IHostEnvironment und der Fallback DOTNET_ENVIRONMENT / ASPNETCORE_ENVIRONMENT), eine Prüfung von zwanzig Zeilen, die bei unbekannter Umgebung geschlossen abriegelt, ein rückwärtskompatibles Rollout, bei dem ein alter, uneingeschränkter Schlüssel weiterhin überall läuft, und die ehrliche Grenze: die Umgebung wird von Ihrer eigenen Konfiguration gemeldet, also geht es um Hygiene und saubere Telemetrie, nicht um eine Mauer gegen einen Operator, der die Variable setzt.
Beobachten Sie eine einzelne Lizenzdatei lange genug, und sie landet überall. Sie stellen einen Schlüssel für das Produkt aus, legen ihn ins Produktionsdeployment, und innerhalb eines Sprints ist er bereits in die Staging-Umgebung kopiert worden, damit die Smoke-Tests vor der Produktion durchlaufen, in das appsettings.Development.json eines Entwicklers eingefügt und in ein CI-Secret eingebacken, damit die Integrationstests laufen. Jetzt präsentieren vier Umgebungen denselben signierten Schlüssel Ihrer Keyright-Instanz, und drei Tatsachen, die Sie gern hätten, sind verschwunden: Sie können aus einer Validierung nicht ablesen, aus welcher Umgebung sie kam, ein Staging-Schlüssel, der leakt, ist ein Produktionsschlüssel, und an dem Tag, an dem Sie den Staging-Schlüssel früher ablaufen lassen wollen, stellen Sie fest, dass er der Produktionsschlüssel ist.
Dieser Beitrag ist eine Migrationsanleitung. Wir vergleichen die drei Wege, auf denen Teams Umgebungen tatsächlich trennen, wählen den, der ein einziges Produkt und einen einzigen Codepfad bewahrt, und migrieren ohne Stichtag auf Keyright dorthin — einschließlich des Teils, den die meisten Rollouts überspringen, nämlich den alten, uneingeschränkten Schlüssel weiterlaufen zu lassen, während die neuen eingeschränkten Schlüssel ausgerollt werden.
Drei Wege, Produktion von Staging zu unterscheiden
Es gibt nur drei Formen dafür, und sie unterscheiden sich darin, wie viel Zeremonie und wie viel Duplizierung sie kosten.
Ein Produkt pro Umgebung. Registrieren Sie acme-studio-prod und acme-studio-staging als getrennte Produkte in Ihrem ausstellenden Dienst, jedes mit eigenem Signaturschlüssel, und liefern Sie pro Build einen anderen öffentlichen Schlüssel aus. Es funktioniert, und die Trennung ist absolut, aber Sie pflegen jetzt von allem zwei — zwei Schlüsselpaare, zwei Entitlement-Kataloge, zwei Rotationspläne — und eine Funktion, die Sie dem einen hinzufügen, müssen Sie daran denken, auch dem anderen hinzuzufügen. Das ist nur dann die richtige Antwort, wenn Staging und Produktion wirklich verschiedene Produkte mit verschiedenen Fähigkeiten sind, was selten vorkommt.
Eine schlichte Datei pro Umgebung, dasselbe Produkt. Stellen Sie zwei Lizenzen für das eine Produkt aus und verlassen Sie sich auf Deployment-Disziplin, um sie getrennt zu halten. Nichts im Schlüssel sagt, für welche Umgebung er ist, also hindert nichts die Staging-Datei daran, in der Produktion zu laufen; sobald jemand die falsche Datei kopiert, sind Sie wieder am Anfang, und das signierte Payload hilft nicht, weil es gar keine Umgebung trägt.
Ein Produkt, mit der Umgebung im signierten Payload. Behalten Sie ein einziges Produkt und einen einzigen öffentlichen Schlüssel und fügen Sie ein scope:env-Entitlement hinzu, das die Umgebung(en) nennt, für die der Schlüssel lizenziert ist. Der Staging-Schlüssel kann sich buchstäblich nicht als in der Produktion lizenziert validieren, weil die Anwendung ihre eigene Umgebung gegen die Behauptung prüft und die Behauptung von der Signatur abgedeckt ist. Kein zweites Produkt, keine zweite Rotation, eine einzige Prüfung. Das ist die Form, zu der wir migrieren.
Was der Schlüssel sagt
Ein scope:env-Entitlement ist ein gewöhnliches signiertes Entitlement — eine Zeichenkette im kanonischen Payload, das die Signatur abdeckt — und enthält eine kommagetrennte Menge von Umgebungsnamen, in denen der Schlüssel gültig ist. Ein Produktionsschlüssel nennt eine Umgebung; ein Schlüssel, den Sie über Ihre eigenen Vorproduktionsstufen hinweg wiederverwenden wollen, nennt mehrere.
{
"product": "acme-studio",
"licensee": "Contoso Ltd",
"expiryUtc": "2027-11-16T00:00:00Z",
"tier": "pro",
"entitlements": {
"scope:env": "production",
"export": "true",
"max-seats": "400"
},
"signature": "…"
}
Das Präfix scope: ist eine Konvention, kein Keyright-Feature, und es verdient seinen Platz auf dieselbe Weise wie site:: Es hält sichtbar getrennt, wo dieser Schlüssel laufen darf, von was dieser Schlüssel freischaltet, damit niemand später die Funktion export an eine Umgebung koppelt oder umgekehrt. Da der Wert im signierten Payload steht, kann ein Kunde — oder ein Entwickler in Eile — production ebenso wenig in staging ändern, wie er das Ablaufdatum um ein Jahr hinausschieben kann: ein geändertes Byte, und die Anwendung sieht LicenseStatus.SignatureInvalid.
Was die Anwendung über ihre eigene Umgebung weiß
Die Anwendung muss die Frage „Welche Umgebung bin ich?” aus ihrer eigenen Konfiguration beantworten, offline, beim Start. In einer ASP.NET-Core- oder Generic-Host-Anwendung existiert die Antwort bereits: IHostEnvironment.EnvironmentName, das der Host aus DOTNET_ENVIRONMENT (oder ASPNETCORE_ENVIRONMENT für den Webhost) auflöst, mit Production als Standard, wenn keines gesetzt ist. Kapseln Sie es hinter einer Schnittstelle, damit die Prüfung testbar bleibt und Anwendungen ohne Host dieselbe Antwort aus einer schlichten Umgebungsvariablen liefern können.
public interface IAppEnvironment
{
string? Name { get; } // "Production", "Staging", … ; null when genuinely unknown
}
// Host apps: let the framework resolve DOTNET_ENVIRONMENT / ASPNETCORE_ENVIRONMENT.
public sealed class HostAppEnvironment(IHostEnvironment env) : IAppEnvironment
{
public string? Name =>
string.IsNullOrWhiteSpace(env.EnvironmentName) ? null : env.EnvironmentName;
}
// Console / worker without a host: same variables, explicit fallback order.
public sealed class VariableAppEnvironment : IAppEnvironment
{
public string? Name =>
Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT")
?? Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
// intentionally NOT defaulting to "Production": see the gate — unknown fails closed
}
Eine bewusste Entscheidung: Der Host-Wrapper erbt das „Standard Production”-Verhalten des Frameworks, der Variablen-Wrapper nicht. Für eine Prüfung soll eine nicht gesetzte Umgebung unbekannt sein, nicht stillschweigend Produktion — eine unbekannte Umgebung auf einem eingeschränkten Schlüssel sollte abgelehnt werden, nicht als privilegierteste Stufe durchgewunken. Der Host-Fall ist die Ausnahme, weil das Framework die Entscheidung bereits für die gesamte Anwendung konsistent getroffen hat, bevor Ihre Prüfung läuft.
Die Prüfung
Die Prüfung läuft nach Validate() und tut nur dann etwas, wenn der Schlüssel tatsächlich eine scope:env-Behauptung trägt. Der Abgleich ist ein Zugehörigkeitstest ohne Groß-/Kleinschreibung gegen die kommagetrennte Menge, sodass scope:env = "staging,production" beide zulässt.
public enum EnvStatus { Ok, NotEnvScoped, Unknown, WrongEnv }
public static class EnvGate
{
public static EnvStatus Check(LicenseInfo info, IAppEnvironment app)
{
var claim = info.Entitlements.GetRaw("scope:env");
if (string.IsNullOrWhiteSpace(claim))
return EnvStatus.NotEnvScoped; // legacy/unscoped key: nothing to check
var here = app.Name;
if (string.IsNullOrWhiteSpace(here))
return EnvStatus.Unknown; // fail closed: unknown ≠ allowed
var allowed = claim.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
foreach (var e in allowed)
if (string.Equals(e, here, StringComparison.OrdinalIgnoreCase))
return EnvStatus.Ok;
return EnvStatus.WrongEnv; // e.g. staging key launched in Production
}
}
Hängen Sie sie beim Start ein, nach den Signatur- und Ablaufprüfungen, die das SDK bereits durchführt:
static readonly KeyrightClient License = KeyrightClient.Initialize(new KeyrightOptions
{
Product = "acme-studio",
PublicKeyBase64 = AcmeKeys.LicensePublicKey, // public key only; safe to ship
});
LicenseInfo info = License.Validate(); // signature, product, expiry
if (!info.IsValid) { RunEvaluation(info); return; }
var env = EnvGate.Check(info, app); // app resolved from DI or the variable wrapper
if (env is not (EnvStatus.Ok or EnvStatus.NotEnvScoped))
{
RunEvaluation(info, reason: env); // "this key is licensed for staging, not Production"
return;
}
RunLicensed(info);
Die Reihenfolge ist wichtig: Die Umgebungsprüfung läuft nach IsValid. Ein Schlüssel mit ungültiger Signatur erreicht die Prüfung nie, sodass die scope:env-Zeichenkette, die ein Angreifer hätte eintippen können, nie gelesen wird — Entitlements sind erst dann vertrauenswürdig, wenn die Signatur über ihnen verifiziert wurde, und Keyright gibt für alles, was nicht validiert hat, eine leere Entitlement-Menge zurück.
Ohne Stichtag migrieren
Die Falle jedes Durchsetzungs-Rollouts ist der Stichtag: Sie liefern die Prüfung und die eingeschränkten Schlüssel in derselben Version, der Produktionsknoten eines Kunden fährt mit dem alten, uneingeschränkten Schlüssel hoch, die Prüfung findet keine Behauptung, die sie erkennt, und Sie haben ein Update in einen Ausfall verwandelt. Die obige Prüfung ist genau dafür geschrieben, das zu vermeiden — NotEnvScoped ist ein Erfolg —, aber es lohnt sich, über die drei Phasen explizit zu sein.
Phase 1 — rückwärtskompatible Ausstellung. Beginnen Sie, neue Schlüssel mit vorhandenem scope:env auszustellen, und lassen Sie jeden bestehenden, uneingeschränkten Schlüssel unangetastet. Da eine fehlende Behauptung NotEnvScoped zurückgibt und das als „läuft überall” behandelt wird, funktioniert der alte Produktionsschlüssel unberührt weiter, während die neuen Staging- und Produktionsschlüssel ihren Scope tragen. Kein Knoten muss für das Update neu verschlüsselt werden.
Phase 2 — auditieren, nicht durchsetzen. Liefern Sie die Prüfung, die EnvStatus berechnet, es aber protokolliert, statt danach zu handeln. Lesen Sie die Protokolle eine Version lang. Hier entdecken Sie die Umgebungsnamen, die Sie nicht vorhergesehen haben — das Staging2, das jemand aufgesetzt hat, den Blue/Green-Slot, der unter einem anderen DOTNET_ENVIRONMENT als Production meldet, den Lasttest-Rig, der einen Produktionsschlüssel geerbt hat. Das Muster des Rollouts im Audit-Modus gilt hier unverändert.
Phase 3 — durchsetzen und neu ausstellen. Schalten Sie die Prüfung so um, dass sie auf WrongEnv/Unknown reagiert, und stellen Sie die verbleibenden uneingeschränkten Altschlüssel bei ihrer nächsten Verlängerung als eingeschränkt neu aus. Der uneingeschränkte Schlüssel ist nicht unsicher — er sagt lediglich nichts über die Umgebung — also gibt es keine Dringlichkeit, nur eine Richtung: Jede Verlängerung verringert den Schadensradius eines Leaks um eine weitere Umgebung.
Einen eingeschränkten Schlüssel ausstellen und die Diagnose
Auf der ausstellenden Seite ist der Scope nur ein weiteres Entitlement, das es zu setzen gilt. Wie auch immer Sie Schlüssel prägen — Admin-API oder CLI gegen Ihre Keyright-Instanz — die Produktions- und Staging-Schlüssel unterscheiden sich in einem Feld:
# production key
keyright issue --product acme-studio --licensee "Contoso Ltd" \
--entitlement scope:env=production --entitlement max-seats=400 --expiry 2027-11-16
# a single key reusable across your own pre-prod tiers
keyright issue --product acme-studio --licensee "Contoso Ltd (pre-prod)" \
--entitlement scope:env=staging,qa --expiry 2027-11-16
Schließen Sie die Übergabelücke so, wie es der Site-Lizenz-Flow tut: Liefern Sie eine einzeilige Diagnose aus, die die Umgebung ausgibt, die die Prüfung prüfen würde, aus genau dem Codepfad, den die Prüfung verwendet, damit „falsche Umgebung” nie zu einem Support-Ticket darüber wird, was die Umgebung tatsächlich ist.
// yourapp --env-info
var app = new VariableAppEnvironment();
Console.WriteLine($"Resolved environment : {app.Name ?? "(unknown — DOTNET_ENVIRONMENT unset)"}");
Was die Umgebungseinschränkung beweist — und was nicht
Seien Sie in Ihrem eigenen Bedrohungsmodell ehrlich darüber, was diese Bindung ist.
Die Umgebung ist selbst gemeldet. scope:env wird gegen einen Wert geprüft, den der laufende Prozess aus seiner eigenen Konfiguration liest, und ein Operator, der diese Konfiguration kontrolliert, kann DOTNET_ENVIRONMENT=Production auf einer Staging-Maschine setzen, und die Prüfung geht durch. Das ist also keine Mauer gegen einen entschlossenen Operator, der den Host besitzt — das soll es auch nicht sein. Was sie aufhält, ist der hundertmal häufigere Unfall: der Staging-Schlüssel, der in die Produktion kopiert wird und dort ein Jahr lang still läuft, der Entwicklerschlüssel, der geleakt ist und nun die Produktionsstufe freischaltet, das CI-Secret, das sich als Produktionslizenz herausstellt. Das sind Konfigurationsfehler, und scope:env verwandelt sie von still in eine laute, präzise Ablehnung mit angehängtem Grund.
Es ist eine Hygiene- und Telemetriegrenze, kein Sitz-Zähler. Die Einschränkung begrenzt nicht, wie viele Maschinen einen Schlüssel ausführen — ein Produktionsschlüssel mit max-seats zählt Sitze weiterhin wie immer; der Scope begrenzt nur, in welcher Stufe er läuft. Beide sind orthogonal, und es lohnt sich, sie so zu halten: Ein Schlüssel, der sowohl sitzbegrenzt als auch umgebungseingeschränkt ist, sagt Ihnen in seiner Telemetrie sowohl, wie viele Produktionsknoten aktiv sind, als auch, dass keiner davon heimlich Staging ist.
Für eine nicht vertrauenswürdige Grenze schränken Sie anders ein. Wenn „Staging” die Umgebung eines anderen Kunden ist statt Ihrer eigenen Stufe, ist selbst gemeldete Konfiguration gänzlich das falsche Instrument — binden Sie an etwas, das die Gegenseite nicht behaupten kann, wie es die Site-Lizenz-Domänenbindung tut, oder stellen Sie wirklich getrennte Produkte aus. Die Umgebungseinschränkung verdient ihren Platz, wenn die Umgebungen alle Ihre sind, das Risiko ein Fehler statt eines Gegners ist und Sie wollen, dass der Schlüssel selbst — nicht ein Deployment-Runbook — das ist, was Produktion und Staging getrennt hält.
Eine Lizenz, die überall läuft, ist bequem bis zum ersten Leak, bei dem „überall” aufhört, ein Vorteil zu sein. Die Umgebung in den signierten Schlüssel zu schreiben kostet ein Entitlement und eine Prüfung von zwanzig Zeilen, migriert ohne Stichtag, weil ein uneingeschränkter Schlüssel weiterhin überall läuft, und gibt jeder Validierung eine Antwort auf die Frage, die Ihrem Audit-Log gefehlt hat: Aus welcher Umgebung kam diese?
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.