Criptare la stringa con Castello Gonfiabile AES/CBC/PKCS7

Ho cercato dappertutto per qualche esempio di codice su come crittografare un semplice stringa di cifratura per il titolo con il Castello Gonfiabile Quadro.

Questo codice verrà eseguito su Windows un progetto Universale.
I miei precedenti tentativi di crittografare con il API non è riuscito a decifrare il server.

Ho provato questo: che mi dà una stringa del tipo:

4pQUfomwVVsl68oQqWoWYNRmRM+Cp+vNFXBNdkN6dZPQ34VZ35vsKn9Q7QGTDVoj+w5mqVYHnGuAOFOgdgl8kA==

s = String.Format("{0}_{1}", s, DateTime.Now.ToString("ddMMyyyyHmmss"));
SymmetricKeyAlgorithmProvider algorithm = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7);
IBuffer keymaterial = CryptographicBuffer.ConvertStringToBinary("[Key]", BinaryStringEncoding.Utf8);
CryptographicKey KEY = algorithm.CreateSymmetricKey(keymaterial);
IBuffer IV = CryptographicBuffer.ConvertStringToBinary("[IV]", BinaryStringEncoding.Utf8);
IBuffer data = CryptographicBuffer.ConvertStringToBinary(s, BinaryStringEncoding.Utf8);
IBuffer output = CryptographicEngine.Encrypt(KEY, data, IV);
return CryptographicBuffer.EncodeToBase64String(output);

Il server non di crittografia/decrittografia con

