/// <summary> /// 解密 /// </summary> public static string Decode(string encryptStr) { byte[] bKey = Encoding.UTF8.GetBytes(Key); byte[] bIV = Encoding.UTF8.GetBytes(IV); encryptStr = encryptStr.Replace(" ", "+"); byte[] byteArray = Convert.FromBase64String(encryptStr); string decrypt = null; DESCryptoServiceProvider des = new DESCryptoServiceProvider(); try { using (MemoryStream mStream = new MemoryStream()) { using (CryptoStream cStream = new CryptoStream(mStream, des.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write)) { cStream.Write(byteArray, 0, byteArray.Length); cStream.FlushFinalBlock(); decrypt = Encoding.UTF8.GetString(mStream.ToArray()); } } } catch { } des.Clear(); return decrypt; }
public static ICryptoTransform CreateEncryptor(string key, CryptionType type) { ICryptoTransform transform; SHA512 sha512 = new SHA512CryptoServiceProvider(); var bytes = sha512.ComputeHash(Sha1(key).ToAsciiBytes()); switch (type) { case CryptionType.Aes: var aes = Rijndael.Create(); aes.Mode = CipherMode.CBC; transform = aes.CreateEncryptor(bytes.Skip(17).Take(32).ToArray(), bytes.Skip(17).Take(16).ToArray()); aes.Clear(); break; case CryptionType.Des: var des = new DESCryptoServiceProvider { Mode = CipherMode.CBC }; transform = des.CreateEncryptor(bytes.Skip(17).Take(8).ToArray(), bytes.Skip(17).Take(16).ToArray()); des.Clear(); break; default: var tripleDes = new TripleDESCryptoServiceProvider { Mode = CipherMode.CBC }; transform = tripleDes.CreateEncryptor(bytes.Skip(17).Take(24).ToArray(), bytes.Skip(17).Take(16).ToArray()); tripleDes.Clear(); break; } return transform; }
public static byte[] smethod_22(byte[] byte_0, string string_0) { System.Security.Cryptography.DESCryptoServiceProvider dESCryptoServiceProvider = new System.Security.Cryptography.DESCryptoServiceProvider(); dESCryptoServiceProvider.Key = System.Text.Encoding.UTF8.GetBytes(string_0); dESCryptoServiceProvider.Mode = System.Security.Cryptography.CipherMode.ECB; dESCryptoServiceProvider.Padding = System.Security.Cryptography.PaddingMode.PKCS7; System.Security.Cryptography.ICryptoTransform cryptoTransform = dESCryptoServiceProvider.CreateDecryptor(); byte[] array = cryptoTransform.TransformFinalBlock(byte_0, 0, byte_0.Length); dESCryptoServiceProvider.Clear(); System.Array.Resize <byte>(ref array, array.Length - 1); return(array); }
/// <summary> /// 解密字符串 /// </summary> public static string Decrypt(string ciphertext) { string password2 = "Ahbool"; string cipher = string.Empty; try { char[] key = new char[8]; if (password.Length > 8) { password = password.Remove(8); } password.CopyTo(0, key, 0, password.Length); char[] iv = new char[8]; if (password2.Length > 8) { password2 = password2.Remove(8); } password2.CopyTo(0, iv, 0, password2.Length); if (ciphertext == null) { return cipher; } SymmetricAlgorithm serviceProvider = new DESCryptoServiceProvider(); serviceProvider.Key = Encoding.ASCII.GetBytes(key); serviceProvider.IV = Encoding.ASCII.GetBytes(iv); byte[] contentArray = Convert.FromBase64String(ciphertext); MemoryStream memoryStream = new MemoryStream(contentArray); CryptoStream cryptoStream = new CryptoStream(memoryStream, serviceProvider.CreateDecryptor(), CryptoStreamMode.Read); StreamReader streamReader = new StreamReader(cryptoStream); cipher = streamReader.ReadToEnd(); streamReader.Dispose(); cryptoStream.Dispose(); memoryStream.Dispose(); serviceProvider.Clear(); } catch { cipher = "123"; } return cipher; }
public static byte[] smethod_21(byte[] byte_0, string string_0) { byte[] array = byte_0; System.Array.Resize <byte>(ref array, array.Length + 1); array[array.Length - 1] = (byte)new System.Random().Next(0, 255); System.Security.Cryptography.DESCryptoServiceProvider dESCryptoServiceProvider = new System.Security.Cryptography.DESCryptoServiceProvider(); dESCryptoServiceProvider.Key = System.Text.Encoding.UTF8.GetBytes(string_0); dESCryptoServiceProvider.Mode = System.Security.Cryptography.CipherMode.ECB; dESCryptoServiceProvider.Padding = System.Security.Cryptography.PaddingMode.PKCS7; System.Security.Cryptography.ICryptoTransform cryptoTransform = dESCryptoServiceProvider.CreateEncryptor(); byte[] result = cryptoTransform.TransformFinalBlock(array, 0, array.Length); dESCryptoServiceProvider.Clear(); return(result); }
/// <summary> /// Decrypts a string using DES /// </summary> /// <param name="Input">Input string</param> /// <param name="Key">Key to use in decryption (must be at least 8 bytes)</param> /// <returns>A decrypted string</returns> public static string Decrypt(string Input,string Key) { if (string.IsNullOrEmpty(Input) || string.IsNullOrEmpty(Key)) { throw new ArgumentNullException("The input/key string can not be empty."); } try { ASCIIEncoding Encoding = new ASCIIEncoding(); byte[] KeyHashArray = Encoding.GetBytes(Key); byte[] KeyArray = new byte[8]; byte[] Key2Array = new byte[8]; SHA1CryptoServiceProvider SHA = new SHA1CryptoServiceProvider(); byte[] Hash = SHA.ComputeHash(KeyHashArray); SHA.Clear(); for (int x = 0; x < 8; ++x) { KeyArray[x] = Hash[x]; Key2Array[x] = Hash[x + 8]; } string Text = null; DESCryptoServiceProvider Decryptor = new DESCryptoServiceProvider(); using (MemoryStream Stream = new MemoryStream(Convert.FromBase64String(Input))) { using (CryptoStream DESStream = new CryptoStream(Stream, Decryptor.CreateDecryptor(KeyArray, Key2Array), CryptoStreamMode.Read)) { using (StreamReader Reader = new StreamReader(DESStream)) { Text = Reader.ReadToEnd(); } } } Decryptor.Clear(); return Text; } catch { throw; } }
/// <summary> /// Encrypts a string using DES /// </summary> /// <param name="Input">String to encrypt</param> /// <param name="Key">Key to encrypt with (must be at least 8 bytes)</param> /// <returns>An encrypted string</returns> public static string Encrypt(string Input, string Key) { if (string.IsNullOrEmpty(Input) || string.IsNullOrEmpty(Key)) { throw new ArgumentNullException("The input/key string can not be empty."); } ASCIIEncoding Encoding = new ASCIIEncoding(); byte[] KeyHashArray = Encoding.GetBytes(Key); byte[] KeyArray = new byte[8]; byte[] Key2Array = new byte[8]; SHA1CryptoServiceProvider SHA = new SHA1CryptoServiceProvider(); byte[] Hash = SHA.ComputeHash(KeyHashArray); SHA.Clear(); for (int x = 0; x < 8; ++x) { KeyArray[x] = Hash[x]; Key2Array[x] = Hash[x + 8]; } byte[] Text = null; DESCryptoServiceProvider Encryptor = new DESCryptoServiceProvider(); using (MemoryStream Stream = new MemoryStream()) { using (CryptoStream DESStream = new CryptoStream(Stream, Encryptor.CreateEncryptor(KeyArray, Key2Array), CryptoStreamMode.Write)) { using (StreamWriter Writer = new StreamWriter(DESStream)) { Writer.Write(Input); Writer.Flush(); DESStream.FlushFinalBlock(); Writer.Flush(); Text = Stream.GetBuffer(); } } } Encryptor.Clear(); return Convert.ToBase64String(Text, 0, (int)Text.Length); }
public static byte[] smethod_0(byte[] byte_0) { Class2.Stream0 stream = new Class2.Stream0(byte_0); byte[] array = new byte[0]; int num = stream.method_1(); if (num == 67324752) { short num2 = (short)stream.method_0(); int num3 = stream.method_0(); int num4 = stream.method_0(); if (num == 67324752 && num2 == 20 && num3 == 0) { if (num4 == 8) { stream.method_1(); stream.method_1(); stream.method_1(); int num5 = stream.method_1(); int num6 = stream.method_0(); int num7 = stream.method_0(); if (num6 > 0) { byte[] buffer = new byte[num6]; stream.Read(buffer, 0, num6); } if (num7 > 0) { byte[] buffer2 = new byte[num7]; stream.Read(buffer2, 0, num7); } byte[] array2 = new byte[stream.Length - stream.Position]; stream.Read(array2, 0, array2.Length); Class2.Class3 @class = new Class2.Class3(array2); array = new byte[num5]; @class.method_2(array, 0, array.Length); goto IL_1FF; } } throw new FormatException("Wrong Header Signature"); } int num8 = num >> 24; num -= num8 << 24; if (num != 8223355) { throw new FormatException("Unknown Header"); } if (num8 == 1) { int num9 = stream.method_1(); array = new byte[num9]; int num11; for (int i = 0; i < num9; i += num11) { int num10 = stream.method_1(); num11 = stream.method_1(); byte[] array3 = new byte[num10]; stream.Read(array3, 0, array3.Length); Class2.Class3 class2 = new Class2.Class3(array3); class2.method_2(array, i, num11); } } if (num8 == 2) { DESCryptoServiceProvider dESCryptoServiceProvider = new DESCryptoServiceProvider(); dESCryptoServiceProvider.Key = new byte[] { 162, 181, 141, 204, 197, 202, 205, 58 }; dESCryptoServiceProvider.IV = new byte[] { 83, 253, 177, 222, 83, 112, 167, 112 }; ICryptoTransform cryptoTransform = dESCryptoServiceProvider.CreateDecryptor(); byte[] byte_ = cryptoTransform.TransformFinalBlock(byte_0, 4, byte_0.Length - 4); dESCryptoServiceProvider.Clear(); array = Class2.smethod_0(byte_); } IL_1FF: stream.Close(); return array; }
/// <summary> /// DES�����ַ��� /// </summary> /// <param name="decryptString">�����ܵ��ַ���</param> /// <param name="decryptKey">������Կ,Ҫ��Ϊ8λ,�ͼ�����Կ��ͬ</param> /// <returns>���ܳɹ����ؽ��ܺ���ַ�����ʧ�ܷ�Դ��</returns> public static string DecryptDES(string decryptString, string decryptKey) { try { byte[] rgbKey = Encoding.UTF8.GetBytes(decryptKey.Substring(0, 8)); byte[] rgbIv = Keys; byte[] inputByteArray = Convert.FromBase64String(decryptString); var dcsp = new DESCryptoServiceProvider { IV = rgbIv, Key = rgbKey }; using (var mStream = new MemoryStream()) { var cStream = new CryptoStream(mStream, dcsp.CreateDecryptor(), CryptoStreamMode.Write); cStream.Write(inputByteArray, 0, inputByteArray.Length); cStream.FlushFinalBlock(); string s = Encoding.UTF8.GetString(mStream.ToArray()); mStream.Close(); dcsp.Clear(); return s; } } catch { return decryptString; } }
/// <summary> /// Encrypt ScopedPdu using DES encryption protocol /// </summary> /// <param name="unencryptedData">Unencrypted ScopedPdu byte array</param> /// <param name="offset">Offset to start encryption</param> /// <param name="length">Length of data to encrypt</param> /// <param name="key">Encryption key. Key has to be at least 32 bytes is length</param> /// <param name="engineBoots">Authoritative engine boots value</param> /// <param name="engineTime">Authoritative engine time value. Not used for DES</param> /// <param name="privacyParameters">Privacy parameters out buffer. This field will be filled in with information /// required to decrypt the information. Output length of this field is 8 bytes and space has to be reserved /// in the USM header to store this information</param> /// <param name="authDigest">Authentication digest class reference. Not used by DES and can be null.</param> /// <returns>Encrypted byte array</returns> /// <exception cref="ArgumentOutOfRangeException">Thrown when encryption key is null or length of the encryption key is too short.</exception> public byte[] Encrypt(byte[] unencryptedData, int offset, int length, byte[] key, int engineBoots, int engineTime, out byte[] privacyParameters, IAuthenticationDigest authDigest) { if (key == null || key.Length < MinimumKeyLength) throw new ArgumentOutOfRangeException("encryptionKey", "Encryption key length has to 32 bytes or more."); privacyParameters = GetSalt(engineBoots); byte[] iv = GetIV(key, privacyParameters); // DES uses 8 byte keys but we need 16 to encrypt ScopedPdu. Get first 8 bytes and use them as encryption key byte[] outKey = GetKey(key); int div = (int)Math.Floor(length / 8.0); if ((length % 8) != 0) div += 1; int newLength = div * 8; byte[] result = new byte[newLength]; byte[] buffer = new byte[newLength]; byte[] inbuffer = new byte[8]; byte[] cipherText = iv; int posIn = 0; int posResult = 0; Buffer.BlockCopy(unencryptedData, offset, buffer, 0, length); DES des = new DESCryptoServiceProvider(); des.Mode = CipherMode.ECB; des.Padding = PaddingMode.None; ICryptoTransform transform = des.CreateEncryptor(outKey, null); for (int b = 0; b < div; b++) { for (int i = 0; i < 8; i++) { inbuffer[i] = (byte)(buffer[posIn] ^ cipherText[i]); posIn++; } transform.TransformBlock(inbuffer, 0, inbuffer.Length, cipherText, 0); Buffer.BlockCopy(cipherText, 0, result, posResult, cipherText.Length); posResult += cipherText.Length; } des.Clear(); return result; }
//JIAMI public static string Encrypt(string cleartext) { string password2 = "Ahbool"; string cipher; char[] key = new char[8]; if (password.Length > 8) { password = password.Remove(8); } password.CopyTo(0, key, 0, password.Length); char[] iv = new char[8]; if (password2.Length > 8) { password2 = password2.Remove(8); } password2.CopyTo(0, iv, 0, password2.Length); if (cleartext == null) { return string.Empty; } SymmetricAlgorithm serviceProvider = new DESCryptoServiceProvider(); serviceProvider.Key = Encoding.ASCII.GetBytes(key); serviceProvider.IV = Encoding.ASCII.GetBytes(iv); MemoryStream memoryStream = new MemoryStream(); CryptoStream cryptoStream = new CryptoStream(memoryStream, serviceProvider.CreateEncryptor(), CryptoStreamMode.Write); StreamWriter streamWriter = new StreamWriter(cryptoStream); streamWriter.Write(cleartext); streamWriter.Dispose(); cryptoStream.Dispose(); byte[] signData = memoryStream.ToArray(); memoryStream.Dispose(); serviceProvider.Clear(); cipher = Convert.ToBase64String(signData); return cipher; }
/// <summary> /// Encrypt ScopedPdu using DES encryption protocol /// </summary> /// <param name="unencryptedData">Unencrypted ScopedPdu byte array</param> /// <param name="key">Encryption key. Key has to be at least 32 bytes is length</param> /// <param name="privacyParameters">Privacy parameters out buffer. This field will be filled in with information /// required to decrypt the information. Output length of this field is 8 bytes and space has to be reserved /// in the USM header to store this information</param> /// <returns>Encrypted byte array</returns> /// <exception cref="ArgumentOutOfRangeException">Thrown when encryption key is null or length of the encryption key is too short.</exception> public static byte[] Encrypt(byte[] unencryptedData, byte[] key, byte[] privacyParameters) { if (unencryptedData == null) { throw new ArgumentNullException("unencryptedData"); } if (key == null) { throw new ArgumentNullException("key"); } if (privacyParameters == null) { throw new ArgumentNullException("privacyParameters"); } if (key.Length < MinimumKeyLength) { throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Encryption key length has to 32 bytes or more. Current: {0}", key.Length), "key"); } var iv = GetIV(key, privacyParameters); // DES uses 8 byte keys but we need 16 to encrypt ScopedPdu. Get first 8 bytes and use them as encryption key var outKey = GetKey(key); var div = (int)Math.Floor(unencryptedData.Length / 8.0); if ((unencryptedData.Length % 8) != 0) { div += 1; } var newLength = div * 8; var result = new byte[newLength]; var buffer = new byte[newLength]; var inbuffer = new byte[8]; var cipherText = iv; var posIn = 0; var posResult = 0; Buffer.BlockCopy(unencryptedData, 0, buffer, 0, unencryptedData.Length); using (DES des = new DESCryptoServiceProvider()) { des.Mode = CipherMode.ECB; des.Padding = PaddingMode.None; using (var transform = des.CreateEncryptor(outKey, null)) { for (var b = 0; b < div; b++) { for (var i = 0; i < 8; i++) { inbuffer[i] = (byte)(buffer[posIn] ^ cipherText[i]); posIn++; } transform.TransformBlock(inbuffer, 0, inbuffer.Length, cipherText, 0); Buffer.BlockCopy(cipherText, 0, result, posResult, cipherText.Length); posResult += cipherText.Length; } } des.Clear(); } return result; }
/// <summary> /// 解密文件 /// </summary> /// <param name="SourceFilePath">源文件路径(被解密的文件路径)</param> /// <param name="TargetFilePath">目标文件路径(解密后生成的文件路径)</param> /// <param name="DecryptKey">解密文件用的密钥</param> public static void DecryptFile(string SourceFilePath, string TargetFilePath, string DecryptKey) { if (string.IsNullOrEmpty(SourceFilePath)) { throw new SourceFilePathIsNullOrEmptyException(); } FileInfo fi = new FileInfo(SourceFilePath); if (!fi.Exists) { throw new SourceFileNotExistException(); } if (fi.Length > 2048000) { throw new FileSizeIsGreaterThan2MException(); } if (string.IsNullOrEmpty(TargetFilePath)) { throw new TargetFilePathIsNullOrEmptyException(); } if (string.IsNullOrEmpty(DecryptKey)) { throw new EncryptKeyIsNullOrEmptyException(); } byte[] IV = { 0x1E, 0xA2, 0x61, 0x5F, 0xD0, 0x3C, 0x99, 0xBB };//这里要与加密的相同,否则解密出来的结果会不相同。 if (DecryptKey.Length < 8) { DecryptKey = DecryptKey.PadRight(8, '0'); } else if (DecryptKey.Length > 8) { DecryptKey = DecryptKey.Remove(8); } byte[] byKey = null; byKey = Encoding.UTF8.GetBytes(DecryptKey.Substring(0, 8)); using (FileStream fsSource = new FileStream(SourceFilePath, FileMode.Open, FileAccess.Read)) { using (MemoryStream ms = new MemoryStream()) { byte[] bSource = new byte[100]; long readLength = 0; long writeLength = fsSource.Length; int iLength = 0; DES des = new DESCryptoServiceProvider(); try { using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(byKey, IV), CryptoStreamMode.Write)) { while (readLength < writeLength) { iLength = fsSource.Read(bSource, 0, bSource.Length); cs.Write(bSource, 0, iLength); readLength = readLength + iLength; } cs.FlushFinalBlock(); using (FileStream fsTarget = new FileStream(TargetFilePath, FileMode.OpenOrCreate, FileAccess.Write)) { ms.WriteTo(fsTarget); fsTarget.Close(); } cs.Clear(); cs.Close(); } } catch (CryptographicException) { throw new DecryptErrorException(); } des.Clear(); ms.Close(); } fsSource.Close(); } }
private static string DESEncrypt(byte[] buffer, byte[] rgbKey, byte[] rgbIV) { string encrypt = null; DESCryptoServiceProvider des = new DESCryptoServiceProvider(); try { using (MemoryStream mStream = new MemoryStream()) { using (CryptoStream cStream = new CryptoStream(mStream, des.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write)) { cStream.Write(buffer, 0, buffer.Length); cStream.FlushFinalBlock(); encrypt = Convert.ToBase64String(mStream.ToArray()); } } } catch { } des.Clear(); return encrypt; }
/// <summary> /// DES 加密(数据加密标准,速度较快,适用于加密大量数据的场合) /// </summary> /// <param name="encryptString">待加密的明文</param> /// <param name="encryptKey">加密的密钥,必须为8位</param> /// <returns>加密后的密文</returns> public static string DESEncrypt(string encryptString, string encryptKey) { if (string.IsNullOrEmpty(encryptString)) { throw (new Exception("明文不得为空!")); } if (string.IsNullOrEmpty(encryptKey)) { throw (new Exception("密钥不得为空!")); } if (encryptKey.Length != 8) { throw new Exception("密钥必须为8位"); } byte[] m_btIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF }; string m_strEncrypt = ""; var m_DESProvider = new DESCryptoServiceProvider(); try { byte[] m_btencryptString = Encoding.Default.GetBytes(encryptString); using (var m_stream = new MemoryStream()) { using (var m_cstream = new CryptoStream(m_stream, m_DESProvider.CreateEncryptor(Encoding.Default.GetBytes(encryptKey), m_btIV), CryptoStreamMode.Write)) { m_cstream.Write(m_btencryptString, 0, m_btencryptString.Length); m_cstream.FlushFinalBlock(); m_strEncrypt = Convert.ToBase64String(m_stream.ToArray()); } } } catch (Exception ex) { throw ex; } finally { m_DESProvider.Clear(); } return m_strEncrypt; }
public void EncryptData(string inName, string outName) { FileStream fileStream = new FileStream(outName, FileMode.OpenOrCreate, FileAccess.Write); fileStream.SetLength(0L); this.desKey[0] = (byte) 20; this.desKey[1] = (byte) 157; this.desKey[2] = (byte) 64; this.desKey[3] = (byte) 213; this.desKey[4] = (byte) 193; this.desKey[5] = (byte) 46; this.desKey[6] = (byte) 85; this.desKey[7] = (byte) 2; this.desIV[0] = (byte) 0; this.desIV[1] = (byte) 0; this.desIV[2] = (byte) 0; this.desIV[3] = (byte) 0; this.desIV[4] = (byte) 0; this.desIV[5] = (byte) 0; this.desIV[6] = (byte) 0; this.desIV[7] = (byte) 0; byte[] buffer = new byte[8]; long num1 = 8L; long num2 = (long) inName.Length; DESCryptoServiceProvider cryptoServiceProvider = new DESCryptoServiceProvider(); cryptoServiceProvider.Mode = CipherMode.CBC; cryptoServiceProvider.Padding = PaddingMode.None; CryptoStream cryptoStream = new CryptoStream((Stream) fileStream, cryptoServiceProvider.CreateEncryptor(this.desKey, this.desIV), CryptoStreamMode.Write); this.i = 0; do { buffer[this.i] = checked ((byte) Strings.Asc(Strings.Mid(inName, this.i + 1, 1))); checked { ++this.i; } } while (this.i <= 7); for (; num1 <= num2; { int count; num1 = (long) Convert.ToInt32((double) num1 + (double) count / (double) cryptoServiceProvider.BlockSize * (double) cryptoServiceProvider.BlockSize); } ) { count = 8; cryptoStream.Write(buffer, 0, count); } cryptoStream.Close(); fileStream.Close(); cryptoStream.Clear(); cryptoServiceProvider.Clear(); try { this.DES_file_name = FileSystem.CurDir() + "\\Password.dat"; FileInfo fileInfo = new FileInfo(this.DES_file_name); if (!fileInfo.Exists) { int num3 = (int) Interaction.MsgBox((object) ("DES output file : " + this.DES_file_name + " does not exist in the local directory"), MsgBoxStyle.OkOnly, (object) null); } this.DES_file_number = FileSystem.FreeFile(); this.DES_file_buffer_len = checked ((int) fileInfo.Length); FileSystem.FileOpen(this.DES_file_number, this.DES_file_name, OpenMode.Binary, OpenAccess.Read, OpenShare.Default, this.DES_file_buffer_len); } catch (Exception ex) { ProjectData.SetProjectError(ex); int num3 = (int) Interaction.MsgBox((object) ("Unable to open DES output file " + this.DES_file_name), MsgBoxStyle.OkOnly, (object) null); ProjectData.ClearProjectError(); } try { FileSystem.FileGet(this.DES_file_number, ref this.DES_file_string_bytes, -1L, false); this.DESBox.Text = ""; MainForm mainForm = this; int num3 = 0; int num4 = checked (this.DES_file_buffer_len - 2); mainForm.i = num3; while (this.i <= num4) { if (Strings.Len(Conversion.Hex(Strings.Asc(Strings.Mid(this.DES_file_string_bytes, checked (this.i + 1), 1)))) == 2) { TextBox desBox = this.DESBox; desBox.Text = desBox.Text + Conversion.Hex(Strings.Asc(Strings.Mid(this.DES_file_string_bytes, checked (this.i + 1), 1))) + "."; } else { TextBox desBox = this.DESBox; desBox.Text = desBox.Text + "0" + Conversion.Hex(Strings.Asc(Strings.Mid(this.DES_file_string_bytes, checked (this.i + 1), 1))) + "."; } checked { ++this.i; } } if (Strings.Len(Conversion.Hex(Strings.Asc(Strings.Mid(this.DES_file_string_bytes, this.DES_file_buffer_len, 1)))) == 2) { TextBox desBox = this.DESBox; desBox.Text = desBox.Text + Conversion.Hex(Strings.Asc(Strings.Mid(this.DES_file_string_bytes, this.DES_file_buffer_len, 1))); } else { TextBox desBox = this.DESBox; desBox.Text = desBox.Text + "0" + Conversion.Hex(Strings.Asc(Strings.Mid(this.DES_file_string_bytes, this.DES_file_buffer_len, 1))); } try { FileSystem.FileClose(new int[1] { this.DES_file_number }); } catch (Exception ex) { ProjectData.SetProjectError(ex); int num5 = (int) Interaction.MsgBox((object) ("Unable to close DES encoded output file " + this.DES_file_name), MsgBoxStyle.OkOnly, (object) null); ProjectData.ClearProjectError(); } } catch (Exception ex1) { ProjectData.SetProjectError(ex1); int num3 = (int) Interaction.MsgBox((object) ("Error reading password file " + this.DES_file_name), MsgBoxStyle.OkOnly, (object) null); try { FileSystem.FileClose(new int[1] { this.DES_file_number }); } catch (Exception ex2) { ProjectData.SetProjectError(ex2); int num4 = (int) Interaction.MsgBox((object) ("Unable to close DES encoded password file " + this.DES_file_name), MsgBoxStyle.OkOnly, (object) null); ProjectData.ClearProjectError(); } ProjectData.ClearProjectError(); } if (this.SaveSeedCheckBox.Checked) return; try { FileSystem.Kill(this.DES_file_name); } catch (Exception ex) { ProjectData.SetProjectError(ex); ProjectData.ClearProjectError(); } }
public void DecryptData(string inName, string outName) { FileStream fileStream1 = new FileStream(inName, FileMode.Open, FileAccess.Read); FileStream fileStream2 = new FileStream(outName, FileMode.OpenOrCreate, FileAccess.Write); fileStream2.SetLength(0L); this.desKey[0] = (byte) 20; this.desKey[1] = (byte) 157; this.desKey[2] = (byte) 64; this.desKey[3] = (byte) 213; this.desKey[4] = (byte) 193; this.desKey[5] = (byte) 46; this.desKey[6] = (byte) 85; this.desKey[7] = (byte) 2; this.desIV[0] = (byte) 0; this.desIV[1] = (byte) 0; this.desIV[2] = (byte) 0; this.desIV[3] = (byte) 0; this.desIV[4] = (byte) 0; this.desIV[5] = (byte) 0; this.desIV[6] = (byte) 0; this.desIV[7] = (byte) 0; byte[] numArray = new byte[8]; long num = 8L; long length = fileStream1.Length; DESCryptoServiceProvider cryptoServiceProvider = new DESCryptoServiceProvider(); cryptoServiceProvider.Mode = CipherMode.CBC; cryptoServiceProvider.Padding = PaddingMode.None; CryptoStream cryptoStream = new CryptoStream((Stream) fileStream2, cryptoServiceProvider.CreateDecryptor(this.desKey, this.desIV), CryptoStreamMode.Write); for (; num <= length; { int count; num = (long) Convert.ToInt32((double) num + (double) count / (double) cryptoServiceProvider.BlockSize * (double) cryptoServiceProvider.BlockSize); } ) { count = fileStream1.Read(numArray, 0, 8); cryptoStream.Write(numArray, 0, count); } cryptoStream.Close(); fileStream1.Close(); fileStream2.Close(); cryptoStream.Clear(); cryptoServiceProvider.Clear(); }
/// <summary> /// 加密字符串 /// </summary> /// <param name="strSource">被加密的字符串</param> /// <param name="EncryptKey">加密用的密钥(8位加密KEY,同解密用的密钥相同)</param> /// <returns>加密后的字符串</returns> public static string EncryptedString(string strSource, string EncryptKey) { if (string.IsNullOrEmpty(strSource)) { throw new SourceIsNullOrEmptyException(); } if (string.IsNullOrEmpty(EncryptKey)) { throw new EncryptKeyIsNullOrEmptyException(); } byte[] IV = { 0x1E, 0xA2, 0x61, 0x5F, 0xD0, 0x3C, 0x99, 0xBB };//这里要与解密的相同,否则解密出来的结果会不相同。 if (EncryptKey.Length < 8) { EncryptKey = EncryptKey.PadRight(8, '0'); } else if (EncryptKey.Length > 8) { EncryptKey = EncryptKey.Remove(8); } byte[] byKey = null; byKey = Encoding.UTF8.GetBytes(EncryptKey.Substring(0, 8)); DESCryptoServiceProvider des = new DESCryptoServiceProvider(); byte[] sourceByteArray = Encoding.UTF8.GetBytes(strSource); string strEncryptString = string.Empty; using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(byKey, IV), CryptoStreamMode.Write)) { cs.Write(sourceByteArray, 0, sourceByteArray.Length); cs.FlushFinalBlock(); cs.Close(); } strEncryptString = Convert.ToBase64String(ms.ToArray()); } des.Clear(); return strEncryptString; }
////////////////////Encrypt Function//////////////////// private static byte[] Encrypt(byte[] plainData, string sKey) { DESCryptoServiceProvider DES = new DESCryptoServiceProvider(); DES.Key = ASCIIEncoding.ASCII.GetBytes(sKey); DES.IV = DES.Key; ICryptoTransform desEncrypt = DES.CreateEncryptor(); Byte[] encryptedData = desEncrypt.TransformFinalBlock(plainData, 0, plainData.Length); DES.Clear(); desEncrypt.Dispose(); return encryptedData; }
/// <summary> /// Decrypt DES encrypted ScopedPdu /// </summary> /// <param name="encryptedData">Source data buffer</param> /// <param name="key">Decryption key. Key length has to be 32 bytes in length or longer (bytes beyond 32 bytes are ignored).</param> /// <param name="privacyParameters">Privacy parameters extracted from USM header</param> /// <returns>Decrypted byte array</returns> /// <exception cref="ArgumentNullException">Thrown when encrypted data is null or length == 0</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown when encryption key length is less then 32 byte or if privacy parameters /// argument is null or length other then 8 bytes</exception> public static byte[] Decrypt(byte[] encryptedData, byte[] key, byte[] privacyParameters) { if (encryptedData == null) { throw new ArgumentNullException("encryptedData"); } if (key == null) { throw new ArgumentNullException("key"); } if (privacyParameters == null) { throw new ArgumentNullException("privacyParameters"); } if (encryptedData.Length == 0) { throw new ArgumentException("empty encrypted data", "encryptedData"); } if ((encryptedData.Length % 8) != 0) { throw new ArgumentException("Encrypted data buffer has to be divisible by 8.", "encryptedData"); } if (privacyParameters.Length != PrivacyParametersLength) { throw new ArgumentOutOfRangeException("privacyParameters", "Privacy parameters argument has to be 8 bytes long"); } if (key.Length < MinimumKeyLength) { throw new ArgumentOutOfRangeException("key", "Decryption key has to be at least 16 bytes long."); } var iv = new byte[8]; for (var i = 0; i < 8; ++i) { iv[i] = (byte)(key[8 + i] ^ privacyParameters[i]); } using (DES des = new DESCryptoServiceProvider()) { des.Mode = CipherMode.CBC; des.Padding = PaddingMode.Zeros; // .NET implementation only takes an 8 byte key var outKey = new byte[8]; Buffer.BlockCopy(key, 0, outKey, 0, 8); des.Key = outKey; des.IV = iv; using (var transform = des.CreateDecryptor()) { var decryptedData = transform.TransformFinalBlock(encryptedData, 0, encryptedData.Length); des.Clear(); return decryptedData; } } }
public static string Encrypt(string orgidata, byte[] key = null, CryptoStringFormat format = CryptoStringFormat.Base64, string iv = null) { if (orgidata == null) { return null; } try { byte[] orgi = Encoding.GetBytes(orgidata); using (DESCryptoServiceProvider des = new DESCryptoServiceProvider()) { des.Key = GetCheckKey(key); des.IV = string.IsNullOrEmpty(iv) ? _iv : Encoding.GetBytes(iv); using (ICryptoTransform transform = des.CreateEncryptor()) { byte[] data = transform.TransformFinalBlock(orgi, 0, orgi.Length); if (data != null) { des.Clear(); switch (format) { case CryptoStringFormat.Base64: return Convert.ToBase64String(data); case CryptoStringFormat.Encoding: return Encoding.GetString(data); } } } } orgi = null; } catch (Exception ex) { Log.WriteException(ex); } return null; }
static byte[] Compute_LM (string password, byte[] challenge) { var buffer = new byte [21]; // create Lan Manager password #if MOONLIGHT DESCryptoServiceProvider des = new DESCryptoServiceProvider (); #else DES des = DES.Create (); #endif des.Mode = CipherMode.ECB; ICryptoTransform ct = null; // Note: In .NET DES cannot accept a weak key // this can happen for a null password if ((password == null) || (password.Length < 1)) { Buffer.BlockCopy (nullEncMagic, 0, buffer, 0, 8); } else { des.Key = PasswordToKey (password, 0); ct = des.CreateEncryptor (); ct.TransformBlock (magic, 0, 8, buffer, 0); } // and if a password has less than 8 characters if ((password == null) || (password.Length < 8)) { Buffer.BlockCopy (nullEncMagic, 0, buffer, 8, 8); } else { des.Key = PasswordToKey (password, 7); ct = des.CreateEncryptor (); ct.TransformBlock (magic, 0, 8, buffer, 8); } des.Clear (); return GetResponse (challenge, buffer); }
/// <summary> /// Decrypts a string using a given private key and the DES algorithm /// </summary> /// <param name="strCipherText">Text to be decrypted</param> /// <param name="privateKey">Private Key used to decrypt</param> /// <returns>Decrypted Text</returns> /// <remarks>The parameter must be 8 characters long</remarks> private static string DESPrivateKeyDecryption(string strCipherText, string privateKey) { DESCryptoServiceProvider crp = new DESCryptoServiceProvider(); UnicodeEncoding uEncode = new UnicodeEncoding(); MemoryStream stmPlainText = new MemoryStream(); byte[] bytCipherText; byte[] slt = new byte[0]; byte[] bytDerivedKey; bytCipherText = Convert.FromBase64String(strCipherText); MemoryStream stmCipherText = new MemoryStream(bytCipherText); crp.KeySize = DES_KEY_SIZE; PasswordDeriveBytes pdb = new PasswordDeriveBytes(privateKey, slt); bytDerivedKey = pdb.GetBytes(8); crp.Key = bytDerivedKey; crp.IV = pdb.GetBytes(8); CryptoStream csDecrypted = new CryptoStream(stmCipherText, crp.CreateDecryptor(), CryptoStreamMode.Read); StreamWriter sw = new StreamWriter(stmPlainText); StreamReader sr = new StreamReader(csDecrypted); sw.Write(sr.ReadToEnd()); sw.Flush(); csDecrypted.Clear(); crp.Clear(); return uEncode.GetString(stmPlainText.ToArray()); }
/// <summary> /// DES 解密(数据加密标准,速度较快,适用于加密大量数据的场合) /// </summary> /// <param name="DecryptString">待解密的密文</param> /// <param name="DecryptKey">解密的密钥</param> /// <returns>returns</returns> public static string DESDecrypt(string DecryptString, string DecryptKey) { if (string.IsNullOrEmpty(DecryptString)) { throw (new Exception("密文不得为空")); } if (string.IsNullOrEmpty(DecryptKey)) { throw (new Exception("密钥不得为空")); } if (DecryptKey.Length != 8) { throw (new Exception("密钥必须为8位")); } byte[] m_btIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF }; string m_strDecrypt = ""; DESCryptoServiceProvider m_DESProvider = new DESCryptoServiceProvider(); try { byte[] m_btDecryptString = Convert.FromBase64String(DecryptString); MemoryStream m_stream = new MemoryStream(); CryptoStream m_cstream = new CryptoStream(m_stream, m_DESProvider.CreateDecryptor(Encoding.Default.GetBytes(DecryptKey), m_btIV), CryptoStreamMode.Write); m_cstream.Write(m_btDecryptString, 0, m_btDecryptString.Length); m_cstream.FlushFinalBlock(); m_strDecrypt = Encoding.Default.GetString(m_stream.ToArray()); m_stream.Close(); m_stream.Dispose(); m_cstream.Close(); m_cstream.Dispose(); } catch (IOException ex) { throw ex; } catch (CryptographicException ex) { throw ex; } catch (ArgumentException ex) { throw ex; } catch (Exception ex) { throw ex; } finally { m_DESProvider.Clear(); } return m_strDecrypt; }
/// <summary> /// Decrypt DES encrypted ScopedPdu /// </summary> /// <param name="encryptedData">Source data buffer</param> /// <param name="offset">Offset within the buffer to start decryption process</param> /// <param name="length">Length of data to decrypt</param> /// <param name="key">Decryption key. Key length has to be 32 bytes in length or longer (bytes beyond 32 bytes are ignored).</param> /// <param name="engineBoots">Authoritative engine boots value</param> /// <param name="engineTime">Authoritative engine time value</param> /// <param name="privacyParameters">Privacy parameters extracted from USM header</param> /// <returns>Decrypted byte array</returns> /// <exception cref="ArgumentNullException">Thrown when encrypted data is null or length == 0</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown when encryption key length is less then 32 byte or if privacy parameters /// argument is null or length other then 8 bytes</exception> public byte[] Decrypt(byte[] encryptedData, int offset, int length, byte[] key, int engineBoots, int engineTime, byte[] privacyParameters) { if ((length % 8) != 0) throw new ArgumentOutOfRangeException("encryptedData", "Encrypted data buffer has to be divisible by 8."); if (encryptedData == null || encryptedData.Length == 0) throw new ArgumentNullException("cryptedData"); if (privacyParameters == null || privacyParameters.Length != PrivacyParametersLength) throw new ArgumentOutOfRangeException("privacyParameters", "Privacy parameters argument has to be 8 bytes long"); if (key == null || key.Length < MinimumKeyLength) throw new ArgumentOutOfRangeException("decryptionKey", "Decryption key has to be at least 16 bytes long."); byte[] iv = new byte[8]; for (int i = 0; i < 8; ++i) { iv[i] = (byte)(key[8 + i] ^ privacyParameters[i]); } DES des = new DESCryptoServiceProvider(); des.Mode = CipherMode.CBC; des.Padding = PaddingMode.Zeros; // .NET implementation only takes an 8 byte key byte[] outKey = new byte[8]; Buffer.BlockCopy(key, 0, outKey, 0, 8); des.Key = outKey; des.IV = iv; ICryptoTransform transform = des.CreateDecryptor(); byte[] decryptedData = transform.TransformFinalBlock(encryptedData, 0, encryptedData.Length); des.Clear(); return decryptedData; }