Comment puis-je créer une clé de produit pour mon application C #?

Comment puis-je 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 chaque année. De plus, je dois en créer un pour les versions d'essai.

En relation:

• Comment masquer au mieux mon code de vérification de licence de produit C #?
• Activation de licence basée sur le Web
• Comment protégez-vous votre logiciel contre la distribution illégale?
• Meilleur logiciel de clé d'activation pour l'application .NET?

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 les fonctionnalités du programme à activer, la date d'expiration, le nom de l'utilisateur (si vous voulez le lier à un utilisateur). Ensuite, cryptez-le en utilisant un algorithme cryptographique avec une clé fixe ou hachez-le. Ensuite, vous le vérifiez simplement dans votre programme. Une façon de distribuer le fichier de licence (sous Windows) est de le fournir sous forme de fichier qui met à jour le registre (évite à l'utilisateur de le saisir).

Méfiez-vous cependant du faux sentiment de sécurité - tôt ou tard, quelqu'un corrigera simplement votre programme pour ignorer cette vérification et distribuera la version corrigée. Ou bien, ils trouveront une clé qui réussira tous les contrôles et la distribueront, ou rétrograderont l'horloge, etc. être capable de cela. Même s'ils ne peuvent pas, quelqu'un le fera et distribuera la version piratée. Il en va de même même si vous fournissez un dongle - si quelqu'un le souhaite, il peut également patcher le chèque pour cela. La signature numérique de votre code n'aidera pas, ils peuvent supprimer cette signature ou la résilier.

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 ce n'est pas à l'épreuve des balles. Vous devez donc simplement rendre la tâche suffisamment difficile pour qu'un utilisateur honnête n'oublie pas de payer. Faites également très attention à ce que votre système ne devienne pas gênant pour les utilisateurs payants - il vaut mieux avoir des copies arnaquées que pour que vos clients payants ne puissent pas utiliser ce pour quoi 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 les capacités que cet identifiant devrait avoir et de le mettre en cache pendant un certain temps. Toutes les mêmes mises en garde s'appliquent cependant - les gens peuvent contourner quelque chose comme ça.

Pensez également aux coûts de support liés à la gestion des utilisateurs qui ont oublié leur clé, etc.

edit: Je veux juste ajouter, n'investissez pas trop de temps là-dedans ou pensez que d'une manière ou d'une autre, votre schéma alambiqué sera différent et incassable. Ce ne sera pas et ne peut pas durer tant que les gens contrôlent le matériel et le système d'exploitation sur lesquels votre programme fonctionne. Les développeurs ont essayé de proposer des schémas de plus en plus complexes pour cela, pensant que s'ils développent leur propre système pour cela, il ne sera connu qu'eux et donc «plus sûr». Mais c'est vraiment l'équivalent en programmation d'essayer de construire une machine à mouvement perpétuel. :-)

A qui avez-vous confiance?

J'ai toujours considéré ce domaine 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 est fissuré pour toutes les applications. C'est arrivé à Discreet en cinq minutes une fois qu'ils ont opté pour une solution de licence tierce pour 3ds Max il y a des années ... Bons moments!

Sérieusement, envisagez de lancer le vôtre pour avoir un contrôle total sur votre algorithme. Si vous le faites, envisagez d'utiliser des composants dans votre clé du type:

• Nom de la licence - le nom du client (le cas échéant) auquel vous attribuez une licence. Utile pour gérer les déploiements de l'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 disposez d'un moyen de suivre les instances en cours d'exécution sur un site, de manière serveur
• Codes de fonction - pour vous permettre d'utiliser le même système de licence sur plusieurs fonctionnalités et sur plusieurs produits. Bien sûr, s'il est fissuré pour un produit, il est fissuré pour tous.

Ensuite, faites une somme de contrôle et ajoutez-y le cryptage (réversible) que vous voulez pour le rendre plus difficile à déchiffrer.

Pour créer une clé de licence d'essai, définissez simplement des valeurs pour les valeurs ci-dessus qui se traduisent par «mode d'essai».

Et comme c'est maintenant probablement le code le plus important de votre application / entreprise, en plus de / au lieu de l'obscurcissement, envisagez de placer les routines de déchiffrement dans un fichier DLL natif et simplement P / Invoke dessus.

Plusieurs entreprises pour lesquelles j'ai travaillé ont adopté des approches généralisées pour cela avec beaucoup de succès. Ou peut-être que les produits ne valaient pas la peine d'être craqués;)

