private void Sort(List <StreamLoader> loaders) { for (int i = 0; i < loaders.Count - 1; i++) { for (int j = i + 1; j < loaders.Count; j++) { if (loaders[i].start > loaders[j].start) { StreamLoader temp = loaders[i]; loaders[i] = loaders[j]; loaders[j] = temp; } } } }
public static void unpackConfig(StreamLoader streamLoader) { ByteBuffer buffer = ByteBuffer.Wrap(streamLoader.getDataForName("flo2.dat")); int count = buffer.GetShort(); overLayFlo317s = new OverLayFlo317[count]; for (int i = 0; i < count; i++) { if (overLayFlo317s[i] == null) { overLayFlo317s[i] = new OverLayFlo317(); } overLayFlo317s[i].parse(buffer); } Debug.Log("530 Overlay Floors amount: " + count); }
public void ParsingFileLoaderGraphHandlerExplicitTurtle() { Graph g = new Graph(); GraphHandler handler = new GraphHandler(g); #if PORTABLE using (var input = File.OpenRead(TestDataFile)) { StreamLoader.Load(handler, TestDataFile, input); } #else FileLoader.Load(handler, TestDataFile); #endif TestTools.ShowGraph(g); Assert.IsFalse(g.IsEmpty, "Graph should not be empty"); }
public void ParsingFileLoaderCountHandlerTurtle() { Graph orig = new Graph(); orig.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl"); CountHandler handler = new CountHandler(); #if PORTABLE using (var input = File.OpenRead(TestDataFile)) { StreamLoader.Load(handler, TestDataFile, input); } #else FileLoader.Load(handler, "temp.ttl"); #endif Assert.AreEqual(orig.Triples.Count, handler.Count); }
public static void LoadFromFile(this IGraph g, string filename, IRdfReader parser) { var path = System.IO.Path.GetFullPath(filename); if (g.IsEmpty && g.BaseUri == null) { if (System.IO.Path.IsPathRooted(filename)) { g.BaseUri = UriFactory.Create("file:///" + filename); } else { g.BaseUri = UriFactory.Create("file:///" + path); } } using (var stream = System.IO.File.OpenRead(path)) { StreamLoader.Load(g, filename, stream, parser); } }
/// <summary> /// Creates a content manager that creates OpenGL object instances, like textures /// </summary> /// <param name="resourceAssembly">The resource assembly that contains the resources.</param> /// <returns>A content manager instance</returns> public static FileContentManager Create(Assembly resourceAssembly) { var streamLoader = new StreamLoader(); streamLoader.AddMappings(resourceAssembly); streamLoader.AddMappings(Assembly.GetExecutingAssembly()); var mgr = new FileContentManager(streamLoader); mgr.RegisterImporter(ContentImporters.String); mgr.RegisterImporter(ContentImporters.ByteBuffer); mgr.RegisterImporter(ContentImporters.DefaultMesh); mgr.RegisterImporter(BitmapImporter); mgr.RegisterImporter(TextureArrayImporter); mgr.RegisterImporter(ShaderProgramImporter); mgr.RegisterUpdater <Texture2dGL>(Update); mgr.RegisterUpdater <ShaderProgramGL>(Update); mgr.RegisterUpdater <TextureArray2dGL>(Update); return(mgr); }
public StreamLine(StreamLine other) { name = other.name + "_duplicated"; group = other.group; loadType = other.loadType; flags = other.flags; unk10 = other.unk10; unk11 = other.unk11; unk5 = other.unk5; unk12 = other.unk12; unk13 = other.unk13; unk14 = other.unk14; unk15 = other.unk15; loadList = new StreamLoader[other.loadList.Length]; for (int i = 0; i < other.loadList.Length; i++) { loadList[i] = new StreamLoader(other.loadList[i]); } }
/// <summary> /// Creates a content manager that creates OpenGL object instances, like textures /// </summary> /// <param name="resourceAssembly">The assembly that contains the resources.</param> /// <param name="solutionMode">Should shaders be built with solution on or off</param> /// <returns>A content manager instance</returns> public static FileContentManager Create(Assembly resourceAssembly, bool solutionMode) { var streamLoader = new StreamLoader(); streamLoader.AddMappings(resourceAssembly); streamLoader.AddMappings(Assembly.GetExecutingAssembly()); //Zenseless.OpenGL resources var mgr = new FileContentManager(streamLoader); mgr.RegisterImporter(ContentImporters.String); mgr.RegisterImporter(ContentImporters.ByteBuffer); mgr.RegisterImporter(ContentImporters.DefaultMesh); mgr.RegisterImporter(BitmapImporter); mgr.RegisterUpdater <Texture2dGL>(Update); mgr.RegisterImporter(TextureArrayImporter); mgr.RegisterUpdater <TextureArray2dGL>(Update); mgr.RegisterImporter((namedStreams) => ShaderProgramImporter(namedStreams, solutionMode)); mgr.RegisterUpdater <ShaderProgramGL>((prog, namedStreams) => Update(prog, namedStreams, solutionMode)); return(mgr); }
private void InitializeRune() { anIntArray1232 = new int[32]; int a = 2; for (int k = 0; k < 32; k++) { anIntArray1232 [k] = a - 1; a += a; } signlink.storeid = 0; signlink.run(); for (int i = 0; i < 5; i++) { decompressors [i] = new Decompressor(signlink.cache_dat, signlink.cache_idx [i], i + 1); } StreamLoader streamLoader_6 = streamLoaderForName(5, "update list", "versionlist"); onDemandFetcher = new OnDemandFetcher(); onDemandFetcher.start(streamLoader_6); StreamLoader streamLoader = streamLoaderForName(2, "config", "config"); RS2Sharp.Animation.unpackConfig(streamLoader); //RS2Sharp.Texture.method368(streamLoader_3); RS2Sharp.Texture.method372(0.80000000000000004D); RS2Sharp.Texture.method367(); ItemDef.unpackConfig(streamLoader); EntityDef.unpackConfig(streamLoader); IDK.unpackConfig(streamLoader); SpotAnim.unpackConfig(streamLoader); Varp.unpackConfig(streamLoader); VarBit.unpackConfig(streamLoader); ObjectDef.unpackConfig(streamLoader); Flo.unpackConfig(streamLoader); OverLayFlo317.unpackConfig(streamLoader); Model.initialize(65535, onDemandFetcher); initialized = true; }
static void ReadApkManifest(String manifestPath, String resourcesPath) { AxmlFile axml = new AxmlFile(StreamLoader.FromFile(manifestPath)); ArscFile resources = new ArscFile(File.ReadAllBytes(resourcesPath)); if (!axml.Header.IsValid || !resources.Header.IsValid) { throw new InvalidOperationException(); } AndroidManifest apk = AndroidManifest.Load(axml, resources); Console.WriteLine("Label: " + apk.Application.Label); Console.WriteLine("Package: " + apk.Package); Console.WriteLine("Icon: " + apk.Application.Icon); Console.WriteLine("Permissions: " + String.Join(", ", apk.UsesPermission.Select(p => p.Name))); Console.WriteLine("Services: " + String.Join(", ", apk.Application.Service)); Console.WriteLine("Activities: " + String.Join(", ", apk.Application.Activity)); Console.WriteLine("Reciever: " + String.Join(", ", apk.Application.Reciever)); Console.WriteLine("Features: " + String.Join(", ", apk.UsesFeature)); Console.WriteLine("Uses Libraries: " + String.Join(", ", apk.Application.UsesLibrary.Select(p => p.Name))); }
private void CompareResultGraphs(string results, string expectedResultsPath, bool reduced) { var expectedResultGraph = new Graph(); #if PORTABLE using (var s = File.OpenRead(expectedResultsPath)) { StreamLoader.Load(expectedResultGraph, expectedResultsPath, s); } #else FileLoader.Load(expectedResultGraph, expectedResultsPath); #endif var resultSet = expectedResultGraph.GetUriNode(new Uri("http://www.w3.org/2001/sw/DataAccess/tests/result-set#ResultSet")); if (resultSet != null) { var rdfParser = new SparqlRdfParser(); var xmlParser = new SparqlXmlParser(); var actualResultSet = new SparqlResultSet(); var expectedResultSet = new SparqlResultSet(); using (var tr = new StringReader(results)) { xmlParser.Load(actualResultSet, tr); } #if PORTABLE rdfParser.Load(expectedResultSet, new StreamReader(expectedResultsPath)); #else rdfParser.Load(expectedResultSet, expectedResultsPath); #endif var bnodeMap = new Dictionary <string, string>(); CompareSparqlResults(actualResultSet, expectedResultSet, reduced, bnodeMap); } else { // This is a constructed graph var actualGraph = new Graph(); actualGraph.LoadFromString(results); CompareTripleCollections(actualGraph.Triples, expectedResultGraph.Triples, reduced); } }
public CollectionsXmlMapper(StreamLoader streamLoader) { this.streamLoader = streamLoader; }
private void BuildData() { linesTree.Nodes.Clear(); blockView.Nodes.Clear(); groupTree.Nodes.Clear(); PropertyGrid_Stream.SelectedObject = null; stream = new StreamMapLoader(file); for (int i = 0; i < stream.GroupHeaders.Length; i++) { TreeNode node = new TreeNode("group" + i); node.Text = stream.GroupHeaders[i]; StreamHeaderGroup HeaderGroup = new StreamHeaderGroup(); HeaderGroup.HeaderName = node.Text; node.Tag = HeaderGroup; linesTree.Nodes.Add(node); } for (int i = 0; i < stream.Groups.Length; i++) { var line = stream.Groups[i]; TreeNode node = new TreeNode(); node.Name = "GroupLoader" + i; node.Text = line.Name; node.Tag = line; for (int x = line.startOffset; x < line.startOffset + line.endOffset; x++) { var loader = stream.Loaders[x]; loader.AssignedGroup = line.Name; loader.GroupID = i; } groupTree.Nodes.Add(node); } for (int i = 0; i != stream.Lines.Length; i++) { var line = stream.Lines[i]; TreeNode node = new TreeNode(); node.Name = line.Name; node.Text = line.Name; node.Tag = line; List <StreamLoader> list = new List <StreamLoader>(); for (int x = 0; x < stream.Loaders.Length; x++) { var loader = stream.Loaders[x]; if (line.lineID >= loader.start && line.lineID <= loader.end) { var newLoader = new StreamLoader(loader); list.Add(newLoader); } } line.loadList = list.ToArray(); linesTree.Nodes[line.groupID].Nodes.Add(node); } for (int i = 0; i < stream.Blocks.Length; i++) { TreeNode node = new TreeNode(); node.Name = "Block" + i; node.Text = "Block: " + i; node.Tag = stream.Blocks[i]; blockView.Nodes.Add(node); } }
internal static async Task InjectDLL(Process Process, string DLLName, bool x86proc) { IntPtr hProcess = Process.Handle; // Length of string containing the DLL file name +1 byte padding IntPtr LenWrite = new IntPtr(DLLName.Length + 1); // Allocate memory within the virtual address space of the target process IntPtr AllocMem = VirtualAllocEx(hProcess, (IntPtr)null, LenWrite, AllocationType.Commit, MemoryProtection.ExecuteReadWrite); //allocation pour WriteProcessMemory // Write DLL file name to allocated memory in target process WriteProcessMemory(hProcess, AllocMem, Encoding.Default.GetBytes(DLLName), LenWrite, out uint bytesout); // Function pointer "Injector" IntPtr Injector; if (Environment.Is64BitProcess && x86proc)//WOW64 case { MODULEENTRY32 k32mod = GetModules((uint)Process.Id).SingleOrDefault(x => x.szModule.Equals("kernel32.dll", StringComparison.InvariantCultureIgnoreCase)); using (PEFile pe = new PEFile(StreamLoader.FromFile(k32mod.szExePath)))//alternatively ReadProcessMemory... but source name? { Version winver = Environment.OSVersion.Version; string LoadLibraryVariant = winver.Major <= 6 && winver.Minor <= 1 ? "LoadLibraryA" : "LoadLibraryExA"; Injector = IntPtr.Add(k32mod.hModule, (int)pe.Export.GetExportFunctions().SingleOrDefault(x => x.Name.Equals(LoadLibraryVariant)).Address); } } else { Injector = GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA"); } if (Injector == null) { LogHost.Default.Error("Injector Error!"); // return failed return; } // Create thread in target process, and store handle in hThread IntPtr hThread = CreateRemoteThread(hProcess, (IntPtr)null, IntPtr.Zero, Injector, AllocMem, 0, out bytesout); // Make sure thread handle is valid if (hThread == null) { //incorrect thread handle ... return failed LogHost.Default.Error("hThread [ 1 ] Error!"); return; } // Time-out is 10 seconds... uint Result = WaitForSingleObject(hThread, 10 * 1000); // Check whether thread timed out... if (Result == 0x00000080L || Result == 0x00000102L || Result == 0xFFFFFFFF) { /* Thread timed out... */ LogHost.Default.Error("hThread [ 2 ] Error!"); // Make sure thread handle is valid before closing... prevents crashes. if (hThread != null) { //Close thread in target process CloseHandle(hThread); } return; } // Sleep for 1 second await Task.Delay(1000);//Thread.Sleep(1000); //for (int w = 0; !PersistentNamedPipeServer.Instance.IsConnected && w < 1000; w += 10) //{ // await Task.Delay(10); //} // Clear up allocated space ( Allocmem ) VirtualFreeEx(hProcess, AllocMem, (UIntPtr)0, 0x8000); // Make sure thread handle is valid before closing... prevents crashes. if (hThread != null) { //Close thread in target process CloseHandle(hThread); } // return succeeded return; }
static void ReadDex(String filePath) { using (DexFile info = new DexFile(StreamLoader.FromFile(filePath))) { var items = info.STRING_ID_ITEM; foreach (string_data_row row in info.STRING_DATA_ITEM) { Utils.ConsoleWriteMembers(row); } Utils.ConsoleWriteMembers(info.header); foreach (DexApi.map_item mapItem in info.map_list) { Utils.ConsoleWriteMembers(mapItem); } foreach (annotation_set_row row in info.ANNOTATION_SET_ITEM) { Utils.ConsoleWriteMembers(row); } foreach (annotation_set_ref_row row in info.ANNOTATION_SET_REF_LIST) { Utils.ConsoleWriteMembers(row); } foreach (annotation_directory_row row in info.ANNOTATIONS_DIRECTORY_ITEM) { Utils.ConsoleWriteMembers(row); } foreach (field_annotation_row row in info.field_annotation) { Utils.ConsoleWriteMembers(row); } foreach (parameter_annotation_row row in info.parameter_annotation) { Utils.ConsoleWriteMembers(row); } foreach (method_annotation_row row in info.method_annotation) { Utils.ConsoleWriteMembers(row); } foreach (class_data_row row in info.CLASS_DATA_ITEM) { Utils.ConsoleWriteMembers(row); } foreach (encoded_field_row row in info.encoded_field) { Utils.ConsoleWriteMembers(row); } foreach (encoded_method_row row in info.encoded_method) { Utils.ConsoleWriteMembers(row); } foreach (code_row row in info.CODE_ITEM) { Utils.ConsoleWriteMembers(row); } foreach (try_item_row row in info.try_item) { Utils.ConsoleWriteMembers(row); } foreach (encoded_catch_handler_row row in info.encoded_catch_handler_list) { Utils.ConsoleWriteMembers(row); } foreach (encoded_type_addr_pair_row row in info.encoded_type_addr_pair) { Utils.ConsoleWriteMembers(row); } foreach (type_list_row row in info.TYPE_LIST) { Utils.ConsoleWriteMembers(row); } foreach (type_id_row row in info.TYPE_ID_ITEM) { Utils.ConsoleWriteMembers(row); } foreach (proto_id_row row in info.PROTO_ID_ITEM) { Utils.ConsoleWriteMembers(row); } foreach (field_id_row row in info.FIELD_ID_ITEM) { Utils.ConsoleWriteMembers(row); } foreach (method_id_row row in info.METHOD_ID_ITEM) { Utils.ConsoleWriteMembers(row); } foreach (class_def_row row in info.CLASS_DEF_ITEM) { Utils.ConsoleWriteMembers(row); } } }
public void ReadFromFile(BinaryReader reader) { if (reader.ReadInt32() != 1299346515) { return; } if (reader.ReadInt32() != 0x6) { return; } int fileSize = reader.ReadInt32(); int unk0 = reader.ReadInt32(); int numGroups = reader.ReadInt32(); int groupOffset = reader.ReadInt32(); int numHeaders = reader.ReadInt32(); int headerOffset = reader.ReadInt32(); int numLines = reader.ReadInt32(); int lineOffset = reader.ReadInt32(); int numLoaders = reader.ReadInt32(); int loadersOffset = reader.ReadInt32(); int numBlocks = reader.ReadInt32(); int blockOffset = reader.ReadInt32(); int numHashes = reader.ReadInt32(); int hashOffset = reader.ReadInt32(); int poolSize = reader.ReadInt32(); int poolOffset = reader.ReadInt32(); if (reader.BaseStream.Position != groupOffset) { throw new FormatException(); } groups = new StreamGroup[numGroups]; for (int i = 0; i < numGroups; i++) { StreamGroup map = new StreamGroup(); map.nameIDX = reader.ReadInt32(); map.Name = ReadFromBuffer((long)((ulong)map.nameIDX + (ulong)poolOffset), reader.BaseStream.Position, reader); map.Type = reader.ReadInt32(); map.Unk01 = reader.ReadInt32(); map.startOffset = reader.ReadInt32(); map.endOffset = reader.ReadInt32(); map.unk5 = reader.ReadInt32(); groups[i] = map; } if (reader.BaseStream.Position != headerOffset) { throw new FormatException(); } groupHeaders = new string[numHeaders]; ulong[] ulongHeaders = new ulong[numHeaders]; for (int i = 0; i < numHeaders; i++) { ulongHeaders[i] = reader.ReadUInt64(); groupHeaders[i] = ReadFromBuffer((long)(ulongHeaders[i] + (ulong)poolOffset), reader.BaseStream.Position, reader); } if (reader.BaseStream.Position != lineOffset) { throw new FormatException(); } lines = new StreamLine[numLines]; for (int i = 0; i < numLines; i++) { StreamLine map = new StreamLine(); map.nameIDX = reader.ReadInt32(); map.lineID = reader.ReadInt32(); map.groupID = reader.ReadInt32(); map.LoadType = reader.ReadInt32(); map.flagIDX = reader.ReadInt32(); map.Unk5 = reader.ReadInt32(); map.Unk10 = reader.ReadUInt64(); map.Unk11 = reader.ReadUInt64(); map.Unk12 = reader.ReadInt32(); map.Unk13 = reader.ReadInt32(); map.Unk14 = reader.ReadInt32(); map.Unk15 = reader.ReadInt32(); map.Group = groupHeaders[map.groupID]; map.Name = ReadFromBuffer((long)((ulong)map.nameIDX + (ulong)poolOffset), reader.BaseStream.Position, reader); map.Flags = ReadBufferSpecial((long)((ulong)map.flagIDX + (ulong)poolOffset), reader.BaseStream.Position, reader).TrimEnd('\0').Replace('\0', '|'); lines[i] = map; } if (reader.BaseStream.Position != loadersOffset) { throw new FormatException(); } loaders = new StreamLoader[numLoaders]; for (int i = 0; i < numLoaders; i++) { StreamLoader map = new StreamLoader(); map.start = reader.ReadInt32(); map.end = reader.ReadInt32(); map.type = reader.ReadInt32(); map.loaderSubID = reader.ReadInt32(); map.loaderID = reader.ReadInt32(); map.LoadType = reader.ReadInt32(); map.pathIDX = reader.ReadInt32(); map.entityIDX = reader.ReadInt32(); map.Path = ReadFromBuffer((long)((ulong)map.pathIDX + (ulong)poolOffset), reader.BaseStream.Position, reader); map.Entity = ReadBufferSpecial((long)((ulong)map.entityIDX + (ulong)poolOffset), reader.BaseStream.Position, reader).TrimEnd('\0').Replace('\0', '|'); loaders[i] = map; } if (reader.BaseStream.Position != blockOffset) { throw new FormatException(); } blocks = new StreamBlock[numBlocks]; for (int i = 0; i < numBlocks; i++) { StreamBlock map = new StreamBlock(); map.startOffset = reader.ReadInt32(); map.endOffset = reader.ReadInt32(); blocks[i] = map; } if (reader.BaseStream.Position != hashOffset) { throw new FormatException(); } hashes = new ulong[numHashes]; for (int i = 0; i < numHashes; i++) { hashes[i] = reader.ReadUInt64(); } if (reader.BaseStream.Position != poolOffset) { throw new FormatException(); } reader.BaseStream.Seek(poolSize, SeekOrigin.Current); if (reader.BaseStream.Position != reader.BaseStream.Length) { throw new FormatException("Borked this up"); } }
static void ReadApk(String filePath) { using (ApkFile apk = new ApkFile(filePath)) { Console.WriteLine("Package: {0}", apk.AndroidManifest.Package); Console.WriteLine("Application name: {0} ({1})", apk.AndroidManifest.Application.Label, apk.AndroidManifest.VersionName); if (apk.MfFile != null) { UInt32 totalFiles = 0; UInt32 hashNotFound = 0; UInt32 invalidHash = 0; foreach (String apkFilePath in apk.GetFiles()) { totalFiles++; String sHash = apk.MfFile[apkFilePath]; if (sHash == null) { //Console.WriteLine("Hash not found for file: {0}", apkFilePath); hashNotFound++; } else if (!apk.MfFile.ValidateHash(apkFilePath, apk.GetFile(apkFilePath))) { //Console.WriteLine("InvalidHash: {0} ({1})", apkFilePath, sHash); invalidHash++; } } Console.WriteLine("Total files: {0:N0}", totalFiles); if (hashNotFound > 0) { Console.WriteLine("Hash Not found: {0:N0}", hashNotFound); } if (invalidHash > 0) { Console.WriteLine("Invalid hash: {0:N0}", invalidHash); } } TreeDto root = BuildTree(apk.GetHeaderFiles().ToArray(), '/'); String test = ConvertTreeToStringRec(root, 0); foreach (String xmlFile in apk.GetHeaderFiles()) { switch (Path.GetExtension(xmlFile).ToLowerInvariant()) { case ".xml": /*if(xmlFile.Equals("AndroidManifest.xml", StringComparison.OrdinalIgnoreCase)) * continue;*/ Byte[] file = apk.GetFile(xmlFile); //ManifestFile manifest = new ManifestFile(file); //Console.WriteLine(manifest.Xml.ConvertToString()); AxmlFile axml = new AxmlFile(StreamLoader.FromMemory(file, xmlFile)); if (axml.Header.IsValid) { XmlNode xml = axml.RootNode; Console.WriteLine("---" + xmlFile + ":"); Console.WriteLine(xml.ConvertToString()); } else { Console.WriteLine("---" + xmlFile + ":"); Console.WriteLine(System.Text.Encoding.UTF8.GetString(file)); } break; } } ReadApkManifestRecursive(apk.AndroidManifest); } }
public void Setup() { loader = new StreamLoader(); }
/// <summary>Create instance of test loader</summary> /// <param name="filePath"></param> public LookupLoader(String filePath) { this._baseLoader = StreamLoader.FromFile(filePath); this._map = new Byte[new FileInfo(filePath).Length]; }
static void ReadManifest(String filePath) { AxmlFile manifest = new AxmlFile(StreamLoader.FromFile(filePath)); Console.Write(manifest.RootNode.ConvertToString()); }
public void ReadFromFile(BinaryReader reader) { if (reader.ReadInt32() != 1299346515) { return; } if (reader.ReadInt32() != 0x6) { return; } int fileSize = reader.ReadInt32(); int unk0 = reader.ReadInt32(); int numGroups = reader.ReadInt32(); int groupOffset = reader.ReadInt32(); int numHeaders = reader.ReadInt32(); int headerOffset = reader.ReadInt32(); int numLines = reader.ReadInt32(); int lineOffset = reader.ReadInt32(); int numLoaders = reader.ReadInt32(); int loadersOffset = reader.ReadInt32(); int numBlocks = reader.ReadInt32(); int blockOffset = reader.ReadInt32(); int numHashes = reader.ReadInt32(); int hashOffset = reader.ReadInt32(); int poolSize = reader.ReadInt32(); int poolOffset = reader.ReadInt32(); Debug.Assert(reader.BaseStream.Position == groupOffset, "Failed to reach the starting offset for group declaration!"); groups = new StreamGroup[numGroups]; for (int i = 0; i < numGroups; i++) { StreamGroup map = new StreamGroup(); map.nameIDX = reader.ReadInt32(); map.Name = ReadFromBuffer((long)((ulong)map.nameIDX + (ulong)poolOffset), reader.BaseStream.Position, reader); map.Type = (GroupTypes)reader.ReadInt32(); map.Unk01 = reader.ReadInt32(); map.startOffset = reader.ReadInt32(); map.endOffset = reader.ReadInt32(); map.unk5 = reader.ReadInt32(); groups[i] = map; } Debug.Assert(reader.BaseStream.Position == headerOffset, "Did not reach the header starting offset"); groupHeaders = new string[numHeaders]; ulong[] ulongHeaders = new ulong[numHeaders]; for (int i = 0; i < numHeaders; i++) { ulongHeaders[i] = reader.ReadUInt64(); groupHeaders[i] = ReadFromBuffer((long)(ulongHeaders[i] + (ulong)poolOffset), reader.BaseStream.Position, reader); } Debug.Assert(reader.BaseStream.Position == lineOffset, "Did not reach the line data starting offset!"); lines = new StreamLine[numLines]; for (int i = 0; i < numLines; i++) { StreamLine map = new StreamLine(); map.nameIDX = reader.ReadInt32(); map.lineID = reader.ReadInt32(); map.groupID = reader.ReadInt32(); map.LoadType = reader.ReadInt32(); map.flagIDX = reader.ReadInt32(); map.Unk5 = reader.ReadInt32(); map.Unk10 = reader.ReadUInt64(); map.Unk11 = reader.ReadUInt64(); map.Unk12 = reader.ReadInt32(); map.Unk13 = reader.ReadInt32(); map.Unk14 = reader.ReadInt32(); map.Unk15 = reader.ReadInt32(); map.Group = groupHeaders[map.groupID]; map.Name = ReadFromBuffer((long)((ulong)map.nameIDX + (ulong)poolOffset), reader.BaseStream.Position, reader); map.Flags = ReadBufferSpecial((long)((ulong)map.flagIDX + (ulong)poolOffset), reader.BaseStream.Position, reader).TrimEnd('\0').Replace('\0', '|'); lines[i] = map; } Debug.Assert(reader.BaseStream.Position == loadersOffset, "Did not reach the loader data starting offset!"); loaders = new StreamLoader[numLoaders]; for (int i = 0; i < numLoaders; i++) { StreamLoader map = new StreamLoader(); map.start = reader.ReadInt32(); map.end = reader.ReadInt32(); map.Type = (GroupTypes)reader.ReadInt32(); map.LoaderSubID = reader.ReadInt32(); map.LoaderID = reader.ReadInt32(); map.LoadType = reader.ReadInt32(); map.pathIDX = reader.ReadInt32(); map.entityIDX = reader.ReadInt32(); map.Path = ReadFromBuffer((long)((ulong)map.pathIDX + (ulong)poolOffset), reader.BaseStream.Position, reader); map.Entity = ReadBufferSpecial((long)((ulong)map.entityIDX + (ulong)poolOffset), reader.BaseStream.Position, reader).TrimEnd('\0').Replace('\0', '|'); loaders[i] = map; } Debug.Assert(reader.BaseStream.Position == blockOffset, "Did not reach the block declaration starting offset!"); blocks = new StreamBlock[numBlocks]; for (int i = 0; i < numBlocks; i++) { StreamBlock map = new StreamBlock(); map.startOffset = reader.ReadInt32(); map.endOffset = reader.ReadInt32(); map.Hashes = new ulong[map.endOffset - map.startOffset]; blocks[i] = map; } Debug.Assert(reader.BaseStream.Position == hashOffset, "Did not reach the block hashes starting offset!"); hashes = new ulong[numHashes]; for (int i = 0; i < numHashes; i++) { hashes[i] = reader.ReadUInt64(); } for (int i = 0; i < numBlocks; i++) { var block = blocks[i]; Array.Copy(hashes, block.startOffset, block.Hashes, 0, block.Hashes.Length); } Debug.Assert(reader.BaseStream.Position == poolOffset, "Did not reach the buffer pool starting offset!"); reader.BaseStream.Seek(poolSize, SeekOrigin.Current); Debug.Assert(reader.BaseStream.Position == reader.BaseStream.Length, "Did not reach the end of the file!"); }
public CollectionXmlMapper(StreamLoader streamLoader) { this.streamLoader = streamLoader; }
static void Main(string[] args) { Console.WriteLine("Skater.net Deobfuscator \n \n"); int nombreDeStringEncodée = 0; ModuleDefMD module = ModuleDefMD.Load(args[0]); //Type which contains String Initialization TypeDef InitialType = null; //We grab native method to count all of them List <MethodDef> ListOfNativeMeths = new List <MethodDef>(); Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); foreach (TypeDef t in module.GetTypes()) { foreach (MethodDef m in t.Methods) { if (m.Name.Contains("OOOOlx")) { ListOfNativeMeths.Add(m); } } } nombreDeStringEncodée = ListOfNativeMeths.Count(); //We grab the type to find cctor afterwards InitialType = ListOfNativeMeths.First().DeclaringType; string DLLName = ListOfNativeMeths.First().ImplMap.Module.Name; Console.WriteLine("Native DLL Name : " + DLLName); //We stock strings in a list List <string> deHexedstring = new List <string>(); //Reading PE using (PEFile file = new PEFile(StreamLoader.FromFile(Path.GetDirectoryName(args[0]) + @"\" + DLLName))) { var section = file.Header.Sections; foreach (var item in section) { var realName = new string(item.Name); //Strings are stored in .data section if (realName.Contains(".data")) { //offset of the beginning of the section var start = item.PointerToRawData; //calculation of section's size var length = item.PointerToRawData + item.SizeOfRawData; //We copy all bytes into a list List <byte> b = new List <byte>(); using (FileStream fsSourceDDS = new FileStream(Path.GetDirectoryName(args[0]) + @"\" + DLLName, FileMode.Open, FileAccess.Read)) using (BinaryReader binaryReader = new BinaryReader(fsSourceDDS)) { fsSourceDDS.Seek(start, SeekOrigin.Begin); while (start < length) { byte y = binaryReader.ReadByte(); b.Add(y); start++; } } dataSectionContent = b.ToArray(); string input = ByteArrayToString(dataSectionContent); //we split the whole strings string[] datacontent = input.Split(new string[] { "00" }, StringSplitOptions.None); //We remove empty results datacontent = datacontent.Where(x => !string.IsNullOrEmpty(x)).ToArray(); //We only need values associated to strings string[] encodedstring = datacontent.Take(nombreDeStringEncodée).Select(i => i.ToString()).ToArray(); foreach (var hexedstring in encodedstring) { deHexedstring.Add(Encoding.UTF8.GetString(StringToByteArray(hexedstring))); } } } } //That's why we needed to find the type MethodDef cctor = InitialType.FindStaticConstructor(); if (cctor == null) { Console.WriteLine("Impossible to find Method which initialize strings"); return; } //We make a dictionnary to replace values of field Dictionary <FieldDef, string> FieldValue = new Dictionary <FieldDef, string>(); for (int i = 0; i < cctor.Body.Instructions.Count - 1; i++) { if (cctor.Body.Instructions[i].OpCode == OpCodes.Ldsfld && cctor.Body.Instructions[i + 1].OpCode == OpCodes.Call && cctor.Body.Instructions[i + 2].OpCode == OpCodes.Stsfld) { cctor.Body.Instructions[i].OpCode = OpCodes.Nop; cctor.Body.Instructions[i + 1].OpCode = OpCodes.Ldstr; string decrypted = smethod_0(deHexedstring[0]); cctor.Body.Instructions[i + 1].Operand = decrypted; FieldValue.Add((FieldDef)cctor.Body.Instructions[i + 2].Operand, decrypted); deHexedstring.RemoveAt(0); } } int DecryptedStrings = 0; //Replacing field values foreach (TypeDef type in module.Types) { foreach (MethodDef method in type.Methods) { if (method.HasBody && method.Body.HasInstructions) { Cleaner(method); for (int i = 0; i < method.Body.Instructions.Count - 1; i++) { try { if (method.Body.Instructions[i].OpCode == OpCodes.Ldsfld) { FieldDef fld = (FieldDef)method.Body.Instructions[i].Operand; if (FieldValue.Keys.Contains(fld)) { method.Body.Instructions[i].OpCode = OpCodes.Ldstr; method.Body.Instructions[i].Operand = FieldValue[fld]; DecryptedStrings++; } } } catch { } } } } } stopWatch.Stop(); Console.WriteLine("Done ! Elapsed time : " + stopWatch.Elapsed.TotalSeconds); //Saving ASM string SavingPath = module.Kind == ModuleKind.Dll ? args[0].Replace(".dll", "-Deobfuscated.dll") : args[0].Replace(".exe", "-Deobfuscated.exe"); var opts = new ModuleWriterOptions(module); opts.MetaDataOptions.Flags = MetaDataFlags.PreserveAll; opts.Logger = DummyLogger.NoThrowInstance; module.Write(SavingPath, opts); Console.WriteLine("Sucessfully decrypted {0} strings", DecryptedStrings); Console.WriteLine("Control Flow removed", DecryptedStrings); Console.ReadLine(); }
private void BuildData() { linesTree.Nodes.Clear(); blockView.Nodes.Clear(); groupTree.Nodes.Clear(); stream = new StreamMapLoader(file); for (int i = 0; i < stream.groupHeaders.Length; i++) { TreeNode node = new TreeNode("group" + i); node.Text = stream.groupHeaders[i]; node.Tag = "Header"; linesTree.Nodes.Add(node); } for (int i = 0; i < stream.groups.Length; i++) { var line = stream.groups[i]; TreeNode node = new TreeNode(); node.Name = "GroupLoader" + i; node.Text = line.Name; node.Tag = line; for (int x = line.startOffset; x < line.startOffset + line.endOffset; x++) { var loader = stream.loaders[x]; loader.Group = line.Name; } groupTree.Nodes.Add(node); } for (int i = 0; i != stream.lines.Length; i++) { var line = stream.lines[i]; TreeNode node = new TreeNode(); node.Name = line.Name; node.Text = line.Name; node.Tag = line; List <StreamLoader> list = new List <StreamLoader>(); for (int x = 0; x < stream.loaders.Length; x++) { var loader = stream.loaders[x]; if (line.lineID >= loader.start && line.lineID <= loader.end) { var newLoader = new StreamLoader(loader); list.Add(newLoader); } } line.loadList = list.ToArray(); linesTree.Nodes[line.groupID].Nodes.Add(node); } for (int i = 0; i < stream.blocks.Length; i++) { var block = stream.blocks[i]; List <ulong> hash = new List <ulong>(); for (int x = block.startOffset; x < block.endOffset; x++) { hash.Add(stream.hashes[x]); } block.Hashes = hash.ToArray(); TreeNode node = new TreeNode(); node.Name = "Block" + i; node.Text = "Block: " + i; node.Tag = block; blockView.Nodes.Add(node); } }
static void ReadSo(String binFile) { using (ElfFile file = new ElfFile(StreamLoader.FromFile(binFile))) { Utils.ConsoleWriteMembers(file.Header.Identification); if (file.Header.IsValid) { DebugStringSection debugSection = file.GetDebugStringSection(); if (debugSection != null) { foreach (var symbolSec in debugSection) { Utils.ConsoleWriteMembers(symbolSec); } } foreach (var noteSec in file.GetNotesSections()) { foreach (var note in noteSec) { Utils.ConsoleWriteMembers(note); } } Utils.ConsoleWriteMembers(file.Header.Header); foreach (var strSec in file.GetStringSections()) { foreach (var str in strSec) { Utils.ConsoleWriteMembers(str); } } foreach (var symbolSec in file.GetSymbolSections()) { foreach (var symbol in symbolSec) { Utils.ConsoleWriteMembers(symbol); } } foreach (var relSec in file.GetRelocationSections()) { foreach (var rel in relSec) { Utils.ConsoleWriteMembers(rel); } } foreach (var relaSec in file.GetRelocationASections()) { foreach (var rela in relaSec) //TODO: Check it { Utils.ConsoleWriteMembers(rela); } } SymbolSection symbols = file.GetSymbolSections().FirstOrDefault(); if (symbols != null) { foreach (var item in symbols) { if (String.IsNullOrEmpty(item.Name)) { Console.WriteLine("EMPTY REF"); } } /*StringSection strings = file.GetStringSections().FirstOrDefault(p => p.Section.Name == ".dynstr"); * foreach(var item in symbols) * { * String str = strings[item.st_name]; * Console.WriteLine(str); * if(String.IsNullOrEmpty(str)) * Console.WriteLine("EMPTY REF"); * if(item.st_shndx != 0) * { * Section someSec = file.Sections.First(p => p.Index == item.st_shndx); * Utils.ConsoleWriteMembers(someSec); * } * }*/ } String[] secTypes = file.Sections.Select(p => p.sh_type.ToString()).Distinct().ToArray(); } } }
public PercentileXmlMapper(StreamLoader streamLoader) { this.streamLoader = streamLoader; }