Le Cryptage RSA, de grandes quantités de données en C#

Ceci est mon premier post, donc espérons que je n'ai pas oublié quelque chose d'important. Je suis en train de faire un projet en C#, où j'ai besoin d'utiliser de clé publique/clé privée de chiffrement pour chiffrer un message, puis de l'envoyer via une connexion SSL.

J'ai choisi d'utiliser le RSACryptoService, selon la documentation, qui a été le seul asymétrique schéma de chiffrement utilisée pour le cryptage des données. Le problème, c'est que je vais avoir beaucoup de problèmes avec cela. (Je voulais faire de chiffrement symétrique, mais ce n'est pas ce que mon professeur me demande de faire, et selon lui, il devrait être facile de déterminer une taille de bloc et ensuite, il doit faire tout le travail pour vous.) Eh bien, jusqu'à présent, aucune chance, et j'en ai essayé quelques-uns des approches différentes, mais maintenant je suis de retour à l'essentiel et d'essayer à nouveau, c'est mon code actuel:

    public string[] GenerateKeysToStrings(string uniqueIdentifier)
    {
        string[] keys;
        using (var rsa = new RSACryptoServiceProvider(4096))
        {
            try
            {
                string privateKey = rsa.ToXmlString(true);
                string publicKey = rsa.ToXmlString(false);

                this.pki.StoreKey(publicKey, uniqueIdentifier);

                keys = new string[2];
                keys[0] = privateKey;
                keys[1] = publicKey;
            }
            finally
            {
                ////Clear the RSA key container, deleting generated keys.
                rsa.PersistKeyInCsp = false;
            }
        }
        return keys;
    }

Comme vous pouvez le voir, je générer les clés et je mimmick une PKI par l'envoi de la clé publique à une simple classe qui stocke, puis la clé privée est écrite dans un fichier
(Notez que j'ai aussi une autre méthode qui ne le même, mais les stocke dans un tableau au lieu de cela, juste parce que je voulais le tester et de vous simplifier les choses que je reçois No such key exceptions et parfois de chiffrement des exceptions quand je le faire de la manière indiquée dans l'exemple, donc j'ai voulu simplifier: il suffit de stocker le rsa.ToXmlString chaîne, comme une chaîne de caractères dans un tableau, mais pas de chance.)

Maintenant, j'ai un crypter et décrypter la méthode comme suit:

    public string Encrypt(string keyString, string message)
    {
        string encryptedMessage;
        using (var rsa = new RSACryptoServiceProvider())
        {
            try
            {
                ////Load the key from the specified path
                var encryptKey = new XmlDocument();
                encryptKey.Load(@"C:\Test\PrivateKeyInfo.xml");
                rsa.FromXmlString(encryptKey.OuterXml);


                ////Conver the string message to a byte array for encryption
                ////var encoder = new UTF8Encoding();
                ASCIIEncoding byteConverter = new ASCIIEncoding();
                byte[] dataToEncrypt = byteConverter.GetBytes(message);

                byte[] encryptedData = rsa.Encrypt(dataToEncrypt, false);

                ////Convert the byte array back to a string message
                encryptedMessage = byteConverter.GetString(encryptedData);
            }
            finally
            {
                ////Clear the RSA key container, deleting generated keys.
                rsa.PersistKeyInCsp = false;
            }
        }
        return encryptedMessage;
    }

Décryptage:

    public string Decrypt(string keyString, string message)
    {
        string decryptedText;
        using (var rsa = new RSACryptoServiceProvider())
        {
            try
            {
                ////Loads the keyinfo into the rsa parameters from the keyfile
                /*
                var privateKey = new XmlDocument();
                privateKey.Load(keyString);
                 */
                rsa.FromXmlString(keyString);

                ////Convert the text from string to byte array for decryption
                ASCIIEncoding byteConverter = new ASCIIEncoding();
                var encryptedBytes = byteConverter.GetBytes(message);

                ////Create an aux array to store all the encrypted bytes
                byte[] decryptedBytes = rsa.Decrypt(encryptedBytes, false);

                decryptedText = byteConverter.GetString(decryptedBytes);
            }
            finally
            {
                ////Clear the RSA key container, deleting generated keys.
                rsa.PersistKeyInCsp = false;
            }
        }
        return decryptedText;
    }

Je sais que c'est un mur de texte, mais j'espère que vous pourrez m'aider parce que j'ai été frapper ma tête contre le mur, depuis si longtemps, c'est pas drôle 🙂

Le problème est, comment dois-je aller sur le chiffrement des messages avec RSA (ou de toute autre collectivité publique/clé privée de chiffrement)

Ici est le client de Test:

    public static void Main(string[] args)
    {
        PublicKeyInfrastructure pki = new PublicKeyInfrastructure();
        Cryptograph crypto = new Cryptograph();
        string[] keys = crypto.GenerateKeysToStrings("[email protected]");


        string plainText = "Hello play with me, please";
        string publicKey = crypto.GetPublicKey("[email protected]");

        string encryptedText = crypto.Encrypt(keys[0], plainText);


        string decryptedText = crypto.Decrypt(keys[1], encryptedText);

    }

Comme je l'ai mentionné, la chaîne des tableaux sont là parce que je voulais éliminer les mauvaises erreur d'analyse à partir de documents XML...

Quand je lance le client de test, si j'utilise la clé privée pour crypter les clés publique et à déchiffrer, je reçois une "Clé n'existe pas d'exception" et si je le fais dans l'autre sens, j'ai mal aux données d'exception.

S'il vous plaît aidez-moi les gars, si vous connaissez un bon guide, ou peut me dire comment faire pour assez simple de mettre en œuvre clé publique/clé privée de chiffrement sur la chaîne messages, merci de m'aider.

J'apprécie toute l'aide.