Cas d'usage
Droits
Les droits sont des concessions signées de type clé/valeur transportées dans chaque licence et lease Keyright. Utilisez-les pour imposer l'accès aux fonctionnalités, les quotas numériques et les versions du produit qu'une licence peut exécuter — le tout à partir d'une seule paire de clés de signature, de sorte que vous livrez une nouvelle version majeure en réémettant une clé, jamais en faisant tourner les clés et en livrant une nouvelle clé publique.
Objectif. Changer ce qu’un client a le droit de faire — quelles fonctionnalités il obtient, quelle quantité de quelque chose il peut utiliser, et quelles versions de votre produit il peut exécuter — sans livrer une nouvelle version, et sans jamais faire tourner vos clés de signature. Les droits sont l’unique mécanisme sous ces trois cas.
Ce qu’est un droit
Un droit est une paire name → value que vous attachez à une licence. Keyright la signe dans la licence avec la clé privée de votre tenant et la livre sur la machine du client de deux façons que votre application vérifie déjà :
- à l’intérieur du fichier de licence hors ligne, et
- à l’intérieur du lease d’activation en ligne de courte durée.
Les deux sont signés en RSA et vérifiés contre la clé publique embarquée dans votre application, de sorte qu’un client ne peut ni ajouter un droit, ni en activer un, ni relever un nombre — modifier le moindre élément casse la signature et le SDK rejette l’ensemble. Rien dans un droit n’est secret ; la sécurité, c’est la signature, pas le fait de cacher la valeur.
Comme chaque SDK (.NET, Node, Python, Java) et le format HTTP brut vérifient la même charge utile signée, les mêmes droits se lisent de la même façon à travers une gamme de produits multilingue à partir d’une seule clé publique.
Le principe : une paire de clés, toutes les versions
L’erreur de licence la plus courante est de lier la paire de clés de signature à une version du produit — émettre des licences 3.0 sous une nouvelle clé et livrer une nouvelle clé publique dans le build 3.0. Cela casse les anciens builds (ils ne peuvent pas vérifier la nouvelle clé), force la migration de tous les clients payants d’un coup, et ne vous donne aucun contrôle par client.
Le modèle de Keyright est l’inverse :
Conservez une seule paire de clés pour toute la vie du produit. Transportez ce qu’une licence a le droit de faire dans des droits signés, et changez-le en réémettant la clé — jamais en faisant tourner les clés.
La clé publique de votre application ne bouge jamais. Livrer la 4.0 n’y touche pas. Qu’une licence donnée puisse exécuter la 4.0 est une question de droit, résolue localement contre la clé que vous embarquez déjà.
Les trois modèles
Lisez les droits depuis le LicenseInfo résolu. Le SDK .NET expose un EntitlementSet avec des accesseurs typés ; les autres SDK exposent l’équivalent.
1. Indicateurs de fonctionnalité — débloquer une capacité
Une concession booléenne : activée ou désactivée. IsEnabled accepte true, 1, yes ou enabled.
var info = client.Validate(); // offline, from the cached lease/license
if (info.Entitlements.IsEnabled("feature.pdf_export"))
EnablePdfExport();
C’est le déblocage classique par édition. Pour le traitement complet — définir des fonctionnalités sur une édition, la condition payant-vs-gratuit, la combinaison avec des indicateurs de fonctionnalité opérationnels — voir Conditionner des fonctionnalités et des éditions.
2. Quotas numériques — imposer une limite
Un nombre que le client a payé : sièges, projets, appels d’API, appareils. GetLimit analyse la valeur et traite "unlimited" comme effectivement infini ; le repli est ce qu’obtient une valeur non licenciée ou absente (échec en mode fermé).
long maxProjects = info.Entitlements.GetLimit("max_projects", fallback: 3);
if (currentProjectCount >= maxProjects)
throw new QuotaExceeded($"Your plan allows {maxProjects} projects.");
Changez la limite d’un client en réémettant sa clé avec un nouveau max_projects — sans build, sans changement de clé.
3. Contrôle des versions — quelles releases une licence exécute
Votre application connaît sa propre version majeure. La licence porte la version majeure la plus haute qu’elle couvre. N’exécutez qu’à ce plafond ou en dessous :
const int runningMajor = 4; // this build's major version
var raw = info.Entitlements.GetRaw("max_major_version"); // e.g. "3" or "4"
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.");
Voilà comment vous livrez une nouvelle version majeure sans faire tourner les clés : une licence vendue pour la ligne 3.x porte max_major_version: "3" (ou rien, si elle précède le schéma), de sorte que la 4.0 la refuse localement ; une licence qui inclut la mise à niveau vers la 4.0 porte "4". Un plafond plus élevé s’exécute toujours sur d’anciens builds, donc une licence 4.x continue de fonctionner sur la 3.x.
max_major_versionest un nom que vous choisissez. Prenez n’importe quelle clé sur laquelle votre application s’accorde. La valeur est une simple chaîne ; analysez-la selon votre façon de versionner.
Besoin d’un contrôle plus fin qu’« une version majeure » ? Si vous vendez par date de release, par fenêtres de maintenance ou par plages de versions exactes — « chaque release 2.x », « tout ce qui sort dans l’année suivant l’achat », « tout ce qui sort tant que l’abonnement est actif » — utilisez le moteur de couverture des versions de première classe de Keyright, qui enregistre et signe l’ensemble de couverture complet et répond à l’éligibilité de n’importe quelle version. Le droit ci-dessus est la version légère, au grain de la majeure, de la même idée ; la couverture des versions est la version précise.
Définir des droits
Sur une seule licence
Attachez des droits lorsque vous émettez (ou mettez à jour) une clé — 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": {
"feature.pdf_export": "true",
"max_projects": "10",
"max_major_version": "3"
}
}'
Dans le tableau de bord, ils apparaissent dans l’éditeur Features du volet Issue-license sous forme de lignes key → value.
Sur un modèle d’édition/de niveau (hérité automatiquement)
Placez les valeurs par défaut sur l’édition pour que chaque clé émise à partir d’elle en hérite. Voilà comment vous le rendez automatique pour l’avenir : définissez max_major_version sur votre édition actuelle aujourd’hui et, lorsque vous livrez la prochaine version majeure, relevez le modèle (ou ajoutez une nouvelle édition) — chaque clé frappée ensuite porte le nouveau plafond, et chaque clé déjà sur le terrain garde ce avec quoi elle a été émise.
curl -X POST "https://keyright.example.com/admin/products/your-product/tiers" \
-H "X-Admin-Token: $KEYRIGHT_ADMIN_TOKEN" -H "Content-Type: application/json" \
-d '{ "name": "Pro", "seats": 3,
"entitlements": { "feature.pdf_export": "true", "max_major_version": "3" } }'
Comment les droits atteignent l’application
issue/update license ──signs──▶ offline license file ─┐
│ ├─▶ your app verifies against the
└──on activation──▶ signed online lease ────────┘ embedded public key, reads EntitlementSet
- Les licences hors ligne portent les droits dans le document signé ; les machines isolées du réseau les lisent sans connexion.
- Les leases en ligne portent les mêmes droits, signés à l’activation, de sorte que le chemin en ligne expose exactement ce que le chemin hors ligne expose. Un lease se renouvelle contre le service avant d’expirer — ainsi, réémettre les droits d’un client prend effet à son prochain renouvellement, sans ressaisie de clé ni réactivation.
Comme les valeurs sont dans la charge utile signée, un fichier altéré ou modifié à la main échoue à la vérification et est rejeté entièrement — vous ne lisez jamais un droit falsifié.
Lire les droits dans chaque SDK
Chaque SDK résout le même ensemble signé. Les accesseurs (les noms peuvent différer légèrement) sont : une vérification booléenne IsEnabled(name), une lecture numérique GetLimit(name, fallback) ("unlimited" ⇒ max), une lecture de chaîne brute, et un utilitaire de liste/appartenance pour les concessions multivaleurs.
- .NET —
info.Entitlements.IsEnabled(...),.GetLimit(...),.GetRaw(...),.GetList(...),.IsListed(name, value). - Node / Python / Java — les mêmes lectures sur les droits de la licence résolue.
- HTTP — les droits sont un objet JSON sur le lease/la licence signé(e) ; vérifiez la signature, puis lisez l’objet directement.
Voir les guides par langage sous Intégration du SDK, et le dépôt d’exemples exécutable (l’opération 7 démontre les trois modèles).
Droit vs. indicateur de fonctionnalité vs. couverture des versions
| Vous voulez… | Utilisez |
|---|---|
| Débloquer une capacité qu’un client a payée | Droit (booléen) — cette page / conditionner des fonctionnalités |
| Imposer une limite numérique (sièges, projets, appels) | Droit (GetLimit) |
| Conditionner une version majeure entière, simplement | Droit (max_major_version) |
| Conditionner par date de release / plage de versions / fenêtre de maintenance | Couverture des versions |
| Échelonner un déploiement que vous contrôlez (pas un achat) | Un indicateur de fonctionnalité opérationnel, superposé à l’intérieur de ce que le droit autorise déjà |
Vérifier
- Émettez deux clés sous le même produit et la même paire de clés — une avec
max_major_version: "3", une avec"4". - Dans un build dont la version majeure est
4, confirmez que la première est refusée (« mise à niveau requise ») et que la seconde s’exécute — avec la même clé publique dans l’application. - Modifiez un lease/une licence stocké(e) pour relever
max_projectsou ajouterfeature.pdf_export; confirmez que le SDK le rejette (la signature ne correspond plus). - Émettez une clé sans
max_major_version; confirmez qu’elle se comporte comme votre valeur par défaut documentée antérieure à la couverture.