解密从PHP服务收到的AES缓冲区

1 回答

• -1

  这就是我用来做的事情：

  这是参数的含义：

  /// <summary>
          /// Decrypts specified ciphertext using Rijndael symmetric key algorithm.
          /// </summary>
          /// <param name="cipherText">
          /// Base64-formatted ciphertext value.
          /// </param>
          /// <param name="passPhrase">
          /// Passphrase from which a pseudo-random password will be derived. The
          /// derived password will be used to generate the encryption key.
          /// Passphrase can be any string. In this example we assume that this
          /// passphrase is an ASCII string.
          /// </param>
          /// <param name="saltValue">
          /// Salt value used along with passphrase to generate password. Salt can
          /// be any string. In this example we assume that salt is an ASCII string.
          /// </param>
          /// <param name="hashAlgorithm">
          /// Hash algorithm used to generate password. Allowed values are: "MD5" and
          /// "SHA1". SHA1 hashes are a bit slower, but more secure than MD5 hashes.
          /// </param>
          /// <param name="passwordIterations">
          /// Number of iterations used to generate password. One or two iterations
          /// should be enough.
          /// </param>
          /// <param name="initVector">
          /// Initialization vector (or IV). This value is required to encrypt the
          /// first block of plaintext data. For RijndaelManaged class IV must be
          /// exactly 16 ASCII characters long.
          /// </param>
          /// <param name="keySize">
          /// Size of encryption key in bits. Allowed values are: 128, 192, and 256.
          /// Longer keys are more secure than shorter keys.
          /// </param>
          /// <returns>
          /// Decrypted string value.
          /// </returns>
          /// <remarks>
          /// Most of the logic in this function is similar to the Encrypt
          /// logic. In order for decryption to work, all parameters of this function
          /// - except cipherText value - must match the corresponding parameters of
          /// the Encrypt function which was called to generate the
          /// ciphertext.
          /// </remarks>
  

  这是实际的功能：

  public static string Decrypt(string cipherText,
                                       string passPhrase,
                                       string saltValue,
                                       string hashAlgorithm,
                                       int passwordIterations,
                                       string initVector,
                                       int keySize)
          {
              // Convert strings defining encryption key characteristics into byte
              // arrays. Let us assume that strings only contain ASCII codes.
              // If strings include Unicode characters, use Unicode, UTF7, or UTF8
              // encoding.
              byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
              byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);
  
              // Convert our ciphertext into a byte array.
              byte[] cipherTextBytes = Convert.FromBase64String(cipherText);
  
              // First, we must create a password, from which the key will be 
              // derived. This password will be generated from the specified 
              // passphrase and salt value. The password will be created using
              // the specified hash algorithm. Password creation can be done in
              // several iterations.
              PasswordDeriveBytes password = new PasswordDeriveBytes(
                                                              passPhrase,
                                                              saltValueBytes,
                                                              hashAlgorithm,
                                                              passwordIterations);
  
              // Use the password to generate pseudo-random bytes for the encryption
              // key. Specify the size of the key in bytes (instead of bits).
              byte[] keyBytes = password.GetBytes(keySize / 8);
  
              // Create uninitialized Rijndael encryption object.
              RijndaelManaged symmetricKey = new RijndaelManaged();
  
              // It is reasonable to set encryption mode to Cipher Block Chaining
              // (CBC). Use default options for other symmetric key parameters.
              symmetricKey.Mode = CipherMode.CBC;
  
              // Generate decryptor from the existing key bytes and initialization 
              // vector. Key size will be defined based on the number of the key 
              // bytes.
              ICryptoTransform decryptor = symmetricKey.CreateDecryptor(
                                                               keyBytes,
                                                               initVectorBytes);
  
              // Define memory stream which will be used to hold encrypted data.
              MemoryStream memoryStream = new MemoryStream(cipherTextBytes);
  
              // Define cryptographic stream (always use Read mode for encryption).
              CryptoStream cryptoStream = new CryptoStream(memoryStream,
                                                            decryptor,
                                                            CryptoStreamMode.Read);
  
              // Since at this point we don't know what the size of decrypted data
              // will be, allocate the buffer long enough to hold ciphertext;
              // plaintext is never longer than ciphertext.
              byte[] plainTextBytes = new byte[cipherTextBytes.Length];
  
              // Start decrypting.
              int decryptedByteCount = cryptoStream.Read(plainTextBytes,
                                                         0,
                                                         plainTextBytes.Length);
  
              // Close both streams.
              memoryStream.Close();
              cryptoStream.Close();
  
              // Convert decrypted data into a string. 
              // Let us assume that the original plaintext string was UTF8-encoded.
              string plainText = Encoding.UTF8.GetString(plainTextBytes,
                                                         0,
                                                         decryptedByteCount);
  
              // Return decrypted string.   
              return plainText;
          }
  

  回复于 2024-04-20T05:47:39+08:00