Query String Paramètre Obfuscation

Avez-vous essayé CODING URL Votre Texte de la chaîne de requête? Il fait partie du HTTTPutilité classe qui:

fournit des méthodes d'encodage et Décoder les URL lors du traitement de la bande Demandes.

et devrait vous permettre de transmettre votre texte codé de base64 dans la chaîne de requête.

Vous pouvez utiliser httpserverutilité.urltokenencode et httpserverutilité.urltokendeCode

Encode utilise le codage de base64, mais remplace les caractères hostiles de l'URL.

Il y a une réponse similaire dans un précédent donc question . Voir la réponse acceptée.

Faites votre cryptage, puis utilisez HTTPSERVERUILLITAIRE.URLTOXENCODE () pour encoder le tableau d'octets.

Voici un exemple de travail que j'ai mis en place à partir de quelques exemples différents qui prend un identifiant entier et la convertit en une chaîne cryptée formatée hexidécimale. Cette chaîne cryptée ne doit pas inclure des caractères hostiles de l'URL et n'inclut pas les caractères échappés non plus.

Voici toute l'application de console de travail. Veuillez noter que c'est un prototype et sans aucun doute pas pour la production - cela illustre simplement une solution et doit certainement être refactored. P>

Lorsque vous exécutez le code, votre sortie doit être ceci: P>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Security.Cryptography;
using System.IO;

namespace ConsoleApplication1
{
    class Program2
    {
        static void Main(string[] args)
        {
            int theId = 1234;   //the ID that's being manipulated
            byte[] byteArray;   //the byte array that stores

            //convert the ID to an encrypted string using a Crypto helper class
            string encryptedString = Crypto.EncryptStringAES(theId.ToString(), "mysecret");
            Console.WriteLine("{0} get encrypted as {1}", theId.ToString(), encryptedString);

            //convert the encrypted string to byte array
            byteArray = ASCIIEncoding.Default.GetBytes(encryptedString);
            StringBuilder result = new StringBuilder();

            //convert each byte to hex and append to a stringbuilder
            foreach (byte outputByte in byteArray)
            {
                result.Append(outputByte.ToString("x2"));
            }

            Console.WriteLine("{0} encrypted is this in hex {1}", encryptedString, result.ToString());

            //now reverse the process, and start with converting each char in string to byte
            int stringLength = result.Length;
            byte[] bytes = new byte[stringLength / 2];

            for (int i = 0; i < stringLength; i += 2)
            {
                bytes[i / 2] = System.Convert.ToByte(result.ToString().Substring(i, 2), 16);
            }

            //convert the byte array to de-"hexed" string
            string dehexedString = ASCIIEncoding.Default.GetString(bytes);

            Console.WriteLine("{0} gets dehexed as {1}", result, dehexedString);

            //decrypt the de-"hexed" string using Crypto helper class
            string decryptedString = Crypto.DecryptStringAES(dehexedString, "mysecret");
            Console.WriteLine("{0} got decrypted as {1}", dehexedString, decryptedString);

            Console.ReadLine();
        }
    }

    public class Crypto
    {
        private static byte[] _salt = Encoding.ASCII.GetBytes("o6806642kbM7c5");

