public static bool Test() { Random rnd = new Random(); // create a random array of random bytes int len = rnd.Next(1000000); byte[] plain = new byte[len]; rnd.NextBytes(plain); Console.Write("Working with " + len + " bytes of plaintext..."); // encrypt with salt RC2CryptoServiceProvider rc2s = new RC2CryptoServiceProvider(); rc2s.UseSalt = true; rc2s.Key = new byte[]{1,2,3,4,5}; byte[] encrypted = (rc2s.CreateEncryptor()).TransformFinalBlock(plain, 0, plain.Length); // decrypt with salt RC2CryptoServiceProvider rc2sd = new RC2CryptoServiceProvider(); rc2sd.UseSalt = true; rc2sd.Key = rc2s.Key; rc2sd.IV = rc2s.IV; byte[] decrypted = (rc2sd.CreateDecryptor()).TransformFinalBlock(encrypted, 0, encrypted.Length); if (CompareSlow(plain, decrypted)) { Console.WriteLine("OK."); return true; } else { Console.WriteLine("FAIL."); return false; } }
public static void Main() { string PlainText = "Titan"; byte[] PlainBytes = new byte[5]; PlainBytes = Encoding.ASCII.GetBytes(PlainText.ToCharArray()); PrintByteArray(PlainBytes); byte[] CipherBytes = new byte[8]; PasswordDeriveBytes pdb = new PasswordDeriveBytes("Titan", null); byte[] IV = new byte[8]; byte[] Key = pdb.CryptDeriveKey("RC2", "SHA1", 40, IV); PrintByteArray(Key); PrintByteArray(IV); // Now use the data to encrypt something RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider(); Console.WriteLine(rc2.Padding); Console.WriteLine(rc2.Mode); ICryptoTransform sse = rc2.CreateEncryptor(Key, IV); MemoryStream ms = new MemoryStream(); CryptoStream cs1 = new CryptoStream(ms, sse, CryptoStreamMode.Write); cs1.Write(PlainBytes, 0, PlainBytes.Length); cs1.FlushFinalBlock(); CipherBytes = ms.ToArray(); cs1.Close(); Console.WriteLine(Encoding.ASCII.GetString(CipherBytes)); PrintByteArray(CipherBytes); ICryptoTransform ssd = rc2.CreateDecryptor(Key, IV); CryptoStream cs2 = new CryptoStream(new MemoryStream(CipherBytes), ssd, CryptoStreamMode.Read); byte[] InitialText = new byte[5]; cs2.Read(InitialText, 0, 5); Console.WriteLine(Encoding.ASCII.GetString(InitialText)); PrintByteArray(InitialText); }
public static bool Test() { Random rnd = new Random(); // create a random array of random bytes int len = rnd.Next(1000000); byte[] plain = new byte[len]; rnd.NextBytes(plain); Console.Write("Working with " + len + " bytes of plaintext..."); // encrypt by default RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider(); rc2.Key = new byte[]{5,4,3,2,1,0,0,0,0,0,0,0,0,0,0,0}; // salt only takes effect when we use a 40-bit key byte[] encrypted1 = (rc2.CreateEncryptor()).TransformFinalBlock(plain, 0, plain.Length); // encrypt with salt RC2CryptoServiceProvider rc2s = new RC2CryptoServiceProvider(); rc2s.UseSalt = true; rc2s.Key = new byte[]{1,2,3,4,5}; rc2s.IV = rc2.IV; byte[] encrypted2 = (rc2s.CreateEncryptor()).TransformFinalBlock(plain, 0, plain.Length); if (CompareSlow(encrypted1, encrypted2)) { Console.WriteLine("OK."); return true; } else { Console.WriteLine("FAIL."); return false; } }
public static void RC2KeySize() { using (RC2 rc2 = new RC2CryptoServiceProvider()) { rc2.KeySize = 40; Assert.Equal(40 / 8, rc2.Key.Length); Assert.Equal(40, rc2.KeySize); rc2.KeySize = 128; Assert.Equal(128 / 8, rc2.Key.Length); Assert.Equal(128, rc2.KeySize); Assert.Throws<CryptographicException>(() => rc2.KeySize = 40 - 8); Assert.Throws<CryptographicException>(() => rc2.KeySize = 128 + 8); } }
static void Main(string[] args) { AesManaged aes = new AesManaged(); Console.WriteLine("AesManaged "); KeySizes[] ks = aes.LegalKeySizes; foreach (KeySizes k in ks) { Console.WriteLine("\tLegal min key size = " + k.MinSize); Console.WriteLine("\tLegal max key size = " + k.MaxSize); } ks = aes.LegalBlockSizes; foreach (KeySizes k in ks) { Console.WriteLine("\tLegal min block size = " + k.MinSize); Console.WriteLine("\tLegal max block size = " + k.MaxSize); } DESCryptoServiceProvider des = new DESCryptoServiceProvider(); Console.WriteLine("DESCryptoServiceProvider "); ks = des.LegalKeySizes; foreach (KeySizes k in ks) { Console.WriteLine("\tLegal min key size = " + k.MinSize); Console.WriteLine("\tLegal max key size = " + k.MaxSize); } ks = des.LegalBlockSizes; foreach (KeySizes k in ks) { Console.WriteLine("\tLegal min block size = " + k.MinSize); Console.WriteLine("\tLegal max block size = " + k.MaxSize); } RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider(); Console.WriteLine("RC2CryptoServiceProvider "); ks = rc2.LegalKeySizes; foreach (KeySizes k in ks) { Console.WriteLine("\tLegal min key size = " + k.MinSize); Console.WriteLine("\tLegal max key size = " + k.MaxSize); } ks = rc2.LegalBlockSizes; foreach (KeySizes k in ks) { Console.WriteLine("\tLegal min block size = " + k.MinSize); Console.WriteLine("\tLegal max block size = " + k.MaxSize); } RijndaelManaged rij = new RijndaelManaged(); Console.WriteLine("RijndaelManaged "); ks = rij.LegalKeySizes; foreach (KeySizes k in ks) { Console.WriteLine("\tLegal min key size = " + k.MinSize); Console.WriteLine("\tLegal max key size = " + k.MaxSize); } ks = rij.LegalBlockSizes; foreach (KeySizes k in ks) { Console.WriteLine("\tLegal min block size = " + k.MinSize); Console.WriteLine("\tLegal max block size = " + k.MaxSize); } TripleDESCryptoServiceProvider tsp = new TripleDESCryptoServiceProvider(); Console.WriteLine("TripleDESCryptoServiceProvider "); ks = tsp.LegalKeySizes; foreach (KeySizes k in ks) { Console.WriteLine("\tLegal min key size = " + k.MinSize); Console.WriteLine("\tLegal max key size = " + k.MaxSize); } ks = tsp.LegalBlockSizes; foreach (KeySizes k in ks) { Console.WriteLine("\tLegal min block size = " + k.MinSize); Console.WriteLine("\tLegal max block size = " + k.MaxSize); } }
//--------------------------------------------------------------------- public static SymmetricAlgorithm Create_SymmetricAlgorithm(SymmetricAlgorithms SymmetricAlgorithm_in, byte[] PasswordBytes_in) { HashAlgorithm HA = Create_HashAlgorithm(HashAlgorithms.SHA_512); SymmetricAlgorithm SA = null; switch (SymmetricAlgorithm_in) { case SymmetricAlgorithms.None: return(null); case SymmetricAlgorithms.Unused_1: return(null); case SymmetricAlgorithms.RC2_64_40: SA = new RC2CryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 40; break; case SymmetricAlgorithms.RC2_64_48: SA = new RC2CryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 48; break; case SymmetricAlgorithms.RC2_64_56: SA = new RC2CryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 56; break; case SymmetricAlgorithms.RC2_64_64: SA = new RC2CryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 64; break; case SymmetricAlgorithms.RC2_64_72: SA = new RC2CryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 72; break; case SymmetricAlgorithms.RC2_64_80: SA = new RC2CryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 80; break; case SymmetricAlgorithms.RC2_64_88: SA = new RC2CryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 88; break; case SymmetricAlgorithms.RC2_64_96: SA = new RC2CryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 96; break; case SymmetricAlgorithms.RC2_64_104: SA = new RC2CryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 104; break; case SymmetricAlgorithms.RC2_64_112: SA = new RC2CryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 112; break; case SymmetricAlgorithms.RC2_64_120: SA = new RC2CryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 120; break; case SymmetricAlgorithms.RC2_64_128: SA = new RC2CryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 128; break; case SymmetricAlgorithms.DES_64_64: SA = new DESCryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 64; break; case SymmetricAlgorithms.DES3_64_128: SA = new TripleDESCryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 128; break; case SymmetricAlgorithms.DES3_64_192: SA = new TripleDESCryptoServiceProvider(); SA.BlockSize = 64; SA.KeySize = 192; break; case SymmetricAlgorithms.AES_128_128: SA = new RijndaelManaged(); SA.BlockSize = 128; SA.KeySize = 128; break; case SymmetricAlgorithms.AES_128_192: SA = new RijndaelManaged(); SA.BlockSize = 128; SA.KeySize = 192; break; case SymmetricAlgorithms.AES_128_256: SA = new RijndaelManaged(); SA.BlockSize = 128; SA.KeySize = 256; break; case SymmetricAlgorithms.AES_192_128: SA = new RijndaelManaged(); SA.BlockSize = 192; SA.KeySize = 128; break; case SymmetricAlgorithms.AES_192_192: SA = new RijndaelManaged(); SA.BlockSize = 192; SA.KeySize = 192; break; case SymmetricAlgorithms.AES_192_256: SA = new RijndaelManaged(); SA.BlockSize = 192; SA.KeySize = 256; break; case SymmetricAlgorithms.AES_256_128: SA = new RijndaelManaged(); SA.BlockSize = 256; SA.KeySize = 128; break; case SymmetricAlgorithms.AES_256_192: SA = new RijndaelManaged(); SA.BlockSize = 256; SA.KeySize = 192; break; case SymmetricAlgorithms.AES_256_256: SA = new RijndaelManaged(); SA.BlockSize = 256; SA.KeySize = 256; break; default: return(null); } SA.Key = Create_CryptographicKey(HashAlgorithms.SHA_256, SA.KeySize, PasswordBytes_in); SA.IV = Create_CryptographicIV(HashAlgorithms.SHA_256, SA.BlockSize, PasswordBytes_in); return(SA); }
public System.Security.Cryptography.ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey, out System.Security.Cryptography.SymmetricAlgorithm algorithm) { System.Security.Cryptography.DES des; switch (this._algorithm) { case EncryptionAlgorithm.Des: des = new DESCryptoServiceProvider(); des.Mode = CipherMode.CBC; if (bytesKey != null) { des.Key = bytesKey; _encKey = des.Key; break; } _encKey = des.Key; break; case EncryptionAlgorithm.Rc2: RC2 rc = new RC2CryptoServiceProvider(); rc.Mode = CipherMode.CBC; if (bytesKey != null) { rc.Key = bytesKey; _encKey = rc.Key; } else { _encKey = rc.Key; } if (_initVec == null) { _initVec = rc.IV; } else { rc.IV = _initVec; } algorithm = rc; return(rc.CreateEncryptor()); case EncryptionAlgorithm.Rijndael: { Rijndael rijndael = new RijndaelManaged(); rijndael.Mode = System.Security.Cryptography.CipherMode.CBC; if (bytesKey != null) { rijndael.Key = bytesKey; _encKey = rijndael.Key; } else { _encKey = rijndael.Key; } if (_initVec == null) { _initVec = rijndael.IV; } else { rijndael.IV = _initVec; } algorithm = rijndael; return(rijndael.CreateEncryptor()); } case EncryptionAlgorithm.TripleDes: { TripleDES edes = new TripleDESCryptoServiceProvider(); edes.Mode = CipherMode.CBC; if (bytesKey != null) { edes.Key = bytesKey; _encKey = edes.Key; } else { _encKey = edes.Key; } if (_initVec == null) { _initVec = edes.IV; } else { edes.IV = _initVec; } algorithm = edes; return(edes.CreateEncryptor()); } default: throw new CryptographicException("Algorithm '" + _algorithm + "' not supported."); } if (_initVec == null) { _initVec = des.IV; } else { des.IV = _initVec; } algorithm = des; return(des.CreateEncryptor()); }
/// <summary> Function to encrypt an one content bytes /// </summary> /// <param name="content">Function to encrypt an one content bytes</param> /// <returns>Array of bytes</returns> public byte[] Encrypt(byte[] content) { if (!IsHashAlgorithm && _key == null) { throw new CryptographicException(Resources.Cypher_NoKey); } if (content == null || content.Equals(String.Empty)) { throw new CryptographicException(Resources.Cypher_NoContent); } byte[] cipherBytes = null; int NumBytes = 0; #if !CompactFramework if (_algorithm == Algorithm.RSA) { //This is an asymmetric call, which has to be treated differently cipherBytes = RSAEncrypt(content); } else #endif if (IsHashAlgorithm) { string hash = GenerateHash(System.Text.Encoding.UTF8.GetString(content, 0, content.Length)); cipherBytes = System.Text.Encoding.UTF8.GetBytes(hash); } else { SymmetricAlgorithm provider; switch (_algorithm) { case Algorithm.DES: provider = new DESCryptoServiceProvider(); NumBytes = Convert.ToInt32(AlgorithmKeySize.DES); break; case Algorithm.TripleDES: provider = new TripleDESCryptoServiceProvider(); NumBytes = Convert.ToInt32(AlgorithmKeySize.TripleDES); break; case Algorithm.Rijndael: provider = new RijndaelManaged(); NumBytes = Convert.ToInt32(AlgorithmKeySize.Rijndael); break; case Algorithm.RC2: provider = new RC2CryptoServiceProvider(); NumBytes = Convert.ToInt32(AlgorithmKeySize.RC2); break; default: throw new CryptographicException(Resources.Cypher_InvalidProvider); } try { //Encrypt the string cipherBytes = SymmetricEncrypt(provider, content, _key, NumBytes); } finally { //Free any resources held by the SymmetricAlgorithm provider provider.Clear(); } } return(cipherBytes); }
private static byte[] _Decrypt(byte[] Content) { if (!IsHashAlgorithm && _key == null) { throw new CryptographicException(ERR_NO_KEY); } if (_algorithm.Equals(-1)) { throw new CryptographicException(ERR_NO_ALGORITHM); } if (Content == null || Content.Length.Equals(0)) { throw new CryptographicException(ERR_NO_CONTENT); } string encText = Encoding.UTF8.GetString(Content); if (_encodingType == EncodingType.BASE_64) { //We need to convert the content to Hex before decryption encText = BytesToHex(System.Convert.FromBase64String(encText)); } byte[] clearBytes = null; int NumBytes = 0; if (_algorithm == Algorithm.RSA) { try { clearBytes = RSADecrypt(encText); } catch (CryptographicException ex) { throw ex; } } else { SymmetricAlgorithm provider = null; switch (_algorithm) { case Algorithm.DES: provider = new DESCryptoServiceProvider(); NumBytes = KeySize.DES; break; case Algorithm.TripleDES: provider = new TripleDESCryptoServiceProvider(); NumBytes = KeySize.TripleDES; break; case Algorithm.Rijndael: provider = new RijndaelManaged(); NumBytes = KeySize.AES; break; case Algorithm.RC2: provider = new RC2CryptoServiceProvider(); NumBytes = KeySize.RC2; break; default: throw new CryptographicException(ERR_INVALID_PROVIDER); } try { clearBytes = SymmetricDecrypt(provider, encText, _key, NumBytes); } catch (CryptographicException ex) { throw ex; } finally { //Free any resources held by the SymmetricAlgorithm provider provider.Clear(); } } //Now return the plain text content return(clearBytes); }
/// <summary> /// Writes the value of 'LicenseString' as an encrypted stream to the file:stream specified /// by 'currentFile'. /// </summary> /// <param name="currentFile">Fully qualified path to the alternate stream</param> /// <param name="LicenseString">The string value to encrypt and write to the alternate stream</param> public static void WriteAlternateStreamEncrypted(string currentFile, string LicenseString) { RC2CryptoServiceProvider rc2 = null; CryptoStream cs = null; MemoryStream ms = null; uint count = 0; IntPtr buffer = IntPtr.Zero; IntPtr hFile = IntPtr.Zero; try { Encoding enc = Encoding.Unicode; byte[] ba = enc.GetBytes(LicenseString); ms = new MemoryStream(); rc2 = new RC2CryptoServiceProvider(); rc2.Key = GetBytesFromHexString("7a6823a42a3a3ae27057c647db812d0"); rc2.IV = GetBytesFromHexString("827d961224d99b2d"); cs = new CryptoStream(ms, rc2.CreateEncryptor(), CryptoStreamMode.Write); cs.Write(ba, 0, ba.Length); cs.FlushFinalBlock(); buffer = Marshal.AllocHGlobal(1000 * sizeof(char)); ZeroMemory(buffer, 1000 * sizeof(char)); uint nBytes = (uint)ms.Length; Marshal.Copy(ms.GetBuffer(), 0, buffer, (int)nBytes); DeleteFile(currentFile); hFile = CreateFile(currentFile, GENERIC_WRITE, 0, IntPtr.Zero, CREATE_ALWAYS, 0, IntPtr.Zero); if (-1 != hFile.ToInt32()) { bool bRtn = WriteFile(hFile, buffer, nBytes, out count, 0); } else { Exception excptn = new Win32Exception(Marshal.GetLastWin32Error()); if (!excptn.Message.Contains("cannot find the file")) { throw excptn; } } } catch (Exception exception) { Console.WriteLine("WriteAlternateStreamEncrypted()"); Console.WriteLine(exception.Message); } finally { CloseHandle(hFile); hFile = IntPtr.Zero; if (cs != null) { cs.Close(); cs.Dispose(); } rc2 = null; if (ms != null) { ms.Close(); ms.Dispose(); } if (buffer != IntPtr.Zero) { Marshal.FreeHGlobal(buffer); } } }
public static void Main() { // Create a new instance of the RC2CryptoServiceProvider class // and automatically generate a Key and IV. RC2CryptoServiceProvider rc2CSP = new RC2CryptoServiceProvider(); Console.WriteLine("Effective key size is {0} bits.", rc2CSP.EffectiveKeySize); // Get the key and IV. byte[] key = rc2CSP.Key; byte[] IV = rc2CSP.IV; // Get an encryptor. ICryptoTransform encryptor = rc2CSP.CreateEncryptor(key, IV); // Encrypt the data as an array of encrypted bytes in memory. MemoryStream msEncrypt = new MemoryStream(); CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write); // Convert the data to a byte array. string original = "Here is some data to encrypt."; byte[] toEncrypt = Encoding.ASCII.GetBytes(original); // Write all data to the crypto stream and flush it. csEncrypt.Write(toEncrypt, 0, toEncrypt.Length); csEncrypt.FlushFinalBlock(); // Get the encrypted array of bytes. byte[] encrypted = msEncrypt.ToArray(); /////////////////////////////////////////////////////// // This is where the data could be transmitted or saved. /////////////////////////////////////////////////////// //Get a decryptor that uses the same key and IV as the encryptor. ICryptoTransform decryptor = rc2CSP.CreateDecryptor(key, IV); // Now decrypt the previously encrypted message using the decryptor // obtained in the above step. MemoryStream msDecrypt = new MemoryStream(encrypted); CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read); // Read the decrypted bytes from the decrypting stream // and place them in a StringBuilder class. StringBuilder roundtrip = new StringBuilder(); int b = 0; do { b = csDecrypt.ReadByte(); if (b != -1) { roundtrip.Append((char)b); } } while (b != -1); // Display the original data and the decrypted data. Console.WriteLine("Original: {0}", original); Console.WriteLine("Round Trip: {0}", roundtrip); Console.ReadLine(); }
public RC2EncryptionService() { rc2Instance = new RC2CryptoServiceProvider(); }
internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey) { // Pick the provider. switch (algorithmID) { case EncryptionAlgorithm.Des: { DES des = new DESCryptoServiceProvider(); des.Mode = CipherMode.CBC; // See if a key was provided if (null == bytesKey) { encKey = des.Key; } else { des.Key = bytesKey; encKey = des.Key; } // See if the client provided an initialization vector if (null == initVec) { // Have the algorithm create one initVec = des.IV; } else { //No, give it to the algorithm des.IV = initVec; } return(des.CreateEncryptor()); } case EncryptionAlgorithm.TripleDes: { TripleDES des3 = new TripleDESCryptoServiceProvider(); des3.Mode = CipherMode.CBC; // See if a key was provided if (null == bytesKey) { encKey = des3.Key; } else { des3.Key = bytesKey; encKey = des3.Key; } // See if the client provided an IV if (null == initVec) { //Yes, have the alg create one initVec = des3.IV; } else { //No, give it to the alg. des3.IV = initVec; } return(des3.CreateEncryptor()); } case EncryptionAlgorithm.Rc2: { RC2 rc2 = new RC2CryptoServiceProvider(); rc2.Mode = CipherMode.CBC; // Test to see if a key was provided if (null == bytesKey) { encKey = rc2.Key; } else { rc2.Key = bytesKey; encKey = rc2.Key; } // See if the client provided an IV if (null == initVec) { //Yes, have the alg create one initVec = rc2.IV; } else { //No, give it to the alg. rc2.IV = initVec; } return(rc2.CreateEncryptor()); } case EncryptionAlgorithm.Rijndael: { Rijndael rijndael = new RijndaelManaged(); rijndael.Mode = CipherMode.CBC; // Test to see if a key was provided if (null == bytesKey) { encKey = rijndael.Key; } else { rijndael.Key = bytesKey; encKey = rijndael.Key; } // See if the client provided an IV if (null == initVec) { //Yes, have the alg create one initVec = rijndael.IV; } else { //No, give it to the alg. rijndael.IV = initVec; } return(rijndael.CreateEncryptor()); } default: { throw new CryptographicException("Algorithm ID '" + algorithmID + "' not supported."); } } }
public Rc2StorageEncryptionProvider(string key) { encryptionProvider = new RC2CryptoServiceProvider(); encryptionProvider.KeySize = 256; encryptionProvider.Key = Encoding.UTF8.GetBytes(key); }
public static byte[] ObtenerIV() { RC2CryptoServiceProvider rC2 = new RC2CryptoServiceProvider(); return(rC2.IV); }
private void process(int action) { //Encrypt/Decrypt Stream try { if (inputStream == null || inputStream.Length == 0) { GuiLogMessage("No input data, aborting now", NotificationLevel.Error); return; } ICryptoTransform p_encryptor; SymmetricAlgorithm p_alg = new RC2CryptoServiceProvider(); ConfigureAlg(p_alg); outputStreamWriter = new CStreamWriter(); ICryptoolStream inputdata = InputStream; if (action == 0) { inputdata = BlockCipherHelper.AppendPadding(InputStream, settings.padmap[settings.Padding], p_alg.BlockSize / 8); } CStreamReader reader = inputdata.CreateReader(); GuiLogMessage("Starting " + ((settings.Action == 0)?"encryption":"decryption") + " [Keysize=" + p_alg.KeySize.ToString() + " Bits, Blocksize=" + p_alg.BlockSize.ToString() + " Bits]", NotificationLevel.Info); DateTime startTime = DateTime.Now; // special handling of OFB mode, as it's not available for RC2 in .Net if (settings.Mode == 3) // OFB - bei OFB ist encrypt = decrypt, daher keine Fallunterscheidung { p_encryptor = p_alg.CreateEncryptor(p_alg.Key, p_alg.IV); byte[] IV = new byte[p_alg.IV.Length]; Array.Copy(p_alg.IV, IV, p_alg.IV.Length); byte[] tmpInput = BlockCipherHelper.StreamToByteArray(inputdata); byte[] outputData = new byte[tmpInput.Length]; for (int pos = 0; pos <= tmpInput.Length - p_encryptor.InputBlockSize;) { int l = p_encryptor.TransformBlock(IV, 0, p_encryptor.InputBlockSize, outputData, pos); for (int i = 0; i < l; i++) { IV[i] = outputData[pos + i]; outputData[pos + i] ^= tmpInput[pos + i]; } pos += l; } outputStreamWriter.Write(outputData); } else { p_encryptor = (action == 0) ? p_alg.CreateEncryptor() : p_alg.CreateDecryptor(); p_crypto_stream = new CryptoStream((Stream)reader, p_encryptor, CryptoStreamMode.Read); byte[] buffer = new byte[p_alg.BlockSize / 8]; int bytesRead; while ((bytesRead = p_crypto_stream.Read(buffer, 0, buffer.Length)) > 0 && !stop) { outputStreamWriter.Write(buffer, 0, bytesRead); } p_crypto_stream.Flush(); } outputStreamWriter.Close(); DateTime stopTime = DateTime.Now; TimeSpan duration = stopTime - startTime; if (action == 1) { outputStreamWriter = BlockCipherHelper.StripPadding(outputStreamWriter, settings.padmap[settings.Padding], p_alg.BlockSize / 8) as CStreamWriter; } if (!stop) { GuiLogMessage(((settings.Action == 0) ? "Encryption" : "Decryption") + " complete! (in: " + InputStream.Length + " bytes, out: " + outputStreamWriter.Length + " bytes)", NotificationLevel.Info); GuiLogMessage("Time used: " + duration, NotificationLevel.Debug); OnPropertyChanged("OutputStream"); } else { GuiLogMessage("Aborted!", NotificationLevel.Info); } } catch (CryptographicException cryptographicException) { // TODO: For an unknown reason p_crypto_stream can not be closed after exception. // Trying so makes p_crypto_stream throw the same exception again. So in Dispose // the error messages will be doubled. // As a workaround we set p_crypto_stream to null here. p_crypto_stream = null; GuiLogMessage(cryptographicException.Message, NotificationLevel.Error); } catch (Exception exception) { GuiLogMessage(exception.Message, NotificationLevel.Error); } finally { ProgressChanged(1, 1); } }
public string Cifrar(Byte modo, string cadena) { try { Byte[] plaintext; string VecI = "20270430"; Byte Algoritmo = 3; string key = "Visa-Preferida"; /*** Procedimiento de cifrado ***/ //encriptar if (modo == 1) { plaintext = Encoding.ASCII.GetBytes(cadena); } else { //desencriptar plaintext = Convert.FromBase64String(cadena); } Byte[] keys = Encoding.ASCII.GetBytes(key); MemoryStream memdata = new MemoryStream(); ICryptoTransform transforma = null; switch (Algoritmo) { case 1: /*** DES ***/ DESCryptoServiceProvider des = new DESCryptoServiceProvider(); des.Mode = CipherMode.CBC; des.Padding = PaddingMode.PKCS7; if (modo == 1) { transforma = des.CreateEncryptor(keys, Encoding.ASCII.GetBytes(VecI)); } else { if (modo == 2) { transforma = des.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI)); } else { transforma = des.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI)); } } break; case 2: /*** TripleDES ***/ TripleDESCryptoServiceProvider des3 = new TripleDESCryptoServiceProvider(); des3.Mode = CipherMode.CBC; des3.Padding = PaddingMode.PKCS7; if (modo == 1) { transforma = des3.CreateEncryptor(keys, Encoding.ASCII.GetBytes(VecI)); } else { if (modo == 2) { transforma = des3.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI)); } else { transforma = des3.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI)); } } break; case 3: /*** RC2 ***/ RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider(); rc2.Mode = CipherMode.CBC; rc2.Padding = PaddingMode.PKCS7; if (modo == 1) { transforma = rc2.CreateEncryptor(keys, Encoding.ASCII.GetBytes(VecI)); } else { if (modo == 2) { transforma = rc2.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI)); } else { transforma = rc2.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI)); } } break; case 4: /*** Rijndael ***/ RijndaelManaged rj = new RijndaelManaged(); rj.Mode = CipherMode.CBC; rj.Padding = PaddingMode.PKCS7; if (modo == 1) { transforma = rj.CreateEncryptor(keys, Encoding.ASCII.GetBytes(VecI)); } else { if (modo == 2) { transforma = rj.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI)); } else { transforma = rj.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI)); } } break; } CryptoStream encstream = new CryptoStream(memdata, transforma, CryptoStreamMode.Write); encstream.Write(plaintext, 0, plaintext.Length); encstream.FlushFinalBlock(); encstream.Close(); if (modo == 1) { cadena = Convert.ToBase64String(memdata.ToArray()); } else { if (modo == 2) { cadena = Encoding.ASCII.GetString(memdata.ToArray()); } else { cadena = Convert.ToBase64String(memdata.ToArray()); } } return(cadena); } catch (Exception) { throw; } }
public RC2EncryptionService(string plainTxt) { rc2Instance = new RC2CryptoServiceProvider(); plainText = plainTxt; }
public void Test36() { UInt16 userId = 65535; DateTime now = DateTime.Now; DateTime y2010 = new DateTime(2010, 1, 1); DateTime y2040 = new DateTime(2040, 1, 1); TimeSpan span = y2040 - y2010; Assert.IsTrue(span.TotalSeconds < UInt32.MaxValue); UInt32 secs = (uint)span.TotalSeconds; byte[] userBytes = BitConverter.GetBytes(userId); byte[] secsBytes = BitConverter.GetBytes(secs); byte[] magicBytes = new byte[8]; // userBytes.CopyTo(magicBytes, 0); // secsBytes.CopyTo(magicBytes, 2); UInt64 magic = BitConverter.ToUInt64(magicBytes, 0); ulong i = UInt64.MaxValue; ulong p; ulong reminder; uint bas = 36; List <ulong> rems = new List <ulong>(); while (true) { p = i / bas; reminder = i % bas; i = p; rems.Add(reminder); if (p == 0) { break; } } StringBuilder sb = new StringBuilder(); // foreach (ulong rem in rems) // { // sb.Append(ConvertTo36((byte) rem)); // } MessageBox.Show(sb.ToString() + " " + rems.Count); RC2CryptoServiceProvider aes = new RC2CryptoServiceProvider(); MemoryStream ms = new MemoryStream(); byte[] rgbKey = Encoding.Default.GetBytes("cjkywtqwertyuiop"); byte[] rgbIV = Encoding.Default.GetBytes("cdtnbnasdfghjklz");; CryptoStream cryptoStream = new CryptoStream(ms, aes.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write); foreach (byte b in BitConverter.GetBytes(int.MaxValue)) { cryptoStream.WriteByte(b); } cryptoStream.Close(); byte[] cipherTextinBytes = ms.ToArray(); }
public string Decrypt(EncoderType type, string decrypt) { string ret = ""; byte[] inputByteArray = Convert.FromBase64String(decrypt); byte[] rgbKey = Convert.FromBase64String(Key); byte[] rgbIV = Convert.FromBase64String(IV); switch (type) { //可逆編碼(對稱金鑰) case EncoderType.AES: using (AesCryptoServiceProvider csp = new AesCryptoServiceProvider()) { using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, csp.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write)) { cs.Write(inputByteArray, 0, inputByteArray.Length); cs.FlushFinalBlock(); ret = Encoding.UTF8.GetString(ms.ToArray()); } } } break; case EncoderType.DES: using (DESCryptoServiceProvider csp = new DESCryptoServiceProvider()) { using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, csp.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write)) { cs.Write(inputByteArray, 0, inputByteArray.Length); cs.FlushFinalBlock(); ret = Encoding.UTF8.GetString(ms.ToArray()); } } } break; case EncoderType.RC2: using (RC2CryptoServiceProvider csp = new RC2CryptoServiceProvider()) { using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, csp.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write)) { cs.Write(inputByteArray, 0, inputByteArray.Length); cs.FlushFinalBlock(); ret = Encoding.UTF8.GetString(ms.ToArray()); } } } break; case EncoderType.TripleDES: using (TripleDESCryptoServiceProvider csp = new TripleDESCryptoServiceProvider()) { using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, csp.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write)) { cs.Write(inputByteArray, 0, inputByteArray.Length); cs.FlushFinalBlock(); ret = Encoding.UTF8.GetString(ms.ToArray()); } } } break; //可逆編碼(非對稱金鑰) case EncoderType.RSA: using (RSACryptoServiceProvider csp = new RSACryptoServiceProvider()) { csp.FromXmlString(Key); ret = Encoding.UTF8.GetString(csp.Decrypt(inputByteArray, false)); } break; } return(ret); }
public void SetUp() { rc2 = new RC2CryptoServiceProvider(); }
public string Encrypt(EncoderType type, string encrypt) { string ret = ""; byte[] inputByteArray = Encoding.UTF8.GetBytes(encrypt); byte[] rgbKey = Convert.FromBase64String(Key); byte[] rgbIV = Convert.FromBase64String(IV); switch (type) { case EncoderType.AES: using (AesCryptoServiceProvider csp = new AesCryptoServiceProvider()) { using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, csp.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write)) { cs.Write(inputByteArray, 0, inputByteArray.Length); cs.FlushFinalBlock(); ret = Convert.ToBase64String(ms.ToArray()); } } } break; case EncoderType.DES: using (DESCryptoServiceProvider csp = new DESCryptoServiceProvider()) { using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, csp.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write)) { cs.Write(inputByteArray, 0, inputByteArray.Length); cs.FlushFinalBlock(); ret = Convert.ToBase64String(ms.ToArray()); } } } break; case EncoderType.RC2: using (RC2CryptoServiceProvider csp = new RC2CryptoServiceProvider()) { using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, csp.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write)) { cs.Write(inputByteArray, 0, inputByteArray.Length); cs.FlushFinalBlock(); ret = Convert.ToBase64String(ms.ToArray()); } } } break; case EncoderType.TripleDES: using (TripleDESCryptoServiceProvider csp = new TripleDESCryptoServiceProvider()) { using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, csp.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write)) { cs.Write(inputByteArray, 0, inputByteArray.Length); cs.FlushFinalBlock(); ret = Convert.ToBase64String(ms.ToArray()); } } } break; case EncoderType.RSA: using (RSACryptoServiceProvider csp = new RSACryptoServiceProvider()) { csp.FromXmlString(Key); ret = Convert.ToBase64String(csp.Encrypt(inputByteArray, false)); } break; case EncoderType.MD5: using (MD5CryptoServiceProvider csp = new MD5CryptoServiceProvider()) { ret = BitConverter.ToString(csp.ComputeHash(inputByteArray)).Replace("-", string.Empty); } break; case EncoderType.SHA1: using (SHA1CryptoServiceProvider csp = new SHA1CryptoServiceProvider()) { ret = BitConverter.ToString(csp.ComputeHash(inputByteArray)).Replace("-", string.Empty); } break; case EncoderType.SHA256: using (SHA256CryptoServiceProvider csp = new SHA256CryptoServiceProvider()) { ret = BitConverter.ToString(csp.ComputeHash(inputByteArray)).Replace("-", string.Empty); } break; case EncoderType.SHA384: using (SHA384CryptoServiceProvider csp = new SHA384CryptoServiceProvider()) { ret = BitConverter.ToString(csp.ComputeHash(inputByteArray)).Replace("-", string.Empty); } break; case EncoderType.SHA512: using (SHA512CryptoServiceProvider csp = new SHA512CryptoServiceProvider()) { ret = BitConverter.ToString(csp.ComputeHash(inputByteArray)).Replace("-", string.Empty); } break; } return(ret); }
public object Crypt(CryptMethod _method, CryptClass _class, object _input, string _key) { SymmetricAlgorithm control; switch (_class) { case CryptClass.AES: control = new AesManaged(); break; case CryptClass.RC2: control = new RC2CryptoServiceProvider(); break; case CryptClass.RIJ: control = new RijndaelManaged(); break; case CryptClass.DES: control = new DESCryptoServiceProvider(); break; case CryptClass.TDES: control = new TripleDESCryptoServiceProvider(); break; default: return(false); } control.Key = UTF8Encoding.UTF8.GetBytes(_key); control.Padding = PaddingMode.PKCS7; control.Mode = CipherMode.ECB; ICryptoTransform cTransform = null; byte[] resultArray; if (_method == CryptMethod.ENCRYPT) { cTransform = control.CreateEncryptor(); } else if (_method == CryptMethod.DECRYPT) { cTransform = control.CreateDecryptor(); } if (_input is string) { byte[] inputArray = UTF32Encoding.UTF8.GetBytes(_input as string); resultArray = cTransform.TransformFinalBlock(inputArray, 0, inputArray.Length); control.Clear(); return(Convert.ToBase64String(resultArray, 0, resultArray.Length)); } else if (_input is byte[]) { resultArray = cTransform.TransformFinalBlock((_input as byte[]), 0, (_input as byte[]).Length); control.Clear(); return(resultArray); } return(false); }
public ICryptoTransform GetCryptoTransform() { bool bHasSecuityKey = false; if (SecurityKey.Length != 0) { bHasSecuityKey = true; } byte[] key = Encoding.ASCII.GetBytes(SecurityKey); switch (algorithmID) { case EncryptionAlgorithm.DES: DES des = new DESCryptoServiceProvider(); if (bHasSecuityKey) { des.Key = key; } if (bHasIV) { des.IV = IV; } return(des.CreateDecryptor()); case EncryptionAlgorithm.Rc2: RC2 rc = new RC2CryptoServiceProvider(); if (bHasSecuityKey) { rc.Key = key; } if (bHasIV) { rc.IV = IV; } return(rc.CreateDecryptor()); case EncryptionAlgorithm.Rijndael: Rijndael rj = new RijndaelManaged(); if (bHasSecuityKey) { rj.Key = key; } if (bHasIV) { rj.IV = IV; } ; return(rj.CreateDecryptor()); case EncryptionAlgorithm.TripleDes: TripleDES tDes = new TripleDESCryptoServiceProvider(); if (bHasSecuityKey) { tDes.Key = key; } if (bHasIV) { tDes.IV = IV; } return(tDes.CreateDecryptor()); default: throw new CryptographicException("Algorithm ID '" + algorithmID + "' not supported."); } }
private static byte[] _Encrypt(byte[] Content) { if (!IsHashAlgorithm && _key == null) { throw new CryptographicException(ERR_NO_KEY); } if (_algorithm.Equals(-1)) { throw new CryptographicException(ERR_NO_ALGORITHM); } if (Content == null || Content.Equals(string.Empty)) { throw new CryptographicException(ERR_NO_CONTENT); } byte[] cipherBytes = null; int NumBytes = 0; if (_algorithm == Algorithm.RSA) { //This is an asymmetric call, which has to be treated differently try { cipherBytes = RSAEncrypt(Content); } catch (CryptographicException ex) { throw ex; } } else { SymmetricAlgorithm provider = null; switch (_algorithm) { case Algorithm.DES: provider = new DESCryptoServiceProvider(); NumBytes = KeySize.DES; break; case Algorithm.TripleDES: provider = new TripleDESCryptoServiceProvider(); NumBytes = KeySize.TripleDES; break; case Algorithm.Rijndael: provider = new RijndaelManaged(); NumBytes = KeySize.AES; break; case Algorithm.RC2: provider = new RC2CryptoServiceProvider(); NumBytes = KeySize.RC2; break; default: throw new CryptographicException(ERR_INVALID_PROVIDER); } try { //Encrypt the string cipherBytes = SymmetricEncrypt(provider, Content, _key, NumBytes); } catch (CryptographicException ex) { throw new CryptographicException(ex.Message, ex.InnerException); } finally { //Free any resources held by the SymmetricAlgorithm provider provider.Clear(); } } return(cipherBytes); }
/// <summary> /// 获取密钥 /// Key为密钥,Value为向量(IV) /// </summary> /// <returns></returns> public static KeyValuePair <string, string> RC2Key() { RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider(); return(new KeyValuePair <string, string>(Convert.ToBase64String(rc2.Key), Convert.ToBase64String(rc2.IV))); }
internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey) { // Pick the provider. switch (algorithmID) { case EncryptionAlgorithm.Des: { DES des = new DESCryptoServiceProvider(); des.Mode = CipherMode.CBC; // See if a key was provided if (null == bytesKey) { des.GenerateKey(); encKey = des.Key; } else { des.Key = bytesKey; encKey = des.Key; } // See if the client provided an initialization vector if (null == initVec) { // Have the algorithm create one des.GenerateIV(); initVec = des.IV; } else { //No, give it to the algorithm des.IV = initVec; } return(des.CreateEncryptor()); } case EncryptionAlgorithm.TripleDes: { TripleDES des3 = new TripleDESCryptoServiceProvider(); des3.Mode = CipherMode.CBC; // See if a key was provided if (null == bytesKey) { des3.GenerateKey(); encKey = des3.Key; } else { des3.Key = bytesKey; encKey = des3.Key; } // See if the client provided an IV if (null == initVec) { //Yes, have the alg create one des3.GenerateIV(); initVec = des3.IV; } else { //No, give it to the alg. des3.IV = initVec; } return(des3.CreateEncryptor()); } case EncryptionAlgorithm.Rc2: { RC2 rc2 = new RC2CryptoServiceProvider(); rc2.Mode = CipherMode.CBC; // Test to see if a key was provided if (null == bytesKey) { rc2.GenerateKey(); encKey = rc2.Key; } else { rc2.Key = bytesKey; encKey = rc2.Key; } // See if the client provided an IV if (null == initVec) { //Yes, have the alg create one rc2.GenerateIV(); initVec = rc2.IV; } else { //No, give it to the alg. rc2.IV = initVec; } return(rc2.CreateEncryptor()); } case EncryptionAlgorithm.Rijndael: { Rijndael rijndael = new RijndaelManaged(); rijndael.Mode = CipherMode.CBC; rijndael.Padding = PaddingMode.PKCS7; // Set the key and block size. // Although the key size defaults to 256, it's better to be explicit. rijndael.KeySize = 256; // BlockSize defaults to 128 bits, so let's set this // to 256 for better security rijndael.BlockSize = 256; // Test to see if a key was provided if (null == bytesKey) { // GenerateKey method utilizes the RNGCryptoServiceProvider // class to generate random bytes of necessary length. rijndael.GenerateKey(); encKey = rijndael.Key; } else { rijndael.Key = bytesKey; encKey = rijndael.Key; } // See if the client provided an IV if (null == initVec) { //Yes, have the alg create one rijndael.GenerateIV(); initVec = rijndael.IV; } else { //No, give it to the alg. rijndael.IV = initVec; } return(rijndael.CreateEncryptor()); } default: { throw new CryptographicException("Algorithm ID '" + algorithmID + "' not supported."); } } }
/// <summary> /// 加密 /// </summary> /// <param name="str">原字符串</param> /// <returns></returns> public static string Encrypt(this string str) { if (string.IsNullOrEmpty(str)) return null; var sBuffer = Encoding.UTF8.GetBytes(str); var provider = new RC2CryptoServiceProvider(); var rgbIV = Encoding.ASCII.GetBytes(IV); var rgbKey = Encoding.ASCII.GetBytes(Key); var encryptor = provider.CreateEncryptor(rgbKey, rgbIV); using (var ms = new MemoryStream()) { using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) { cs.Write(sBuffer, 0, sBuffer.Length); cs.FlushFinalBlock(); } byte[] buffer = ms.ToArray(); str = Convert.ToBase64String(buffer); } return HttpUtility.HtmlEncode(str.Trim()); }
/// <summary> Function to decrypt an one content bytes /// </summary> /// <param name="content">To be encrypted content</param> /// <returns>Array of bytes</returns> public byte[] Decrypt(byte[] content) { if (IsHashAlgorithm) { throw new CryptographicException(Resources.Cypher_DecryptHash); } if (_key == null) { throw new CryptographicException(Resources.Cypher_NoKey); } if (content == null || content.Equals(String.Empty)) { throw new CryptographicException(Resources.Cypher_NoContent); } string encText = System.Text.Encoding.UTF8.GetString(content, 0, content.Length); if (_encodingType == EncodingType.Base64) { //We need to convert the content to Hex before decryption encText = BytesToHex(System.Convert.FromBase64String(encText)); } byte[] clearBytes = null; int NumBytes = 0; #if !CompactFramework if (_algorithm == Algorithm.RSA) { clearBytes = RSADecrypt(encText); } else #endif { SymmetricAlgorithm provider; switch (_algorithm) { case Algorithm.DES: provider = new DESCryptoServiceProvider(); NumBytes = Convert.ToInt32(AlgorithmKeySize.DES); break; case Algorithm.TripleDES: provider = new TripleDESCryptoServiceProvider(); NumBytes = Convert.ToInt32(AlgorithmKeySize.TripleDES); break; case Algorithm.Rijndael: provider = new RijndaelManaged(); NumBytes = Convert.ToInt32(AlgorithmKeySize.Rijndael); break; case Algorithm.RC2: provider = new RC2CryptoServiceProvider(); NumBytes = Convert.ToInt32(AlgorithmKeySize.RC2); break; default: throw new CryptographicException(Resources.Cypher_InvalidProvider); } try { clearBytes = SymmetricDecrypt(provider, encText, _key, NumBytes); } finally { //Free any resources held by the SymmetricAlgorithm provider provider.Clear(); } } //Now return the plain text content return(clearBytes); }
/// <summary> /// 解密 /// </summary> /// <param name="str">原字符串</param> /// <returns></returns> public static string Decrypt(this string str) { try { if (string.IsNullOrEmpty(str)) return null; var decodeStr = HttpUtility.HtmlDecode(str); var sBuffer = Convert.FromBase64String(decodeStr); var provider = new RC2CryptoServiceProvider(); var rgbIV = Encoding.ASCII.GetBytes(IV); var rgbKey = Encoding.ASCII.GetBytes(Key); var decryptor = provider.CreateDecryptor(rgbKey, rgbIV); using (var ms = new MemoryStream()) { using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write)) { cs.Write(sBuffer, 0, sBuffer.Length); cs.FlushFinalBlock(); } byte[] buffer = ms.ToArray(); str = Encoding.UTF8.GetString(buffer); } return str; } catch (Exception ex) { throw new DecryptException(ex); } }
internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey) { ICryptoTransform iCryptoTransform; switch (algorithmID) { case EncryptionAlgorithm.Des: DES dES = new DESCryptoServiceProvider(); dES.Mode = CipherMode.CBC; if (bytesKey == null) { encKey = dES.Key; } else { dES.Key = bytesKey; encKey = dES.Key; } if (initVec == null) { initVec = dES.IV; } else { dES.IV = initVec; } iCryptoTransform = dES.CreateEncryptor(); break; case EncryptionAlgorithm.TripleDes: TripleDES tripleDES = new TripleDESCryptoServiceProvider(); tripleDES.Mode = CipherMode.CBC; if (bytesKey == null) { encKey = tripleDES.Key; } else { tripleDES.Key = bytesKey; encKey = tripleDES.Key; } if (initVec == null) { initVec = tripleDES.IV; } else { tripleDES.IV = initVec; } iCryptoTransform = tripleDES.CreateEncryptor(); break; case EncryptionAlgorithm.Rc2: RC2 rC2 = new RC2CryptoServiceProvider(); rC2.Mode = CipherMode.CBC; if (bytesKey == null) { encKey = rC2.Key; } else { rC2.Key = bytesKey; encKey = rC2.Key; } if (initVec == null) { initVec = rC2.IV; } else { rC2.IV = initVec; } iCryptoTransform = rC2.CreateEncryptor(); break; case EncryptionAlgorithm.Rijndael: Rijndael rijndael = new RijndaelManaged(); rijndael.Mode = CipherMode.CBC; if (bytesKey == null) { encKey = rijndael.Key; } else { rijndael.Key = bytesKey; encKey = rijndael.Key; } if (initVec == null) { initVec = rijndael.IV; } else { rijndael.IV = initVec; } iCryptoTransform = rijndael.CreateEncryptor(); break; default: throw new CryptographicException(String.Concat("Algorithm ID \'", algorithmID, "\' not supported.")); } return(iCryptoTransform); }
/// <summary>対称アルゴリズム暗号化サービスプロバイダ生成</summary> /// <param name="esa">EnumSymmetricAlgorithm</param> /// <param name="cm">CipherMode</param> /// <param name="pm">PaddingMode</param> /// <returns>SymmetricAlgorithm</returns> private SymmetricAlgorithm CreateSymmetricAlgorithm(EnumSymmetricAlgorithm esa, CipherMode cm, PaddingMode pm) { #region Constructor SymmetricAlgorithm sa = null; #region Aes if (esa.HasFlag(EnumSymmetricAlgorithm.AES_CSP)) { // AesCryptoServiceProviderサービスプロバイダ sa = AesCryptoServiceProvider.Create(); // devps(1703) } else if (esa.HasFlag(EnumSymmetricAlgorithm.AES_M)) { // AesManagedサービスプロバイダ sa = AesManaged.Create(); // devps(1703) } #if NET45 || NET46 #else else if (esa.HasFlag(EnumSymmetricAlgorithm.AES_CNG)) { // AesCngサービスプロバイダ sa = AesCng.Create(); // devps(1703) } #endif #endregion #region TripleDES else if (esa.HasFlag(EnumSymmetricAlgorithm.TDES_CSP)) { // TripleDESCryptoServiceProviderサービスプロバイダ sa = TripleDESCryptoServiceProvider.Create(); // devps(1703) } #if NET45 || NET46 #else else if (esa.HasFlag(EnumSymmetricAlgorithm.TDES_CNG)) { // TripleDESCngサービスプロバイダ sa = TripleDESCng.Create(); // devps(1703) } #endif #endregion #region Others else if (esa.HasFlag(EnumSymmetricAlgorithm.DES_CSP)) { // DESCryptoServiceProviderサービスプロバイダ sa = DESCryptoServiceProvider.Create(); // devps(1703) } else if (esa.HasFlag(EnumSymmetricAlgorithm.RC2_CSP)) { // RC2CryptoServiceProviderサービスプロバイダ sa = RC2CryptoServiceProvider.Create(); // devps(1703) } else if (esa.HasFlag(EnumSymmetricAlgorithm.Rijndael_M)) { // RijndaelManagedサービスプロバイダ sa = RijndaelManaged.Create(); // devps(1703) } #endregion else { throw new ArgumentException( PublicExceptionMessage.ARGUMENT_INCORRECT, "EnumSymmetricAlgorithm esa"); } #endregion #region Options // cmが設定されている場合。 if (cm != 0) { sa.Mode = cm; } // pmが設定されている場合。 if (pm != 0) { sa.Padding = pm; } #endregion return(sa); }
/// <summary> /// 복호화 /// </summary> /// <param name="cipherText">암호문</param> /// <param name="DecryptCheck">암호화 해시 함수</param> /// <param name="DecryptType">암호화 알고리즘</param> public static string DecryptText(string cipherText, string DecryptCheck, string DecryptType, string CryptoKey) { byte[] keyArray; byte[] toEncryptArray = Convert.FromBase64String(cipherText); string key = CryptoKey; switch (DecryptCheck.Trim().ToUpper().ToString()) { case "MD5": MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider(); keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key)); hashmd5.Clear(); break; case "SHA1": SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider(); keyArray = sha1.ComputeHash(UTF8Encoding.UTF8.GetBytes(key)); sha1.Clear(); break; case "SHA256": SHA256Managed sha256 = new SHA256Managed(); keyArray = sha256.ComputeHash(UTF8Encoding.UTF8.GetBytes(key)); sha256.Clear(); break; case "SHA384": SHA384Managed sha384 = new SHA384Managed(); keyArray = sha384.ComputeHash(UTF8Encoding.UTF8.GetBytes(key)); sha384.Clear(); break; case "SHA512": SHA512Managed sha512 = new SHA512Managed(); keyArray = sha512.ComputeHash(UTF8Encoding.UTF8.GetBytes(key)); sha512.Clear(); break; default: keyArray = UTF8Encoding.UTF8.GetBytes(key); break; } byte[] resultArray = null; if (keyArray.Length > 16) { byte[] temp = new byte[16]; for (int i = 0; i < 16; i++) { temp[i] = keyArray[i]; } keyArray = temp; } if (keyArray.Length < 16) { byte[] temp = new byte[16]; for (int j = keyArray.Length; j < 16; j++) { temp[j] = keyArray[0]; } keyArray = temp; } switch (DecryptType.Trim().ToUpper().ToString()) { case "RC2": RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider(); rc2.Key = keyArray; rc2.Mode = CipherMode.ECB; rc2.Padding = PaddingMode.PKCS7; ICryptoTransform rc2Transform = rc2.CreateDecryptor(); resultArray = rc2Transform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); rc2.Clear(); break; case "TRIPLE": TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider(); tdes.Key = keyArray; tdes.Mode = CipherMode.ECB; tdes.Padding = PaddingMode.PKCS7; ICryptoTransform tdesTransform = tdes.CreateDecryptor(); resultArray = tdesTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); tdes.Clear(); break; case "DES": DESCryptoServiceProvider des = new DESCryptoServiceProvider(); des.Key = UTF8Encoding.UTF8.GetBytes(key.Substring(0, 8).ToString().Trim()); des.Mode = CipherMode.ECB; des.Padding = PaddingMode.PKCS7; ICryptoTransform desTransform = des.CreateDecryptor(); resultArray = desTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); des.Clear(); break; case "AES": RijndaelManaged Rijndae = new RijndaelManaged(); Rijndae.Key = keyArray; Rijndae.Mode = CipherMode.ECB; Rijndae.Padding = PaddingMode.PKCS7; ICryptoTransform RijndaeTransform = Rijndae.CreateDecryptor(); resultArray = RijndaeTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); Rijndae.Clear(); break; } return(UTF8Encoding.UTF8.GetString(resultArray)); }
/// <summary> /// Define un objeto para la operaciones básicas de transformaciones /// criptográficas. /// </summary> /// <param name="Key">Clave de encripción.</param> /// <param name="IV">Vector de inicialización.</param> /// <returns>Devuelve el objeto que implementa la interfaz ICryptoTransform. /// </returns> internal ICryptoTransform GetServiceProvider(byte[] Key, byte[] IV) { // creamos la variable que contendrá al objeto ICryptoTransform. ICryptoTransform transform = null; // dependiendo del algoritmo seleccionado, se devuelve el objeto adecuado. switch (this.algorithm) { // Algoritmo DES. case CryptoProvider.DES: // dependiendo de la acción a realizar. // creamos el objeto adecuado. DESCryptoServiceProvider des = new DESCryptoServiceProvider(); switch (cAction) { case CryptoAction.Encrypt: // si estamos cifrando, // creamos el objeto cifrador. transform = des.CreateEncryptor(Key, IV); break; case CryptoAction.Desencrypt: // sí estamos descifrando, // creamos el objeto descifrador. transform = des.CreateDecryptor(Key, IV); break; } // devolvemos el objeto transform correspondiente. return(transform); // algoritmo TripleDES. case CryptoProvider.TripleDES: TripleDESCryptoServiceProvider des3 = new TripleDESCryptoServiceProvider(); switch (cAction) { case CryptoAction.Encrypt: transform = des3.CreateEncryptor(Key, IV); break; case CryptoAction.Desencrypt: transform = des3.CreateDecryptor(Key, IV); break; } return(transform); // algoritmo RC2. case CryptoProvider.RC2: RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider(); switch (cAction) { case CryptoAction.Encrypt: transform = rc2.CreateEncryptor(Key, IV); break; case CryptoAction.Desencrypt: transform = rc2.CreateDecryptor(Key, IV); break; } return(transform); // algoritmo Rijndael. case CryptoProvider.Rijndael: Rijndael rijndael = new RijndaelManaged(); switch (cAction) { case CryptoAction.Encrypt: transform = rijndael.CreateEncryptor(Key, IV); break; case CryptoAction.Desencrypt: transform = rijndael.CreateDecryptor(Key, IV); break; } return(transform); default: // en caso que no exista el proveedor seleccionado, generamos // una excepción para informarlo. throw new CryptographicException("Error al inicializar al proveedor de cifrado"); } }
private void okB_Click(object sender, RoutedEventArgs e) { codeEnc = codeT.Password; if (codeEnc != "" && codeEnc.Length > 4 && codeEnc.Length < 17) { StreamReader encReader = new StreamReader(way2); string encrypted = encReader.ReadToEnd(); encReader.Close(); RC2CryptoServiceProvider rc2CSP = new RC2CryptoServiceProvider(); byte[] key = Encoding.Default.GetBytes(codeT.Password); rc2CSP.Key = key; byte[] IV = { 156, 158, 224, 153, 115, 56, 171, 196 }; rc2CSP.IV = IV; ICryptoTransform decryptor = rc2CSP.CreateDecryptor(key, rc2CSP.IV); byte[] toEncrypt = Encoding.Default.GetBytes(encrypted); MemoryStream msDecrypt = new MemoryStream(toEncrypt); CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read); StringBuilder roundtrip = new StringBuilder(); int b = 0; try { do { b = csDecrypt.ReadByte(); if (b != -1) { roundtrip.Append((char)b); } } while (b != -1); msDecrypt.Close(); csDecrypt.Close(); } catch (Exception a) { } FileInfo fileInf = new FileInfo(way); if (fileInf.Exists) { fileInf.Delete(); } FileStream wtf = fileInf.Create(); wtf.Dispose(); wtf.Close(); StreamWriter myWriter = new StreamWriter(way); myWriter.Write(roundtrip.ToString()); myWriter.Close(); StreamReader myReader = new StreamReader(way); string line = myReader.ReadLine(); string[] data; do { data = line.Split('|'); if (data[0] == "admin") { adminF = !adminF; break; } line = myReader.ReadLine(); } while (line != null); myReader.Close(); if (adminF) { MessageBox.Show("Код верен!", "Добро пожаловать!"); this.Close(); } else { fileInf.Delete(); MessageBox.Show("Код неверен!", "Ошибка!"); this.Close(); } } else { MessageBox.Show("Код неверен!", "Ошибка!"); this.Close(); } }
public static Boolean TestKnown() { Boolean bRes = true; Byte[] IV = new Byte[8]; Byte[] PlainText = {0,1,2,3,4,5,6,7}; Byte[] KnownVector = {0x7A, 0x50, 0x39, 0x82, 0xB5, 0x0E, 0xB0, 0x0D, 0x1F, 0x37, 0x9D, 0xC8, 0x36, 0x09, 0xD3, 0xFF}; PasswordDeriveBytes pdb = new PasswordDeriveBytes("simplepassword", null); Byte[] the_key = pdb.CryptDeriveKey("RC2", "MD5", 40, IV); RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider(); ICryptoTransform sse = rc2.CreateEncryptor(the_key, IV); MemoryStream ms = new MemoryStream(); CryptoStream cs = new CryptoStream(ms, sse, CryptoStreamMode.Write); cs.Write(PlainText,0,PlainText.Length); cs.FlushFinalBlock(); byte[] ciphertext = ms.ToArray(); cs.Close(); Console.WriteLine("--- Cipher Text : ----"); PrintByteArray(ciphertext); Console.WriteLine("--- Known vector : ----"); PrintByteArray(KnownVector); if(!Compare(ciphertext, KnownVector)) { Console.WriteLine("Known and calculated values differ!"); bRes = false; } return bRes; }
/// <summary> /// this function provide to Get CryptoServiceProvider /// </summary> /// <param name="bytesKey">key</param> /// <returns>CryptoServiceProvider</returns> internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey) { // 选取提供程序。 switch (algorithmID) { case EncryptionAlgorithm.Des: { DES des = new DESCryptoServiceProvider(); des.Mode = CipherMode.CBC; // 查看是否提供了密钥 if (null == bytesKey) { encKey = des.Key; } else { des.Key = bytesKey; encKey = des.Key; } // 查看客户端是否提供了初始化向量 if (null == initVec) { // 让算法创建一个 initVec = des.IV; } else { //不,将它提供给算法 des.IV = initVec; } return(des.CreateEncryptor()); } case EncryptionAlgorithm.TripleDes: { TripleDES des3 = new TripleDESCryptoServiceProvider(); des3.Mode = CipherMode.CBC; // See if a key was provided if (null == bytesKey) { encKey = des3.Key; } else { des3.Key = bytesKey; encKey = des3.Key; } // 查看客户端是否提供了初始化向量 if (null == initVec) { //是,让算法创建一个 initVec = des3.IV; } else { //不,将它提供给算法。 des3.IV = initVec; } return(des3.CreateEncryptor()); } case EncryptionAlgorithm.Rc2: { RC2 rc2 = new RC2CryptoServiceProvider(); rc2.Mode = CipherMode.CBC; // 测试是否提供了密钥 if (null == bytesKey) { encKey = rc2.Key; } else { rc2.Key = bytesKey; encKey = rc2.Key; } // 查看客户端是否提供了初始化向量 if (null == initVec) { //是,让算法创建一个 initVec = rc2.IV; } else { //不,将它提供给算法。 rc2.IV = initVec; } return(rc2.CreateEncryptor()); } case EncryptionAlgorithm.Rijndael: { Rijndael rijndael = new RijndaelManaged(); rijndael.Mode = CipherMode.CBC; // 测试是否提供了密钥 if (null == bytesKey) { encKey = rijndael.Key; } else { rijndael.Key = bytesKey; encKey = rijndael.Key; } // 查看客户端是否提供了初始化向量 if (null == initVec) { // 是,让算法创建一个 initVec = rijndael.IV; } else { // 不,将它提供给算法。 rijndael.IV = initVec; } return(rijndael.CreateEncryptor()); } case EncryptionAlgorithm.Md5: { MD5 md5 = new MD5CryptoServiceProvider(); return(md5); } default: { throw new CryptographicException("算法 ID '" + algorithmID + "' 不受支持"); } } }
/// <summary> /// 创建一个对称加密算法提供者实例 /// </summary> /// <param name="symmetricAlgorithmType"></param> /// <returns></returns> SymmetricAlgorithm CreateSymmetricAlgorithmProvider(SymmetricAlgorithmType symmetricAlgorithmType) { SymmetricAlgorithm symmetricAlgorithm = null; switch (symmetricAlgorithmType) { case SymmetricAlgorithmType.DES: //<key:64,block:64,feedback:8>,key[64,64<skip:0>],block[64,64<skip:0>] ; IV[8byte],KEY[8byte] symmetricAlgorithm = new DESCryptoServiceProvider(); multiKey = 8; multiIV = 8; break; case SymmetricAlgorithmType.RC2_40: //<key:128,block:64,feedback:8>,key[40,128<skip:8>],block[64,64<skip:0>] ; IV[8byte],KEY[16byte] symmetricAlgorithm = new RC2CryptoServiceProvider(); multiKey = 5; multiIV = 8; break; case SymmetricAlgorithmType.RC2_64: //<key:128,block:64,feedback:8>,key[40,128<skip:8>],block[64,64<skip:0>] ; IV[8byte],KEY[16byte] symmetricAlgorithm = new RC2CryptoServiceProvider(); multiKey = 8; multiIV = 8; break; case SymmetricAlgorithmType.RC2_96: //<key:128,block:64,feedback:8>,key[40,128<skip:8>],block[64,64<skip:0>] ; IV[8byte],KEY[16byte] symmetricAlgorithm = new RC2CryptoServiceProvider(); multiKey = 12; multiIV = 8; break; case SymmetricAlgorithmType.RC2_128: //<key:128,block:64,feedback:8>,key[40,128<skip:8>],block[64,64<skip:0>] ; IV[8byte],KEY[16byte] symmetricAlgorithm = new RC2CryptoServiceProvider(); multiKey = 16; multiIV = 8; break; case SymmetricAlgorithmType.Rijndael_128: //<key:256,block:128,feedback:128>,key[128,256<skip:64>],block[128,256<skip:64>] ; IV[16byte],KEY[32byte] symmetricAlgorithm = new RijndaelManaged(); multiKey = 16; multiIV = 16; break; case SymmetricAlgorithmType.Rijndael_192: //<key:256,block:128,feedback:128>,key[128,256<skip:64>],block[128,256<skip:64>] ; IV[16byte],KEY[32byte] symmetricAlgorithm = new RijndaelManaged(); multiKey = 24; multiIV = 16; break; case SymmetricAlgorithmType.Rijndael_256: //<key:256,block:128,feedback:128>,key[128,256<skip:64>],block[128,256<skip:64>] ; IV[16byte],KEY[32byte] symmetricAlgorithm = new RijndaelManaged(); multiKey = 32; multiIV = 16; break; case SymmetricAlgorithmType.TripleDES_128: //<key:192,block:64,feedback:8>,key[128,192<skip:64>],block[64,64<skip:0>] ; IV[8byte],KEY[24byte] symmetricAlgorithm = new TripleDESCryptoServiceProvider(); multiKey = 16; multiIV = 8; break; case SymmetricAlgorithmType.TripleDES_192: //<key:192,block:64,feedback:8>,key[128,192<skip:64>],block[64,64<skip:0>] ; IV[8byte],KEY[24byte] symmetricAlgorithm = new TripleDESCryptoServiceProvider(); multiKey = 24; multiIV = 8; break; default: break; } symmetricAlgorithm.KeySize = factorKey * multiKey; symmetricAlgorithm.BlockSize = factorIV * multiIV; return symmetricAlgorithm; }
/// <summary> /// Gets the crypto service provider. /// </summary> /// <param name="bytesKey">The bytes key.</param> /// <returns></returns> internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey) { switch (algorithmID) { case EncryptionAlgorithm.Des: DES des = new DESCryptoServiceProvider(); des.Mode = CipherMode.CBC; if (null == bytesKey) { encKey = des.Key; } else { des.Key = bytesKey; encKey = des.Key; } if (null == initVec) { initVec = des.IV; } else { des.IV = initVec; } return(des.CreateEncryptor()); case EncryptionAlgorithm.TripleDes: TripleDES des3 = new TripleDESCryptoServiceProvider(); des3.Mode = CipherMode.CBC; if (null == bytesKey) { encKey = des3.Key; } else { des3.Key = bytesKey; encKey = des3.Key; } if (null == initVec) { initVec = des3.IV; } else { des3.IV = initVec; } return(des3.CreateEncryptor()); case EncryptionAlgorithm.Rc2: RC2 rc2 = new RC2CryptoServiceProvider(); rc2.Mode = CipherMode.CBC; if (null == bytesKey) { encKey = rc2.Key; } else { rc2.Key = bytesKey; encKey = rc2.Key; } if (null == initVec) { initVec = rc2.IV; } else { rc2.IV = initVec; } return(rc2.CreateEncryptor()); case EncryptionAlgorithm.Rijndael: Rijndael rijndael = new RijndaelManaged(); rijndael.Mode = CipherMode.CBC; if (null == bytesKey) { encKey = rijndael.Key; } else { rijndael.Key = bytesKey; encKey = rijndael.Key; } if (null == initVec) { initVec = rijndael.IV; } else { rijndael.IV = initVec; } return(rijndael.CreateEncryptor()); default: throw new CryptographicException("Algorithm ID '" + algorithmID + "' not supported!"); } }
static public bool RC2_CBC_Symmetry_Decode_Byte(byte[] decryptByte, uint startPos, uint inLen, ref byte[] outBytes, byte[] rgbKey) { try { RC2CryptoServiceProvider m_RC2Provider = new RC2CryptoServiceProvider(); MemoryStream m_stream = new MemoryStream(); CryptoStream m_cstream = new CryptoStream(m_stream, m_RC2Provider.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write); m_cstream.Write(decryptByte, (int)startPos, (int)inLen); m_cstream.FlushFinalBlock(); outBytes = m_stream.ToArray(); m_stream.Close(); m_stream.Dispose(); m_cstream.Close(); m_cstream.Dispose(); return true; } catch { return false; } }