Licenciez toutes les versions depuis une seule paire de clés
Faire tourner vos clés de signature à chaque version majeure est le piège : cela casse les builds plus anciens, impose une migration de masse et ne vous laisse aucun contrôle par client. Le meilleur modèle conserve une seule paire de clés pour toute la vie du produit et porte ce qu'une licence peut faire — quelles versions elle exécute, quelles fonctionnalités elle déverrouille, combien elle peut utiliser — dans des droits signés. Cet article montre les trois schémas avec du vrai code, comment les concessions restent inviolables en ligne comme hors ligne, et quand recourir plutôt à la couverture de versions complète.
Il existe un raccourci tentant quand vous publiez une nouvelle version majeure d’un produit payant : émettre les licences de la nouvelle version avec une nouvelle paire de clés de signature, embarquer la nouvelle clé publique dans le nouveau build et laisser les anciennes clés cesser de vérifier. Cela ressemble à une rupture nette. C’est un piège.
Une paire de clés liée à une version casse tout ce qui est plus ancien : un build 3.x ne peut pas vérifier une licence signée avec la clé 4.x, et inversement. Vous êtes forcé de réémettre et de migrer tous vos clients payants d’un coup, selon votre calendrier, pas le leur. Et vous n’obtenez aucune granularité : vous ne pouvez pas laisser la licence d’un client couvrir à la fois 3.x et 4.x, car la clé est tout ou rien. La paire de clés est le mauvais endroit pour encoder une décision commerciale.
Le modèle : une paire de clés, pour toute la vie du produit
Conservez une seule paire de clés de signature pour le produit, à jamais. La clé publique embarquée dans votre application ne bouge jamais : publier la 4.0 n’y touche pas. Portez ce qu’une licence peut faire dans des droits : des concessions signées de type nom → valeur qui voyagent dans la licence et sont vérifiées face à la clé que vous embarquez déjà.
Changez ce qu’un client peut exécuter, déverrouiller ou utiliser en réémettant sa clé, jamais en faisant tourner les clés et en livrant une nouvelle clé publique.
Un droit est livré de deux manières que votre application vérifie déjà : dans le fichier de licence hors ligne et dans le bail d’activation en ligne de courte durée. Les deux sont signés en RSA et contrôlés face à votre clé publique embarquée ; un client ne peut donc pas ajouter une concession, basculer un drapeau ni relever un nombre — éditer quoi que ce soit casse la signature et le SDK refuse l’artefact entier. Comme chaque SDK (.NET, Node, Python, Java) et le format HTTP brut vérifient le même payload signé, les mêmes concessions se lisent de façon identique dans une gamme de produits multilingue depuis une seule clé publique.
Cas 1 — contrôle des versions, sans faire tourner les clés
Votre application connaît sa propre version majeure. La licence porte la version majeure la plus haute qu’elle couvre. N’exécutez qu’au niveau ou en dessous de ce plafond :
const int runningMajor = 4; // this build's major version
var raw = info.Entitlements.GetRaw("max_major_version"); // e.g. "3" or "4" (a name you choose)
int ceiling = int.TryParse(raw, out var m) ? m : 3; // absent => your pre-coverage default
if (runningMajor > ceiling)
ShowUpgradeRequired($"Your license covers up to v{ceiling}.x.");
Une licence vendue pour la ligne 3.x porte max_major_version: "3" — ou rien, si elle précède le schéma, auquel cas votre code traite « absent » comme la dernière version majeure avant l’ajout de la règle. Publiez la 4.0 et elle refuse cette clé localement, face à la clé publique déjà présente dans l’application. Un client qui achète la mise à niveau 4.0 voit sa clé réémise avec "4". Un plafond plus élevé tourne toujours sur les builds plus anciens, donc une licence 4.x continue de fonctionner sur 3.x. Aucune clé n’a bougé ; aucun build n’a livré de nouvelle clé publique.
Cas 2 — déverrouiller une fonctionnalité
Une concession booléenne : activée ou désactivée. L’accesseur traite true, 1, yes ou enabled comme activés :
if (info.Entitlements.IsEnabled("feature.pdf_export"))
EnablePdfExport();
C’est le déverrouillage par édition : « Export », « SSO », « rapports avancés » s’activent depuis la licence du client, vérifiés hors ligne, et vous changez qui obtient quoi en réémettant, sans nouveau build. (Les feature flags opérationnels d’un déploiement que vous contrôlez se superposent à l’intérieur de ce que le droit autorise déjà ; le droit est toujours la barrière dure.)
Cas 3 — imposer un quota numérique
Un nombre que le client a payé : sièges, projets, appels API, appareils. La lecture de la limite traite "unlimited" comme effectivement infini, et la valeur de repli est ce que reçoit une valeur absente (échec fermé) :
long maxProjects = info.Entitlements.GetLimit("max_projects", fallback: 3);
if (currentProjectCount >= maxProjects)
throw new QuotaExceeded($"Your plan allows {maxProjects} projects.");
Relever la limite d’un client est une réémission de clé avec un nouveau max_projects. Aucun build, aucun changement de clé, et cela prend effet à son prochain renouvellement de bail ou à sa prochaine licence hors ligne.
Définir les concessions
Attachez les droits quand vous émettez ou mettez à jour une clé — depuis le tableau de bord ou l’API d’administration :
curl -X POST "https://keyright.example.com/admin/licenses" \
-H "X-Admin-Token: $KEYRIGHT_ADMIN_TOKEN" -H "Content-Type: application/json" \
-d '{ "licensee": "Acme Ltd", "product": "your-product", "tier": "pro",
"entitlements": { "max_major_version": "3", "feature.pdf_export": "true", "max_projects": "10" } }'
Mieux encore, placez les valeurs par défaut sur le modèle d’édition/niveau afin que chaque clé émise sous lui en hérite. Voilà comment « automatique à l’avenir » fonctionne : définissez max_major_version sur votre édition actuelle aujourd’hui, et quand vous publiez la prochaine version majeure, relevez le modèle (ou ajoutez une nouvelle édition). Chaque clé frappée ensuite porte le nouveau plafond ; chaque clé déjà sur le terrain garde ce avec quoi elle a été émise, et continue de fonctionner.
Quand recourir plutôt à la couverture de versions
Un droit simple max_major_version répond à « quelles versions cette licence peut-elle exécuter » à la granularité d’une version majeure. Si vous vendez par date de sortie, fenêtres de maintenance ou plages de versions exactes — « chaque version 2.x », « tout ce qui sort dans l’année suivant l’achat », « tout ce qui sort tant que l’abonnement est actif » — utilisez la couverture de versions de première classe de Keyright, qui enregistre et signe l’ensemble complet de couverture et répond à l’éligibilité de n’importe quel build précis. Le droit est la version légère, à la granularité majeure, de la même idée ; la couverture de versions est la précise.
À retenir
Votre paire de clés de signature identifie votre produit, pas une version de celui-ci. Gardez-la stable pour toute la vie du produit et laissez les droits signés porter les décisions commerciales : quelles versions une licence exécute, quelles fonctionnalités elle déverrouille, combien elle peut utiliser. Vous changez ce qu’un client peut faire en réémettant sa clé face à la clé que vous livrez déjà, et les builds plus anciens ne cassent jamais car la clé publique n’a jamais bougé.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.