Si vous vous interrogez sur les clés que vous pouvez saisir, comme 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 à 5 chiffres, comme abcde-fghij-kljmo-pqrst, puis de spécifier des relations internes telles que f + k + p devraient être égales à a, ce qui signifie que les premiers chiffres du 2 , Les groupes 3 et 4 devraient totaliser a. Cela signifie que 8xxxx-2xxxx-4xxxx-2xxxx est valide, tout comme 8xxxx-1xxxx-0xxxx-7xxxx. Bien sûr, il y aurait également d'autres relations, y compris des relations complexes comme, si le deuxième chiffre du premier groupe est impair, alors le dernier chiffre du dernier groupe devrait être également impair. 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 cela 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écryptée) par la clé publique et si elle est trouvée valide, le produit est activé.

Qu'il soit trivial ou difficile à craquer, je ne suis pas sûr que cela fasse vraiment une grande différence.

La probabilité que votre application soit craquée est beaucoup plus proportionnelle à son utilité qu'à la force de la gestion des clés de produit.

Personnellement, je pense qu'il existe deux classes d'utilisateurs. Ceux qui paient. Ceux qui ne le font pas. Ceux qui le feront le feront probablement avec la protection la plus insignifiante. Ceux qui ne le feront pas attendront une pause ou chercheront ailleurs. Quoi qu'il en soit, cela ne vous rapportera plus d'argent.

Je dois admettre que je ferais quelque chose d'assez fou.

1. Trouvez un goulot d'étranglement du processeur et extrayez-le dans un fichier DLL P / Invokeable .
2. En tant qu'action post-build, cryptez une partie du fichier DLL avec une clé de cryptage XOR.
3. Sélectionnez un schéma de clé publique / privée, incluez la clé publique dans le fichier DLL
4. Faites en sorte que le déchiffrement de la clé de produit et le XOR des deux moitiés aboutissent à la clé de chiffrement de la DLL.
5. Dans le code DllMain de la DLL, désactivez la protection (PAGE_EXECUTE_READWRITE) et décryptez-la avec la clé.
6. Créez une méthode LicenseCheck () qui effectue une vérification de l'intégrité de la clé de licence et des paramètres, puis totalise l'ensemble du fichier DLL, ce qui entraîne une violation de licence sur l'un ou l'autre. Oh, et faites une autre initialisation ici.

Quand ils trouvent et suppriment le LicenseCheck, quel plaisir suivra lorsque la DLL commencera la segmentation en panne .

Il existe également l'option Services de licence et de protection logicielle Microsoft (SLP). Après avoir lu à ce sujet, j'aimerais vraiment pouvoir l'utiliser.

J'aime beaucoup l'idée de bloquer des parties de code en fonction de la licence. Trucs chauds et les plus sécurisés pour .NET. Lecture intéressante même si vous ne l'utilisez pas!

Les services de licence et de protection des logiciels Microsoft® (SLP) sont un service d'activation de logiciels qui permet aux éditeurs de logiciels indépendants (ISV) d'adopter des conditions de licence flexibles pour leurs clients. Les services Microsoft SLP utilisent une méthode de protection unique qui permet de protéger vos informations d'application et de licence, ce qui vous permet d'accéder plus rapidement au marché tout en augmentant la conformité des clients.

Remarque: c'est la seule façon de publier un produit avec un code sensible (tel qu'un algorithme précieux).

Si vous voulez une solution simple pour créer et vérifier les numéros de série, essayez Ellipter . Il utilise la cryptographie à courbes elliptiques et dispose d'une fonction «Date d'expiration» afin que vous puissiez créer des versions d'essai ou des clés d'enregistrement limitées dans le temps.

Un autre bon outil peu coûteux pour les clés de produit et les activations est un produit appelé InstallKey. Jetez un œil sur www.lomacons.com

