public static void TripleDesCreate() { byte[] inputBytes = Encoding.ASCII.GetBytes("This is a secret message and is a sentence that is longer than a block, it ensures that multi-block functions work."); TripleDES tripleDes = TripleDES.Create(); byte[] encryptedBytes; using (MemoryStream input = new MemoryStream(inputBytes)) using (CryptoStream cryptoStream = new CryptoStream(input, tripleDes.CreateEncryptor(), CryptoStreamMode.Read)) using (MemoryStream output = new MemoryStream()) { cryptoStream.CopyTo(output); encryptedBytes = output.ToArray(); } Assert.NotEqual(inputBytes, encryptedBytes); byte[] decryptedBytes; using (MemoryStream input = new MemoryStream(encryptedBytes)) using (CryptoStream cryptoStream = new CryptoStream(input, tripleDes.CreateDecryptor(), CryptoStreamMode.Read)) using (MemoryStream output = new MemoryStream()) { cryptoStream.CopyTo(output); decryptedBytes = output.ToArray(); } Assert.Equal(inputBytes, decryptedBytes); }
/// <summary> /// Decrypt /// </summary> /// <param name="input"></param> /// <returns></returns> public byte[] Decrypt(byte[] input) { // Grab the Initialization Vector out of the input var ivBytes = new byte[(mBlockSize / 8)]; Array.Copy(input, ivBytes, ivBytes.Length); // Take the remaining bytes which represent the actual encrypted payload var encryptedBytes = new byte[input.LongLength - ivBytes.Length]; Array.Copy(input, ivBytes.Length, encryptedBytes, 0, encryptedBytes.LongLength); using (AesManaged aesManaged = new AesManaged { Key = mKey, BlockSize = mBlockSize, IV = ivBytes, Mode = CipherMode.CBC }) using (Stream ms = new MemoryStream(encryptedBytes)) using (ICryptoTransform ct = aesManaged.CreateDecryptor(aesManaged.Key, aesManaged.IV)) using (CryptoStream cs = new CryptoStream(ms, ct, CryptoStreamMode.Read)) using (MemoryStream outputStream = new MemoryStream()) { cs.CopyTo(outputStream); if (!mUseCompression) { return(outputStream.ToArray()); } outputStream.Position = 0; using (var zipStream = new GZipStream(outputStream, CompressionMode.Decompress)) using (var outputZipStream = new MemoryStream()) { zipStream.CopyTo(outputZipStream); zipStream.Close(); return(outputZipStream.ToArray()); } } }
public byte[] DecryptBytes(byte[] bytes, string password, string salt) { // Using the default key size. Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(password, Encoding.ASCII.GetBytes(salt)); RijndaelManaged aesAlgorithm = new RijndaelManaged(); aesAlgorithm.Key = key.GetBytes(aesAlgorithm.KeySize / 8); using (MemoryStream inputStream = new MemoryStream(bytes)) { // Read in the array size and the cryptographic data. byte[] ivLengthArray = new byte[sizeof(Int32)]; inputStream.Read(ivLengthArray, 0, ivLengthArray.Length); int ivLength = BitConverter.ToInt32(ivLengthArray, 0); inputStream.Read(aesAlgorithm.IV, 0, ivLength); // Read the rest of the stream to decrypt the data. using (ICryptoTransform decryptor = aesAlgorithm.CreateDecryptor(aesAlgorithm.Key, aesAlgorithm.IV)) { using (CryptoStream cryptoStream = new CryptoStream(inputStream, decryptor, CryptoStreamMode.Read)) { using (MemoryStream outputStream = new MemoryStream()) { cryptoStream.CopyTo(outputStream); byte[] dataWithIv = outputStream.ToArray(); byte[] cleanedData = new byte[dataWithIv.Length - aesAlgorithm.IV.Length]; Array.Copy(dataWithIv, aesAlgorithm.IV.Length, cleanedData, 0, cleanedData.Length); return(cleanedData); } } } } }
// Throw error if not valid public IEnumerable <OpenPgpPacket> GetDecryptedPackets(SymmetricAlgorithm keyedAlgorithm) { var transform = new OpenPgpCfbTransform(keyedAlgorithm, encrypt: false); var decryptor = new CryptoStream(EncryptedStream, transform, CryptoStreamMode.Read); var decrypted = new MemoryStream(); decryptor.CopyTo(decrypted); // Get rid of the modification detection code, but verify it var mdcStart = decrypted.Length - (1 + 1 + 20); decrypted.Position = mdcStart; var mdcStream = new MemoryStream(); decrypted.CopyTo(mdcStream); decrypted.Position = 0; decrypted.SetLength(mdcStart + 2); var hasher = SHA1.Create(); var hashIncludingHeaderAndLength = hasher.ComputeHash(transform.PrefixBytes.Concat(decrypted.ToArray()).ToArray()); decrypted.SetLength(decrypted.Length - 2); decrypted.Position = 0; // TODO: mdcStream.Position = 0; var mdc = OpenPgpPacketReader.ReadAllPackets(mdcStream).First() as ModificationDetectionCodeOpenPgpPacket; for (int i = 0; i < hashIncludingHeaderAndLength.Length; i++) { if (hashIncludingHeaderAndLength[i] != mdc.HashValue[i]) { throw new ModificationDetectedException(); } } return(OpenPgpPacketReader.ReadAllPackets(decrypted)); }
/// <summary></summary> public byte[] DecryptAes(byte[] abEncrypted, byte[] abKey) { byte[] abReturn = null; if ((abEncrypted != null) && (abEncrypted.Length > ciAesBlockLength) && (abKey != null)) { _AesServices.Padding = PaddingMode.PKCS7; for (int i = 0; i < ciAesBlockLength; i++) { _abInitialisationVector[i] = abEncrypted[i]; } using (ICryptoTransform AesDecryptor = _AesServices.CreateDecryptor(abKey, _abInitialisationVector)) { using (MemoryStream EncryptedStream = new MemoryStream(abEncrypted, ciAesBlockLength, abEncrypted.Length - ciAesBlockLength)) { try { using (CryptoStream AesCryptoStream = new CryptoStream(EncryptedStream, AesDecryptor, CryptoStreamMode.Read)) { using (MemoryStream DecryptedStream = new MemoryStream()) { AesCryptoStream.CopyTo(DecryptedStream); abReturn = DecryptedStream.ToArray(); } } } catch (CryptographicException) { // } } } } return(abReturn); }
public void Decrypt(IByteBufferAllocator allocator, EncryptMode mode, Stream src, Stream dst, bool reliable) { using (var data = new BufferWrapper(allocator.Buffer().WithOrder(ByteOrder.LittleEndian))) using (var decryptor = GetAlgorithm(mode).CreateDecryptor()) using (var cs = new CryptoStream(src, decryptor, CryptoStreamMode.Read)) { var padding = cs.ReadByte(); var checksum = cs.ReadByte() | cs.ReadByte() << 8 | cs.ReadByte() << 16 | cs.ReadByte() << 24; using (var dataStream = new WriteOnlyByteBufferStream(data.Buffer, false)) cs.CopyTo(dataStream); if (reliable) { var counter = (ushort)(Interlocked.Increment(ref _decryptCounter) - 1); var messageCounter = data.Buffer.GetShort(data.Buffer.ReaderIndex); if (counter != messageCounter) { throw new ProudException($"Invalid decrypt counter! Remote: {messageCounter} Local: {counter}"); } } var slice = data.Buffer.ReadSlice(data.Buffer.ReadableBytes - padding); using (var dataStream = new ReadOnlyByteBufferStream(slice, false)) { if (Hash.GetUInt32 <CRC32>(dataStream) != (uint)checksum) { throw new ProudException("Invalid checksum"); } dataStream.Position = reliable ? 2 : 0; dataStream.CopyTo(dst); } } }
public static Byte[] SimmetricDecrypt(string password, byte[] salt, byte[] data) { try { using var aes = Aes.Create(); using var encryptor = aes.GetDecryptorFromPassword(password, salt); using MemoryStream msDecrypt = new MemoryStream(); using MemoryStream msOriginalData = new MemoryStream(data); using (CryptoStream csDecrypt = new CryptoStream(msOriginalData, encryptor, CryptoStreamMode.Read)) { csDecrypt.CopyTo(msDecrypt); } // important, dispose CryptoStream before accessing the array return(msDecrypt.ToArray()); } catch (CryptographicException cex) { Log.Error(cex, "Error decrypting message"); //Do not disclose anything to the caller. throw new SecurityException("Error in decrypting"); } }
public static byte[] DecryptData(byte[] encrypted, byte[] key) { var iv = new byte[16]; Buffer.BlockCopy(encrypted, 0, iv, 0, iv.Length); using (var aesAlg = Aes.Create()) { aesAlg.Mode = CipherMode.CBC; using (var decryptor = aesAlg.CreateDecryptor(key, iv)) { using (var msDecrypt = new MemoryStream(encrypted, iv.Length, encrypted.Length - iv.Length)) { using (var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) { using (var resultStream = new MemoryStream()) { csDecrypt.CopyTo(resultStream); return(resultStream.ToArray()); } } } } } }
public void Decrypt(Stream src, Stream dst, bool reliable) { if (RC4 == null) { throw new ObjectDisposedException(GetType().FullName); } using (var decryptor = RC4.CreateDecryptor()) using (var cs = new CryptoStream(src, decryptor, CryptoStreamMode.Read)) { if (reliable) { var counter = (ushort)(Interlocked.Increment(ref _decryptCounter) - 1); var messageCounter = cs.ReadByte() | cs.ReadByte() << 8; if (counter != messageCounter) { throw new ProudException($"Invalid decrypt counter! Remote: {messageCounter} Local: {counter}"); } } cs.CopyTo(dst); } }
/// <summary> /// Decrypts the specified encrypted data using a symmetric key algorithm. /// </summary> /// <param name="encryptedData">The encrypted data.</param> /// <param name="key">The key.</param> /// <param name="initializationVector">The initialization vector.</param> /// <param name="method">The encryption method.</param> /// <returns></returns> public static byte[] Decrypt( byte[] encryptedData, byte[] key, byte[] initializationVector, SymmetricEncryptionMethod method) { using (SymmetricAlgorithm provider = GetSymmetricEncryptionAlgorithm(method)) { // assigned the specified key and IV as // a pair is created upon creation of the provider provider.Key = key; provider.IV = initializationVector; ICryptoTransform decryptor = provider.CreateDecryptor(); using (MemoryStream ms = new MemoryStream(encryptedData)) { using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read)) { using (MemoryStream os = new MemoryStream()) { cs.CopyTo(os); return(os.ToArray()); } } } } }
// SetValue gets called by Json.Net during deserialization. // The value parameter has the encrypted value read from the JSON; // target is the object on which to set the decrypted value. public void SetValue(object target, object value) { byte[] buffer = Convert.FromBase64String((string)value); using (MemoryStream inputStream = new MemoryStream(buffer, false)) using (MemoryStream outputStream = new MemoryStream()) using (AesManaged aes = new AesManaged { Key = encryptionKey }) { byte[] iv = new byte[16]; int bytesRead = inputStream.Read(iv, 0, 16); if (bytesRead < 16) { throw new CryptographicException("IV is missing or invalid."); } ICryptoTransform decryptor = aes.CreateDecryptor(encryptionKey, iv); using (CryptoStream cryptoStream = new CryptoStream(inputStream, decryptor, CryptoStreamMode.Read)) { cryptoStream.CopyTo(outputStream); } string decryptedValue = Encoding.UTF8.GetString(outputStream.ToArray()); targetProperty.SetValue(target, decryptedValue); } }
/// <summary> /// /// </summary> /// <param name="stream"></param> /// <param name="transform"></param> /// <param name="mode"></param> /// <returns></returns> protected static BitStream CryptoStream(BitwiseStream stream, ICryptoTransform transform, CryptoStreamMode mode) { BitStream ret = new BitStream(); if (mode == CryptoStreamMode.Write) { var cs = new CryptoStream(ret, transform, mode); stream.CopyTo(cs); cs.FlushFinalBlock(); } else { var cs = new CryptoStream(stream, transform, mode); cs.CopyTo(ret); } if (stream.Position != stream.Length) { throw new PeachException("Didn't transform all bytes."); } ret.Seek(0, SeekOrigin.Begin); return(ret); }
public CachedLicense TryRetrieve(string productIdentifier, string email) { string filename = Path.Combine(RootDirectory, FilenameFromIdentifier(productIdentifier + email)); if (File.Exists(filename)) { using (MemoryStream ms = new MemoryStream()) { using (Aes aes = Aes.Create()) using (ICryptoTransform transform = aes.CreateDecryptor(Key, IV)) using (FileStream fileStream = File.OpenRead(filename)) using (CryptoStream cs = new CryptoStream(fileStream, transform, CryptoStreamMode.Read)) { cs.CopyTo(ms); } ms.Seek(0, SeekOrigin.Begin); return((CachedLicense) new XmlSerializer(typeof(CachedLicense)).Deserialize(ms)); } } return(null); }
public string Decrypt(string cipherText) { byte[] encryptedPayload = Convert.FromBase64String(cipherText); using (var aes = new AesManaged()) { int ivLength = aes.BlockSize / 8; byte[] iv = encryptedPayload.Take(ivLength).ToArray(); byte[] cipherBytes = encryptedPayload.Skip(ivLength).ToArray(); ICryptoTransform decryptor = aes.CreateDecryptor(_key, iv); using (var memStream = new MemoryStream(cipherBytes)) using (var decryptedStream = new MemoryStream()) { using (var cryptStream = new CryptoStream(memStream, decryptor, CryptoStreamMode.Read)) cryptStream.CopyTo(decryptedStream); byte[] payload = decryptedStream.ToArray(); return(DecodePayload(payload)); } } }
//private static string Decrypt(byte[] paddingPrefixedBlob) //{ // return Encoding.Unicode.GetString(RawDecrypt(paddingPrefixedBlob)).TrimEnd('\0'); //} private static byte[] DecryptRaw(byte[] paddingPrefixedBlob) { if (paddingPrefixedBlob == null) { return(new byte[0]); } using (MemoryStream ms = new MemoryStream(paddingPrefixedBlob, 4, paddingPrefixedBlob.Length - 4)) { using (CryptoStream cs = new CryptoStream(ms, _decryptor, CryptoStreamMode.Read)) { using (MemoryStream msResult = new MemoryStream()) { cs.CopyTo(msResult); byte[] buffer = msResult.ToArray(); Dump("buffer", buffer); byte[] b2 = new byte[buffer.Length - 4]; Buffer.BlockCopy(buffer, 4, b2, 0, b2.Length); return(b2); } } } }
public static byte[] DecryptAes256(byte[] ciphertext, byte[] iv, byte[] encryptionKey) { try { using (var aes = new AesManaged { KeySize = 256, Key = encryptionKey, Mode = CipherMode.CBC, IV = iv }) using (var decryptor = aes.CreateDecryptor()) using (var inputStream = new MemoryStream(ciphertext, false)) using (var cryptoStream = new CryptoStream(inputStream, decryptor, CryptoStreamMode.Read)) using (var outputStream = new MemoryStream()) { cryptoStream.CopyTo(outputStream); return(outputStream.ToArray()); } } catch (CryptographicException e) { throw new ParseException( ParseException.FailureReason.IncorrectPassword, "Decryption failed due to incorrect password or data corruption", e); } }
public static void Encrypt(string input, string output, SymmetricAlgorithm alg) { using (var inputStream = new FileStream(input, FileMode.Open, FileAccess.Read)) { using (var outputStream = new FileStream(output, FileMode.Create, FileAccess.Write)) { using (var cryptoStream = new CryptoStream(inputStream, alg.CreateEncryptor(), CryptoStreamMode.Read)) { { cryptoStream.CopyTo(outputStream); } } } } using (var outputStream = new FileStream(key, FileMode.Create, FileAccess.Write)) { using (var streamWriter = new StreamWriter(outputStream)) { streamWriter.WriteLine(Convert.ToBase64String(alg.Key)); streamWriter.WriteLine(Convert.ToBase64String(alg.IV)); } } }
public byte[] Decrypt <T>(byte[] aEncryptedMessage, SymetricKey SymetricKey) where T : SymmetricAlgorithm, new() { DeriveBytes rgb = new Rfc2898DeriveBytes(SymetricKey.Key, SymetricKey.Salt, SymetricKey.Iteration); SymmetricAlgorithm algorithm = new T(); algorithm.Key = SymetricKey.Key; algorithm.IV = SymetricKey.Salt; algorithm.Mode = this.Mode; //algorithm.Padding = PaddingMode.PKCS7; ICryptoTransform transform = algorithm.CreateDecryptor(SymetricKey.Key, SymetricKey.Salt); using (MemoryStream buffer = new MemoryStream(aEncryptedMessage)) using (CryptoStream stream = new CryptoStream(buffer, transform, CryptoStreamMode.Read)) using (MemoryStream mo = new MemoryStream()) { stream.CopyTo(mo); mo.Position = 0; return(mo.ToArray()); } }
public static byte[] DecryptFileToArray(User user, string iFileName, string token) { try { if (!File.Exists(iFileName) || !IsTokenGood(token)) { return(new byte[0]); } byte[] keyArr = StringToByteArray(token.Substring(0, 32)); byte[] ivArr = StringToByteArray(token.Substring(32)); if (!(keyArr.Length == ivArr.Length && keyArr.Length == 16)) { return(new byte[0]); } using (MemoryStream doStream = new MemoryStream()) { using (AesCryptoServiceProvider aesProvider = new AesCryptoServiceProvider()) { aesProvider.KeySize = KeySizeBits; aesProvider.IV = ivArr; aesProvider.Key = keyArr; using (FileStream eiStream = File.OpenRead(iFileName)) using (CryptoStream cryptoStream = new CryptoStream(eiStream, aesProvider.CreateDecryptor(), CryptoStreamMode.Read)) { cryptoStream.CopyTo(doStream); } } return(doStream.ToArray()); } } catch (Exception e) { ProgramLog.LogError(user, "Crypt", "DecryptFileToArray", e.Message); return(new byte[0]); } }
private void DecryptFileCore(string inputFile, string outputFile, byte[] key, bool overwrite) { var fileMode = (overwrite) ? FileMode.Create : FileMode.CreateNew; using (var alg = new AesManaged()) { alg.Key = key; alg.IV = DefaultFileEncryptionIV; alg.Mode = CipherMode.CBC; var decryptor = alg.CreateDecryptor(); using (var inStream = new FileStream(inputFile, FileMode.Open, FileAccess.Read, FileShare.Read)) { using (var outStream = new FileStream(outputFile, fileMode)) { using (var cryptoStream = new CryptoStream(inStream, decryptor, CryptoStreamMode.Read)) { cryptoStream.CopyTo(outStream); } } } } }
private static byte[] DecryptBytes(byte[] encryptedBytes) { Stream sourceStream = null; try { sourceStream = new MemoryStream(encryptedBytes); using (var aes = Aes.Create("AesManaged")) { aes.Key = encryptionKey; var iv = new byte[aes.BlockSize / 8]; sourceStream.Read(iv, 0, iv.Length); aes.IV = iv; using (var decryptor = aes.CreateDecryptor()) { using (var cryptoStream = new CryptoStream(sourceStream, decryptor, CryptoStreamMode.Read)) { sourceStream = null; using (var targetStream = new MemoryStream()) { cryptoStream.CopyTo(targetStream); return(targetStream.ToArray()); } } } } } finally { if (sourceStream != null) { sourceStream.Dispose(); } } }
private static Stream ReceiveEncryptedDataStream(AsymmetricAlgorithm privateKey, Stream encryptedDataStream, byte[] iv, byte[] sessionKey) { var decryptedDataStream = new MemoryStream(); var deformatter = new GostKeyExchangeDeformatter(privateKey); // Получатель принимает от отправителя зашифрованный сессионный ключ и дешифрует его using (var receiverSessionKey = deformatter.DecryptKeyExchangeAlgorithm(sessionKey)) { // Получатель принимает от отправителя вектор инициализации receiverSessionKey.IV = iv; // Получатель дешифрует данные с использованием сессионного ключа using (var decryptor = receiverSessionKey.CreateDecryptor()) { var cryptoStream = new CryptoStream(encryptedDataStream, decryptor, CryptoStreamMode.Read); cryptoStream.CopyTo(decryptedDataStream); } } decryptedDataStream.Position = 0; return(decryptedDataStream); }
private static void DecryptStream(FileStream encryptedFile, FileStream decryptedFile, byte[] key) { var aes = Aes.Create(); var shrinkedKey = new byte[32]; var ivBase = new byte[16]; Array.Copy(key, 0, shrinkedKey, 0, 32); Array.Copy(key, 32, ivBase, 0, 16); aes.Mode = CipherMode.CBC; aes.Key = shrinkedKey; aes.Padding = PaddingMode.None; int numRead; var buffer = new byte[65536]; var iv = new byte[16]; Array.Copy(ivBase, iv, 16); while ((numRead = encryptedFile.Read(buffer, 0, buffer.Length)) > 0) { var offsetBytes = new byte[16]; Array.Copy(BitConverter.GetBytes(encryptedFile.Position - numRead), offsetBytes, 8); var ivCrypter = aes.CreateEncryptor(shrinkedKey, new byte[16]); var newIv = ivCrypter.TransformFinalBlock(offsetBytes, 0, 16); var ms = new MemoryStream(buffer, 0, numRead); var dec = aes.CreateDecryptor(shrinkedKey, newIv); using (var cs = new CryptoStream(ms, dec, CryptoStreamMode.Read)) cs.CopyTo(decryptedFile); } }
/// <summary> /// Функция дешифрования файла /// </summary> /// <param name="filePath"></param> /// <param name="key"></param> /// <param name="iV"></param> /// <returns></returns> private void DecryptFileFromAES(string filePath, byte[] key, byte[] iV) { // Check arguments. if (filePath == null || filePath.Length <= 0) { throw new ArgumentNullException("cipherText"); } if (key == null || key.Length <= 0) { throw new ArgumentNullException("Key"); } if (iV == null || iV.Length <= 0) { throw new ArgumentNullException("IV"); } // Create an AesCryptoServiceProvider object // with the specified key and IV. using (AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider()) { aesAlg.Key = key; aesAlg.IV = iV; // Create a decryptor to perform the stream transform. ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); #region Old Worked //using (StreamReader reader = new StreamReader(filePath, Encoding.Default)) //{ // var tmp = Encoding.Default.GetBytes(reader.ReadToEnd()); // // Create the streams used for decryption. // using (MemoryStream msDecrypt = new MemoryStream(tmp)) // { // using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) // { // using (StreamReader srDecrypt = new StreamReader(csDecrypt)) // { // reader.Close(); // string chiperText = srDecrypt.ReadToEnd(); // // Перезаписываем шифрованный файл на место файла // using (FileStream openFile = File.Create(filePath)) // { // // Перезаписываем шифрованный файл на место файла // using (StreamWriter writer = new StreamWriter(openFile, Encoding.Default)) // { // writer.Write(chiperText); // } // } // File.Move(filePath, filePath.Replace(".crypto", "")); // } // } // } //} #endregion #region New Perfect Worked string tmpPath = Path.GetTempFileName(); using (FileStream fsSrc = File.OpenRead(filePath)) { using (CryptoStream cs = new CryptoStream(fsSrc, decryptor, CryptoStreamMode.Read, true)) using (FileStream fsDst = File.Create(tmpPath)) { cs.CopyTo(fsDst); } } File.Delete(filePath); File.Move(tmpPath, filePath.Replace(".crypto", "")); #endregion } }
Script LoadScript(string p, ScriptType type, Dictionary <string, string> switches = null, Dictionary <string, string[]> assertSwitches = null) { var script = new Script() { name = p.Split('\\').Last() }; string pbase = ""; ZipArchive archive = null; IArchive compress = null; archive = null; MemoryStream zrpstream = null; Bitmap GetBitmap(string path) { if (type == ScriptType.Folder) { if (path == null) { } path = Path.Combine(p, pbase, path); FileStream s; try { s = File.OpenRead(path); } catch { throw new Exception("Could not open " + path); } Bitmap b; try { b = new Bitmap(s); } catch { throw new Exception("Corrupt image: " + path); } s.Close(); return(b); } else if (type == ScriptType.Zip || type == ScriptType.Zrp) { path = Path.Combine(pbase, path); Stream s; try { s = archive.GetEntry(path).Open(); } catch { throw new Exception("Could not open " + path); } Bitmap b; try { b = new Bitmap(s); } catch { throw new Exception("Corrupt image: " + path); } s.Close(); return(b); } else { path = Path.Combine(pbase, path); Stream s; var e = compress.Entries.Where(a => a.Key == path).ToArray(); if (e.Length == 0) { throw new Exception("Could not open " + path); } s = e[0].OpenEntryStream(); Bitmap b; try { b = new Bitmap(s); } catch { throw new Exception("Corrupt image: " + path); } s.Close(); return(b); } } try { string code = ""; if (type == ScriptType.Folder) { var files = Directory.GetFiles(p, "*script.cs", SearchOption.AllDirectories) .Where(s => s.EndsWith("\\script.cs")) .Select(s => s.Substring(p.Length + 1)) .ToArray(); Array.Sort(files.Select(s => s.Length).ToArray(), files); if (files.Length == 0) { throw new Exception("Could not find script.cs file"); } var jsonpath = files[0]; pbase = jsonpath.Substring(0, jsonpath.Length - "script.cs".Length); if (files.Length == 0) { throw new Exception("Could not find script.cs file"); } try { code = File.ReadAllText(Path.Combine(p, jsonpath)); } catch { throw new Exception("Could not read script.cs file"); } } else if (type == ScriptType.Zip || type == ScriptType.Zrp) { if (type == ScriptType.Zrp) { var encoded = File.OpenRead(p); var key = new byte[16]; var iv = new byte[16]; encoded.Read(key, 0, 16); encoded.Read(iv, 0, 16); zrpstream = new MemoryStream(); using (AesManaged aes = new AesManaged()) { ICryptoTransform decryptor = aes.CreateDecryptor(key, iv); using (CryptoStream cs = new CryptoStream(encoded, decryptor, CryptoStreamMode.Read)) { cs.CopyTo(zrpstream); } zrpstream.Position = 0; archive = new ZipArchive(zrpstream); } } else { archive = ZipFile.OpenRead(p); } var files = archive.Entries.Where(e => e.Name == "script.cs").ToArray(); Array.Sort(files.Select(s => s.FullName.Length).ToArray(), files); if (files.Length == 0) { throw new Exception("Could not find script.cs file"); } var jsonfile = files[0]; pbase = jsonfile.FullName.Substring(0, jsonfile.FullName.Length - "script.cs".Length); using (var jfile = new StreamReader(jsonfile.Open())) { code = jfile.ReadToEnd(); } } else { if (type == ScriptType.Rar) { compress = RarArchive.Open(p); } if (type == ScriptType.SevenZip) { compress = SevenZipArchive.Open(p); } if (type == ScriptType.Tar) { compress = TarArchive.Open(p); } var files = compress.Entries.Where(e => e.Key.EndsWith("/script.cs") || e.Key == "script.cs").ToArray(); Array.Sort(files.Select(s => s.Key.Length).ToArray(), files); if (files.Length == 0) { throw new Exception("Could not find script.cs file"); } var jsonfile = files[0]; pbase = jsonfile.Key.Substring(0, jsonfile.Key.Length - "script.cs".Length); using (var jfile = new StreamReader(jsonfile.OpenEntryStream())) { code = jfile.ReadToEnd(); } } var fc = code.Replace(" ", "").Replace("\t", "").Replace("\n", "").Replace("\r", ""); Dictionary <string, string> notallowed = new Dictionary <string, string>() { { "System.IO", null }, { "System.Reflection", null }, { "Microsoft.CSharp", null }, { "System.Net", null }, { "Microsoft.VisualBasic", null }, { "System.Drawing", null }, { "System.AttributeUsage", null }, { "System.EnterpriseServices", null }, { "System.Media", null }, { "System.Messaging", null }, { "System.Printing", null }, { "System.Security", null }, { "System.ServiceModel", null }, { "System.ServiceProcess", null }, { "System.Speech", null }, { "System.Web", null }, { "System.Windows", null }, { "System.Xml", null }, { "Microsoft.Windows", null }, { "Microsoft.Win32", null }, { "Microsoft.SqlServer", null }, { "Microsoft.JScript", null }, { "Microsoft.Build", null }, { "Accessibility", null }, { "Microsoft.Activities", null }, { "System.Diagnostics", "random user" }, { "System.Runtime", "random user" }, { "System.Management", "random user" } }; foreach (var n in notallowed) { if (fc.Contains(n.Key)) { if (n.Value == null) { throw new Exception(n.Key + " is not allowed"); } else if (fc.Contains(n.Key)) { throw new Exception(n.Key + " is not allowed (found by " + n.Value + ")"); } } } CompilerParameters compiler_parameters = new CompilerParameters(); compiler_parameters.GenerateInMemory = true; compiler_parameters.GenerateExecutable = false; compiler_parameters.ReferencedAssemblies.Add(typeof(object).Assembly.Location); compiler_parameters.ReferencedAssemblies.Add(typeof(OpenTK.Vector2).Assembly.Location); compiler_parameters.ReferencedAssemblies.Add(typeof(IEnumerable <object>).Assembly.Location); compiler_parameters.ReferencedAssemblies.Add(typeof(LinkedList <object>).Assembly.Location); compiler_parameters.ReferencedAssemblies.Add(typeof(System.Drawing.Color).Assembly.Location); compiler_parameters.ReferencedAssemblies.Add(typeof(IO).Assembly.Location); compiler_parameters.ReferencedAssemblies.Add(typeof(System.Linq.Enumerable).Assembly.Location); compiler_parameters.CompilerOptions = "/optimize /unsafe /nostdlib"; CompilerResults results = provider.CompileAssemblyFromSource(compiler_parameters, code); if (results.Errors.HasErrors) { StringBuilder builder = new StringBuilder(); foreach (CompilerError error in results.Errors) { builder.AppendLine(String.Format("Error ({0}): {1}", error.ErrorNumber, error.ErrorText)); } throw new Exception(String.Format("Error on line {0}:\n{1}", results.Errors[0].Line, results.Errors[0].ErrorText) + "\n" + builder.ToString()); } IO.loadTexture = (path, loop, linear) => { var bmp = GetBitmap(path); var loaded = new Texture() { bitmap = bmp, path = path, width = bmp.Width, height = bmp.Height, aspectRatio = bmp.Width / (double)bmp.Height, looped = loop, linear = linear }; script.textures.Add(loaded); return(loaded); }; IO.loadFont = (size, name, style, chars) => { var font = new Font() { charMap = chars, fontName = name, fontPixelSize = size, fontStyle = style }; script.fonts.Add(font); return(font); }; Assembly assembly = results.CompiledAssembly; var renderType = assembly.GetType("Script"); var instance = (dynamic)Activator.CreateInstance(renderType); script.instance = instance; script.renderType = renderType; IO.callLoadFunction(script.instance); if (renderType.GetField("Description") != null) { script.description = instance.Description; } if (renderType.GetField("Preview") != null) { script.preview = GetBitmap(instance.Preview); } if (renderType.GetMethod("Load") == null) { throw new Exception("Load method required"); } if (renderType.GetMethod("Render") == null) { throw new Exception("Render method required"); } if (renderType.GetMethod("RenderInit") != null) { script.hasPreRender = true; } if (renderType.GetMethod("RenderDispose") != null) { script.hasPostRender = true; } bool hasVar(string name, Type ftype) { if (renderType.GetField(name) != null) { if (ftype.IsAssignableFrom(renderType.GetField(name).FieldType)) { return(true); } } if (renderType.GetProperty(name) != null) { if (ftype.IsAssignableFrom(renderType.GetProperty(name).PropertyType)) { return(true); } } return(false); } if (hasVar("ManualNoteDelete", typeof(bool))) { script.hasManualNoteDelete = true; } if (hasVar("NoteCollectorOffset", typeof(double))) { script.hasCollectorOffset = true; } if (hasVar("NoteScreenTime", typeof(double))) { script.hasNoteScreenTime = true; } if (hasVar("LastNoteCount", typeof(long))) { script.hasNoteCount = true; } if (hasVar("UseProfiles", typeof(bool))) { script.hasProfiles = script.instance.UseProfiles; } if (hasVar("SettingsUI", typeof(IEnumerable <UISetting>))) { script.uiSettings = instance.SettingsUI; } } catch (Exception e) { if (e is TargetInvocationException) { e = e.InnerException; } script.error = true; script.description = e.Message; } finally { if (archive != null) { archive.Dispose(); } if (zrpstream != null) { zrpstream.Dispose(); } if (compress != null) { compress.Dispose(); } } return(script); }
public static byte[] Decrypt(byte[] cipherText, string sharedSecret) { if (string.IsNullOrEmpty(sharedSecret)) { throw new ArgumentNullException("sharedSecret"); } // Declare the RijndaelManaged object // used to decrypt the data. //RijndaelManaged aesAlg = null; //AesManaged aesAlg = new AesManaged(); // Declare the string used to hold // the decrypted text. List <byte> outputData = new List <byte>(); try { // generate the key from the shared secret and the salt Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, _salt); // Create a RijndaelManaged object // with the specified key and IV. //aesAlg = new RijndaelManaged(); AesManaged aesAlg = new AesManaged(); aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8); aesAlg.IV = key.GetBytes(aesAlg.BlockSize / 8); // Create a decrytor to perform the stream transform. ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); // Create the streams used for decryption. using (MemoryStream msDecrypt = new MemoryStream(cipherText)) { using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) { //using (StreamReader srDecrypt = new StreamReader(csDecrypt)) // // Read the decrypted bytes from the decrypting stream // // and place them in a string. // Convert.FromBase64String(srDecrypt.ReadToEnd()); //while (true) //{ // int b = csDecrypt.ReadByte(); // if (b != -1) // outputData.Add((byte)b); // else // break; //} using (MemoryStream outputMemoryStream = new MemoryStream()) { csDecrypt.CopyTo(outputMemoryStream); return(outputMemoryStream.ToArray()); } } } } finally { // Clear the RijndaelManaged object. //if (aesAlg != null) // aesAlg.Clear(); } }
public static void Unpack(string inputFileName, string outputDirectory, byte[] key, byte[] iv) { var info = new List <string>(); if (key.Length != 16) { throw new ApplicationException("Invalid key length"); } if (iv.Length != 16) { throw new ApplicationException("Invalid IV length"); } if (!File.Exists(inputFileName)) { throw new ApplicationException("Input file not found"); } info.Add("name " + Path.GetFileName(inputFileName)); info.Add("key " + BitConverter.ToString(key).Replace("-", "")); info.Add("iv " + BitConverter.ToString(iv).Replace("-", "")); // decrypt var decryptedData = new MemoryStream(); var aes = new RijndaelManaged { Mode = CipherMode.CFB, Key = key, IV = iv, Padding = PaddingMode.None }; var decryptor = new NoPaddingTransformWrapper(aes.CreateDecryptor()); using (var inputFile = File.OpenRead(inputFileName)) { info.Add("original.size " + inputFile.Length); info.Add("original.sha256 " + HashStream(inputFile)); using (var cryptoStream = new CryptoStream(inputFile, decryptor, CryptoStreamMode.Read)) { cryptoStream.CopyTo(decryptedData); } info.Add("decrypted.size " + decryptedData.Length); info.Add("decrypted.sha256 " + HashStream(decryptedData)); } var outputDecryptedName = Path.Combine(outputDirectory, Path.GetFileNameWithoutExtension(inputFileName)) + ".decrypted"; File.WriteAllBytes(outputDecryptedName, decryptedData.ToArray()); // First 4 bytes are unknown. The next 2 bytes are the zlib header 789C. After that the raw deflate data follows. var header = new byte[6]; if (decryptedData.Read(header, 0, header.Length) != header.Length) { throw new IOException("Did not read the full header"); } if (header[4] != 0x78 || header[5] != 0x9C)//zlib header { throw new ApplicationException("Incorrect key/iv"); } decryptedData.Position = 6; int revision; // decompress using deflate var tempFileName = Path.Combine(outputDirectory, "TempDataCenter"); using (var unpackedData = File.Create(tempFileName)) { using (var deflateStream = new DeflateStream(decryptedData, CompressionMode.Decompress, true)) { deflateStream.CopyTo(unpackedData); } info.Add("unpacked.size " + unpackedData.Length); info.Add("unpacked.sha256 " + HashStream(unpackedData)); using (var reader = new BinaryReader(unpackedData, Encoding.Unicode, true)) { unpackedData.Position = 0x0C; revision = reader.ReadInt32(); info.Insert(1, "revision " + revision); } } File.WriteAllLines(Path.ChangeExtension(outputDecryptedName, revision + ".dcinfo"), info); File.Copy(tempFileName, Path.ChangeExtension(outputDecryptedName, revision + ".unpacked"), true); File.Delete(tempFileName); File.Delete(outputDecryptedName); }
private void Decrypt(Stream dataStream, Stream destinationStream, byte[] buffer) { destinationStream.SetLength(0); using (var cryptoStream = new CryptoStream(dataStream, decryptor, CryptoStreamMode.Read)) cryptoStream.CopyTo(destinationStream, buffer); }
private void BruteForce(int currentIndex) { for (int i1 = 0; i1 < alphabet.Length; i1++) { guess[0] = alphabet[i1]; for (int i2 = 0; i2 < alphabet.Length; i2++) { guess[1] = alphabet[i2]; for (int i3 = 0; i3 < alphabet.Length; i3++) { guess[2] = alphabet[i3]; for (int i4 = 0; i4 < alphabet.Length; i4++) { guess[3] = alphabet[i4]; for (int i5 = 0; i5 < alphabet.Length; i5++) { guess[4] = alphabet[i5]; for (int i6 = 0; i6 < alphabet.Length; i6++) { guess[5] = alphabet[i6]; for (int i7 = 0; i7 < alphabet.Length; i7++) { guess[6] = alphabet[i7]; for (int i8 = 0; i8 < alphabet.Length; i8++) { guess[7] = alphabet[i8]; counter++; if (counter == 1000000) { sw.Stop(); addLog(sw.Elapsed.TotalSeconds.ToString()); return; } byte[] key = new UnicodeEncoding().GetBytes(guess); byte[] iv = new UnicodeEncoding().GetBytes(guess); var rmCrypto = new RijndaelManaged(); rmCrypto.Padding = PaddingMode.Zeros; var decryptor = rmCrypto.CreateDecryptor(key, iv); using (MemoryStream msCrypt = new MemoryStream(buffer)) { CryptoStream cs = new CryptoStream(msCrypt, decryptor, CryptoStreamMode.Read); var decrypted = new MemoryStream(); cs.CopyTo(decrypted); var decryptedArray = decrypted.ToArray(); bool result = true; for (int j = 0; j < 4; j++) { if (decryptedArray[j] != pdfSignature[j]) { result = false; } } if (result) { password = new string(guess); return; } } } } } } } } } } }
public static void Decrypt <TType>(String inFileName, String keyFileName, String outFileName) where TType : SymmetricAlgorithm, new() { Console.WriteLine("Try to decrypt data..."); try { using (FileStream inFs = new FileStream(inFileName, FileMode.Open, FileAccess.Read)) { using (TType coder = new TType()) { try { using (FileStream keyFs = new FileStream(keyFileName, FileMode.Open, FileAccess.Read)) { using (BinaryReader str = new BinaryReader(keyFs)) { string base64IV = str.ReadString(); coder.IV = Convert.FromBase64String(base64IV); string base64Key = str.ReadString(); coder.Key = Convert.FromBase64String(base64Key); } } } catch (FileNotFoundException) { Console.WriteLine("ERROR!!! - can't find key file"); return; } catch (Exception) { Console.WriteLine("ERROR!!! - can't read initialization vector or key, maybe wrong algorythm selected"); return; } using (ICryptoTransform transform = coder.CreateDecryptor()) { using (CryptoStream cs = new CryptoStream(inFs, transform, CryptoStreamMode.Read)) { using (FileStream outFs = new FileStream(outFileName, FileMode.Create, FileAccess.Write)) { cs.CopyTo(outFs); cs.Flush(); //necessary? outFs.Flush(); //necessary? } } } } } } catch (FileNotFoundException) { Console.WriteLine("ERROR!!! - encoded file is not found"); return; } catch (Exception) { Console.WriteLine("ERROR!!! - can't decode data"); return; } Console.WriteLine("Data successfully decrypted!"); }
public override int Read(byte[] buffer, int offset, int count) { //Check for bytes buffered that weren't recieved last time. //This operation shifts any unread data to the left, at position 0. long available = inputBuffer.Length - inputBuffer.Position; if (available > 0) { byte[] availableData = new byte[available]; int availableRead = inputBuffer.Read(availableData, 0, availableData.Length); //Check to be sure the available data is enough to fix on the stream. if (availableRead > 0) { //Reset the input buffer's position and write the un-read data. inputBuffer.Position = 0; inputBuffer.Write(availableData, 0, availableRead); //Reset the length and position to match the unread data's length. inputBuffer.SetLength(availableRead); inputBuffer.Position = availableRead; } } else { //No bytes were missed last read, reset the stream. inputBuffer.Position = 0; inputBuffer.SetLength(0); } //While we don't have enough bytes for the upper-level stream, read more from the network. while (inputBuffer.Length < count) { //Read in the encrypted data. BinaryReader binaryReader = new BinaryReader(baseStream); byte[] encryptedBuffer = Packet.ReadBytes(binaryReader); //Read in the HMAC and ensure the data has not been tampered. byte[] hmac = new byte[inputHmac.HashSize / 8]; baseStream.Read(hmac, 0, hmac.Length); if (!inputHmac.ComputeHash(encryptedBuffer).SequenceEqual(hmac)) { throw new SecurityException("Recieved HMAC does not match expected cryptographic digest."); } //Create a new crypto stream around an array of bytes on the underlying stream. CryptoStream cryptoStream = new CryptoStream( new MemoryStream( encryptedBuffer ), symmetricKeyPair.Remote.CreateDecryptor(), CryptoStreamMode.Read ); //Copy the decompressed bytes to the input buffer. cryptoStream.CopyTo(inputBuffer); //Dispose of the data. cryptoStream.Dispose(); } //Reset the position of the input buffer, now full of fresh data. inputBuffer.Position = 0; //Return the data required by the operation to the upper-level. return(inputBuffer.Read(buffer, offset, count)); }
private static void TestAesDecrypt( CipherMode mode, byte[] key, byte[] iv, byte[] encryptedBytes, byte[] expectedAnswer) { byte[] decryptedBytes; using (Aes aes = AesFactory.Create()) { aes.Mode = mode; aes.Key = key; if (iv != null) { aes.IV = iv; } using (MemoryStream input = new MemoryStream(encryptedBytes)) using (CryptoStream cryptoStream = new CryptoStream(input, aes.CreateDecryptor(), CryptoStreamMode.Read)) using (MemoryStream output = new MemoryStream()) { cryptoStream.CopyTo(output); decryptedBytes = output.ToArray(); } } Assert.NotEqual(encryptedBytes, decryptedBytes); Assert.Equal(expectedAnswer, decryptedBytes); }
private static void RandomKeyRoundtrip(Aes aes) { byte[] decryptedBytes; byte[] encryptedBytes; using (MemoryStream input = new MemoryStream(s_multiBlockBytes)) using (CryptoStream cryptoStream = new CryptoStream(input, aes.CreateEncryptor(), CryptoStreamMode.Read)) using (MemoryStream output = new MemoryStream()) { cryptoStream.CopyTo(output); encryptedBytes = output.ToArray(); } Assert.NotEqual(s_multiBlockBytes, encryptedBytes); using (MemoryStream input = new MemoryStream(encryptedBytes)) using (CryptoStream cryptoStream = new CryptoStream(input, aes.CreateDecryptor(), CryptoStreamMode.Read)) using (MemoryStream output = new MemoryStream()) { cryptoStream.CopyTo(output); decryptedBytes = output.ToArray(); } Assert.Equal(s_multiBlockBytes, decryptedBytes); }
public static void AesZeroPad() { byte[] decryptedBytes; byte[] expectedAnswer; using (Aes aes = AesFactory.Create()) { aes.Padding = PaddingMode.Zeros; int blockBytes = aes.BlockSize / 8; int missingBytes = blockBytes - (s_multiBlockBytes.Length % blockBytes); // Zero-padding doesn't have enough information to remove the trailing zeroes. // Therefore we expect the answer of ZeroPad(s_multiBlockBytes). // So, make a long enough array, and copy s_multiBlockBytes to the beginning of it. expectedAnswer = new byte[s_multiBlockBytes.Length + missingBytes]; Buffer.BlockCopy(s_multiBlockBytes, 0, expectedAnswer, 0, s_multiBlockBytes.Length); byte[] encryptedBytes; using (MemoryStream input = new MemoryStream(s_multiBlockBytes)) using (CryptoStream cryptoStream = new CryptoStream(input, aes.CreateEncryptor(), CryptoStreamMode.Read)) using (MemoryStream output = new MemoryStream()) { cryptoStream.CopyTo(output); encryptedBytes = output.ToArray(); } using (MemoryStream input = new MemoryStream(encryptedBytes)) using (CryptoStream cryptoStream = new CryptoStream(input, aes.CreateDecryptor(), CryptoStreamMode.Read)) using (MemoryStream output = new MemoryStream()) { cryptoStream.CopyTo(output); decryptedBytes = output.ToArray(); } } Assert.Equal(expectedAnswer, decryptedBytes); }
public static void WrongKeyFailDecrypt_2() { // The test: // Using the encrypted bytes from the AES-192-ECB test, try decrypting // with the first 192 bits from the AES-256-CBC test. That would only work if // the implementation of AES was "return s_multiBlockBytes". // For this specific key/data combination, we actually expect a padding exception. byte[] encryptedBytes = new byte[] { 0xC9, 0x7F, 0xA5, 0x5B, 0xC3, 0x92, 0xDC, 0xA6, 0xE4, 0x9F, 0x2D, 0x1A, 0xEF, 0x7A, 0x27, 0x03, 0x04, 0x9C, 0xFB, 0x56, 0x63, 0x38, 0xAE, 0x4F, 0xDC, 0xF6, 0x36, 0x98, 0x28, 0x05, 0x32, 0xE9, 0xF2, 0x6E, 0xEC, 0x0C, 0x04, 0x9D, 0x12, 0x17, 0x18, 0x35, 0xD4, 0x29, 0xFC, 0x01, 0xB1, 0x20, 0xFA, 0x30, 0xAE, 0x00, 0x53, 0xD4, 0x26, 0x25, 0xA4, 0xFD, 0xD5, 0xE6, 0xED, 0x79, 0x35, 0x2A, 0xE2, 0xBB, 0x95, 0x0D, 0xEF, 0x09, 0xBB, 0x6D, 0xC5, 0xC4, 0xDB, 0x28, 0xC6, 0xF4, 0x31, 0x33, 0x9A, 0x90, 0x12, 0x36, 0x50, 0xA0, 0xB7, 0xD1, 0x35, 0xC4, 0xCE, 0x81, 0xE5, 0x2B, 0x85, 0x6B, }; byte[] decryptedBytes; // Load key as the first 192 bits of s_aes256Key. // It has the correct cipher block size, but the wrong value. byte[] key = new byte[s_aes192Key.Length]; Buffer.BlockCopy(s_aes256Key, 0, key, 0, key.Length); using (Aes aes = AesFactory.Create()) { aes.Mode = CipherMode.ECB; aes.Key = key; Assert.Throws<CryptographicException>(() => { using (MemoryStream input = new MemoryStream(encryptedBytes)) using (CryptoStream cryptoStream = new CryptoStream(input, aes.CreateDecryptor(), CryptoStreamMode.Read)) using (MemoryStream output = new MemoryStream()) { cryptoStream.CopyTo(output); decryptedBytes = output.ToArray(); } }); } }