        /// <summary>
        /// Encrypt the given string using AES.  The string can be decrypted using 
        /// DecryptStringAES().  The sharedSecret parameters must match.
        /// </summary>
        /// <param name="plainText">The text to encrypt.</param>
        /// <param name="sharedSecret">A password used to generate a key for encryption.</param>
        public static string EncryptStringAES(string plainText, string sharedSecret)
        {
            if (string.IsNullOrEmpty(plainText))
                throw new ArgumentNullException("plainText");
            if (string.IsNullOrEmpty(sharedSecret))
                throw new ArgumentNullException("sharedSecret");

            string outStr = null;                       // Encrypted string to return
            RijndaelManaged aesAlg = null;              // RijndaelManaged object used to encrypt the data.

            try
            {
                // generate the key from the shared secret and the salt
                Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, _salt);

                // Create a RijndaelManaged object
                // with the specified key and IV.
                aesAlg = new RijndaelManaged();
                aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
                aesAlg.IV = key.GetBytes(aesAlg.BlockSize / 8);

                // Create a decrytor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {

                            //Write all data to the stream.
                            swEncrypt.Write(plainText);
                        }
                    }
                    outStr = Convert.ToBase64String(msEncrypt.ToArray());
                }
            }
            finally
            {
                // Clear the RijndaelManaged object.
                if (aesAlg != null)
                    aesAlg.Clear();
            }

            // Return the encrypted bytes from the memory stream.
            return outStr;
        }

        /// <summary>
        /// Decrypt the given string.  Assumes the string was encrypted using 
        /// EncryptStringAES(), using an identical sharedSecret.
        /// </summary>
        /// <param name="cipherText">The text to decrypt.</param>
        /// <param name="sharedSecret">A password used to generate a key for decryption.</param>
        public static string DecryptStringAES(string cipherText, string sharedSecret)
        {
            if (string.IsNullOrEmpty(cipherText))
                throw new ArgumentNullException("cipherText");
            if (string.IsNullOrEmpty(sharedSecret))
                throw new ArgumentNullException("sharedSecret");

            // Declare the RijndaelManaged object
            // used to decrypt the data.
            RijndaelManaged aesAlg = null;

            // Declare the string used to hold
            // the decrypted text.
            string plaintext = null;

            try
            {
                // generate the key from the shared secret and the salt
                Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, _salt);

                // Create a RijndaelManaged object
                // with the specified key and IV.
                aesAlg = new RijndaelManaged();
                aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
                aesAlg.IV = key.GetBytes(aesAlg.BlockSize / 8);

                // Create a decrytor to perform the stream transform.
                ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
                // Create the streams used for decryption.                
                byte[] bytes = Convert.FromBase64String(cipherText);
                using (MemoryStream msDecrypt = new MemoryStream(bytes))
                {
                    using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (StreamReader srDecrypt = new StreamReader(csDecrypt))

                            // Read the decrypted bytes from the decrypting stream
                            // and place them in a string.
                            plaintext = srDecrypt.ReadToEnd();
                    }
                }
            }
            finally
            {
                // Clear the RijndaelManaged object.
                if (aesAlg != null)
                    aesAlg.Clear();
            }

            return plaintext;
        }
    }

}

Le problème d'obscurcissement de l'identifiant, c'est que vous avez besoin d'un moyen de déconcerter. Cela nécessite soit:

1. Cryptage complet enBLOWN, lequel s'il est bon, il faut une valeur assez importante.
2. stocker la valeur avec le numéro d'identification, il devient donc un identifiant alternatif.
3. quelque chose qui dépend de la sécurité par obscurité.

   alternativement, gardez l'identifiant clair, mais utilisez également un chèque. xxx

   plus la valeur est élevée pour réduire, plus le résultat est plus petit (jusqu'à ce que à 6, il continue à produire la chaîne vide). Une valeur faible (ou 0) donne une meilleure sécurité, au coût d'une URI plus longue.

   la chaîne "Il s'agit d'un sel arbitraire" doit être secret pour la meilleure sécurité. Il peut être codé dur dans certaines utilisations, mais voudrait être obtenu à partir d'une source sécurisée pour d'autres.

   avec ce qui précède, un ID de 15 et un réduit < / code> de 3 produit un résultat de 05469B1E. Nous pouvons ensuite utiliser ceci comme suit:

   www.domain.com/?id=15&chk=05469b1e

   dans le gestionnaire qui chercherait ce que 15 est , nous faisons la même chose, et si le résultat est différent de 05469B1E, nous pouvons renvoyer une 403 interdite ou sans doute plus raisonnable 404 non trouvée (sur la base que nous avons reçu une URI que dans son ensemble n'identifie rien ).