Sécuriser une clé de licence avec une clé RSA

il est tard, je suis fatigué et probablement très dense …

J’ai écrit une application que je dois sécuriser afin qu’elle ne s’exécute que sur des machines pour lesquelles je génère une clé. Ce que je fais pour le moment, c’est d’obtenir le numéro de série du BIOS et de générer un hachage à partir de celui-ci. Je le chiffre ensuite à l’aide d’une clé privée XML RSA. Je signe ensuite le XML pour m’assurer qu’il n’est pas falsifié. J’essaie d’empaqueter la clé publique pour la déchiffrer et de vérifier la signature, mais chaque fois que j’essaie d’exécuter le code en tant qu’utilisateur différent de celui qui a généré la signature, j’obtiens un échec.

La plupart de mon code est modifié à partir d’un exemple de code que j’ai trouvé car je ne suis pas aussi familier avec le cryptage RSA que je le voudrais. Vous trouverez ci-dessous le code que j’utilisais et le code que je pensais devoir utiliser pour que cela fonctionne correctement …

Tout commentaire serait grandement apprécié, car le code original sur lequel je travaillais était le suivant: ce code fonctionne bien tant que l’utilisateur qui lance le programme est le même qui a signé le document à l’origine …

CspParameters cspParams = new CspParameters(); cspParams.KeyContainerName = "XML_DSIG_RSA_KEY"; cspParams.Flags = CspProviderFlags.UseMachineKeyStore; // Create a new RSA signing key and save it in the container. RSACryptoServiceProvider rsaKey = new RSACryptoServiceProvider(cspParams) { PersistKeyInCsp = true, }; 

Ce code est ce que je crois que je devrais faire mais il ne vérifie pas la signature, peu importe ce que je fais, que ce soit le même utilisateur ou un autre.

 RSACryptoServiceProvider rsaKey = new RSACryptoServiceProvider(); //Load the private key from xml file XmlDocument xmlPrivateKey = new XmlDocument(); xmlPrivateKey.Load("KeyPriv.xml"); rsaKey.FromXmlSsortingng(xmlPrivateKey.InnerXml); 

Je pense que cela a quelque chose à voir avec le nom du conteneur de clé (étant un véritable imbécile ici, veuillez m’excuser), je suis tout à fait sûr que c’est la ligne qui le fait fonctionner dans le premier cas et l’empêche de fonctionner dans le deuxième cas ….

 cspParams.KeyContainerName = "XML_DSIG_RSA_KEY"; 

Existe-t-il un moyen pour moi de signer / chiffrer le XML avec une clé privée lorsque la licence de l’application est générée, puis de déposer la clé publique dans le répertoire de l’application et de l’utiliser pour vérifier / déchiffrer le code? Je peux laisser tomber la partie chiffrement si je peux faire en sorte que la partie signature fonctionne correctement. Je l’utilisais en tant que sauvegarde pour masquer l’origine du code de licence que je saisis.

Est-ce que cela a du sens? Suis-je un cancre total?

Merci pour toute aide que n’importe qui peut me donner dans ce domaine ..

J’ai utilisé cette méthode pour signer des documents XML à l’aide d’une clé privée stockée dans un fichier XML que j’ai ensuite intégré à l’application .dll en tant que ressource. Je pense que vous pouvez avoir du mal à obtenir des permissions pour accéder au fichier de clés, ce qui créerait également des tracas en transférant le code vers d’autres serveurs, etc.

Voici le code permettant d’obtenir la clé privée en tant que ressource incorporée et de signer le document: (Sign est le nom de la classe dans laquelle cette méthode est située, Licensing.Private.Private.xml est une combinaison de l’espace de nom par défaut + dossier + nom du fichier. de la ressource)

 public static void SignDocument(XmlDocument xmldoc) { //Get the XML content from the embedded XML privatekey. Stream s = null; ssortingng xmlkey = ssortingng.Empty; try { s = typeof(Sign).Assembly.GetManifestResourceStream("Licensing.Private.Private.xml"); // Read-in the XML content. StreamReader reader = new StreamReader(s); xmlkey = reader.ReadToEnd(); reader.Close(); } catch (Exception e) { throw new Exception("Error: could not import key:",e); } // Create an RSA crypto service provider from the embedded // XML document resource (the private key). RSACryptoServiceProvider csp = new RSACryptoServiceProvider(); csp.FromXmlSsortingng(xmlkey); //Creating the XML signing object. SignedXml sxml = new SignedXml(xmldoc); sxml.SigningKey = csp; //Set the canonicalization method for the document. sxml.SignedInfo.CanonicalizationMethod = SignedXml.XmlDsigCanonicalizationUrl; // No comments. //Create an empty reference (not enveloped) for the XPath transformation. Reference r = new Reference(""); //Create the XPath transform and add it to the reference list. r.AddTransform(new XmlDsigEnvelopedSignatureTransform(false)); //Add the reference to the SignedXml object. sxml.AddReference(r); //Compute the signature. sxml.ComputeSignature(); // Get the signature XML and add it to the document element. XmlElement sig = sxml.GetXml(); xmldoc.DocumentElement.AppendChild(sig); } 

Utilisez le code suivant pour générer les clés private.xml et public.xml. Gardez le fichier private.xml en sécurité, évidemment.

 RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); File.WriteAllText(@"C:\privateKey.xml", rsa.ToXmlSsortingng(true)); // Private Key File.WriteAllText(@"C:\publicKey.xml", rsa.ToXmlSsortingng(false)); // Public Key 

Devinez, le problème est que différents utilisateurs n’ont pas access à la clé stockée pour le 1er utilisateur (Remarque: je ne suis pas un expert en cryptographie).