public static string Encrypt(string text, byte[] key, byte[] iv, int keysize = 128, int blocksize = 128, CipherMode cipher = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
{
    AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
    aes.BlockSize = blocksize;
    aes.KeySize = keysize;
    aes.Mode = cipher;
    aes.Padding = padding;

    byte[] src = Encoding.UTF8.GetBytes(text);
    using (ICryptoTransform encrypt = aes.CreateEncryptor(key, iv))
    {
        byte[] dest = encrypt.TransformFinalBlock(src, 0, src.Length);
        encrypt.Dispose();
        return Convert.ToBase64String(dest);
    }
}

public static string Decrypt(string text, byte[] key, byte[] iv, int keysize = 128, int blocksize = 128, CipherMode cipher = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
{
    AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
    aes.BlockSize = blocksize;
    aes.KeySize = keysize;
    aes.Mode = cipher;
    aes.Padding = padding;

    byte[] src = Convert.FromBase64String(text);
    using (ICryptoTransform decrypt = aes.CreateDecryptor(key, iv))
    {
        byte[] dest = decrypt.TransformFinalBlock(src, 0, src.Length);
        decrypt.Dispose();
        return Encoding.UTF8.GetString(dest); //Padding is invalid and cannot be removed. 
    }
}

Ma non riesce perchè:

Imbottitura non è valido e non può essere rimosso.

È per questo che voglio provare a Castello Gonfiabile, ma non trovo nessun idoneo codice di esempio.

MODIFICA

Ho provato con Castello Gonfiabile con il codice fornito nella risposta.
Ora ricevo l’errore:

di inizializzazione del vettore deve essere la stessa lunghezza come la dimensione del blocco

byte[] inputBytes = Encoding.UTF8.GetBytes(s);
byte[] IV = Encoding.UTF8.GetBytes("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
byte[] key = Encoding.UTF8.GetBytes("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");

//Set up
AesEngine engine = new AesEngine();
CbcBlockCipher blockCipher = new CbcBlockCipher(engine);
PaddedBufferedBlockCipher cipher = new PaddedBufferedBlockCipher(blockCipher, new Pkcs7Padding());
Debug.WriteLine(IV.Length); //32
Debug.WriteLine(cipher.GetBlockSize()); //16
KeyParameter keyParam = new KeyParameter(key);
ParametersWithIV keyParamWithIv = new ParametersWithIV(keyParam, IV);


cipher.Init(true, keyParamWithIv); //Error Message thrown
byte[] outputBytes = new byte[cipher.GetOutputSize(inputBytes.Length)]; //cip
int length = cipher.ProcessBytes(inputBytes, outputBytes, 0);
cipher.DoFinal(outputBytes, length); //Do the final block
string encryptedInput = Convert.ToBase64String(outputBytes);

La lunghezza sul server è di 128. Come posso forzare per essere uguali e la stessa lunghezza?

  • Modificato la domanda con quello che cerco
  • Si può sostituire la crittografia qualcosa di sicuro?
  • Potresti spiegare meglio cosa intendi
  • La tua chiave e un vettore di inizializzazione sembra strano. Supponendo che ogni X rappresenta uno è il carattere hex codificato AES128 chiave & IV ma non decodificare la rappresentazione esadecimale. Quindi la chiave e IV sono troppo lunghi.
  • Che risultato vuoi arrivare e cosa si dovrebbe ottenere?
InformationsquelleAutor tim | 2015-04-17



2 Replies
  1. 18

    Qui sono frammenti di utilizzo. Utilizza la predefinito di Sistema.Di sicurezza.Crittografia. Non ha bisogno di essere A.C.

        ///<summary>
        ///Encrypt a byte array using AES 128
        ///</summary>
        ///<param name="key">128 bit key</param>
        ///<param name="secret">byte array that need to be encrypted</param>
        ///<returns>Encrypted array</returns>
        public static byte[] EncryptByteArray(byte[] key, byte[] secret)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                using (AesManaged cryptor = new AesManaged())
                {
                    cryptor.Mode = CipherMode.CBC;
                    cryptor.Padding = PaddingMode.PKCS7;
                    cryptor.KeySize = 128;
                    cryptor.BlockSize = 128;
    
                    //We use the random generated iv created by AesManaged
                    byte[] iv = cryptor.IV;
    
                    using (CryptoStream cs = new CryptoStream(ms, cryptor.CreateEncryptor(key, iv), CryptoStreamMode.Write))
                    {
                        cs.Write(secret, 0, secret.Length);
                    }
                    byte[] encryptedContent = ms.ToArray();
    
                    //Create new byte array that should contain both unencrypted iv and encrypted data
                    byte[] result = new byte[iv.Length + encryptedContent.Length];
    
                    //copy our 2 array into one
                    System.Buffer.BlockCopy(iv, 0, result, 0, iv.Length);
                    System.Buffer.BlockCopy(encryptedContent, 0, result, iv.Length, encryptedContent.Length);
    
                    return result;
                }
            }
        }
    
        ///<summary>
        ///Decrypt a byte array using AES 128
        ///</summary>
        ///<param name="key">key in bytes</param>
        ///<param name="secret">the encrypted bytes</param>
        ///<returns>decrypted bytes</returns>
        public static byte[] DecryptByteArray(byte[] key, byte[] secret)
        {
            byte[] iv = new byte[16]; //initial vector is 16 bytes
            byte[] encryptedContent = new byte[secret.Length - 16]; //the rest should be encryptedcontent
    
            //Copy data to byte array
            System.Buffer.BlockCopy(secret, 0, iv, 0, iv.Length);
            System.Buffer.BlockCopy(secret, iv.Length, encryptedContent, 0, encryptedContent.Length);
    
            using (MemoryStream ms = new MemoryStream())
            {
                using (AesManaged cryptor = new AesManaged())
                {
                    cryptor.Mode = CipherMode.CBC;
                    cryptor.Padding = PaddingMode.PKCS7;
                    cryptor.KeySize = 128;
                    cryptor.BlockSize = 128;
    
                    using (CryptoStream cs = new CryptoStream(ms, cryptor.CreateDecryptor(key, iv), CryptoStreamMode.Write))
                    {
                        cs.Write(encryptedContent, 0, encryptedContent.Length);
    
                    }
                    return ms.ToArray();
                }
            }
        }

    Se si ha realmente bisogno di BC, qui è un test rapido riesco a scrivere basato sulla prova costume https://github.com/bcgit/bc-csharp/blob/master/crypto/test/src/crypto/test/AESFastTest.cs
    È possibile personalizzare per il vostro bisogno

        private static void TestBC()
        {
            //Demo params
            string keyString = "jDxESdRrcYKmSZi7IOW4lw==";   
    
            string input = "abc";
            byte[] inputBytes = Encoding.UTF8.GetBytes(input);            
            byte[] iv = new byte[16]; //for the sake of demo
    
            //Set up
            AesEngine engine = new AesEngine();
            CbcBlockCipher blockCipher = new CbcBlockCipher(engine); //CBC
            PaddedBufferedBlockCipher cipher = new PaddedBufferedBlockCipher(blockCipher); //Default scheme is PKCS5/PKCS7
            KeyParameter keyParam = new KeyParameter(Convert.FromBase64String(keyString));
            ParametersWithIV keyParamWithIV = new ParametersWithIV(keyParam, iv, 0, 16);
    
            //Encrypt
            cipher.Init(true, keyParamWithIV);
            byte[] outputBytes = new byte[cipher.GetOutputSize(inputBytes.Length)];
            int length = cipher.ProcessBytes(inputBytes, outputBytes, 0);
            cipher.DoFinal(outputBytes, length); //Do the final block
            string encryptedInput = Convert.ToBase64String(outputBytes);
    
            Console.WriteLine("Encrypted string: {0}", encryptedInput);
    
            //Decrypt            
            cipher.Init(false, keyParamWithIV);
            byte[] comparisonBytes = new byte[cipher.GetOutputSize(outputBytes.Length)];
            length = cipher.ProcessBytes(outputBytes, comparisonBytes, 0);
            cipher.DoFinal(comparisonBytes, length); //Do the final block
    
            Console.WriteLine("Decrypted string: {0}",Encoding.UTF8.GetString(comparisonBytes)); //Should be abc
        }
    • Hmm, mi piace il tuo sforzo, ma AesManaged non è disponibile per Windows Universale (correggimi se sbaglio). Il codice per il Castello Gonfiabile comunque non vedo l’imbottitura PKCS7, IV, né di una stringa di output. Ho solo bisogno di stringa crittografata.
    • PaddedBufferedBlockCipher default usa PKCS5/PKCS7 (cs.berkeley.edu/~giona/bc/org/bouncycastle/crypto/imbottiture/…) Per IV, si può avvolgere la keyParameter all’interno del ParametersWithIV E la stringa di output può essere ottenuta convertendo il byte di output in Base64
    • A cura BC parte di PKCS7 + IV + stringa di output. Non provare nulla con Windows Universale, però.
    • Grazie ho aggiornato la mia domanda con che cosa ho provato.
    • IV per AES a 128 dovrebbe essere a 128 bit = 16 byte solo. Basta assicurarsi che si passa a 16 byte array e sarà bene. Se si ha realmente bisogno di applicare questo farà: ParametersWithIV keyParamWithIV = new ParametersWithIV(keyParam, iv, 0, 16);
    • Fatto questo lavoro? Devo premio il bounty? O lasciarlo scadere? Che tipo di problemi stai avendo @SeaSharp? Ci può dire che cosa hai visto e cosa ci si aspetta?

  2. 0

    inserire descrizione del link qui

            byte[] k; //32 byte
            string para; //plaintext
            string msgRefNo; //16byte
    
            byte[] inputBytes = Encoding.UTF8.GetBytes(para);
            byte[] IV = Encoding.UTF8.GetBytes(msgRefNo);
            byte[] key = k;
    
    
            AesEngine engine = new AesEngine();
            CbcBlockCipher blockCipher = new CbcBlockCipher(engine);
            PaddedBufferedBlockCipher cipher1 = new PaddedBufferedBlockCipher(blockCipher, new Pkcs7Padding());
    
            KeyParameter keyParam = new KeyParameter(key);
            ParametersWithIV keyParamWithIv = new ParametersWithIV(keyParam, IV);
    
    
            cipher1.Init(true, keyParamWithIv); //Error Message thrown
            byte[] outputBytes = new byte[cipher1.GetOutputSize(inputBytes.Length)]; //cip
            int length = cipher1.ProcessBytes(inputBytes, outputBytes, 0);
            cipher1.DoFinal(outputBytes, length); //Do the final block
            string encryptedInput = Convert.ToBase64String(outputBytes);
            return encryptedInput;

Lascia un commento