Une méthode simple consiste à utiliser un identificateur global unique (GUID). Les GUID sont généralement stockés sous forme de 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 tirets, 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 cela aide.

L'astuce est d'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 cryptage asymétrique d'un ensemble de données binaires (qui pourraient inclure un identifiant unique, des numéros de version, etc.) et distribuer les données cryptées comme clé.

Peut - être aussi la peine de lire les réponses à cette question aussi bien

Certains outils et API sont disponibles pour cela. Cependant, je ne pense pas que vous en trouverez un gratuitement;)

Il existe par exemple la suite OLicense: http://www.olicense.de/index.php?lang=en

Vous pouvez vérifier LicenseSpot . Il offre:

• Composant de licence gratuite
• Activation en ligne
• API pour intégrer votre application et votre boutique en ligne
• Génération du numéro de série
• Révoquer les licences
• Gestion des abonnements

Je vais reprendre un peu la bonne réponse de @ frankodwyer et approfondir un peu plus les licences en ligne. Je suis le fondateur de Keygen , une API REST de licence conçue pour les développeurs.

Puisque vous avez mentionné vouloir 2 "types" de licences pour votre application, à savoir une "version complète" et une "version d'essai", nous pouvons simplifier cela et utiliser un modèle de licence de fonctionnalité lequel vous accordez une licence à des fonctionnalités spécifiques de votre application (dans ce cas, il y a un ensemble de fonctionnalités «complet» et un ensemble de fonctionnalités «d'essai»).

Pour commencer, nous pourrions créer 2 types de licence (appelées politiques dans Keygen) et chaque fois qu'un utilisateur enregistre un compte, vous pouvez générer une licence «d'essai» pour lui permettre de démarrer (la licence «d'essai» met en œuvre notre politique de fonctionnalité «d'essai») , 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 la construction là -dessus , chaque fois qu'un utilisateur achète votre application (si vous utilisez PayPal, Stripe, etc.), vous pouvez générer une licence mise en œuvre de la politique de fonction « complète » et l' associer à l'utilisateur du compte . Maintenant, dans votre application, vous pouvez vérifier si l'utilisateur dispose d'une licence «complète» qui peut faire Pro-Feature-X et Pro-Feature-Y (en faisant quelque chose comme user.HasLicenseFor(FEATURE_POLICY_ID)).

J'ai mentionné le fait d'autoriser vos utilisateurs à créer des comptes utilisateur. Qu'est-ce que je veux dire par là? Je suis entré dans cela en détail dans quelques autres réponses , mais un bref aperçu des raisons pour lesquelles je pense que c'est un moyen supérieur d'authentifier et d'identifier vos utilisateurs:

1. Les comptes d'utilisateurs vous permettent d'associer plusieurs licences et plusieurs machines à un seul utilisateur , vous donnant un aperçu du comportement de vos clients et de les inviter à effectuer des «achats intégrés», c'est -à- dire acheter votre version «complète» (un peu comme des applications mobiles).
2. Nous ne devrions pas obliger nos clients à saisir de longues clés de licence, qui sont toutes deux fastidieuses à saisir et difficiles à suivre, c'est-à - dire qu'elles se perdent facilement. (Essayez de rechercher «clé de licence perdue» sur Twitter!)
3. Les clients sont habitués à utiliser un e-mail / 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 souhaitez pas gérer les comptes utilisateurs et que vous souhaitez vos utilisateurs saisissent des clés de licence, c'est tout à fait correct (et Keygen prend également en charge le faire ). J'offre juste une autre façon de gérer cet aspect de la licence et j'espère fournir une belle UX à vos clients.

Enfin, puisque vous avez également mentionné que vous souhaitez mettre à jour ces licences chaque année, vous pouvez définir un durée sur vos stratégies afin que les licences "complètes" expirent après un an et les licences "d'essai" durent deux semaines, ce qui oblige vos utilisateurs à acheter un nouveau licence après expiration.

Je pourrais creuser davantage, associer des machines avec des utilisateurs et des choses comme ça, mais j'ai pensé que j'essaierais de garder cette réponse courte et de me concentrer simplement sur l'octroi de licences de fonctionnalités à vos utilisateurs.

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 étape par étape (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();