Stream BuildStreamOnUnderlyingIStream( IStream underlyingIStream, FileAccess access, StreamInfo parent) { Stream rawStream = new CFStream(underlyingIStream, access, parent); if (null == core.dataSpaceLabel) { // The stream is not transformed in any data space, add buffering and return return(new BufferedStream(rawStream)); } else { // Pass raw stream to data space manager to get real stream return(parentStorage.Root.GetDataSpaceManager().CreateDataSpaceStream( StreamReference, rawStream)); } }
public void Test_ADD_LARGE_NUMBER_OF_ITEMS() { int ITEM_NUMBER = 10000; CompoundFile f = null; byte[] buffer = Helpers.GetBuffer(10, 0x0A); try { f = new CompoundFile(); for (int i = 0; i < ITEM_NUMBER; i++) { CFStream st = f.RootStorage.AddStream("Stream" + i.ToString()); st.Append(buffer); } if (File.Exists("$ItemsLargeNumber.cfs")) { File.Delete("$ItemsLargeNumber.cfs"); } f.Save("$ItemsLargeNumber.cfs"); f.Close(); f = new CompoundFile("$ItemsLargeNumber.cfs"); CFStream cfs = f.RootStorage.GetStream("Stream" + (ITEM_NUMBER / 2).ToString()); Assert.IsTrue(cfs != null, "Item is null"); Assert.IsTrue(Helpers.CompareBuffer(cfs.GetData(), buffer), "Items are different"); f.Close(); } catch (Exception ex) { Assert.Fail(ex.Message); } finally { //if (File.Exists("$ItemsLargeNumber.cfs")) // File.Delete("$ItemsLargeNumber.cfs"); } }
/// <summary> /// Добавить поток с указанными зашифрованными данными в указанный каталог файла MCDF. /// </summary> /// <param name="dir">Каталог, в который необходимо добавить поток</param> /// <param name="data">Данные в виде массива байт</param> /// <param name="diskKey">Ключ</param> /// <param name="diskTable">Таблица</param> /// <returns></returns> private static CFStream AddStream(CFStorage dir, byte[] data, byte[] diskKey, byte[] diskTable) { // сгенерировать синхропосылку byte[] synchroArr = GenerateSynchro(); byte[] imito; // зашифровать данные и получить от них хеш Mathdll.CryptData(diskKey, diskTable, synchroArr, ref data, out imito); // создать поток с именем, являющимся 16-тиричным представлением массива байт - imito CFStream stream = dir.AddStream(ReadKey.BinToHex(imito)); // создать бефер для объединения данных и синхропосылки byte[] buffer = new byte[data.Length + synchroArr.Length]; Array.Copy(data, 0, buffer, 0, data.Length); Array.Copy(synchroArr, 0, buffer, data.Length, synchroArr.Length); // записать данные в поток stream.SetData(buffer); // return(stream); }
static public byte[] SendFile(HttpListenerRequest request) { Console.WriteLine("Serving request from " + request.RemoteEndPoint.ToString() + " with user agent " + request.UserAgent); CompoundFile cf = null; try { cf = new CompoundFile(outFilename, CFSUpdateMode.Update, 0); } catch (Exception e) { Console.WriteLine("ERROR: Could not open file " + outFilename); Console.WriteLine("Please make sure this file exists and is .docm or .xlsm file or a .doc in the Office 97-2003 format."); Console.WriteLine(); Console.WriteLine(e.Message); } CFStream streamData = cf.RootStorage.GetStorage("Macros").GetStorage("VBA").GetStream("_VBA_PROJECT"); byte[] streamBytes = streamData.GetData(); string UACpu = ""; if (request.Headers["UA-CPU"] != null) { UACpu = request.Headers["UA-CPU"]; } string targetOfficeVersion = UserAgentToOfficeVersion(request.UserAgent, UACpu); ReplaceOfficeVersionInVBAProject(streamBytes, targetOfficeVersion); cf.RootStorage.GetStorage("Macros").GetStorage("VBA").GetStream("_VBA_PROJECT").SetData(streamBytes); // Commit changes and close file cf.Commit(); cf.Close(); Console.WriteLine("Serving out file '" + outFilename + "'"); return(File.ReadAllBytes(outFilename)); }
public void Test_RESIZE_STREAM_NO_TRANSITION() { CompoundFile cf = null; //CFStream st = null; byte[] b = Helpers.GetBuffer(1024 * 1024 * 2); //2MB buffer cf = new CompoundFile(CFSVersion.Ver_3, CFSConfiguration.Default); cf.RootStorage.AddStream("AStream").SetData(b); cf.Save("$Test_RESIZE_STREAM.cfs"); cf.Close(); cf = new CompoundFile("$Test_RESIZE_STREAM.cfs", CFSUpdateMode.Update, CFSConfiguration.SectorRecycle); CFStream item = cf.RootStorage.GetStream("AStream"); item.Resize(item.Size / 2); //cf.RootStorage.AddStream("BStream").SetData(b); cf.Commit(true); cf.Close(); }
/// <summary> /// Read each entry in the Entry Stream /// </summary> /// <returns></returns> private List <EntryStreamData> ReadEntryStream() { List <EntryStreamData> entries = new List <EntryStreamData>(); CFStream entryStream = _compoundFile.RootStorage.GetStorage(STORAGE_NAME).GetStream(EntryStreamData.STREAM_NAME); byte[] data = entryStream.GetData(); int numberOfEntries = data.Length / 8; for (int i = 0; i < numberOfEntries; i++) { EntryStreamData es = new EntryStreamData(); es.NameIdentifier = BitConverter.ToInt32(data, i * 8); es.GUIDIndex = BitConverter.ToInt16(data, (i * 8) + 4); es.PropertyIndex = BitConverter.ToInt16(data, (i * 8) + 6); es.IsString = es.GUIDIndex % 2 == 1; //is a string es.GUIDIndex = (short)(es.GUIDIndex >> 1); //cut off the last bit entries.Add(es); } return(entries); }
/// <summary> /// Сформировать HTML разметку из данных, считанных и расшифрованных из файла MCDF. /// </summary> /// <param name="file">Файл источник (хранилище)</param> /// <param name="fileUri">Ссылка на поток в файле</param> /// <param name="diskKey">Ключ</param> /// <param name="diskTable">Таблица</param> /// <returns></returns> public static string GetHTML(CompoundFile file, string fileUri, byte[] diskKey, byte[] diskTable) { string[] uri = fileUri.Split(':'); if (uri.Length != 2) { return(null); } string xslPath; switch (uri[0]) { case "svd": xslPath = @"styles\svod_style"; break; case "ops": xslPath = @"styles\szv_opis_style"; break; case "ind": xslPath = @"styles\szv_style"; break; default: xslPath = null; break; } if (xslPath == null) { return(null); } CFStream xmlStream = GetFileStream(file, uri[1]); CFStream xslStream = GetFileStream(file, xslPath); byte[] xmlData = DecryptStream(xmlStream, diskKey, diskTable); byte[] xslData = DecryptStream(xslStream, diskKey, diskTable); string resHTML = XmlData.GetHTML(xmlData, xslData); // return(resHTML); }
private void ChangeTreeViewNode(TreeNode newNode) { if (newNode == null) { return; } if (hexEditor.ByteProvider != null && hexEditor.ByteProvider.HasChanges()) { if (MessageBox.Show("Do you want to save pending changes ?", "Save changes", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes) { hexEditor.ByteProvider.ApplyChanges(); } } treeView1.SelectedNode = newNode; // The tag property contains the underlying CFItem. CFItem target = (CFItem)newNode.Tag; if (target.IsStream) { addStorageStripMenuItem1.Enabled = false; addStreamToolStripMenuItem.Enabled = false; importDataStripMenuItem1.Enabled = true; exportDataToolStripMenuItem.Enabled = true; } else { addStorageStripMenuItem1.Enabled = true; addStreamToolStripMenuItem.Enabled = true; importDataStripMenuItem1.Enabled = false; exportDataToolStripMenuItem.Enabled = false; } propertyGrid1.SelectedObject = newNode.Tag; CFStream targetStream = newNode.Tag as CFStream; hexEditor.ByteProvider = targetStream != null ? new StreamDataProvider(targetStream) : null; }
public void Test_DELETE_STREAM_SECTOR_REUSE() { CompoundFile cf = null; CFStream st = null; byte[] b = Helpers.GetBuffer(1024 * 1024 * 2); //2MB buffer byte[] cmp = new byte[] { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 }; cf = new CompoundFile(CFSVersion.Ver_4, CFSConfiguration.Default); st = cf.RootStorage.AddStream("AStream"); st.Append(b); cf.Save("SectorRecycle.cfs"); cf.Close(); cf = new CompoundFile("SectorRecycle.cfs", CFSUpdateMode.Update, CFSConfiguration.SectorRecycle); cf.RootStorage.Delete("AStream"); cf.Commit(true); cf.Close(); cf = new CompoundFile("SectorRecycle.cfs", CFSUpdateMode.ReadOnly, CFSConfiguration.Default); //No sector recycle st = cf.RootStorage.AddStream("BStream"); st.Append(Helpers.GetBuffer(1024 * 1024 * 1)); cf.Save("SectorRecycleLarger.cfs"); cf.Close(); Assert.IsFalse((new FileInfo("SectorRecycle.cfs").Length) >= (new FileInfo("SectorRecycleLarger.cfs").Length)); cf = new CompoundFile("SectorRecycle.cfs", CFSUpdateMode.ReadOnly, CFSConfiguration.SectorRecycle); st = cf.RootStorage.AddStream("BStream"); st.Append(Helpers.GetBuffer(1024 * 1024 * 1)); cf.Save("SectorRecycleSmaller.cfs"); cf.Close(); long larger = (new FileInfo("SectorRecycle.cfs").Length); long smaller = (new FileInfo("SectorRecycleSmaller.cfs").Length); Assert.IsTrue(larger >= smaller, "Larger size:" + larger.ToString() + " - Smaller size:" + smaller.ToString()); }
public void WriteDocument(string filePath, byte[] wbBytes) { CompoundFile cf = new CompoundFile(); //Can be Book or Workbook CFStream workbookStream = cf.RootStorage.AddStream("Workbook"); workbookStream.Write(wbBytes, 0); OLEPropertiesContainer dsiContainer = new OLEPropertiesContainer(1252, ContainerType.DocumentSummaryInfo); OLEPropertiesContainer siContainer = new OLEPropertiesContainer(1252, ContainerType.SummaryInfo); //TODO [Stealth] Fill these streams with the expected data information, don't leave them empty CFStream dsiStream = cf.RootStorage.AddStream("\u0005DocumentSummaryInformation"); byte[] cfStreamBytes = new byte[] { 0xFE, 0xFF, 0x00, 0x00, 0x06, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xE0, 0x85, 0x9F, 0xF2, 0xF9, 0x4F, 0x68, 0x10, 0xAB, 0x91, 0x08, 0x00, 0x2B, 0x27, 0xB3, 0xD9, 0x30, 0x00, 0x00, 0x00, 0xB0, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x9C, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xE4, 0x04, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x55, 0x73, 0x65, 0x72, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x55, 0x73, 0x65, 0x72, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20, 0x45, 0x78, 0x63, 0x65, 0x6C, 0x00, 0x40, 0x00, 0x00, 0x00, 0x80, 0x45, 0xA1, 0x6B, 0x7B, 0x93, 0xD6, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0xD3, 0x32, 0xDA, 0x7C, 0x93, 0xD6, 0x01, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; dsiContainer.Save(dsiStream); CFStream siStream = cf.RootStorage.AddStream("\u0005SummaryInformation"); // siStream.SetData(cfStreamBytes); siContainer.Save(siStream); cf.Save(filePath); }
public bool CheckForVBAMacros(string path) { try { CompoundFile cf = new CompoundFile(path); // This line throws an exception if there is no _VBA_PROJECT_CUR/VBA/dir stream in the OLE. // _VBA_PROJECT_CUR/VBA/dir has to be in an OLE if it contains a VBA macro // https://docs.microsoft.com/en-us/openspecs/office_file_formats/ms-ovba/005bffd7-cd96-4f25-b75f-54433a646b88 if (path.ToLower().EndsWith(".xls")) { CFStream dirStream = cf.RootStorage.GetStorage("_VBA_PROJECT_CUR").GetStorage("VBA").GetStream("dir"); } else { // .doc CFStream dirStream = cf.RootStorage.GetStorage("Macros").GetStorage("VBA").GetStream("dir"); } return(true); } catch (Exception) { return(false); } }
public static string GetText(ref CompoundFile cf, CFNode nodo) { string a = Path.GetExtension(nodo.Name).ToLower(); CFStream stream = CFUtil.GetStream(ref cf, nodo.Path, nodo.Name); MemoryStream input = MSUtil.CFtoMStream(stream); MemoryStream stream2; if (a == "") { stream2 = MSUtil.RemoveTrailingSegment(input, 12); } else if (MSUtil.IsCompressedWithLW77(stream)) { stream2 = MSUtil.UncompressLW77(input); } else { stream2 = MSUtil.RemoveTrailingSegment(input, 8); } return(new StreamReader(stream2, (a == ".csv") ? Encoding.ASCII : Encoding.Unicode).ReadToEnd()); }
/// <summary> /// Indicates if a Compound File stream is an image. /// </summary> /// <param name="ms"></param> /// <returns>0: Unknown - 1: BMP - 2: JPEG</returns> public static int VerifyIfImage(CFStream ms) { byte[] buffer = new byte[20]; ms.Read(buffer, 0L, 20); if (buffer[10] == 0xFF & buffer[11] == 0xD8 & buffer[12] == 0xFF & buffer[13] == 0xE0) { // It's BMP return(1); } else if (buffer[8] == 0xFF & buffer[9] == 0xD8 & buffer[10] == 0xFF & buffer[11] == 0xE0) { // It's JPEG return(2); } else if ((buffer[10] == 0x42) & (buffer[11] == 0x4D)) { // It's BMP return(1); } return(0); }
public void WriteDocument(string filePath, byte[] wbBytes) { CompoundFile cf = new CompoundFile(); CFStream workbookStream = cf.RootStorage.AddStream("Workbook"); workbookStream.Write(wbBytes, 0); OLEPropertiesContainer dsiContainer = new OLEPropertiesContainer(1252, ContainerType.DocumentSummaryInfo); OLEPropertiesContainer siContainer = new OLEPropertiesContainer(1252, ContainerType.SummaryInfo); //TODO [Stealth] Fill these streams with the expected data information, don't leave them empty CFStream dsiStream = cf.RootStorage.AddStream("\u0005DocumentSummaryInformation"); dsiContainer.Save(dsiStream); CFStream siStream = cf.RootStorage.AddStream("\u0005SummaryInformation"); siContainer.Save(siStream); cf.Save(filePath); }
private void importDataStripMenuItem1_Click(object sender, EventArgs e) { string fileName = String.Empty; if (openDataFileDialog.ShowDialog() == DialogResult.OK) { CFStream s = treeView1.SelectedNode.Tag as CFStream; if (s != null) { FileStream f = new FileStream(openDataFileDialog.FileName, FileMode.Open, FileAccess.Read, FileShare.Read); byte[] data = new byte[f.Length]; f.Read(data, 0, (int)f.Length); f.Flush(); f.Close(); s.SetData(data); RefreshTree(); } } }
public void Test_APPEND_DATA_TO_STREAM() { MemoryStream ms = new MemoryStream(); byte[] b = new byte[] { 0x0, 0x1, 0x2, 0x3 }; byte[] b2 = new byte[] { 0x4, 0x5, 0x6, 0x7 }; CompoundFile cf = new CompoundFile(); CFStream st = cf.RootStorage.AddStream("MyMiniStream"); st.SetData(b); st.Append(b2); cf.Save(ms); cf.Close(); byte[] cmp = new byte[] { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 }; cf = new CompoundFile(ms); byte[] data = cf.RootStorage.GetStream("MyMiniStream").GetData(); Assert.IsTrue(Helpers.CompareBuffer(cmp, data)); }
private ActionResult GetTemplateFile(HttpRequest request, string filename) { if (request.Headers.ContainsKey(HeaderNames.UserAgent)) { Console.WriteLine("Serving request from " + request.HttpContext.Connection.RemoteIpAddress + " with user agent " + request.Headers[HeaderNames.UserAgent]); CompoundFile cf = null; try { cf = new CompoundFile(filename, CFSUpdateMode.Update, 0); } catch (Exception e) { Console.WriteLine("ERROR: Could not open file " + filename); Console.WriteLine("Please make sure this file exists and is .docm or .xlsm file or a .doc in the Office 97-2003 format."); Console.WriteLine(); Console.WriteLine(e.Message); } CFStream streamData = cf.RootStorage.GetStorage("Macros").GetStorage("VBA").GetStream("_VBA_PROJECT"); byte[] streamBytes = streamData.GetData(); string targetOfficeVersion = UserAgentToOfficeVersion(request.Headers[HeaderNames.UserAgent]); ReplaceOfficeVersionInVBAProject(streamBytes, targetOfficeVersion); cf.RootStorage.GetStorage("Macros").GetStorage("VBA").GetStream("_VBA_PROJECT").SetData(streamBytes); // Commit changes and close file cf.Commit(); cf.Close(); Console.WriteLine("Serving out file '" + filename + "'"); return(File(System.IO.File.ReadAllBytes(filename), GetMime(filename))); } else { return(NotFound()); } }
static public byte[] SendFile(HttpListenerRequest request) { Console.WriteLine("Serving request from " + request.RemoteEndPoint.ToString() + " with user agent " + request.UserAgent); CompoundFile cf = new CompoundFile(filename, CFSUpdateMode.Update, 0); CFStream streamData = cf.RootStorage.GetStorage("Macros").GetStorage("VBA").GetStream("_VBA_PROJECT"); byte[] streamBytes = streamData.GetData(); string targetOfficeVersion = UserAgentToOfficeVersion(request.UserAgent); ReplaceOfficeVersionInVBAProject(streamBytes, targetOfficeVersion); cf.RootStorage.GetStorage("Macros").GetStorage("VBA").GetStream("_VBA_PROJECT").SetData(streamBytes); // Commit changes and close file cf.Commit(); cf.Close(); return(File.ReadAllBytes(filename)); }
protected static void Visit(CFItem item) { Console.WriteLine(String.Format("Item: {0}. Is Storage: {1}. Is Stream: {2}", item.Name, item.IsStorage, item.IsStream)); if (item.IsStorage) { CFStorage storage = (CFStorage)item; Console.WriteLine("Visiting Children of storage " + storage.Name); storage.VisitEntries(Visit, false); } if (item.IsStream && item.Name == "ThisWorkbook") { Console.WriteLine("Parsing ThisWorkbook"); CFStream stream = (CFStream)item; byte[] data = stream.GetData(); File.WriteAllBytes("ThisWorkbook.bin", data); } }
public VbaStorage(CompoundFile VbaBinFile) { this.m_disposable = VbaBinFile; // _VBA_PROJECT stream var VBAStorage = VbaBinFile.RootStorage.GetStorage("VBA"); this._VBA_PROJECTStream = ReadVbaProjectStream(VBAStorage); // DIR STREAM ------------------------- CFStream thisWorkbookStream = VBAStorage.GetStream("dir"); Byte[] compressedData = thisWorkbookStream.GetData(); Byte[] uncompressed = XlCompressionAlgorithm.Decompress(compressedData); var uncompressedDataReader = new XlBinaryReader(ref uncompressed); this.DirStream = new DirStream(uncompressedDataReader); // MODULE STREAMS ---------------------------------------- this._ModuleStreams = new Dictionary <string, ModuleStream>(DirStream.ModulesRecord.Modules.Length); this.ModuleStreams = new ReadOnlyDictionary <string, ModuleStream>(this._ModuleStreams); foreach (var module in DirStream.ModulesRecord.Modules) { var streamName = module.StreamNameRecord.GetStreamNameAsString(); var stream = VBAStorage.GetStream(streamName).GetData(); var localreader = new XlBinaryReader(ref stream); var moduleStream = new ModuleStream(DirStream.InformationRecord, module, localreader); this._ModuleStreams.Add(streamName, moduleStream); } // PROJECT stream CFStream ProjectStorage = VbaBinFile.RootStorage.GetStream("PROJECT"); this.ProjectStream = ReadProjectStream(ProjectStorage, this.DirStream.InformationRecord.CodePageRecord); }
public void Test_FIX_BUG_GH_15() { String filename = "MyFile.dat"; String storageName = "MyStorage"; String streamName = "MyStream"; int BUFFER_SIZE = 800 * Mb; int iterationCount = 6; int streamCount = 1; CompoundFile compoundFile = new CompoundFile(CFSVersion.Ver_4, CFSConfiguration.Default); CFStorage st = compoundFile.RootStorage.AddStorage(storageName); for (int streamId = 0; streamId < streamCount; ++streamId) { CFStream sm = st.AddStream(streamName + streamId); for (int iteration = 0; iteration < iterationCount; ++iteration) { byte b = (byte)(0x0A + iteration); sm.Append(Helpers.GetBuffer(BUFFER_SIZE, b)); } } compoundFile.Save(filename); compoundFile.Close(); byte[] readBuffer = new byte[15]; compoundFile = new CompoundFile(filename); byte c = 0x0A; for (int i = 0; i < iterationCount; i++) { compoundFile.RootStorage.GetStorage(storageName).GetStream(streamName + 0.ToString()).Read(readBuffer, ((long)BUFFER_SIZE + ((long)BUFFER_SIZE * i)) - 15, 15); Assert.IsTrue(readBuffer.All(by => by == c)); c++; } compoundFile.Close(); }
public void Perf_SteamOfLargeFile() { if (!File.Exists(_fileName)) { Helpers.CreateFile(_fileName); } using (var cf = new CompoundFile(_fileName)) { Stopwatch sw = new Stopwatch(); sw.Start(); CFStream s = cf.RootStorage.GetStream("Test1"); sw.Stop(); var executionTime = sw.ElapsedMilliseconds; for (int i = 0; i < sw.ElapsedMilliseconds; i++) { _testCounter.Increment(); } Console.WriteLine($"Took {executionTime} seconds"); } }
public void Test_WRITE_READ_CFS_VERSION_4_STREAM() { String filename = "WRITE_COMMIT_READ_CFS_V4.cfs"; CompoundFile cf = new CompoundFile(CFSVersion.Ver_4, CFSConfiguration.SectorRecycle | CFSConfiguration.EraseFreeSectors); CFStorage st = cf.RootStorage.AddStorage("MyStorage"); CFStream sm = st.AddStream("MyStream"); byte[] b = Helpers.GetBuffer(227); sm.SetData(b); cf.Save(filename); cf.Close(); CompoundFile cf2 = new CompoundFile(filename); CFStorage st2 = cf2.RootStorage.GetStorage("MyStorage"); CFStream sm2 = st2.GetStream("MyStream"); Assert.IsNotNull(sm2); Assert.IsTrue(sm2.Size == b.Length); cf2.Close(); }
public void Test_WRITE_AND_READ_CFS_VERSION_4() { String filename = "WRITE_AND_READ_CFS_V4.cfs"; CompoundFile cf = new CompoundFile(CFSVersion.Ver_4, CFSConfiguration.EraseFreeSectors | CFSConfiguration.SectorRecycle); CFStorage st = cf.RootStorage.AddStorage("MyStorage"); CFStream sm = st.AddStream("MyStream"); byte[] b = new byte[220]; sm.SetData(b); cf.Save(filename); cf.Close(); CompoundFile cf2 = new CompoundFile(filename); CFStorage st2 = cf2.RootStorage.GetStorage("MyStorage"); CFStream sm2 = st2.GetStream("MyStream"); Assert.IsNotNull(sm2); Assert.IsTrue(sm2.Size == 220); cf2.Close(); }
public void Test_FIX_BUG_31() { CompoundFile cf = new CompoundFile(); cf.RootStorage.AddStorage("Level_1") .AddStream("Level2Stream") .SetData(Helpers.GetBuffer(100)); cf.Save("$Hel1"); cf.Close(); CompoundFile cf1 = new CompoundFile("$Hel1"); try { CFStream cs = cf1.RootStorage.GetStorage("Level_1").AddStream("Level2Stream"); } catch (Exception ex) { Assert.IsTrue(ex.GetType() == typeof(CFDuplicatedItemException)); } }
public OLECompoundFileInfo(string FileToScan, ref XMLParser raport) { CompoundFile file = new CompoundFile(FileToScan); CFStream summaryinformation = file.RootStorage.GetStream("\u0005SummaryInformation"); PropertySetStream propertySetStream = summaryinformation.AsOLEProperties(); raport.InitializeOle(); for (int i = 0; i < propertySetStream.PropertySet0.NumProperties; i++) { raport.AddSummInfoAtt(propertySetStream.PropertySet0.PropertyIdentifierAndOffsets.ElementAt(i).PropertyIdentifier, propertySetStream.PropertySet0.Properties[i].Value.ToString()); } CFStream documentSummaryinformation = file.RootStorage.TryGetStream("\u0005DocumentSummaryInformation"); if (documentSummaryinformation != null) { PropertySetStream propertyDSSetStream = documentSummaryinformation.AsOLEProperties(); raport.InitializeDocOle(); for (int i = 0; i < propertyDSSetStream.PropertySet0.NumProperties; i++) { raport.AddDocSummInfoAtt(propertyDSSetStream.PropertySet0.PropertyIdentifierAndOffsets.ElementAt(i).PropertyIdentifier, propertyDSSetStream.PropertySet0.Properties[i].Value.ToString()); } } }
public static byte[] GetStructuredStorageStream(string filePath, string streamName) { logger.Debug(string.Format("Attempting to read \"{0}\" stream from structured storage file at \"{1}\"", streamName, filePath)); int res = StgIsStorageFile(filePath); if (res == 0) { CompoundFile cf = new CompoundFile(filePath); CFStream foundStream = cf.RootStorage.TryGetStream(streamName); if (foundStream != null) { byte[] streamData = foundStream.GetData(); cf.Close(); return(streamData); } return(null); } else { throw new NotSupportedException("File is not a structured storage file"); } }
public void Test_DIFAT_CHECK() { CompoundFile f = null; try { f = new CompoundFile(); CFStream st = f.RootStorage.AddStream("LargeStream"); st.Append(Helpers.GetBuffer(20000000, 0x0A)); //Forcing creation of two DIFAT sectors byte[] b1 = Helpers.GetBuffer(3, 0x0B); st.Append(b1); //Forcing creation of two DIFAT sectors f.Save("$OpenMcdf$LargeFile.cfs"); f.Close(); int cnt = 3; f = new CompoundFile("$OpenMcdf$LargeFile.cfs"); byte[] b2 = new byte[cnt]; cnt = f.RootStorage.GetStream("LargeStream").Read(b2, 20000000, cnt); f.Close(); Assert.IsTrue(Helpers.CompareBuffer(b1, b2)); } finally { if (f != null) { f.Close(); } if (File.Exists("$OpenMcdf$LargeFile.cfs")) { File.Delete("$OpenMcdf$LargeFile.cfs"); } } }
public void CreateResponseAuth() { CFHTTPMessage response = null; var done = false; var taskCompletionSource = new TaskCompletionSource <CFHTTPMessage> (); // the following code has to be in a diff thread, else, we are blocking the current loop, not cool // perform a request so that we fail in the auth, then create the auth object and check the count TestRuntime.RunAsync(DateTime.Now.AddSeconds(30), async() => { using (var request = CFHTTPMessage.CreateRequest( new Uri(NetworkResources.Httpbin.GetStatusCodeUrl(HttpStatusCode.Unauthorized)), "GET", null)) { request.SetBody(Array.Empty <byte> ()); // empty body, we are not interested using (var stream = CFStream.CreateForHTTPRequest(request)) { Assert.IsNotNull(stream, "Null stream"); // we are only interested in the completed event stream.ClosedEvent += (sender, e) => { taskCompletionSource.SetResult(stream.GetResponseHeader()); done = true; }; // enable events and run in the current loop stream.EnableEvents(CFRunLoop.Main, CFRunLoop.ModeDefault); stream.Open(); response = await taskCompletionSource.Task; } } }, () => done); if (!done) { TestRuntime.IgnoreInCI("Transient network failure - ignore in CI"); } Assert.IsTrue(done, "Network request completed"); using (var auth = CFHTTPAuthentication.CreateFromResponse(response)) { Assert.NotNull(auth, "Null Auth"); Assert.IsTrue(auth.IsValid, "Auth is valid"); Assert.That(TestRuntime.CFGetRetainCount(auth.Handle), Is.EqualTo((nint)1), "RetainCount"); } }
static void SetSolutionConfigValue(CFStream cfStream, IEnumerable <string> startupProjectGuids) { var single = Encoding.GetEncodings().Single(x => string.Equals(x.Name, "utf-16", StringComparison.OrdinalIgnoreCase)); var encoding = single.GetEncoding(); var nul = '\u0000'; var dc1 = '\u0011'; var etx = '\u0003'; var soh = '\u0001'; var builder = new StringBuilder(); builder.Append(dc1); builder.Append(nul); builder.Append("MultiStartupProj"); builder.Append(nul); builder.Append('='); builder.Append(etx); builder.Append(soh); builder.Append(nul); builder.Append(';'); foreach (var startupProjectGuid in startupProjectGuids) { builder.Append('4'); builder.Append(nul); builder.AppendFormat("{{{0}}}.dwStartupOpt", startupProjectGuid); builder.Append(nul); builder.Append('='); builder.Append(etx); builder.Append(dc1); builder.Append(nul); builder.Append(';'); } var newBytes = encoding.GetBytes(builder.ToString()); cfStream.SetData(newBytes); }
void HandleErrorEvent (object sender, CFStream.StreamEventArgs e) { var stream = (CFHTTPStream)sender; StreamBucket bucket; if (!streamBuckets.TryGetValue (stream.Handle, out bucket)) return; bucket.Response.TrySetException (stream.GetError ()); CloseStream (stream); }
void HandleClosedEvent (object sender, CFStream.StreamEventArgs e) { var stream = (CFHTTPStream)sender; CloseStream (stream); }
void HandleHasBytesAvailableEvent (object sender, CFStream.StreamEventArgs e) { var stream = (CFHTTPStream) sender; StreamBucket bucket; if (!streamBuckets.TryGetValue (stream.Handle, out bucket)) return; if (bucket.Response.Task.IsCompleted) { bucket.ContentStream.ReadStreamData (); return; } var header = stream.GetResponseHeader (); // Is this possible? if (!header.IsHeaderComplete) throw new NotImplementedException (); bucket.ContentStream = new CFContentStream (stream); var response_msg = new HttpResponseMessage (header.ResponseStatusCode); response_msg.RequestMessage = bucket.Request; response_msg.ReasonPhrase = header.ResponseStatusLine; response_msg.Content = bucket.ContentStream; var fields = header.GetAllHeaderFields (); if (fields != null) { foreach (var entry in fields) { if (entry.Key == null) continue; var key = entry.Key.ToString (); var value = entry.Value == null ? string.Empty : entry.Value.ToString (); HttpHeaders item_headers; if (HttpHeaders.GetKnownHeaderKind (key) == Headers.HttpHeaderKind.Content) { item_headers = response_msg.Content.Headers; } else { item_headers = response_msg.Headers; if (cookies != null && (key == "Set-Cookie" || key == "Set-Cookie2")) AddCookie (value, bucket.Request.RequestUri, key); } item_headers.TryAddWithoutValidation (key, value); } } bucket.Response.TrySetResult (response_msg); bucket.ContentStream.ReadStreamData (); }