Comment créer une clé de produit pour mon application C #?
Comment créer une clé de produit pour mon application C #?
Je dois créer une clé de produit (ou de licence) que je mets à jour annuellement. De plus, je dois en créer un pour les versions d'évaluation.
En relation:
Vous pouvez faire quelque chose comme créer un enregistrement contenant les données que vous souhaitez authentifier auprès de l'application. Cela peut inclure tout ce que vous voulez - par exemple fonctionnalités du programme pour activer, date d'expiration, nom de l'utilisateur (si vous souhaitez le lier à un utilisateur). Puis chiffrez cela en utilisant un algorithme de chiffrement avec une clé fixe ou hachez-le. Ensuite, il vous suffit de le vérifier dans votre programme. Un moyen de distribuer le fichier de licence (sous Windows) consiste à le fournir sous forme de fichier qui met à jour le registre (en évitant à l'utilisateur de le saisir).
Attention toutefois au faux sentiment de sécurité - tôt ou tard, quelqu'un va tout simplement corriger votre programme pour ignorer cette vérification et distribuer la version corrigée. Ou bien, ils travailleront sur une clé qui passe toutes les vérifications et la distribueront, ou antidater l'horloge, etc. Peu importe la complexité de vos stratagèmes, tout ce que vous ferez dans ce but sera finalement une sécurité par l'obscurité et être capable de cela. Même s'ils ne peuvent pas, quelqu'un le fera et distribuera la version piratée. La même chose s'applique même si vous fournissez un dongle - si quelqu'un le souhaite, il peut également corriger le chèque. Signer numériquement votre code ne vous aidera pas, ils peuvent supprimer cette signature ou la démissionner.
Vous pouvez compliquer un peu les choses en utilisant des techniques pour empêcher le programme de s'exécuter dans un débogueur, etc., mais même ceci n'est pas à l'abri des balles. Donc, vous devriez juste rendre assez difficile qu'un utilisateur honnête n'oublie pas de payer. Veillez également à ce que votre système ne devienne pas gênant pour les utilisateurs payants - il est préférable d’avoir des copies arrachées plutôt que de permettre à vos clients payants de ne pas utiliser ce qu’ils ont payé.
Une autre option consiste à effectuer une vérification en ligne: il suffit de fournir à l'utilisateur un identifiant unique, de vérifier en ligne quelles fonctionnalités cet identifiant doit avoir et de le mettre en cache pendant un certain temps. Les mêmes mises en garde s’appliquent cependant: les gens peuvent éviter ce genre de situation.
Pensez également aux coûts de support liés au fait de devoir traiter avec des utilisateurs qui ont oublié leur clé, etc.
edit: Je veux juste ajouter, n'investissez pas trop de temps dans ceci ou pensez que votre système compliqué sera différent et infranchissable. Il ne le sera pas et ne pourra pas être aussi longtemps que des personnes contrôlent le matériel et Les développeurs ont essayé de concevoir des schémas de plus en plus complexes, pensant que s’ils développaient leur propre système, ils ne le sauraient que par eux-mêmes et seraient donc "plus sûrs". l'équivalent de la programmation d'essayer de construire une machine à mouvement perpétuel.: -)
En qui as-tu confiance?
J'ai toujours estimé que ce domaine était trop critique pour faire confiance à un tiers pour gérer la sécurité d'exécution de votre application. Une fois que ce composant est fissuré pour une application, il l'est pour toutes les applications. Il est arrivé à Discret en cinq minutes une fois qu'ils sont partis avec une solution de licence tierce pour ds Max il y a des années ... De bons moments!
Sérieusement, envisagez de lancer le vôtre pour avoir le contrôle total de votre algorithme. Si vous le faites, envisagez d’utiliser des composants dans votre clé selon les axes suivants:
- Nom de la licence - le nom du client (le cas échéant) que vous utilisez. Utile pour la gestion des déploiements d'entreprise: donnez-leur le sentiment d'avoir un nom "personnalisé" dans les informations de licence que vous leur fournissez.
- Date d'expiration de la licence
- Nombre d'utilisateurs à exécuter sous la même licence. Cela suppose que vous ayez un moyen de suivre les instances en cours d'exécution sur un site, de manière serveur-ish
- Codes de fonction - pour vous permettre d'utiliser le même système de licence pour plusieurs fonctionnalités et pour plusieurs produits. Bien sûr, si un produit est fissuré, il l'est pour tous.
Puis, contrôlez l’enfer et ajoutez le cryptage (réversible) de votre choix pour le rendre plus difficile à craquer.
Pour créer une clé de licence d'évaluation, il vous suffit de définir les valeurs ci-dessus, qui se traduisent par "mode d'évaluation".
Et comme il s’agit maintenant probablement du code le plus important dans votre application/société, au-delà de/au lieu de l’obscurcissement, envisagez de placer les routines de déchiffrement dans un fichier natif DLL et simplement P/Invoke à cela.
Plusieurs entreprises pour lesquelles j'ai travaillé ont adopté des approches généralisées pour cela avec un grand succès. Ou peut-être que les produits ne valaient pas la peine d'être craqués;)
Si vous posez des questions sur les clés que vous pouvez saisir, telles que les clés de produit Windows, elles sont basées sur certaines vérifications. Si vous parlez des clés que vous devez copier coller, elles sont basées sur une signature numérique (cryptage par clé privée).
Une logique de clé de produit simple pourrait être de commencer par dire que la clé de produit se compose de quatre groupes de 5 chiffres, comme abcde-fghij-kljmo-pqrst, puis spécifiez les relations internes telles que f + k + p doit être égal à a, ce qui signifie que les premiers chiffres des groupes 2, 3 et 4 doivent être égaux à a. Cela signifie que 8xxxx-2xxxx-4xxxx-2xxxx est valide, donc 8xxxx-1xxxx-0xxxx-7xxxx. Bien sûr, il y aurait également d'autres relations, y compris des relations complexes telles que, si le deuxième chiffre du premier groupe est impair, alors le dernier chiffre du dernier groupe devrait également l'être. De cette façon, il y aurait des générateurs pour les clés de produit et la vérification des clés de produit vérifierait simplement si elle correspond à toutes les règles.
Le chiffrement est normalement la chaîne d'informations sur la licence chiffrée à l'aide d'une clé privée (== signée numériquement) et convertie en Base64 . La clé publique est distribuée avec l'application. Lorsque la chaîne Base64 arrive, elle est vérifiée (== déchiffrée) par la clé publique et, si elle est jugée valide, le produit est activé.
Que ce soit trivial ou difficile à résoudre, je ne suis pas sûr que cela fasse une grande différence.
La probabilité que votre application soit fissurée est bien plus proportionnelle à son utilité qu'à la puissance de la manipulation de la clé de produit.
Personnellement, je pense qu'il y a deux classes d'utilisateurs. Ceux qui paient. Ceux qui ne le font pas. Ceux qui le feront le feront probablement avec la protection même la plus triviale. Ceux qui n'attendront pas une fissure ou regarder ailleurs. De toute façon, cela ne vous rapportera plus d'argent.
Je dois admettre que je ferais quelque chose d'assez fou.
- Recherchez un goulot d'étranglement de l'unité centrale et extrayez-le dans un fichier P/Invokeable DLL.
- En tant qu’action de post-génération, chiffrez une partie du fichier DLL avec une clé de cryptage XOR.
- Sélectionnez un schéma de clé publique/privée, incluez la clé publique dans le fichier DLL
- Faites en sorte que le déchiffrement de la clé de produit et la conversion XOR des deux moitiés ensemble donnent la clé de chiffrement de la DLL.
- Dans le code DllMain de la DLL, désactivez la protection (PAGE_EXECUTE_READWRITE) et déchiffrez-la avec la clé.
- Créez une méthode LicenseCheck () qui vérifie la validité de la clé de licence et de ses paramètres, puis contrôle le fichier entier DLL, en jetant une violation de licence. Oh, et effectuez une autre initialisation ici.
Quand ils trouveront et retireront le LicenseCheck, quel plaisir suivra quand le DLL commencera faute de segmentation .
Si vous voulez une solution simple pour créer et vérifier les numéros de série, essayez Ellipter . Il utilise la cryptographie des courbes elliptiques et dispose d'une fonctionnalité "Date d'expiration" vous permettant de créer des versions d'évaluation ou des clés d'enregistrement limitées dans le temps.
Il existe également l’option Licence et protection logicielles Microsoft (SLP) Services. Après avoir lu à ce sujet, j'aimerais vraiment pouvoir l'utiliser.
J'aime beaucoup l'idée de bloquer des parties de code basées sur la licence. Hot stuff, et le plus sécurisé pour .NET. Intéressant à lire même si vous ne l'utilisez pas!
Les services SLP (Microsoft Licence Software and Protection) sont un service d'activation de logiciel qui permet aux éditeurs de logiciels indépendants (ISV) d'adopter des conditions de licence souples pour leurs clients. Les services Microsoft SLP utilisent une méthode de protection unique qui permet de protéger les informations relatives à votre application et à vos licences, vous permettant ainsi d’accéder plus rapidement à la commercialisation tout en améliorant la conformité client.
Remarque: C’est la seule façon pour moi de publier un produit avec un code sensible (tel qu’un algorithme précieux).
Un autre outil bon marché pour les clés de produit et les activations est un produit appelé InstallKey. Jetez un oeil à www.lomacons.com
Une méthode simple consiste à utiliser un identificateur global unique (GUID). Les GUID sont généralement stockés en tant que valeurs 128 bits et sont généralement affichés sous forme de 32 chiffres hexadécimaux avec des groupes séparés par des traits d'union, tels que {21EC2020-3AEA-4069-A2DD-08002B30309D}.
Utilisez le code suivant en C # par System.Guid.NewGuid().
getKey = System.Guid.NewGuid().ToString().Substring(0, 8).ToUpper(); //Will generate a random 8 digit hexadecimal string.
_key = Convert.ToString(Regex.Replace(getKey, ".{4}", "$0/")); // And use this to separate every four digits with a "/".
J'espère que ça aide.
L'astuce consiste à avoir un algorithme que vous seul connaissez (tel qu'il puisse être décodé à l'autre bout).
Il y a des choses simples comme "Choisissez un nombre premier et ajoutez-y un nombre magique"
Des options plus compliquées, telles que l’utilisation du chiffrement asymétrique d’un ensemble de données binaires (pouvant inclure un identifiant unique, les numéros de version, etc.) et la distribution des données chiffrées en tant que clé.
Cela pourrait également valoir la peine de lire les réponses à cette question ainsi
Il existe des outils et des API disponibles pour cela. Cependant, je ne pense pas que vous en trouverez un gratuitement;)
Il y a par exemple la suite OLicense: http://www.olicense.de/index.php?lang=fr
Vous pouvez vérifier LicenseSpot . Il offre:
- Composant Licence Libre
- Activation en ligne
- API pour intégrer votre application et votre boutique en ligne
- Génération de numéro de série
- Révoquer des licences
- Gestion des abonnements
Veuillez vérifier cette réponse: https://stackoverflow.com/a/38598174/1275924
L'idée est d'utiliser Cryptolens comme serveur de licences. Voici un exemple pas à pas (en C # et VB.NET). J'ai également joint un extrait de code pour la vérification de la clé ci-dessous (en C #):
var licenseKey = "GEBNC-WZZJD-VJIHG-GCMVD";
var RSAPubKey = "{enter the RSA Public key here}";
var auth = "{access token with permission to access the activate method}";
var result = Key.Activate(token: auth, parameters: new ActivateModel()
{
Key = licenseKey,
ProductId = 3349,
Sign = true,
MachineCode = Helpers.GetMachineCode()
});
if (result == null || result.Result == ResultType.Error ||
!result.LicenseKey.HasValidSignature(RSAPubKey).IsValid())
{
// an error occurred or the key is invalid or it cannot be activated
// (eg. the limit of activated devices was achieved)
Console.WriteLine("The license does not work.");
}
else
{
// everything went fine if we are here!
Console.WriteLine("The license is valid!");
}
Console.ReadLine();
Je vais revenir un peu sur l'excellente réponse de @ frankodwyer et approfondir un peu plus les licences en ligne. Je suis le fondateur de Keygen , une API de licence REST construite pour les développeurs.
Puisque vous avez indiqué vouloir 2 "types" de licences pour votre application, à savoir une "version complète" et une "version d'évaluation", nous pouvons simplifier cela et utiliser un modèle de licence feature où vous utilisez une licence spécifique. fonctionnalités de votre application (dans ce cas, il existe un ensemble de fonctionnalités "complet" et un ensemble de fonctionnalités "à l'essai").
Pour commencer, nous pourrions créer 2 types de licence (appelées règles dans Keygen) et chaque fois qu'un utilisateur enregistre un compte vous pouvez générer une licence "d'évaluation" pour qu'ils puissent commencer (la licence "d'évaluation" implémente notre politique de fonctionnalité "d'évaluation", que vous pouvez utiliser pour effectuer diverses vérifications dans l'application, par exemple L'utilisateur peut-il utiliser Trial-Feature-A et Trial-Feature-B.
Et en partant de là, chaque fois qu'un utilisateur achète votre application (que vous utilisiez Paypal, Stripe, etc.), vous pouvez générer une licence mettant en œuvre la stratégie de fonctionnalité "complète" et l'associer à l'utilisateur compte. Maintenant, dans votre application, vous pouvez vérifier si l'utilisateur dispose d'une licence "complète" pouvant faire Pro-Feature-X et Pro-Feature-Y (par faire quelque chose comme user.HasLicenseFor(FEATURE_POLICY_ID)).
J'ai mentionné permettre à vos utilisateurs de créer comptes d'utilisateurs - qu'est-ce que je veux dire par là? J'ai détaillé ces informations dans deux autres réponses , mais voici un bref aperçu des raisons pour lesquelles je pense que c'est un moyen supérieur d'authentifier et d'identifier vos utilisateurs:
- Les comptes d'utilisateur vous permettent d'associer plusieurs licences et plusieurs machines à un utilisateur unique, vous donnant un aperçu du comportement de votre client = et de les inviter à effectuer des "achats intégrés" c'est-à-dire d'acheter votre version "complète" (un peu comme les applications mobiles).
- Nous ne devrions pas demander à nos clients de saisir de longues clés de licence, qui sont fastidieuses; et difficiles à suivre c’est-à-dire qu’elles se perdent facilement. (Essayez de chercher "clé de licence perdue" sur Twitter!)
- Les clients sont habitués à utiliser un email/mot de passe; Je pense que nous devrions faire ce que les gens ont l'habitude de faire pour pouvoir offrir une bonne expérience utilisateur (UX).
Bien sûr, si vous ne voulez pas gérer les comptes d'utilisateurs et vous voulez vos utilisateurs pour saisir les clés de licence, c'est très bien (et Keygen soutient le faire aussi ). Je propose simplement une autre façon de gérer cet aspect de la licence et, espérons-le, de fournir un Nice UX à vos clients.
Enfin, puisque vous avez également indiqué que vous souhaitiez mettre à jour ces licences chaque année, vous pouvez définir un durée dans vos stratégies de sorte que les licences "complètes" expirent après un an et que les licences "d'essai" durent une dernière fois 2 semaines, exigeant que vos utilisateurs achètent une nouvelle licence après expiration.
Je pourrais creuser davantage, en associant des machines à des utilisateurs, etc., mais je pensais essayer de garder cette réponse courte et de me concentrer sur l'octroi de licences à des utilisateurs.