public bool ShowDialog(Window owner, EncryptionAlgorithm value)
        {
            Owner = owner;

            AlgorithmBox.Focus();
            Keyboard.Focus(AlgorithmBox);

            AlgorithmBox.Items.Clear();
            foreach (var enumvalue in Enum.GetValues(typeof (EncryptionAlgorithm)))
            {
                AlgorithmBox.Items.Add(enumvalue);
            }

            AlgorithmBox.SelectedItem = value;

            if (ShowDialog() ?? false)
            {
                Algorithm = (EncryptionAlgorithm) AlgorithmBox.SelectedItem;
                return true;
            }
            else
            {
                Algorithm = EncryptionAlgorithm.Plain;
                return false;
            }
        }

 public static string Decrypt(EncryptionAlgorithm algorithm, CiphertextFormat format, string data, Key key,
     byte[] salt, byte[] iv, PaddingMode paddingMode)
 {
     var _d = new byte[0];
     switch (format)
     {
         case CiphertextFormat.Base64:
         {
             _d = Convert.FromBase64String(data);
             break;
         }
         case CiphertextFormat.Hex:
         {
             _d = HexToByteArray(data);
             break;
         }
         case CiphertextFormat.Url:
         {
             var encoding = new UTF8Encoding();
             _d = encoding.GetBytes(HttpUtility.UrlDecode(data));
             break;
         }
     }
     return Decrypt(algorithm, _d, key, salt, iv, paddingMode);
 }

 public static bool ValidateEncryptionAlgorithm(EncryptionAlgorithm value)
 {
     if ((value != EncryptionAlgorithm.None) && (value != EncryptionAlgorithm.Rc2))
     {
         return (value == EncryptionAlgorithm.Rc4);
     }
     return true;
 }

 public static bool ValidateEncryptionAlgorithm(EncryptionAlgorithm value)
 {
     //
     // note that EncryptionAlgorithm has disjoined values
     //
     return (value == EncryptionAlgorithm.None) ||
            (value == EncryptionAlgorithm.Rc2) ||
            (value == EncryptionAlgorithm.Rc4);
 }

		/// <summary>
		/// Initializes a new instance of the <see cref="MimeKit.Cryptography.CmsRecipient"/> class.
		/// </summary>
		/// <remarks>
		/// The initial value of the <see cref="EncryptionAlgorithms"/> property will be set to
		/// the Triple-DES encryption algorithm, which should be safe to assume for all modern
		/// S/MIME v3.x client implementations.
		/// </remarks>
		/// <param name="certificate">The recipient's certificate.</param>
		/// <param name="recipientIdentifierType">The recipient identifier type.</param>
		/// <exception cref="System.ArgumentNullException">
		/// <paramref name="certificate"/> is <c>null</c>.
		/// </exception>
		public CmsRecipient (X509Certificate certificate, SubjectIdentifierType recipientIdentifierType = SubjectIdentifierType.IssuerAndSerialNumber)
		{
			if (certificate == null)
				throw new ArgumentNullException (nameof (certificate));

			if (recipientIdentifierType == SubjectIdentifierType.IssuerAndSerialNumber)
				RecipientIdentifierType = SubjectIdentifierType.IssuerAndSerialNumber;
			else
				RecipientIdentifierType = SubjectIdentifierType.SubjectKeyIdentifier;

			EncryptionAlgorithms = new EncryptionAlgorithm[] { EncryptionAlgorithm.TripleDes };
			Certificate = certificate;
		}

 public static IEncryptionAlgorithm Create(EncryptionAlgorithm algoType)
 {
     IEncryptionAlgorithm encryptionInstance = null;
     switch (algoType) {
         case EncryptionAlgorithm.AES:
             encryptionInstance = new Encryption.AES();
             break;
         case EncryptionAlgorithm.Rijndael:
             encryptionInstance = new Encryption.Rijndael();
             break;
         default:
             throw new Exception("Incorrect use of EncryptionAlgoritm factory");
     }
     return encryptionInstance;
 }

		public virtual TlsCipher CreateCipher(TlsClientContext context,
			EncryptionAlgorithm encryptionAlgorithm, DigestAlgorithm digestAlgorithm)
		{
			switch (encryptionAlgorithm)
			{
				case EncryptionAlgorithm.cls_3DES_EDE_CBC:
					return CreateDesEdeCipher(context, 24, digestAlgorithm);
				case EncryptionAlgorithm.AES_128_CBC:
					return CreateAesCipher(context, 16, digestAlgorithm);
				case EncryptionAlgorithm.AES_256_CBC:
					return CreateAesCipher(context, 32, digestAlgorithm);
				default:
					throw new TlsFatalAlert(AlertDescription.internal_error);
			}
		}

        private PasspadDocument(EncryptionAlgorithm algo, SecureString pw, string content, string hint, string file)
        {
            fileAlgorithm = algo;
            Algorithm = algo;

            filePassword = pw;
            Password = pw;

            fileContent = content;
            Content = content;

            fileHint = hint;
            Hint = hint;

            File = file;
        }

        public static void SaveFile(string file, string text, string hint, SecureString password, EncryptionAlgorithm algorithm)
        {
            var data = AbstractEncryptionAlgorithm.GetAlgorithm(algorithm).Encode(text, password);
            var data64 = Convert.ToBase64String(data);

            StringBuilder result = new StringBuilder();

            result.AppendLine(string.Format("<hint>{0}</hint>", SecurityElement.Escape(hint)));
            result.AppendLine(string.Format("<encrypted algorithm=\"{0}\">", algorithm));
            for (int i = 0; i < Math.Ceiling(data64.Length / 64.0); i++)
            {
                result.AppendLine("    " + data64.Substring(i*64, Math.Min(64, data64.Length - i * 64)));
            }
            result.AppendLine("</encrypted>");

            File.WriteAllText(file, result.ToString(), Encoding.UTF8);
        }

        public static string ReadFile(XDocument xdoc, SecureString password, out EncryptionAlgorithm algorithm)
        {
            if (!Enum.TryParse(xdoc.Root?.Element("encrypted")?.Attribute("algorithm").Value ?? string.Empty, true, out algorithm))
            {
                algorithm = EncryptionAlgorithm.Plain;
                return null;
            }

            var data = (xdoc.Root?.Element("encrypted")?.Value ?? string.Empty)
                .Replace("\t", "")
                .Replace(" ", "")
                .Replace("\r", "")
                .Replace("\n", "")
                .Trim();

            var bdata = Convert.FromBase64String(data);

            return AbstractEncryptionAlgorithm.GetAlgorithm(algorithm).Decode(bdata, password);
        }

        public void CreateAuthenticatedEncryptor_RoundTripsData_CngGcmImplementation(EncryptionAlgorithm encryptionAlgorithm)
        {
            // Parse test input
            int keyLengthInBits = Int32.Parse(Regex.Match(encryptionAlgorithm.ToString(), @"^AES_(?<keyLength>\d{3})_GCM$").Groups["keyLength"].Value, CultureInfo.InvariantCulture);

            // Arrange
            var masterKey = Secret.Random(512 / 8);
            var control = new GcmAuthenticatedEncryptor(
                keyDerivationKey: masterKey,
                symmetricAlgorithmHandle: CachedAlgorithmHandles.AES_GCM,
                symmetricAlgorithmKeySizeInBytes: (uint)(keyLengthInBits / 8));
            var test = CreateDescriptor(encryptionAlgorithm, ValidationAlgorithm.HMACSHA256 /* unused */, masterKey).CreateEncryptorInstance();

            // Act & assert - data round trips properly from control to test
            byte[] plaintext = new byte[] { 1, 2, 3, 4, 5 };
            byte[] aad = new byte[] { 2, 4, 6, 8, 0 };
            byte[] ciphertext = control.Encrypt(new ArraySegment<byte>(plaintext), new ArraySegment<byte>(aad));
            byte[] roundTripPlaintext = test.Decrypt(new ArraySegment<byte>(ciphertext), new ArraySegment<byte>(aad));
            Assert.Equal(plaintext, roundTripPlaintext);
        }

        public void CreateAuthenticatedEncryptor_RoundTripsData_ManagedImplementation(EncryptionAlgorithm encryptionAlgorithm, ValidationAlgorithm validationAlgorithm)
        {
            // Parse test input
            int keyLengthInBits = Int32.Parse(Regex.Match(encryptionAlgorithm.ToString(), @"^AES_(?<keyLength>\d{3})_CBC$").Groups["keyLength"].Value, CultureInfo.InvariantCulture);

            // Arrange
            var masterKey = Secret.Random(512 / 8);
            var control = new ManagedAuthenticatedEncryptor(
                keyDerivationKey: masterKey,
                symmetricAlgorithmFactory: () => new AesCryptoServiceProvider(),
                symmetricAlgorithmKeySizeInBytes: keyLengthInBits / 8,
                validationAlgorithmFactory: () => KeyedHashAlgorithm.Create(validationAlgorithm.ToString()));
            var test = CreateDescriptor(encryptionAlgorithm, validationAlgorithm, masterKey).CreateEncryptorInstance();

            // Act & assert - data round trips properly from control to test
            byte[] plaintext = new byte[] { 1, 2, 3, 4, 5 };
            byte[] aad = new byte[] { 2, 4, 6, 8, 0 };
            byte[] ciphertext = control.Encrypt(new ArraySegment<byte>(plaintext), new ArraySegment<byte>(aad));
            byte[] roundTripPlaintext = test.Decrypt(new ArraySegment<byte>(ciphertext), new ArraySegment<byte>(aad));
            Assert.Equal(plaintext, roundTripPlaintext);
        }

 public static AbstractEncryptionAlgorithm GetAlgorithm(EncryptionAlgorithm algo)
 {
     switch (algo)
     {
         case EncryptionAlgorithm.Plain:
             return new AlgorithmPlain();
         case EncryptionAlgorithm.Blowfish:
             return new AlgorithmBlowfish();
         case EncryptionAlgorithm.Twofish:
             return new AlgorithmTwofish();
         case EncryptionAlgorithm.AES:
             return new AlgorithmAES();
         case EncryptionAlgorithm.TripleDES:
             return new AlgorithmTripleDES();
         case EncryptionAlgorithm.CAST:
             return new AlgorithmCAST();
         case EncryptionAlgorithm.XOR:
             return new AlgorithmXOR();
         case EncryptionAlgorithm.DES:
             return new AlgorithmDES();
         default:
             throw new NotImplementedException();
     }
 }

 /// <summary>
 /// �ṩ����ʵ�ֽ��ܵķ���
 /// </summary>
 /// <param name="algorithm"></param>
 /// <param name="bytesData">��Ҫ���ܵ���Ϣ</param>
 /// <returns></returns>
 public byte[] Decrypt(EncryptionAlgorithm algorithm, byte[] bytesData)
 {
     byte[] result = new byte[0];
     using (MemoryStream stream = new MemoryStream())
     {
         ICryptoTransform cryptoServiceProvider = GetDecryptoServiceProvider(algorithm);
         using (CryptoStream stream2 = new CryptoStream(stream, cryptoServiceProvider, CryptoStreamMode.Write))
         {
             try
             {
                 stream2.Write(bytesData, 0, bytesData.Length);
                 stream2.FlushFinalBlock();
                 stream2.Close();
                 result = stream.ToArray();
             }
             catch (Exception exception)
             {
                 throw new Exception("Error while writing decrypted data to the stream: \n" + exception.Message);
             }
         }
         stream.Close();
     }
     return result;
 }

        internal static int GetLengthOfCryptoHeaderBytes(EncryptionAlgorithm a)
        {
            //if ((_BitField & 0x01) != 0x01) return 0;
            if (a == EncryptionAlgorithm.None) return 0;

#if AESCRYPTO
            if (a == EncryptionAlgorithm.WinZipAes128 ||
                a == EncryptionAlgorithm.WinZipAes256)
            {
                int KeyStrengthInBits = GetKeyStrengthInBits(a);
                int sizeOfSaltAndPv = ((KeyStrengthInBits / 8 / 2) + 2);
                return sizeOfSaltAndPv;
            }
#endif
            if (a == EncryptionAlgorithm.PkzipWeak)
                return 12;
            throw new ZipException("internal error");
        }

 private static int GetKeyStrengthInBits(EncryptionAlgorithm a)
 {
     if (a == EncryptionAlgorithm.WinZipAes256) return 256;
     else if (a == EncryptionAlgorithm.WinZipAes128) return 128;
     return -1;
 }

 public Decryptor(EncryptionAlgorithm algId)
 {
     transformer = new DecryptTransformer(algId);
 }

 void RadioButton4_CheckedChanged(object sender, EventArgs e)
 {
     if (RadioButton1.Checked) {
         MahEncType = EncryptionAlgorithm.None;
     } else if (RadioButton2.Checked) {
         MahEncType = EncryptionAlgorithm.PkzipWeak;
     } else if (RadioButton3.Checked) {
         MahEncType = EncryptionAlgorithm.WinZipAes128;
     } else if (RadioButton4.Checked) {
         MahEncType = EncryptionAlgorithm.WinZipAes256;
     } else {
         MessageBox.Show("Error: Invalid Encryption Type!");
     }
 }

        void _Zip64_Over65534Entries(Zip64Option z64option,
                                            EncryptionAlgorithm encryption,
                                            Ionic.Zlib.CompressionLevel compression)
        {
            // Emitting a zip file with > 65534 entries requires the use of ZIP64 in
            // the central directory.
            int numTotalEntries = _rnd.Next(4616)+65534;
            //int numTotalEntries = _rnd.Next(461)+6534;
            //int numTotalEntries = _rnd.Next(46)+653;
            string enc = encryption.ToString();
            if (enc.StartsWith("WinZip")) enc = enc.Substring(6);
            else if (enc.StartsWith("Pkzip")) enc = enc.Substring(0,5);
            string zipFileToCreate = String.Format("Zip64.ZF_Over65534.{0}.{1}.{2}.zip",
                                                   z64option.ToString(),
                                                   enc,
                                                   compression.ToString());

            _testTitle = String.Format("ZipFile #{0} 64({1}) E({2}), C({3})",
                                       numTotalEntries,
                                       z64option.ToString(),
                                       enc,
                                       compression.ToString());
            _txrx = TestUtilities.StartProgressMonitor(zipFileToCreate,
                                                       _testTitle,
                                                       "starting up...");

            _txrx.Send("pb 0 max 4"); // 3 stages: AddEntry, Save, Verify
            _txrx.Send("pb 0 value 0");

            string password = Path.GetRandomFileName();

            string statusString = String.Format("status Encrypt:{0} Compress:{1}...",
                                                enc,
                                                compression.ToString());

            int numSaved = 0;
            var saveProgress = new EventHandler<SaveProgressEventArgs>( (sender, e) => {
                    switch (e.EventType)
                    {
                        case ZipProgressEventType.Saving_Started:
                        _txrx.Send("status saving...");
                        _txrx.Send("pb 1 max " + numTotalEntries);
                        numSaved= 0;
                        break;

                        case ZipProgressEventType.Saving_AfterWriteEntry:
                        numSaved++;
                        if ((numSaved % 128) == 0)
                        {
                            _txrx.Send("pb 1 value " + numSaved);
                            _txrx.Send(String.Format("status Saving entry {0}/{1} ({2:N0}%)",
                                                     numSaved, numTotalEntries,
                                                     numSaved / (0.01 * numTotalEntries)
                                                     ));
                        }
                        break;

                        case ZipProgressEventType.Saving_Completed:
                        _txrx.Send("status Save completed");
                        _txrx.Send("pb 1 max 1");
                        _txrx.Send("pb 1 value 1");
                        break;
                    }
                });

            string contentFormatString =
                "This is the content for entry #{0}.\r\n\r\n" +
                "AAAAAAA BBBBBB AAAAA BBBBB AAAAA BBBBB AAAAA\r\n"+
                "AAAAAAA BBBBBB AAAAA BBBBB AAAAA BBBBB AAAAA\r\n";
            _txrx.Send(statusString);
            int dirCount= 0;
            using (var zip = new ZipFile())
            {
                _txrx.Send(String.Format("pb 1 max {0}", numTotalEntries));
                _txrx.Send("pb 1 value 0");

                zip.Password = password;
                zip.Encryption = encryption;
                zip.CompressionLevel = compression;
                zip.SaveProgress += saveProgress;
                zip.UseZip64WhenSaving = z64option;
                // save space when saving the file:
                zip.EmitTimesInWindowsFormatWhenSaving = false;
                zip.EmitTimesInUnixFormatWhenSaving = false;

                // add files:
                for (int m=0; m<numTotalEntries; m++)
                {
                    if (_rnd.Next(7)==0)
                    {
                        string entryName = String.Format("{0:D5}", m);
                        zip.AddDirectoryByName(entryName);
                        dirCount++;
                    }
                    else
                    {
                        string entryName = String.Format("{0:D5}.txt", m);
                        if (_rnd.Next(12)==0)
                        {
                            string contentBuffer = String.Format(contentFormatString, m);
//.........这里部分代码省略.........

 /// <summary>
 /// Set the password and algorithm used by the Berkeley DB library to
 /// perform encryption and decryption. 
 /// </summary>
 /// <param name="password">
 /// The password used to perform encryption and decryption.
 /// </param>
 /// <param name="alg">
 /// The algorithm used to perform encryption and decryption.
 /// </param>
 public void SetEncryption(String password, EncryptionAlgorithm alg)
 {
     encryptionIsSet = true;
     encryptPwd = password;
     encryptAlg = alg;
 }